Enum TypeExpr 

pub enum TypeExpr {
    OptRowFun {
        opt_dom: TypeOptDomV1,
        dom: TypeProd,
        arrow: ArrowTok,
        cod: Box<TypeExpr>,
    },
    Fun {
        dom: TypeProd,
        arrow: ArrowTok,
        cod: Box<TypeExpr>,
    },
    Atom(TypeProd),
}

A type-expression grammar (typ/typ_prod/typ_app/typ_bot, parser_v1.mly:685-752, simplified — same scope as crate::cst::ast::TypeExpr). Spells products (length * length, TypeProd) and prefix type application (list int, TypeApp) — without them a type bind could declare almost nothing — plus the ?(…) labeled-optional domain prefix (TypeExpr::OptRowFun), where a row-variable TAIL (?(… | ?'r) ->) parses but is rejected at lowering (it needs signature-level row quantification, not yet implemented). Self-recursive only through Fun’s/OptRowFun’s codomain (right recursion); parenthesized nesting goes through super::TyErasedV1.

Variants

OptRowFun

?(l : ty, … [| ?'r]) dom -> cod (typ :688-693, typ_opt_dom :753-758). ?-headed — neither Fun/Atom (headed by TypeProd) can start with OptionalTypeTok, so declared order relative to them is safety-neutral; declared first to mirror the upstream typ production order. Lowered (v1/lower.rs) to cst::ast::TypeExpr::OptRowFun, thence (typecheck.rs) to MonoType::Func(Row::Cons(l1, ty1, … Row::Empty), dom, cod) — a CLOSED row, matching what Ast::LambdaOpt infers, so an explicit ?(l:τ)-> signature unifies against an actual ?(l=x)-taking function.

Fields

opt_dom: TypeOptDomV1

dom: TypeProd

arrow: ArrowTok

cod: Box<TypeExpr>

Fun

dom -> cod (right-associative). This field is TypeExpr’s own self-loop (the root SCC). dom widened from TypeAtom to TypeProd so e.g. 'a option -> 'b option and 'a * 'b -> 'c both parse at their expected precedence.

Fields

dom: TypeProd

arrow: ArrowTok

cod: Box<TypeExpr>

Atom(TypeProd)

The non-arrow fallthrough — widened from TypeAtom to TypeProd: a product/application with no enclosing arrow is still just “the whole type expression minus ->”.

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<__SyanMacro_Atom> Parse<__SyanMacro_Atom> for TypeExpr

where __SyanMacro_Atom: Spanned + Clone, TypeOptDomV1: Parse<__SyanMacro_Atom>, TypeProd: Parse<__SyanMacro_Atom>, ArrowTok: Parse<__SyanMacro_Atom>, Self: ParseRanked8909385c15d27adc<(((),),), __SyanMacro_Atom>,

type Error = <TypeExpr as ParseRanked8909385c15d27adc<(((),),), __SyanMacro_Atom>>::Error

Every error must be convertible to the universal one, so a field’s failure can become the enclosing type’s failure with no per-field where-predicate. Stating it HERE rather than at each derived impl is what keeps it out of the obligation graph: a per-field <FieldTy as Parse<Atom>>::Error: Into<…> predicate re-creates a projection cycle on a recursive field (E0275), which decycle’s bound-peeling does not break.

fn parse_stream<__SyanMacro_S: ParseStream<Atom = __SyanMacro_Atom>>( __syan_stream: &mut __SyanMacro_S, ) -> Result<Self, Self::Error>

Parse from a reborrowable stream.

fn parse(stream: impl IntoParseStream<Atom = Atom>) -> Result<Self, Self::Error>

Parse from anything that can become a stream — String, TokenStream, an existing stream.

fn attempt(self) -> Attempt<Self>

Wrap this value in Attempt, the atomic-parse marker: parsing an Attempt<Self> parses Self but rewinds the stream on failure (it requires Atom: Clone). This is the value constructor; value.attempt() is sugar for Attempt(value).

impl PartialEq for TypeExpr

fn eq(&self, other: &TypeExpr) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for TypeExpr

impl<__SyanMacro_Atom> Unparse<__SyanMacro_Atom> for TypeExpr

where TypeOptDomV1: Unparse<__SyanMacro_Atom>, TypeProd: Unparse<__SyanMacro_Atom>, ArrowTok: Unparse<__SyanMacro_Atom>, Self: UnparseRanked8909385c15d27adc<(((),),), __SyanMacro_Atom>,

fn unparse<__Syan_Emitter: Emitter<__SyanMacro_Atom>>( &self, __syan_sink: &mut __Syan_Emitter, ) -> Result<(), <__Syan_Emitter as Emitter<__SyanMacro_Atom>>::Error>