Enum Format 

#[non_exhaustive]
pub enum Format {
    Variable(Variable<Self>),
    TypeName(QualifiedTypeName),
    Unit,
    Bool,
    I8,
    I16,
    I32,
    I64,
    I128,
    U8,
    U16,
    U32,
    U64,
    U128,
    F32,
    F64,
    Char,
    Str,
    Bytes,
    Uuid,
    Option(Box<Self>),
    Seq(Box<Self>),
    Set(Box<Self>),
    Map {
        key: Box<Self>,
        value: Box<Self>,
    },
    Tuple(Vec<Self>),
    TupleArray {
        content: Box<Self>,
        size: usize,
    },
}

The shape of a value type — an AST node describing how a field, variant payload, or nested value is serialized.

Primitives are leaf nodes; composites (Option, Seq, Map, Tuple) contain nested Format nodes; and TypeName is a reference to a ContainerFormat in the Registry.

Format and ContainerFormat are separate types, not variants of the same enum. A ContainerFormat is a type declaration (a struct or enum definition) that holds Format nodes as its children (field types, variant payloads). A Format is a type usage — and Format::TypeName closes the loop by referencing back to a ContainerFormat in the registry.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Variable(Variable<Self>)

A placeholder for a format not yet known at construction time. Format::unknown() creates one of these, and it is also the Default value for Format. Fields start as variables and are filled in as the RegistryBuilder processes each type, resolving to a concrete format (e.g. U32, Str, TypeName(...)). Not involved in code generation — all variables must be resolved before RegistryBuilder::build completes.

TypeName(QualifiedTypeName)

A reference to a named container type in the Registry.

Unit

Bool

I8

I16

I32

I64

I128

U8

U16

U32

U64

U128

F32

F64

Char

Str

Bytes

Uuid

A UUID. On the wire this is identical to Bytes (16 raw bytes, length-prefixed) for non-human-readable encoders (e.g. bincode), and a lowercase hyphenated string for human-readable encoders (e.g. JSON). Foreign-language emitters map this to the native UUID type for the target language (e.g. Foundation.UUID in Swift, java.util.UUID in Kotlin, System.Guid in C#, branded string in TypeScript).

Option(Box<Self>)

The format of Option<T>.

Seq(Box<Self>)

A sequence, e.g. the format of Vec<Foo>.

Set(Box<Self>)

A set, e.g. the format of HashSet<Foo>.

Map

A map, e.g. the format of BTreeMap<K, V>.

Fields

key: Box<Self>

value: Box<Self>

Tuple(Vec<Self>)

A tuple, e.g. the format of (Foo, Bar).

TupleArray

Alias for (Foo, ... Foo). E.g. the format of [Foo; N].

Fields

content: Box<Self>

size: usize

Implementations

impl Format

pub fn unknown() -> Self

Return a format made of a fresh variable with no known value.

Trait Implementations

impl Clone for Format

fn clone(&self) -> Format

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Format

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Format

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Format

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Emitter<Kotlin> for Format

fn write<W: IndentWrite>(&self, w: &mut W, lang: &Kotlin) -> Result<()>

Write the code for this node to the provided IndentWrite.

impl Emitter<Swift> for Format

fn write<W: IndentWrite>(&self, w: &mut W, lang: &Swift) -> Result<()>

Write the code for this node to the provided IndentWrite.

impl Emitter<TypeScript> for Format

fn write<W: IndentWrite>(&self, w: &mut W, lang: &TypeScript) -> Result<()>

Write the code for this node to the provided IndentWrite.

impl Eq for Format

impl FormatHolder for Format

fn visit<'a>( &'a self, f: &mut dyn FnMut(&'a Format) -> Result<()>, ) -> Result<()>

Visit all the formats in self in a depth-first way. Variables are not supported and will cause an error.

fn visit_mut( &mut self, f: &mut dyn FnMut(&mut Format) -> Result<()>, ) -> Result<()>

Mutably visit all the formats in self in a depth-first way.

fn is_unknown(&self) -> bool

Whether this format is a variable with no known value yet.

fn normalize(&mut self) -> Result<()>

Finalize the formats within self by removing variables and making sure that all eligible tuples are compressed into a TupleArray. Return an error if any variable has an unknown value.

fn reduce(&mut self)

Attempt to remove known variables within self. Silently abort if some variables have unknown values.

impl PartialEq for Format

fn eq(&self, other: &Format) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Format

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Format