Enum TypeExpr 

pub enum TypeExpr {
    Named {
        name: String,
        args: Vec<TypeExpr>,
        span: ExprSpan,
    },
    Array {
        element: Box<TypeExpr>,
        span: ExprSpan,
    },
    Tuple {
        elements: Vec<TypeExpr>,
        span: ExprSpan,
    },
}

type_expr = identifier | "(" [ type_expr ["," [ type_expr { "," type_expr } ]] ] ")".

() is the empty tuple type (0 elements); (T) is grouping (same as bare T — types have no precedence to disambiguate, but staying symmetric with cel_parser’s expression grammar costs nothing); (T,) is a 1-element tuple; (T, U, ...) is n-element, no trailing comma. Shared verbatim with cel_parser (which additionally supports [T] array types and Name(args) parameterized/generic types) so both crates resolve, format, and error on exactly one type-expression grammar. type_expression = identifier [ "(" [ type_expression { "," type_expression } ] ")" ] | "[" type_expression "]" | "(" [ type_expression ["," [ type_expression { "," type_expression } ]] ] ")".

() is the empty tuple type (0 elements); (T) is grouping (same as bare T); (T,) is a 1-element tuple; (T, U, ...) is n-element, no trailing comma. [T] names a rank-one array whose elements have type T; nested brackets compose recursively. Name(A, B) names a parameterized (generic) type applying zero or more type arguments (RangeInclusive(f64), RangeFull()); an identifier immediately followed by ( has no other meaning in type position, so this is unambiguous with adjacent tuple-grouping syntax. Fn((A, B), R) reserves structural callable syntax: the first argument must be a tuple of parameter types and the second is the result. Fn((), R) has no parameters; Fn((A,), R) has one. This syntax is resolved before host generic-leaf lookup.

Variants

Named

A single type name, optionally applying type arguments, resolved later through a [TypeResolver].

Fields

name: String

The unresolved type name, exactly as written.

args: Vec<TypeExpr>

Type arguments, e.g. f64 in RangeInclusive(f64). Empty for a plain name.

span: ExprSpan

The source span of the full name token, including any parenthesized argument list.

Array

A recursively nested array type expression ([T]).

Fields

element: Box<TypeExpr>

The element type expression.

span: ExprSpan

The span of the whole bracketed type.

Tuple

A recursively nested tuple type expression.

Fields

elements: Vec<TypeExpr>

The tuple element type expressions, in source order.

span: ExprSpan

The span of the whole parenthesized type.

Implementations

impl TypeExpr

pub fn span(&self) -> ExprSpan

Returns this type expression’s source span.

pub fn resolve( &self, resolver: &dyn TypeResolver, ) -> Result<ResolvedType, ParseError>

Resolves every named leaf through resolver, preserving the recursive type shape.

Errors

Returns Err if some named leaf is not recognized by resolver, or Fn lacks exactly two arguments with a tuple of parameter types first.

• Complexity: O(n) in the number of nodes in this type tree.

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<(), Error>

Formats the value using the given formatter.