Enum TypeRef 

pub enum TypeRef {
    Primitive(PrimitiveType),
    Optional(Box<TypeRef>),
    Array(Box<TypeRef>),
    Named(String),
    Generic {
        base: String,
        args: Vec<TypeRef>,
    },
    Ref(Box<TypeRef>),
    RefMut(Box<TypeRef>),
    Unit,
    Result {
        ok: Box<TypeRef>,
        err: Box<TypeRef>,
    },
}

A language-agnostic type reference.

Types are represented semantically and can be rendered differently per target language.

Variants

Primitive(PrimitiveType)

A primitive type (string, int, bool, etc.).

Optional(Box<TypeRef>)

An optional/nullable type.

Array(Box<TypeRef>)

An array/list/vector type.

Named(String)

A named type (custom struct, class, interface, etc.).

Generic

A generic type with type arguments.

Fields

base: String

Base type name (e.g., “HashMap”, “Map”, “Record”).

args: Vec<TypeRef>

Type arguments (e.g., [String, Int] for HashMap<String, i64>).

Ref(Box<TypeRef>)

A reference type (Rust: &T, others: usually no-op).

RefMut(Box<TypeRef>)

A mutable reference type (Rust: &mut T).

Unit

Unit/void type.

Result

Result type with Ok and Err types.

Fields

ok: Box<TypeRef>

The success type.

err: Box<TypeRef>

The error type.

Implementations

impl TypeRef

pub fn primitive(ty: PrimitiveType) -> Self

Create a primitive type reference.

pub fn optional(inner: TypeRef) -> Self

Create an optional type reference.

pub fn array(inner: TypeRef) -> Self

Create an array type reference.

pub fn named(name: impl Into<String>) -> Self

Create a named type reference.

pub fn generic(base: impl Into<String>, args: Vec<TypeRef>) -> Self

Create a generic type reference.

pub fn ref_(inner: TypeRef) -> Self

Create a reference type.

pub fn ref_mut(inner: TypeRef) -> Self

Create a mutable reference type.

pub fn unit() -> Self

Create a unit type.

pub fn result(ok: TypeRef, err: TypeRef) -> Self

Create a Result type.

pub fn string() -> Self

Convenience: String type.

pub fn int() -> Self

Convenience: Int type.

pub fn float() -> Self

Convenience: Float type.

pub fn bool() -> Self

Convenience: Bool type.

pub fn path() -> Self

Convenience: Path type.

pub fn duration() -> Self

Convenience: Duration type.

pub fn is_optional(&self) -> bool

Check if this type is optional.

pub fn inner_type(&self) -> Option<&TypeRef>

Get the inner type for wrapper types (Optional, Array, Ref, RefMut).

Returns None for non-wrapper types.

Trait Implementations

impl Clone for TypeRef

fn clone(&self) -> TypeRef

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TypeRef

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

Formats the value using the given formatter.

impl PartialEq for TypeRef

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

impl StructuralPartialEq for TypeRef