specta

When exporting to Java, specta-java focuses on generating data models rather than serialization adapters. Note the following behaviors:

• Field Names: Legal formatted field names are preserved.
• Enums: String-based enums expose their wire value through a .value() method.
• Escaping: Names that are invalid in Java are escaped deterministically. Ensure your application's serializer is configured to use these escaped names and enum values to maintain compatibility.
• Tuples:
  • Rust tuples used as fields are converted into nested Java records.
  • Anonymous tuple positions that cannot be safely named are converted into Java Lists.

The configuration_options.rs example demonstrates how to customize the Swift code generation. You can control several aspects of the output, including:

• Naming Conventions: Switch between PascalCase, camelCase, and snake_case.
• Indentation: Configure indentation using spaces or tabs and specify the width.
• Type Styles: Choose between protocol constraints or typealias for generic types, and decide between ? syntax or Optional<T> for optional types.
• Metadata: Add custom headers and documentation.
• Conformance: Add additional protocol conformance and configure Serde validation settings.

The specta-java exporter supports two primary ways of organizing generated files:

1. Flat-file layout (Default): All generated types are nested inside a single wrapper class (e.g., Bindings). When using this layout, the output must be written to a file that matches the configured class name (e.g., Bindings.java).
2. Individual files layout: Use Layout::Files with the export_to method to generate one public Java source file per type instead of nesting them.

Rust doc comments (///) are preserved and formatted as Swift documentation comments in the generated output.

/// A comprehensive user account
///
/// # Security Notes
/// - The password field should never be logged
#[derive(Type)]
struct User {
    /// Unique identifier
    id: u32,
    name: String,
}

// Generates:

/// A comprehensive user account
///
/// # Security Notes
/// - The password field should never be logged
public struct User: Codable {
    /// Unique identifier
    public let id: UInt32
    public let name: String
}

Use specta-java to export your Rust types (defined via specta::Type) into Java 17 records, enums, and sealed interfaces. This allows you to maintain type-safe data models across the Rust/Java boundary.

To export, use the Java exporter with export_to. You must register your types using Types::default().register::<T>() and specify a serialization format (e.g., specta_serde::Format).

use specta::{Type, Types};
use specta_java::Java;

#[derive(Type)]
struct User {
    name: String,
}

Java::default()
    .export_to(
        "Bindings.java",
        &Types::default().register::<User>(),
        specta_serde::Format,
    )?;

The specta-swift examples directory provides several specialized examples to help you understand how different Rust types are translated into Swift:

• Fundamental Mappings: Use basic_types to see how primitives (i8, u32, f64, etc.), Option<T>, Vec<T>, and Tuples are converted.
• Complex Enums: Use advanced_unions or string_enums to see how recursive types, generic enums, and string-based enums with Codable are handled.
• Special Types: Use special_types to see how Duration is mapped to a RustDuration helper with a timeInterval property.
• Documentation: Use comments_example to see how Rust doc comments are preserved as Swift-compatible documentation.
• Full Showcase: Use comprehensive_demo for a realistic application pattern including user management, task tracking, and pagination.

To use specta-rescript to export Rust types to ReScript, add the following dependencies to your Cargo.toml file. Note that specta requires the derive feature enabled.

[dependencies]
specta = { version = "2.0.0-rc.26", features = ["derive"] }
specta-rescript = "0.0.1"
specta-serde = "0.0.13"

To use specta-rescript, you can generate .res files from Rust definitions and then verify them using the ReScript compiler.

1. Generate .res files

Run any specific example using cargo run with the -p specta-rescript package flag:

cargo run -p specta-rescript --example rescript_simple_usage
cargo run -p specta-rescript --example rescript_basic_types

2. Type-check the generated code

Navigate to the generated/ directory to install dependencies and run the ReScript compiler:

cd examples/generated
npm install
npm run check

Note: The lib/ directory produced by rescript build is ignored by git.

Do not add specta-macros as a direct dependency in your Cargo.toml. Instead, use the main specta crate, which re-exports the macros. This ensures version compatibility and simplifies dependency management.

# Do NOT do this:
# specta-macros = "..."

# DO this:
[dependencies]
specta = "..."