Enum Expr 

pub enum Expr {
    Unit {
        name: String,
    },
    Quote {
        string: String,
    },
    Const {
        value: Numeric,
    },
    Date {
        tokens: Vec<DateToken>,
    },
    BinOp(BinOpExpr),
    UnaryOp(UnaryOpExpr),
    Mul {
        exprs: Vec<Expr>,
    },
    Of {
        property: String,
        expr: Box<Expr>,
    },
    Call {
        func: Function,
        args: Vec<Expr>,
    },
    Error {
        message: String,
    },
}

Variants

Unit

Fields

name: String

Quote

Fields

string: String

Const

Fields

value: Numeric

Date

Fields

tokens: Vec<DateToken>

BinOp(BinOpExpr)

UnaryOp(UnaryOpExpr)

Mul

Fields

exprs: Vec<Expr>

Of

Fields

property: String

expr: Box<Expr>

Call

Fields

func: Function

args: Vec<Expr>

Error

Fields

message: String

Implementations

impl Expr

pub fn new_const(value: Numeric) -> Expr

pub fn new_error(message: String) -> Expr

pub fn new_unit(name: String) -> Expr

pub fn new_call(func: Function, args: Vec<Expr>) -> Expr

pub fn new_mul(exprs: Vec<Expr>) -> Expr

pub fn new_bin(op: BinOpType, numer: Expr, denom: Expr) -> Expr

pub fn new_add(numer: Expr, denom: Expr) -> Expr

pub fn new_sub(numer: Expr, denom: Expr) -> Expr

pub fn new_frac(numer: Expr, denom: Expr) -> Expr

pub fn new_pow(numer: Expr, denom: Expr) -> Expr

pub fn new_equals(numer: Expr, denom: Expr) -> Expr

pub fn new_of(property: &str, expr: Expr) -> Expr

pub fn new_unary(op: UnaryOpType, expr: Expr) -> Expr

pub fn new_suffix(suffix: Degree, expr: Expr) -> Expr

pub fn new_plus(expr: Expr) -> Expr

pub fn new_negate(expr: Expr) -> Expr

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl Display for Expr

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

Formats the value using the given formatter.

impl From<i64> for Expr

fn from(x: i64) -> Self

Converts to this type from the input type.

impl PartialEq for Expr

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Expr