Enum Simple

pub enum Simple<'a> {
    Missing,
    Number(&'a str),
    Text(&'a str),
    Ident(&'a str),
    Symbol(&'a str),
    Unary(SimpleUnary<'a>),
    Func(SimpleFunc<'a>),
    Binary(SimpleBinary<'a>),
    Group(Group<'a>),
    Matrix(Matrix<'a>),
}

A simple element of parsing

This is the lowest level in the parse tree, but can be scaled back up with a group or matrix

Variants

Missing

A missing expression

This is found in places where something didn’t exist, e.g. “sin” by itself will have a missing argument, but still be parsed.

Number(&'a str)

A raw number

Text(&'a str)

Raw text

Ident(&'a str)

An identity, usually a single character of something that doesn’t have asciimath meaning

Symbol(&'a str)

A recognized symbol

Unary(SimpleUnary<'a>)

A unary operator

Func(SimpleFunc<'a>)

A simple unary function

Binary(SimpleBinary<'a>)

A binary function

Group(Group<'a>)

A bracketed group

Matrix(Matrix<'a>)

A matrix

Implementations

impl<'a> Simple<'a>

pub fn as_option(&self) -> Option<&Self>

Get as an option where Missing is None

Trait Implementations

impl<'a> Clone for Simple<'a>

fn clone(&self) -> Simple<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Simple<'a>

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

Formats the value using the given formatter.

impl<'a> Default for Simple<'a>

fn default() -> Simple<'a>

Returns the “default value” for a type.

impl<'a> From<Group<'a>> for Simple<'a>

fn from(inp: Group<'a>) -> Self

Converts to this type from the input type.

impl<'a> From<Matrix<'a>> for Simple<'a>

fn from(inp: Matrix<'a>) -> Self

Converts to this type from the input type.

impl<'a> From<SimpleBinary<'a>> for Simple<'a>

fn from(inp: SimpleBinary<'a>) -> Self

Converts to this type from the input type.

impl<'a> From<SimpleFunc<'a>> for Simple<'a>

fn from(inp: SimpleFunc<'a>) -> Self

Converts to this type from the input type.

impl<'a> From<SimpleUnary<'a>> for Simple<'a>

fn from(inp: SimpleUnary<'a>) -> Self

Converts to this type from the input type.

impl<'a> PartialEq for Simple<'a>

fn eq(&self, other: &Simple<'a>) -> bool

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

const 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<'a> Eq for Simple<'a>

impl<'a> StructuralPartialEq for Simple<'a>