Enum TypeExpr 

pub enum TypeExpr<'a> {
    Simple(&'a str, Vec<TypeExprParam<'a>>, bool),
    UserDefined(&'a str, Vec<TypeExprParam<'a>>, bool),
    TypeVariable(u32, bool),
}

Available on crate feature parse only.

A parsed type expression from a type string, with lifetime tied to the original string.

This represents the syntactic structure only - type names are not validated. Convert to ConcreteType for semantic validation.

Variants

Simple(&'a str, Vec<TypeExprParam<'a>>, bool)

A type without the u! prefix (expected to be a builtin like i32, List, etc.)

Contains: (name, parameters, nullable)

UserDefined(&'a str, Vec<TypeExprParam<'a>>, bool)

A user-defined extension type with the u! prefix (e.g., u!geometry)

Contains: (name without u! prefix, parameters, nullable)

TypeVariable(u32, bool)

Type variable (e.g., any1, any2)

Contains: (variable id, nullable)

Implementations

impl<'a> TypeExpr<'a>

pub fn parse(type_str: &'a str) -> Result<Self, TypeParseError>

Parse a type string into a TypeExpr.

pub fn visit_references<F>(&self, on_ext: &mut F)

where F: FnMut(&str),

Visit all extension type references contained in a parsed type, calling on_ext for each encountered extension name (including named extension forms).

Trait Implementations

impl<'a> Clone for TypeExpr<'a>

fn clone(&self) -> TypeExpr<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for TypeExpr<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for TypeExpr<'a>

fn eq(&self, other: &TypeExpr<'a>) -> 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<'a> TryFrom<TypeExpr<'a>> for ConcreteType

type Error = ExtensionTypeError

The type returned in the event of a conversion error.

fn try_from(parsed_type: TypeExpr<'a>) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> StructuralPartialEq for TypeExpr<'a>