Enum Atomic 

pub enum Atomic {
    Length(LengthTok),
    Float(FloatTok),
    Int(IntTok),
    Literal(LiteralTok),
    True(KwTrue),
    False(KwFalse),
    Ctor(CtorTok),
    Var(VarTok),
    VarWithMod(VarWithModTok),
    OpRef(OpNameTok),
    Command {
        kw: CommandTok,
        name: AnyHorzCmdTok,
    },
    Unit {
        paren: UnitParen,
    },
    Paren {
        paren: ParenGroup<()>,
        inner: Box<ParenBody>,
    },
    OpenModule {
        grp: OpenModuleGroup<()>,
        body: Box<ParenBody>,
    },
    Record {
        rec: RecordGroup<()>,
        body: RecordBody,
    },
    List {
        list: ListGroup<()>,
        items: Vec<ListItem>,
    },
    InlineText {
        igrp: InlineGroup<()>,
        elems: Vec<InlineElem>,
    },
    BlockText {
        bgrp: BlockGroup<()>,
        elems: Vec<BlockElem>,
    },
    MathText {
        mgrp: MathGroup<()>,
        elems: Vec<MathErased>,
    },
}

nxbot (plus the ctor-head case usually found in nxun): an atomic expression.

Variants

Length(LengthTok)

Float(FloatTok)

Int(IntTok)

Literal(LiteralTok)

True(KwTrue)

False(KwFalse)

Ctor(CtorTok)

A bare constructor, e.g. None, or the head of Some 1.

Var(VarTok)

VarWithMod(VarWithModTok)

Mod.x — a module-qualified variable (VARWITHMOD).

OpRef(OpNameTok)

( ‹op› ) — a bare reference to a (possibly user-defined) operator as a first-class value, e.g. (+++), (-->) (nxbot’s LPAREN binop RPAREN alternative — the same syntax super::BindName accepts in binding position, here used as an ordinary atomic expression). Resolves via the same name BinOpTok::op_text yields, exactly like Var (elaborate.rs).

Command

command \cmd (upstream nxapp: COMMAND hcmd → UTContentOf(mods, csnm)): a first-class value that simply names an inline command’s own binding — no argument tail, so modeling it as an atom (rather than upstream’s nxapp level) is strictly simpler and covers every bundled usage (always parenthesized, e.g. (command \math)). Only the horizontal form is spelled upstream; if a package ever writes command +cmd/a math form, extend with an AnyVertCmdTok/math alternative then.

Fields

kw: CommandTok

name: AnyHorzCmdTok

Unit

()

Fields

paren: UnitParen

Paren

( expr ) or ( expr, expr, … ) (the latter elaborates to a tuple).

Fields

paren: ParenGroup<()>

inner: Box<ParenBody>

OpenModule

Mod.(e) ≡ open Mod in e (nxbot’s OPENMODULE nxlet RPAREN production). Reuses ParenBody exactly like Atomic::Paren above (so Mod.(e, e, …) would elaborate to a tuple the same way, though no bundled package writes it that way) — the Mod.( sigil is the open delimiter (OpenModuleTok, carrying the module name), closed by a plain ). Elaborated via the same machinery as Expr::OpenIn (elaborate.rs’s open_module helper).

Fields

grp: OpenModuleGroup<()>

body: Box<ParenBody>

Record

(| label = expr; … |) or (| base with label = expr; … |) (nxrecordsynt; see RecordBody).

Fields

rec: RecordGroup<()>

body: RecordBody

List

[ expr; … ]

Fields

list: ListGroup<()>

items: Vec<ListItem>

InlineText

{ inline text }

Fields

igrp: InlineGroup<()>

elems: Vec<InlineElem>

BlockText

'< block text >

Fields

bgrp: BlockGroup<()>

elems: Vec<BlockElem>

MathText

${ math } (nxbot’s BMATHGRP mathblock EMATHGRP case).

Fields

mgrp: MathGroup<()>

elems: Vec<MathErased>

Trait Implementations

impl Clone for Atomic

fn clone(&self) -> Atomic

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Atomic

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

Formats the value using the given formatter.

impl<__SyanMacro_Atom> Parse<__SyanMacro_Atom> for Atomic

