Enum MathExpr 

pub enum MathExpr {
    Ident {
        value: String,
    },
    Number {
        value: String,
    },
    Operator(MathOperator),
    Text {
        value: String,
    },
    Row {
        children: Vec<MathExpr>,
    },
    Fenced {
        open: Delimiter,
        close: Delimiter,
        body: Vec<MathExpr>,
    },
    Superscript {
        base: Box<MathExpr>,
        script: Box<MathExpr>,
    },
    Subscript {
        base: Box<MathExpr>,
        script: Box<MathExpr>,
    },
    Subsuperscript {
        base: Box<MathExpr>,
        sub: Box<MathExpr>,
        sup: Box<MathExpr>,
    },
    Frac {
        numerator: Box<MathExpr>,
        denominator: Box<MathExpr>,
        style: FracStyle,
    },
    Sqrt {
        index: Option<Box<MathExpr>>,
        body: Box<MathExpr>,
    },
    Overline {
        body: Box<MathExpr>,
    },
    Underline {
        body: Box<MathExpr>,
    },
    Overbrace {
        body: Box<MathExpr>,
        annotation: Option<Box<MathExpr>>,
    },
    Underbrace {
        body: Box<MathExpr>,
        annotation: Option<Box<MathExpr>>,
    },
    Overset {
        over: Box<MathExpr>,
        base: Box<MathExpr>,
    },
    Underset {
        under: Box<MathExpr>,
        base: Box<MathExpr>,
    },
    Accent {
        kind: AccentKind,
        body: Box<MathExpr>,
    },
    BigOperator {
        op: MathOperator,
        limits: LimitStyle,
        lower: Option<Box<MathExpr>>,
        upper: Option<Box<MathExpr>>,
    },
    Matrix {
        rows: Vec<Vec<MathExpr>>,
        delimiters: MatrixDelimiters,
    },
    Cases {
        rows: Vec<CaseRow>,
    },
    Array {
        columns: Vec<ColumnAlign>,
        rows: Vec<Vec<MathExpr>>,
    },
    Align {
        rows: Vec<AlignRow>,
        numbered: bool,
    },
    Gather {
        rows: Vec<MathExpr>,
        numbered: bool,
    },
    Space(MathSpace),
    Phantom {
        body: Box<MathExpr>,
    },
    HPhantom {
        body: Box<MathExpr>,
    },
    VPhantom {
        body: Box<MathExpr>,
    },
    Smash {
        body: Box<MathExpr>,
        mode: SmashMode,
    },
    StyleOverride {
        style: MathStyle,
        body: Box<MathExpr>,
    },
    FontOverride {
        font: MathFont,
        body: Box<MathExpr>,
    },
    Color {
        color: String,
        body: Box<MathExpr>,
    },
    Chem {
        value: String,
    },
    Error {
        raw: String,
        message: String,
    },
}

Structured math expression tree (Section 2.11).

This is a recursive algebraic type representing the parsed structure of a LaTeX math expression. Box<MathExpr> is used for recursive fields to keep the type sized.

Variants

Ident

Fields

value: String

Number

Fields

value: String

Operator(MathOperator)

Text

Fields

value: String

Row

Fields

children: Vec<MathExpr>

Fenced

Fields

open: Delimiter

close: Delimiter

body: Vec<MathExpr>

Superscript

Fields

base: Box<MathExpr>

script: Box<MathExpr>

Subscript

Fields

base: Box<MathExpr>

script: Box<MathExpr>

Subsuperscript

Fields

base: Box<MathExpr>

sub: Box<MathExpr>

sup: Box<MathExpr>

Frac

Fields

numerator: Box<MathExpr>

denominator: Box<MathExpr>

style: FracStyle

Sqrt

Fields

index: Option<Box<MathExpr>>

body: Box<MathExpr>

Overline

Fields

body: Box<MathExpr>

Underline

Fields

body: Box<MathExpr>

Overbrace

Fields

body: Box<MathExpr>

annotation: Option<Box<MathExpr>>

Underbrace

Fields

body: Box<MathExpr>

annotation: Option<Box<MathExpr>>

Overset

Fields

over: Box<MathExpr>

base: Box<MathExpr>

Underset

Fields

under: Box<MathExpr>

base: Box<MathExpr>

