Enum aftermath::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

Fields

val: f64

The value of the real number

A real number

ImaginaryNumber

Fields

val: f64

The value of the imaginary number, without the i unit

An imaginary number

ComplexNumber

Fields

val: Complex64

The value of the complex number’s node

Complex number

Binding

Fields

name: &'arena mut str

The name of the variable

A variable

FunctionCall

Fields

ident: &'arena mut str

Name of the function

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

List of argument in order they appeard

A function call, with an variable amount of arguments

Operator

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

An 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<Expr<'arena>> for Expr<'arena>

fn eq(&self, other: &Expr<'arena>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'arena> StructuralPartialEq for Expr<'arena>