Enum TypeExpr 

pub enum TypeExpr {
    Path(TypePath),
    Reference {
        mutable: bool,
        inner: Box<TypeExpr>,
    },
    Pointer {
        mutable: bool,
        inner: Box<TypeExpr>,
    },
    Array {
        element: Box<TypeExpr>,
        size: Box<Expr>,
    },
    Slice(Box<TypeExpr>),
    Tuple(Vec<TypeExpr>),
    Function {
        params: Vec<TypeExpr>,
        return_type: Option<Box<TypeExpr>>,
    },
    Evidential {
        inner: Box<TypeExpr>,
        evidentiality: Evidentiality,
        error_type: Option<Box<TypeExpr>>,
    },
    Cycle {
        modulus: Box<Expr>,
    },
    Simd {
        element: Box<TypeExpr>,
        lanes: u8,
    },
    Atomic(Box<TypeExpr>),
    Never,
    Infer,
}

Type expressions.

Variants

Path(TypePath)

Simple named type: i32, String

Reference

Reference: &T, &mut T

Fields

mutable: bool

inner: Box<TypeExpr>

Pointer

Pointer: *const T, *mut T

Fields

mutable: bool

inner: Box<TypeExpr>

Array

Array: [T; N]

Fields

element: Box<TypeExpr>

size: Box<Expr>

Slice(Box<TypeExpr>)

Slice: [T]

Tuple(Vec<TypeExpr>)

Tuple: (A, B, C)

Function

Function: fn(A, B) -> C

Fields

params: Vec<TypeExpr>

return_type: Option<Box<TypeExpr>>

Evidential

With evidentiality: T!, T?, T~, or with error type: T?[Error], T![Error] The error type syntax is sugar for Result<T, Error> with evidentiality tracking:

• T?[E] means Result<T, E> with uncertain evidentiality
• T![E] means Result<T, E> with known/infallible path
• T~[E] means Result<T, E> from external/reported source

Fields

inner: Box<TypeExpr>

evidentiality: Evidentiality

error_type: Option<Box<TypeExpr>>

Optional error type for Result sugar: T?[ErrorType]

Cycle

Cycle type: Cycle<N>

Fields

modulus: Box<Expr>

Simd

SIMD vector type: simd<f32, 4>, Vec4f

Fields

element: Box<TypeExpr>

lanes: u8

Atomic(Box<TypeExpr>)

Atomic type: atomic<T>

Never

Never type: ! or never

Infer

Inferred: _

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