Enum MathExpr 

#[non_exhaustive]
pub enum MathExpr {
    Row(Vec<MathExpr>),
    Identifier(String),
    Number(String),
    Operator(String),
    OperatorWithMetadata {
        text: String,
        lspace: Option<f32>,
        rspace: Option<f32>,
        large_operator: Option<bool>,
        movable_limits: Option<bool>,
    },
    Text(String),
    Space(f32),
    Fraction {
        numerator: Arc<MathExpr>,
        denominator: Arc<MathExpr>,
    },
    Sqrt(Arc<MathExpr>),
    Root {
        base: Arc<MathExpr>,
        index: Arc<MathExpr>,
    },
    Scripts {
        base: Arc<MathExpr>,
        sub: Option<Arc<MathExpr>>,
        sup: Option<Arc<MathExpr>>,
    },
    UnderOver {
        base: Arc<MathExpr>,
        under: Option<Arc<MathExpr>>,
        over: Option<Arc<MathExpr>>,
    },
    Accent {
        base: Arc<MathExpr>,
        accent: Arc<MathExpr>,
        stretch: bool,
    },
    Fenced {
        open: Option<String>,
        close: Option<String>,
        body: Arc<MathExpr>,
    },
    Table {
        rows: Vec<Vec<MathExpr>>,
        column_alignments: Vec<MathColumnAlignment>,
        column_gap: Option<f32>,
        row_gap: Option<f32>,
    },
    Source {
        source: Range<usize>,
        body: Arc<MathExpr>,
    },
    Error(String),
}

Presentation-oriented math expression tree, shaped like MathML Core.

Each variant corresponds to a MathML Core element (noted per variant), so MathML interchange is a near 1:1 mapping. Trees are produced by parse_tex/parse_mathml (or built directly) and turned into renderable boxes by layout_math.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Row(Vec<MathExpr>)

Horizontal sequence of sub-expressions (<mrow>).

Identifier(String)

Identifier such as a variable or function name (<mi>); rendered italic.

Number(String)

Numeric literal (<mn>); rendered upright.

Operator(String)

Operator, relation, or punctuation (<mo>). Spacing and big-operator behavior come from a built-in table keyed on the operator text.

OperatorWithMetadata

Operator (<mo>) with explicit attribute overrides; unset fields fall back to the built-in operator table used by MathExpr::Operator.

Fields

text: String

The operator text.

lspace: Option<f32>

Space before the operator in em (MathML lspace).

rspace: Option<f32>

Space after the operator in em (MathML rspace).

large_operator: Option<bool>

Whether to draw an enlarged glyph in block display (MathML largeop).

movable_limits: Option<bool>

Whether attached scripts become under/over limits in block display (MathML movablelimits).

Text(String)

Literal text rendered upright (<mtext>).

Space(f32)

Horizontal space of the given width in em (<mspace>).

Fraction

Fraction with a horizontal rule (<mfrac>).

Fields

numerator: Arc<MathExpr>

Expression above the fraction rule.

denominator: Arc<MathExpr>

Expression below the fraction rule.

Sqrt(Arc<MathExpr>)

Square root (<msqrt>).

Root

Root with an explicit degree, e.g. a cube root (<mroot>).

Fields

base: Arc<MathExpr>

Expression under the radical.

index: Arc<MathExpr>

Degree of the root, drawn small above the radical’s hook.

Scripts

Base with attached subscript and/or superscript (<msub>/<msup>/<msubsup>).

Fields

base: Arc<MathExpr>

Expression the scripts attach to.

sub: Option<Arc<MathExpr>>

Subscript, if any.

sup: Option<Arc<MathExpr>>

Superscript, if any.

UnderOver

Base with material placed directly below and/or above it (<munder>/<mover>/<munderover>), e.g. limits of a sum.

Fields

base: Arc<MathExpr>

Expression the under/over material attaches to.

under: Option<Arc<MathExpr>>

Expression centered below the base, if any.

over: Option<Arc<MathExpr>>

Expression centered above the base, if any.

Accent

Accented base such as a hat or overline (<mover accent="true">).

Fields

base: Arc<MathExpr>

Expression under the accent.

accent: Arc<MathExpr>

The accent expression, drawn close above the base.

stretch: bool

Whether the accent stretches to the base’s width (MathML stretchy); currently honored for overline-style accents.

Fenced

Body wrapped in (possibly stretchy) fence delimiters (<mfenced>, or an <mrow> with stretchy <mo> fences).

Fields

open: Option<String>

Opening delimiter text, or None for no opening fence.

close: Option<String>

Closing delimiter text, or None for no closing fence.

body: Arc<MathExpr>

Expression between the fences.

Table

Rows and columns of aligned cells (<mtable>), also used for matrix and aligned/cases TeX environments.

Fields

rows: Vec<Vec<MathExpr>>

Cell expressions, outer Vec per row, inner Vec per column.

column_alignments: Vec<MathColumnAlignment>

Per-column alignment (MathML columnalign); columns beyond the list fall back to the last entry or the default (center).

column_gap: Option<f32>

Gap between columns in em (MathML columnspacing), or None for the built-in default.

row_gap: Option<f32>

Gap between rows in em (MathML rowspacing), or None for the built-in default.

Source

Transparent wrapper recording which byte range of the original source produced body; emitted by parse_tex_with_source_ranges and ignored by layout. No MathML equivalent.

Fields

source: Range<usize>

Byte range into the original source string.

body: Arc<MathExpr>

The wrapped expression.

Error(String)

Parse error or unsupported construct; the message is rendered as plain text in place of the expression.

Implementations

impl MathExpr

pub fn row(children: impl IntoIterator<Item = MathExpr>) -> Self

Builds a MathExpr::Row from children, collapsing the trivial cases: zero children yield an empty row and a single child is returned as-is without a wrapping row.

pub fn source_range(&self) -> Option<&Range<usize>>

Returns the source byte range if this node is a MathExpr::Source wrapper, without descending into children.

pub fn without_source(&self) -> &MathExpr

Unwraps any (nested) MathExpr::Source wrappers and returns the underlying expression; returns self for all other variants.

Trait Implementations

impl Clone for MathExpr

fn clone(&self) -> MathExpr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MathExpr

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

Formats the value using the given formatter.

impl PartialEq for MathExpr

fn eq(&self, other: &MathExpr) -> 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 MathExpr