Enum TypeApp 

pub enum TypeApp {
    InlineCmdTy {
        kw: KwInline,
        ilist: ListGroup<()>,
        args: Vec<TypeCmdArgItemV1>,
    },
    BlockCmdTy {
        kw: KwBlock,
        blist: ListGroup<()>,
        args: Vec<TypeCmdArgItemV1>,
    },
    MathCmdTy {
        kw: KwMath,
        mlist: ListGroup<()>,
        args: Vec<TypeCmdArgItemV1>,
    },
    AppliedLong {
        ctor: VarWithModTok,
        first: TypeAtom,
        rest: Vec<TypeAtom>,
    },
    Applied {
        ctor: VarTok,
        first: TypeAtom,
        rest: Vec<TypeAtom>,
    },
    Atom(TypeAtom),
}

typ_app (parser_v1.mly:711-739). 0.1 delta from crate::cst::ast::TypeApp (cst.rs:1297-1312): application is PREFIX and n-ary (list int, pair int bool), not 0.0.6’s postfix single-argument (int list) — the prefix→postfix bridge (with an arity-1 guard: arity ≥ 2 is a LowerError, not a parse error) lives in v1/lower.rs. Applied/AppliedLong (needing at least one argument atom) are tried before Atom — a bare name has no argument atom to consume and falls through cleanly (a following keyword/=/and/->/* never parses as a TypeAtom).

Four further arms are keyword- or token-headed and so disjoint from Applied/Atom’s VarTok-headed shapes (ordering them BEFORE those is cosmetic, not load-bearing):

• TypeApp::InlineCmdTy/TypeApp::BlockCmdTy/ TypeApp::MathCmdTy: inline [τ, …]/ block [τ, …]/math [τ, …] command types (parser.mly:730-735, typ_cmd_arg :763-774; math […]: parser.mly:830-831), KwInline/KwBlock/KwMath-headed (all three are V0_1 keywords already — val inline/val block binds; math since the math-split). One deliberate superset of upstream remains: each bracketed slot is a full super::TyErasedV1 (TypeExpr), not upstream’s narrower typ_prod. The ?(label: τ, …) optional-labeled-slot prefix is modeled — see TypeCmdArgItemV1::opts; MathCmdTy reuses TypeCmdArgItemV1 as-is, so math [?(l : τ) …] sig rows come for free.
• AppliedLong: M.t τ… — the LONG_LOWER qualified-head twin of Applied (parser.mly:720-728, LONG_LOWER lexer.mll:318), VarWithModTok-headed (lexed by the program-mode capital-head scan, lexer.rs:753-777). Needed to NAME an abstract type from outside its sealing module — without it, an opaque M.t could never appear in another module’s signature at all.

Variants

InlineCmdTy

inline [τ, …] — see the enum doc comment.

Fields

kw: KwInline

ilist: ListGroup<()>

args: Vec<TypeCmdArgItemV1>

BlockCmdTy

block [τ, …] — see the enum doc comment.

Fields

kw: KwBlock

blist: ListGroup<()>

args: Vec<TypeCmdArgItemV1>

MathCmdTy

math [τ, …] (upstream parser.mly:830-831 MATH L_SQUARE optterm_list(COMMA, typ_cmd_arg) R_SQUARE → MMathCommandType(mncmdargtys) — same typ_cmd_arg as inline/block). KwMath-headed, so this arm is disjoint from Applied/Atom and ambiguity-free: a bare math can never lex as a VarTok under V0_1 at all.

Fields

kw: KwMath

mlist: ListGroup<()>

args: Vec<TypeCmdArgItemV1>

AppliedLong

M.t τ… — see the enum doc comment. Mirrors Applied’s n-ary shape (v1/lower.rs’s prefix→postfix bridge rejects arity ≥ 2 identically for both).

Fields

ctor: VarWithModTok

first: TypeAtom

rest: Vec<TypeAtom>

Applied

Fields

ctor: VarTok

first: TypeAtom

rest: Vec<TypeAtom>

Atom(TypeAtom)

Trait Implementations

impl Clone for TypeApp

fn clone(&self) -> TypeApp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TypeApp

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

Formats the value using the given formatter.

impl<__SyanMacro_Atom> Parse<__SyanMacro_Atom> for TypeApp

where __SyanMacro_Atom: Spanned + Clone, KwInline: Parse<__SyanMacro_Atom>, ListGroup<()>: GroupShape<__SyanMacro_Atom>, __SyanSubstructOfOwn_ilist_TypeApp_InlineCmdTy_17677086792962917609: Parse<__SyanMacro_Atom>, KwBlock: Parse<__SyanMacro_Atom>, __SyanSubstructOfOwn_blist_TypeApp_BlockCmdTy_17677086792962917609: Parse<__SyanMacro_Atom>, KwMath: Parse<__SyanMacro_Atom>, __SyanSubstructOfOwn_mlist_TypeApp_MathCmdTy_17677086792962917609: Parse<__SyanMacro_Atom>, VarWithModTok: Parse<__SyanMacro_Atom>, TypeAtom: Parse<__SyanMacro_Atom>, Vec<TypeAtom>: Parse<__SyanMacro_Atom>, VarTok: Parse<__SyanMacro_Atom>,

type Error = ParseError<<__SyanMacro_Atom as Spanned>::Span>

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 TypeApp

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for TypeApp

impl<__SyanMacro_Atom> Unparse<__SyanMacro_Atom> for TypeApp

where KwInline: Unparse<__SyanMacro_Atom>, ListGroup<()>: GroupUnparse<__SyanMacro_Atom>, for<'syan_substruct_ref> __SyanSubstructOfRef_ilist_TypeApp_InlineCmdTy_17677086792962917609<'syan_substruct_ref>: Unparse<__SyanMacro_Atom>, KwBlock: Unparse<__SyanMacro_Atom>, for<'syan_substruct_ref> __SyanSubstructOfRef_blist_TypeApp_BlockCmdTy_17677086792962917609<'syan_substruct_ref>: Unparse<__SyanMacro_Atom>, KwMath: Unparse<__SyanMacro_Atom>, for<'syan_substruct_ref> __SyanSubstructOfRef_mlist_TypeApp_MathCmdTy_17677086792962917609<'syan_substruct_ref>: Unparse<__SyanMacro_Atom>, VarWithModTok: Unparse<__SyanMacro_Atom>, TypeAtom: Unparse<__SyanMacro_Atom>, Vec<TypeAtom>: Unparse<__SyanMacro_Atom>, VarTok: Unparse<__SyanMacro_Atom>,

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