where __SyanMacro_Atom: Spanned + Clone, LengthTok: Parse<__SyanMacro_Atom>, FloatTok: Parse<__SyanMacro_Atom>, IntTok: Parse<__SyanMacro_Atom>, LiteralTok: Parse<__SyanMacro_Atom>, KwTrue: Parse<__SyanMacro_Atom>, KwFalse: Parse<__SyanMacro_Atom>, CtorTok: Parse<__SyanMacro_Atom>, VarTok: Parse<__SyanMacro_Atom>, VarWithModTok: Parse<__SyanMacro_Atom>, OpNameTok: Parse<__SyanMacro_Atom>, CommandTok: Parse<__SyanMacro_Atom>, AnyHorzCmdTok: Parse<__SyanMacro_Atom>, UnitParen: Parse<__SyanMacro_Atom>, ParenGroup<()>: GroupShape<__SyanMacro_Atom>, __SyanSubstructOfOwn_paren_Atomic_Paren_7059716982297851496: Parse<__SyanMacro_Atom>, OpenModuleGroup<()>: GroupShape<__SyanMacro_Atom>, __SyanSubstructOfOwn_grp_Atomic_OpenModule_7059716982297851496: Parse<__SyanMacro_Atom>, RecordGroup<()>: GroupShape<__SyanMacro_Atom>, __SyanSubstructOfOwn_rec_Atomic_Record_7059716982297851496: Parse<__SyanMacro_Atom>, ListGroup<()>: GroupShape<__SyanMacro_Atom>, __SyanSubstructOfOwn_list_Atomic_List_7059716982297851496: Parse<__SyanMacro_Atom>, InlineGroup<()>: GroupShape<__SyanMacro_Atom>, __SyanSubstructOfOwn_igrp_Atomic_InlineText_7059716982297851496: Parse<__SyanMacro_Atom>, BlockGroup<()>: GroupShape<__SyanMacro_Atom>, __SyanSubstructOfOwn_bgrp_Atomic_BlockText_7059716982297851496: Parse<__SyanMacro_Atom>, MathGroup<()>: GroupShape<__SyanMacro_Atom>, __SyanSubstructOfOwn_mgrp_Atomic_MathText_7059716982297851496: 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 Atomic

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Atomic

impl<__SyanMacro_Atom> Unparse<__SyanMacro_Atom> for Atomic

where LengthTok: Unparse<__SyanMacro_Atom>, FloatTok: Unparse<__SyanMacro_Atom>, IntTok: Unparse<__SyanMacro_Atom>, LiteralTok: Unparse<__SyanMacro_Atom>, KwTrue: Unparse<__SyanMacro_Atom>, KwFalse: Unparse<__SyanMacro_Atom>, CtorTok: Unparse<__SyanMacro_Atom>, VarTok: Unparse<__SyanMacro_Atom>, VarWithModTok: Unparse<__SyanMacro_Atom>, OpNameTok: Unparse<__SyanMacro_Atom>, CommandTok: Unparse<__SyanMacro_Atom>, AnyHorzCmdTok: Unparse<__SyanMacro_Atom>, UnitParen: Unparse<__SyanMacro_Atom>, ParenGroup<()>: GroupUnparse<__SyanMacro_Atom>, for<'syan_substruct_ref> __SyanSubstructOfRef_paren_Atomic_Paren_7059716982297851496<'syan_substruct_ref>: Unparse<__SyanMacro_Atom>, OpenModuleGroup<()>: GroupUnparse<__SyanMacro_Atom>, for<'syan_substruct_ref> __SyanSubstructOfRef_grp_Atomic_OpenModule_7059716982297851496<'syan_substruct_ref>: Unparse<__SyanMacro_Atom>, RecordGroup<()>: GroupUnparse<__SyanMacro_Atom>, for<'syan_substruct_ref> __SyanSubstructOfRef_rec_Atomic_Record_7059716982297851496<'syan_substruct_ref>: Unparse<__SyanMacro_Atom>, ListGroup<()>: GroupUnparse<__SyanMacro_Atom>, for<'syan_substruct_ref> __SyanSubstructOfRef_list_Atomic_List_7059716982297851496<'syan_substruct_ref>: Unparse<__SyanMacro_Atom>, InlineGroup<()>: GroupUnparse<__SyanMacro_Atom>, for<'syan_substruct_ref> __SyanSubstructOfRef_igrp_Atomic_InlineText_7059716982297851496<'syan_substruct_ref>: Unparse<__SyanMacro_Atom>, BlockGroup<()>: GroupUnparse<__SyanMacro_Atom>, for<'syan_substruct_ref> __SyanSubstructOfRef_bgrp_Atomic_BlockText_7059716982297851496<'syan_substruct_ref>: Unparse<__SyanMacro_Atom>, MathGroup<()>: GroupUnparse<__SyanMacro_Atom>, for<'syan_substruct_ref> __SyanSubstructOfRef_mgrp_Atomic_MathText_7059716982297851496<'syan_substruct_ref>: Unparse<__SyanMacro_Atom>,

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