Enum ModExpr 

pub enum ModExpr {
    Functor {
        fun_kw: KwFun,
        lp: LParenTok,
        param: CtorTok,
        colon: ColonTok,
        dom: Box<SigExpr>,
        rp: RParenTok,
        arrow: ArrowTok,
        body: Box<ModExpr>,
    },
    Coerce {
        name: CtorTok,
        coerce: CoerceTok,
        sig_: Box<SigExpr>,
    },
    App {
        func: ModChainV1,
        arg: ModChainV1,
    },
    Var(ModChainV1),
    Struct {
        struct_kw: KwStruct,
        binds: Vec<StructBindV1>,
        end_kw: KwEnd,
    },
}

modexpr (parser_v1.mly:380-403). SELF-LOOP ROOT: Functor.body: Box<ModExpr> (:381-382). Variant order is parse priority: Functor (fun-headed) and Struct (struct-headed) are keyword-disjoint from everything; Coerce (UPPER :>) must precede App/Var so the :> suffix is claimed before a bare chain matches; App (two chains, modexpr_app :388-394) precedes Var (one chain, modexpr_bot :398-400) for longest-match. Struct bodies go through super::StructBindV1 (the struct-body connector, erased), so ModExpr never statically references super::Bind — see the module doc comment’s SCC story.

Variants

Functor

FUN ( UPPER : sigexpr ) ARROW modexpr (parser_v1.mly:381-382).

Fields

fun_kw: KwFun

lp: LParenTok

param: CtorTok

colon: ColonTok

dom: Box<SigExpr>

rp: RParenTok

arrow: ArrowTok

body: Box<ModExpr>

Coerce

UPPER COERCE sigexpr (:383-384) — coercion applies to a BARE module name only, upstream-faithfully (A.B :> S is a parse error there too).

Fields

name: CtorTok

coerce: CoerceTok

sig_: Box<SigExpr>

App

mod_chain mod_chain — functor application (:389-394).

Fields

func: ModChainV1

arg: ModChainV1

Var(ModChainV1)

mod_chain — a (possibly long) module path (:399-400).

Struct

STRUCT list(bind) END (:401-402) — the only form v1/lower.rs gives real semantics to; reuses the struct-body connector.

Fields

struct_kw: KwStruct

binds: Vec<StructBindV1>

end_kw: KwEnd

Trait Implementations

impl Clone for ModExpr

fn clone(&self) -> ModExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ModExpr

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

Formats the value using the given formatter.

impl<__SyanMacro_Atom> Parse<__SyanMacro_Atom> for ModExpr

where __SyanMacro_Atom: Spanned + Clone, KwFun: Parse<__SyanMacro_Atom>, LParenTok: Parse<__SyanMacro_Atom>, CtorTok: Parse<__SyanMacro_Atom>, ColonTok: Parse<__SyanMacro_Atom>, RParenTok: Parse<__SyanMacro_Atom>, ArrowTok: Parse<__SyanMacro_Atom>, CoerceTok: Parse<__SyanMacro_Atom>, ModChainV1: Parse<__SyanMacro_Atom>, KwStruct: Parse<__SyanMacro_Atom>, Vec<StructBindV1>: Parse<__SyanMacro_Atom>, KwEnd: 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 = <ModExpr 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 ModExpr

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ModExpr

impl<__SyanMacro_Atom> Unparse<__SyanMacro_Atom> for ModExpr

where KwFun: Unparse<__SyanMacro_Atom>, LParenTok: Unparse<__SyanMacro_Atom>, CtorTok: Unparse<__SyanMacro_Atom>, ColonTok: Unparse<__SyanMacro_Atom>, RParenTok: Unparse<__SyanMacro_Atom>, ArrowTok: Unparse<__SyanMacro_Atom>, CoerceTok: Unparse<__SyanMacro_Atom>, ModChainV1: Unparse<__SyanMacro_Atom>, KwStruct: Unparse<__SyanMacro_Atom>, Vec<StructBindV1>: Unparse<__SyanMacro_Atom>, KwEnd: 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>