Enum SigExpr 

pub enum SigExpr {
    Functor {
        lp: LParenTok,
        param: CtorTok,
        colon: ColonTok,
        dom: Box<SigExpr>,
        rp: RParenTok,
        arrow: ArrowTok,
        cod: Box<SigExpr>,
    },
    WithType {
        base: SigBotV1,
        with_kw: KwWith,
        path: Option<ModChainV1>,
        type_kw: KwType,
        binds: TypeBindsErasedV1,
    },
    Bot(SigBotV1),
}

sigexpr (parser_v1.mly:558-573). SELF-LOOP ROOT: Functor.dom/ Functor.cod: Box<SigExpr> (:570-571).

Left-recursion note (load-bearing). The naive sketch would write With { base: Box<SigExpr>, … } — as a syan2 ordered-choice production that is LEFT RECURSION (SigExpr would begin by parsing SigExpr; syan2 gives no diagnostic, it just recurses/fails at parse time — a known consumer hazard). Upstream is not left-recursive: the with base is sigexpr_bot (:559,564) and with cannot chain (the result of a with is never itself a valid with base). So the faithful encoding is bot + one optional-shaped suffix arm, tried before the bare-bot fallthrough: S with type t = int with type u = bool is a parse error here exactly as upstream (pinned in tests). NO arm of this enum may ever begin with Box<SigExpr>/SigExpr as its first field — reviewer checklist item.

Variants

Functor

( UPPER : sigexpr ) ARROW sigexpr (:570-571) — the functor signature. (-headed; no SigBotV1 starts with (, so this is token-disjoint from the other arms.

Fields

lp: LParenTok

param: CtorTok

colon: ColonTok

dom: Box<SigExpr>

rp: RParenTok

arrow: ArrowTok

cod: Box<SigExpr>

WithType

sigexpr_bot WITH TYPE bind_type (:559-563) / sigexpr_bot WITH mod_chain TYPE bind_type (:564-569). The Option<ModChainV1> is greedy-then-backtrack: on with type the chain fails (type is a keyword token, not UPPER/LONG_UPPER) and collapses to None. binds goes through super::TypeBindsErasedV1.

Fields

base: SigBotV1

with_kw: KwWith

path: Option<ModChainV1>

type_kw: KwType

binds: TypeBindsErasedV1

Bot(SigBotV1)

A bare sigexpr_bot (:572-573). Must come after SigExpr::WithType (maximal munch of the with suffix).

Trait Implementations

impl Clone for SigExpr

fn clone(&self) -> SigExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SigExpr

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

Formats the value using the given formatter.

impl<__SyanMacro_Atom> Parse<__SyanMacro_Atom> for SigExpr

where __SyanMacro_Atom: Spanned + Clone, LParenTok: Parse<__SyanMacro_Atom>, CtorTok: Parse<__SyanMacro_Atom>, ColonTok: Parse<__SyanMacro_Atom>, RParenTok: Parse<__SyanMacro_Atom>, ArrowTok: Parse<__SyanMacro_Atom>, SigBotV1: Parse<__SyanMacro_Atom>, KwWith: Parse<__SyanMacro_Atom>, Option<ModChainV1>: Parse<__SyanMacro_Atom>, KwType: Parse<__SyanMacro_Atom>, TypeBindsErasedV1: Parse<__SyanMacro_Atom>, Self: ParseRanked8909385c15d27adc<(((),),), __SyanMacro_Atom>,

type Error = <SigExpr 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 SigExpr

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for SigExpr

impl<__SyanMacro_Atom> Unparse<__SyanMacro_Atom> for SigExpr

where LParenTok: Unparse<__SyanMacro_Atom>, CtorTok: Unparse<__SyanMacro_Atom>, ColonTok: Unparse<__SyanMacro_Atom>, RParenTok: Unparse<__SyanMacro_Atom>, ArrowTok: Unparse<__SyanMacro_Atom>, SigBotV1: Unparse<__SyanMacro_Atom>, KwWith: Unparse<__SyanMacro_Atom>, Option<ModChainV1>: Unparse<__SyanMacro_Atom>, KwType: Unparse<__SyanMacro_Atom>, TypeBindsErasedV1: 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>