Enum Node 

pub enum Node {
    Root {
        children: Vec<NodeId>,
        mode: ContentMode,
    },
    Group {
        children: Vec<NodeId>,
        kind: GroupKind,
        mode: ContentMode,
    },
    Command {
        name: String,
        args: Vec<ArgumentSlot>,
        known: bool,
    },
    Infix {
        name: String,
        args: Vec<ArgumentSlot>,
        left: NodeId,
        right: NodeId,
    },
    Declarative {
        name: String,
        args: Vec<ArgumentSlot>,
    },
    Environment {
        name: String,
        args: Vec<ArgumentSlot>,
        known: bool,
        body: NodeId,
    },
    Scripted {
        base: NodeId,
        subscript: Option<NodeId>,
        superscript: Option<NodeId>,
    },
    Prime {
        count: usize,
    },
    Text(String),
    Char(char),
    ActiveSpace,
    Error {
        message: String,
        snippet: String,
    },
}

Mutable AST node stored inside Ast.

Variants

Root

Main document root containing top-level children and parse mode.

Fields

children: Vec<NodeId>

Ordered direct children of the root

mode: ContentMode

Content mode used to parse the formula

Group

Group node containing ordered children and mode metadata.

Fields

children: Vec<NodeId>

Ordered direct children of the group

kind: GroupKind

Source-level grouping form

mode: ContentMode

Content mode used to parse the group

Command

Prefix command with argument slots.

Fields

name: String

Command name without leading backslash

args: Vec<ArgumentSlot>

Slots defined by the matched command spec

known: bool

Whether this name is present in the knowledge base.

Infix

Infix command with explicit left and right operands.

Fields

name: String

Command name without leading backslash

args: Vec<ArgumentSlot>

Additional argument slots owned by the infix node

left: NodeId

Left operand subtree

right: NodeId

Right operand subtree

Declarative

Declarative command with explicit argument slots.

Fields

name: String

Command name without leading backslash

args: Vec<ArgumentSlot>

Additional argument slots owned by the declarative node

Environment

Environment node whose body must always be a group.

Fields

name: String

Environment name without begin / end

args: Vec<ArgumentSlot>

Parsed argument slots attached to the environment

known: bool

Whether this name is present in the knowledge base.

body: NodeId

Environment body subtree. Must be a Node::Group

Scripted

Scripted expression such as x_i^2.

Fields

base: NodeId

Base expression

subscript: Option<NodeId>

Optional subscript subtree

superscript: Option<NodeId>

Optional superscript subtree

Prime

Math prime shorthand represented by one or more consecutive prime marks.

Fields

count: usize

Number of consecutive prime marks. Must be greater than zero.

Text(String)

Text-mode text chunk

Char(char)

Single character node

ActiveSpace

Active ~ space node

Error

Parser-produced error placeholder, mirroring SyntaxNode::Error.

Error is a first-class structural leaf: a tree containing Error nodes is still structurally valid. Semantic completeness (the absence of Error nodes) is a separate property, not a structural invariant. Error carries the original recovery message and the source snippet so serialization can round-trip it losslessly.

Fields

message: String

Human-readable recovery message captured by the parser.

snippet: String

Verbatim source slice the parser failed to interpret.

Implementations

impl Node

pub const fn kind(&self) -> NodeKind

Return the lightweight discriminant for this node.

Trait Implementations

impl Clone for Node

fn clone(&self) -> Node

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Node

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

Formats the value using the given formatter.

impl Eq for Node

impl PartialEq for Node

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Node