Accent

Fields

kind: AccentKind

body: Box<MathExpr>

BigOperator

Fields

op: MathOperator

limits: LimitStyle

lower: Option<Box<MathExpr>>

upper: Option<Box<MathExpr>>

Matrix

Fields

rows: Vec<Vec<MathExpr>>

delimiters: MatrixDelimiters

Cases

Fields

rows: Vec<CaseRow>

Array

Fields

columns: Vec<ColumnAlign>

rows: Vec<Vec<MathExpr>>

Align

Fields

rows: Vec<AlignRow>

numbered: bool

Gather

Fields

rows: Vec<MathExpr>

numbered: bool

Space(MathSpace)

Phantom

Fields

body: Box<MathExpr>

HPhantom

Fields

body: Box<MathExpr>

VPhantom

Fields

body: Box<MathExpr>

Smash

Fields

body: Box<MathExpr>

mode: SmashMode

StyleOverride

Fields

style: MathStyle

body: Box<MathExpr>

FontOverride

Fields

font: MathFont

body: Box<MathExpr>

Color

Fields

color: String

body: Box<MathExpr>

Chem

Fields

value: String

Error

Fields

raw: String

message: String

Trait Implementations

impl Archive for MathExpr

where String: Archive, MathOperator: Archive, Delimiter: Archive, FracStyle: Archive, AccentKind: Archive, LimitStyle: Archive, MatrixDelimiters: Archive, Vec<ColumnAlign>: Archive, bool: Archive, MathSpace: Archive, SmashMode: Archive, MathStyle: Archive, MathFont: Archive,

type Archived = ArchivedMathExpr

The archived representation of this type.

type Resolver = MathExprResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve( &self, resolver: <MathExpr as Archive>::Resolver, out: Place<<MathExpr as Archive>::Archived>, )

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

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<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MathExpr

fn deserialize<__D>( __deserializer: __D, ) -> Result<MathExpr, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D> Deserialize<MathExpr, __D> for <MathExpr as Archive>::Archived

where __D: Fallible + ?Sized, <__D as Fallible>::Error: Source, String: Archive, <String as Archive>::Archived: Deserialize<String, __D>, MathOperator: Archive, <MathOperator as Archive>::Archived: Deserialize<MathOperator, __D>, Delimiter: Archive, <Delimiter as Archive>::Archived: Deserialize<Delimiter, __D>, FracStyle: Archive, <FracStyle as Archive>::Archived: Deserialize<FracStyle, __D>, AccentKind: Archive, <AccentKind as Archive>::Archived: Deserialize<AccentKind, __D>, LimitStyle: Archive, <LimitStyle as Archive>::Archived: Deserialize<LimitStyle, __D>, MatrixDelimiters: Archive, <MatrixDelimiters as Archive>::Archived: Deserialize<MatrixDelimiters, __D>, Vec<ColumnAlign>: Archive, <Vec<ColumnAlign> as Archive>::Archived: Deserialize<Vec<ColumnAlign>, __D>, bool: Archive, <bool as Archive>::Archived: Deserialize<bool, __D>, MathSpace: Archive, <MathSpace as Archive>::Archived: Deserialize<MathSpace, __D>, SmashMode: Archive, <SmashMode as Archive>::Archived: Deserialize<SmashMode, __D>, MathStyle: Archive, <MathStyle as Archive>::Archived: Deserialize<MathStyle, __D>, MathFont: Archive, <MathFont as Archive>::Archived: Deserialize<MathFont, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<MathExpr, <__D as Fallible>::Error>

Deserializes using the given deserializer

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<__S> Serialize<__S> for MathExpr

where __S: Fallible + Writer + Allocator + ?Sized, <__S as Fallible>::Error: Source, String: Serialize<__S>, MathOperator: Serialize<__S>, Delimiter: Serialize<__S>, FracStyle: Serialize<__S>, AccentKind: Serialize<__S>, LimitStyle: Serialize<__S>, MatrixDelimiters: Serialize<__S>, Vec<ColumnAlign>: Serialize<__S>, bool: Serialize<__S>, MathSpace: Serialize<__S>, SmashMode: Serialize<__S>, MathStyle: Serialize<__S>, MathFont: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<MathExpr as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl Serialize for MathExpr

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for MathExpr