Enum NodeDoc 

pub enum NodeDoc {
    Atom(Symbol),
    Frac {
        num: Vec<NodeDoc>,
        den: Vec<NodeDoc>,
        style: FracStyle,
    },
    Script {
        base: Vec<NodeDoc>,
        sub: Option<Vec<NodeDoc>>,
        sup: Option<Vec<NodeDoc>>,
    },
    BigOp {
        op: Symbol,
        lower: Vec<NodeDoc>,
        upper: Vec<NodeDoc>,
    },
    Sqrt {
        index: Vec<NodeDoc>,
        radicand: Vec<NodeDoc>,
    },
    Delim {
        open: char,
        close: char,
        body: Vec<NodeDoc>,
    },
    Accent {
        mark: Mark,
        base: Vec<NodeDoc>,
    },
    UnderOver {
        base: Vec<NodeDoc>,
        over: Option<Vec<NodeDoc>>,
        under: Option<Vec<NodeDoc>>,
        over_deco: Deco,
        under_deco: Deco,
    },
    Styled {
        variant: Variant,
        content: Vec<NodeDoc>,
    },
    HostBox {
        token: u32,
    },
    Matrix {
        env: MatrixEnv,
        rows: Vec<Vec<Vec<NodeDoc>>>,
    },
    Ratio {
        left: Vec<NodeDoc>,
        right: Vec<NodeDoc>,
    },
    EvalBar {
        body: Vec<NodeDoc>,
        lower: Vec<NodeDoc>,
        upper: Vec<NodeDoc>,
    },
    LabeledArrow {
        arrow: Arrow,
        over: Vec<NodeDoc>,
        under: Vec<NodeDoc>,
    },
}

The serialized form of one node.

Variants

Atom(Symbol)

A single leaf token.

Frac

A fraction.

Fields

num: Vec<NodeDoc>

Numerator nodes.

den: Vec<NodeDoc>

Denominator nodes.

style: FracStyle

Visual style.

Script

Subscript and superscript on a base, at least one of the two is present.

Fields

base: Vec<NodeDoc>

Base nodes.

sub: Option<Vec<NodeDoc>>

Subscript nodes when present.

sup: Option<Vec<NodeDoc>>

Superscript nodes when present.

BigOp

A big operator with limits.

Fields

op: Symbol

The operator symbol.

lower: Vec<NodeDoc>

Lower limit nodes.

upper: Vec<NodeDoc>

Upper limit nodes.

Sqrt

A radical.

Fields

index: Vec<NodeDoc>

Degree nodes, empty for a square root.

radicand: Vec<NodeDoc>

Radicand nodes.

Delim

Stretchy delimiters around a body.

Fields

open: char

Opening delimiter character.

close: char

Closing delimiter character.

body: Vec<NodeDoc>

Body nodes.

Accent

An accent over a base.

Fields

mark: Mark

The accent mark.

base: Vec<NodeDoc>

Base nodes.

UnderOver

A base with optional labels above and below.

Fields

base: Vec<NodeDoc>

Base nodes.

over: Option<Vec<NodeDoc>>

Label above when present.

under: Option<Vec<NodeDoc>>

Label below when present.

over_deco: Deco

Decoration between the base and the label above.

under_deco: Deco

Decoration between the base and the label below.

Styled

Content in a font variant or in text mode.

Fields

variant: Variant

The variant.

content: Vec<NodeDoc>

Content nodes.

HostBox

An opaque host owned object.

Fields

token: u32

The host minted token.

Matrix

A rectangular grid of cells.

Fields

env: MatrixEnv

The environment.

rows: Vec<Vec<Vec<NodeDoc>>>

Cells by row, each cell a node list.

Ratio

Two terms joined by a ratio colon spaced as a relation.

Fields

left: Vec<NodeDoc>

First term nodes.

right: Vec<NodeDoc>

Second term nodes.

EvalBar

An evaluation bar after a body, as in F(x) evaluated from a to b.

Fields

body: Vec<NodeDoc>

Body nodes left of the bar.

lower: Vec<NodeDoc>

Lower limit nodes.

upper: Vec<NodeDoc>

Upper limit nodes.

LabeledArrow

An extensible arrow with labels above and below.

Fields

arrow: Arrow

The arrow drawn.

over: Vec<NodeDoc>

Label above nodes.

under: Vec<NodeDoc>

Label below nodes, empty for none.

Trait Implementations

impl Clone for NodeDoc

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NodeDoc

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NodeDoc

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for NodeDoc

impl PartialEq for NodeDoc

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for NodeDoc

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for NodeDoc