Enum Expr

pub enum Expr<'arena> {
    RealNumber {
        val: f64,
    },
    ImaginaryNumber {
        val: f64,
    },
    ComplexNumber {
        val: Complex64,
    },
    Binding {
        name: &'arena mut str,
    },
    FunctionCall {
        ident: &'arena mut str,
        args: Vec<'arena, &'arena mut Expr<'arena>>,
    },
    Operator {
        op: Operator,
        rhs: &'arena mut Expr<'arena>,
        lhs: &'arena mut Expr<'arena>,
    },
}

A token Tree representing a whole Expression It lives inside an Arena

Variants

RealNumber

A real number

Fields

val: f64

The value of the real number

ImaginaryNumber

An imaginary number

Fields

val: f64

The value of the imaginary number, without the i unit

ComplexNumber

Complex number

Fields

val: Complex64

The value of the complex number’s node

Binding

A variable

Fields

name: &'arena mut str

The name of the variable

FunctionCall

A function call, with an variable amount of arguments

Fields

ident: &'arena mut str

Name of the function

args: Vec<'arena, &'arena mut Expr<'arena>>

List of argument in order they appeard

Operator

An operation

Fields

op: Operator

The operator

rhs: &'arena mut Expr<'arena>

Left side of the operation

lhs: &'arena mut Expr<'arena>

Right side of the operation

Implementations

impl<'arena> Expr<'arena>

pub fn clone_in<'new_arena>( &self, arena: &'new_arena Bump, ) -> &'new_arena mut Expr<'new_arena>

Clone an AST with another backing arena

impl<'arena> Expr<'arena>

pub fn parse<'input, 'words: 'input + 'word, 'word: 'input>( arena: &'arena Bump, input: &'input str, reserved_words: &'words [&'word str], ) -> Result<&'arena mut Expr<'arena>, BuildError<'input>>

Create an AST from an input str

Errors

This will error on any wrong input

Trait Implementations

impl<'arena> Debug for Expr<'arena>

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

Formats the value using the given formatter.

impl<'arena> Display for Expr<'arena>

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

Formats the value using the given formatter.

impl<'arena> PartialEq for Expr<'arena>

fn eq(&self, other: &Expr<'arena>) -> 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<'arena> StructuralPartialEq for Expr<'arena>