Enum TypeDef 

pub enum TypeDef {
    Primitive(Primitive),
    Array(Box<TypeDef>),
    Tuple(Vec<TypeDef>),
    Object(Vec<Field>),
    Union(Vec<TypeDef>),
    Intersection(Vec<TypeDef>),
    Record {
        key: Box<TypeDef>,
        value: Box<TypeDef>,
    },
    Named {
        name: String,
        def: Box<TypeDef>,
    },
    Ref(String),
    Literal(Literal),
    Function {
        params: Vec<Field>,
        return_type: Box<TypeDef>,
    },
    Generic {
        base: String,
        args: Vec<TypeDef>,
    },
}

Intermediate representation for TypeScript types.

This enum represents all TypeScript types that ferrotype can generate. It serves as the IR between Rust types and TypeScript output, enabling analysis and transformation before rendering.

Type Categories

• Primitives: string, number, boolean, null, etc.
• Compounds: Arrays, tuples, objects, unions, intersections
• References: Named types and type references
• Literals: Specific string, number, or boolean values

Variants

Primitive(Primitive)

A primitive TypeScript type.

Array(Box<TypeDef>)

An array type: T[]

Tuple(Vec<TypeDef>)

A tuple type: [T1, T2, ...]

Object(Vec<Field>)

An object type with named fields: { field1: T1; field2?: T2; }

Union(Vec<TypeDef>)

A union type: T1 | T2 | ...

Intersection(Vec<TypeDef>)

An intersection type: T1 & T2 & ...

Record

A record/dictionary type: Record<K, V> or { [key: K]: V }

Fields

key: Box<TypeDef>

value: Box<TypeDef>

Named

A named type definition that should be emitted as a separate declaration. This is the primary mechanism for type deduplication.

Fields

name: String

def: Box<TypeDef>

Ref(String)

A reference to a named type. Used to avoid infinite recursion and to generate cleaner output by referencing previously-defined types.

Literal(Literal)

A literal type with a specific value.

Function

A function type: (arg1: T1, arg2: T2) => R

Fields

params: Vec<Field>

return_type: Box<TypeDef>

Generic

A generic type application: Generic<T1, T2>

Fields

base: String

args: Vec<TypeDef>

Implementations

impl TypeDef

pub fn render(&self) -> String

Renders this TypeDef to TypeScript syntax.

pub fn render_declaration(&self) -> String

Renders a full type declaration for named types.

For Named types, this returns type Name = Definition; For other types, this just returns the rendered type.

Trait Implementations

impl Clone for TypeDef

fn clone(&self) -> TypeDef

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TypeDef

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

Formats the value using the given formatter.

impl PartialEq for TypeDef

fn eq(&self, other: &TypeDef) -> 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 StructuralPartialEq for TypeDef