Enum TypeExpr 

pub enum TypeExpr {
    Path(TypePath),
    Reference {
        lifetime: Option<String>,
        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,
    Lifetime(String),
    TraitObject(Vec<TypeExpr>),
    Hrtb {
        lifetimes: Vec<String>,
        bound: Box<TypeExpr>,
    },
    InlineStruct {
        fields: Vec<FieldDef>,
    },
    InlineEnum {
        variants: Vec<EnumVariant>,
    },
    ImplTrait(Vec<TypeExpr>),
    AssocTypeBinding {
        name: Ident,
        ty: Box<TypeExpr>,
    },
    ConstExpr(Box<Expr>),
    Linear(Box<TypeExpr>),
    Affine(Box<TypeExpr>),
    Relevant(Box<TypeExpr>),
    QualifiedPath {
        self_type: Box<TypeExpr>,
        trait_path: Option<TypePath>,
        item_path: TypePath,
    },
}

Type expressions.

Variants

Path(TypePath)

Simple named type: i32, String

Reference

Reference: &T, &mut T, &'a T, &'static mut T

Fields

lifetime: Option<String>

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: _

Lifetime(String)

Lifetime bound: 'static, 'a

TraitObject(Vec<TypeExpr>)

Trait object: dyn Trait or dyn Trait + Send + 'static

Hrtb

Higher-ranked trait bound: for<'a> Trait<'a>

Fields

lifetimes: Vec<String>

bound: Box<TypeExpr>

InlineStruct

Inline struct type: struct { field: Type, ... }

Fields

fields: Vec<FieldDef>

InlineEnum

Inline enum type: enum { Variant1, Variant2(Type), ... }

Fields

variants: Vec<EnumVariant>

ImplTrait(Vec<TypeExpr>)

Impl trait: impl Trait, impl Fn() -> R

AssocTypeBinding

Associated type binding: Output = Type used in trait bounds

Fields

name: Ident

ty: Box<TypeExpr>

ConstExpr(Box<Expr>)

Const expression in type position (for const generics): <32>, <{N + 1}>

Linear(Box<TypeExpr>)

Linear type: linear T - must be used exactly once (no-cloning)

Affine(Box<TypeExpr>)

Affine type: affine T - can be used at most once (may be dropped)

Relevant(Box<TypeExpr>)

Relevant type: relevant T - can be used at least once (may be cloned)

QualifiedPath

Qualified path type: <Type as Trait>::AssociatedType Also supports <Type>::Associated for inherent associated types

Fields

self_type: Box<TypeExpr>

The base type: Type in <Type as Trait>::...

trait_path: Option<TypePath>

Optional trait bound: Trait in <Type as Trait>::...

item_path: TypePath

The associated item path: AssociatedType or Associated::Nested

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