Enum TypeExpr 

pub enum TypeExpr {
    Named(Ident),
    Unit(Span),
    Never(Span),
    Array {
        element: Box<TypeExpr>,
        length: u64,
        span: Span,
    },
    AnonymousStruct {
        directives: Directives,
        posture: Posture,
        fields: Vec<AnonStructField>,
        methods: Vec<Method>,
        span: Span,
    },
    AnonymousEnum {
        directives: Directives,
        posture: Posture,
        variants: Vec<EnumVariant>,
        methods: Vec<Method>,
        span: Span,
    },
    AnonymousInterface {
        methods: Vec<MethodSig>,
        span: Span,
    },
    TypeCall {
        callee: Ident,
        args: Vec<TypeExpr>,
        span: Span,
    },
    Tuple {
        elems: Vec<TypeExpr>,
        span: Span,
    },
}

A type expression in the AST.

Variants

Named(Ident)

A simple named type (e.g., i32, bool, MyStruct)

Unit(Span)

Unit type: ()

Never(Span)

Never type: !

Array

Array type: [T; N] where T is the element type and N is the length

Fields

element: Box<TypeExpr>

length: u64

span: Span

AnonymousStruct

Anonymous struct type: struct { field: Type, fn method(…) { … }, … } Used in comptime type construction (e.g., fn Pair(comptime T: type) -> type { struct { first: T, second: T } }) Methods can be included inside the struct definition (Zig-style).

Fields

directives: Directives

Directives applied to the struct expression (e.g., @derive(...), ADR-0058). Parsed before the struct keyword.

posture: Posture

Declared ownership posture (ADR-0080). Affine when neither @mark(copy) nor @mark(linear) appears in the directive list.

fields: Vec<AnonStructField>

Field declarations (name and type)

methods: Vec<Method>

Method definitions inside the anonymous struct

span: Span

AnonymousEnum

Anonymous enum type: enum { Variant, Variant(T), Variant { field: T }, fn method(…) { … }, … } Used in comptime type construction (e.g., fn Option(comptime T: type) -> type { enum { Some(T), None } }) Methods can be included inside the enum definition (Zig-style).

Fields

directives: Directives

Directives applied to the enum expression (ADR-0058).

posture: Posture

Declared ownership posture (ADR-0080). Affine when neither @mark(copy) nor @mark(linear) appears in the directive list.

variants: Vec<EnumVariant>

Enum variants

methods: Vec<Method>

Method definitions inside the anonymous enum

span: Span

AnonymousInterface

Anonymous interface type: interface { fn name(self) [-> T]; … } (ADR-0057) — comptime-constructed interface type, parallel to AnonymousStruct and AnonymousEnum. Used inside fn ... -> type bodies to build parameterized interfaces.

Fields

methods: Vec<MethodSig>

Required method signatures (no bodies, no associated functions).

span: Span

TypeCall

Parameterized type call (ADR-0057): Name(arg1, arg2, ...) used in type position to invoke a comptime function returning type. Resolves at sema time by evaluating the call at comptime.

Fields

callee: Ident

The function being called (e.g. Sized).

args: Vec<TypeExpr>

Type-or-expression arguments. Currently restricted to type expressions; expressions like integer literals can be added when comptime value parameters become common at type positions.

span: Span

Tuple

Tuple type: (T,), (T, U), (T, U, V), … (ADR-0048)

() remains the unit type. A 1-tuple requires a trailing comma ((T,)) to distinguish it from a parenthesised type.

Fields

elems: Vec<TypeExpr>

span: Span

Implementations

impl TypeExpr

pub fn span(&self) -> Span

Get the span of this type expression.

Trait Implementations

impl Clone for TypeExpr

fn clone(&self) -> TypeExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TypeExpr

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TypeExpr

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for TypeExpr

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

Formats the value using the given formatter.

impl PartialEq for TypeExpr

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for TypeExpr

impl StructuralPartialEq for TypeExpr