Enum TypeExpr 

pub enum TypeExpr {
    Primitive {
        kind: PrimType,
        span: Span,
    },
    Named {
        name: String,
        span: Span,
    },
    Array {
        elem: Box<TypeExpr>,
        size: u64,
        span: Span,
    },
    DynArray {
        elem: Box<TypeExpr>,
        span: Span,
    },
    Tuple {
        elems: Vec<TypeExpr>,
        span: Span,
    },
    Fn {
        params: Vec<TypeExpr>,
        ret: Box<TypeExpr>,
        span: Span,
    },
    Generic {
        name: String,
        args: Vec<TypeExpr>,
        span: Span,
    },
}

a type as written in source: a primitive name, a named type, a fixed or dynamic array, a tuple, a function type, or a generic application. type expressions appear in parameter and return positions, struct fields, enum variant data, and let x: T = ....

Variants

Primitive

a primitive type name: i64, f64, bool, str, byte, void.

Fields

kind: PrimType

span: Span

Named

a named type – a struct, enum, or interface name (the parser does not distinguish; Phase 3 resolves it).

Fields

name: String

span: Span

Array

[ elem; size ] – a fixed-size array. size is the literal length.

Fields

elem: Box<TypeExpr>

size: u64

span: Span

DynArray

[ elem ] – a dynamic array.

Fields

elem: Box<TypeExpr>

span: Span

Tuple

( T1, T2, ... ) – a tuple type.

Fields

elems: Vec<TypeExpr>

span: Span

Fn

fn( T1, T2 ) -> T3 – a function type.

Fields

params: Vec<TypeExpr>

ret: Box<TypeExpr>

span: Span

Generic

Name< T1, T2 > – a generic application (used by Result<T, E> and Option<T>). the parser allows it on any name; restricting which names may be generic is Phase 3’s job.

Fields

name: String

args: Vec<TypeExpr>

span: Span

Implementations

impl TypeExpr

pub fn span(&self) -> Span

the source span of this type expression.

every variant carries its span field; the match is exhaustive, the proof every type node has one.

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 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 StructuralPartialEq for TypeExpr