Enum Expr 

pub enum Expr {
    F64 {
        value: f64,
    },
    Int {
        value: i64,
    },
    Bool {
        value: bool,
    },
    Var {
        name: String,
    },
    Array {
        items: Vec<Expr>,
    },
    Index {
        array: Box<Expr>,
        index: Box<Expr>,
    },
    Len {
        array: Box<Expr>,
    },
    Neg {
        arg: Box<Expr>,
    },
    Not {
        arg: Box<Expr>,
    },
    Add {
        lhs: Box<Expr>,
        rhs: Box<Expr>,
    },
    Sub {
        lhs: Box<Expr>,
        rhs: Box<Expr>,
    },
    Mul {
        lhs: Box<Expr>,
        rhs: Box<Expr>,
    },
    Div {
        lhs: Box<Expr>,
        rhs: Box<Expr>,
    },
    Eq {
        lhs: Box<Expr>,
        rhs: Box<Expr>,
    },
    Ne {
        lhs: Box<Expr>,
        rhs: Box<Expr>,
    },
    Lt {
        lhs: Box<Expr>,
        rhs: Box<Expr>,
    },
    Le {
        lhs: Box<Expr>,
        rhs: Box<Expr>,
    },
    Gt {
        lhs: Box<Expr>,
        rhs: Box<Expr>,
    },
    Ge {
        lhs: Box<Expr>,
        rhs: Box<Expr>,
    },
    And {
        lhs: Box<Expr>,
        rhs: Box<Expr>,
    },
    Or {
        lhs: Box<Expr>,
        rhs: Box<Expr>,
    },
    Call {
        func: String,
        args: Vec<Expr>,
    },
}

An expression. The JSON form is an object tagged by "op".

Variants

F64

A float literal (2.0, 1e-3); must be finite.

Fields

value: f64

The literal’s value.

Int

An integer literal (2).

Fields

value: i64

The literal’s value.

Bool

true or false.

Fields

value: bool

The literal’s value.

Var

A variable reference.

Fields

name: String

The variable’s name.

Array

An array literal [a, b, c] (its elements must evaluate to numbers).

Fields

items: Vec<Expr>

The element expressions.

Index

array[index].

Fields

array: Box<Expr>

The indexed array.

index: Box<Expr>

The index.

Len

array.len().

Fields

array: Box<Expr>

The array.

Neg

-arg.

Fields

arg: Box<Expr>

The operand.

Not

!arg.

Fields

arg: Box<Expr>

The operand.

Add

lhs + rhs.

Fields

lhs: Box<Expr>

Left operand.

rhs: Box<Expr>

Right operand.

Sub

lhs - rhs.

Fields

lhs: Box<Expr>

Left operand.

rhs: Box<Expr>

Right operand.

Mul

lhs * rhs.

Fields

lhs: Box<Expr>

Left operand.

rhs: Box<Expr>

Right operand.

Div

lhs / rhs (always float division).

Fields

lhs: Box<Expr>

Left operand.

rhs: Box<Expr>

Right operand.

Eq

lhs == rhs.

Fields

lhs: Box<Expr>

Left operand.

rhs: Box<Expr>

Right operand.

Ne

lhs != rhs.

Fields

lhs: Box<Expr>

Left operand.

rhs: Box<Expr>

Right operand.

Lt

lhs < rhs.

Fields

lhs: Box<Expr>

Left operand.

rhs: Box<Expr>

Right operand.

Le

lhs <= rhs.

Fields

lhs: Box<Expr>

Left operand.

rhs: Box<Expr>

Right operand.

Gt

lhs > rhs.

Fields

lhs: Box<Expr>

Left operand.

rhs: Box<Expr>

Right operand.

Ge

lhs >= rhs.

Fields

lhs: Box<Expr>

Left operand.

rhs: Box<Expr>

Right operand.

And

lhs && rhs (short-circuit).

Fields

lhs: Box<Expr>

Left operand.

rhs: Box<Expr>

Right operand.

Or

lhs || rhs (short-circuit).

Fields

lhs: Box<Expr>

Left operand.

rhs: Box<Expr>

Right operand.

Call

A call of a registered pure function: exp(x), max(a, b).

Fields

func: String

The registered function name.

args: Vec<Expr>

The arguments.

Implementations

impl Expr

pub fn var(name: impl Into<String>) -> Expr

A variable reference.

pub fn binary(op: BinOp, lhs: Expr, rhs: Expr) -> Expr

The binary expression lhs op rhs.

pub fn as_binary(&self) -> Option<(BinOp, &Expr, &Expr)>

Some((op, lhs, rhs)) for a binary expression, None otherwise.

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Self

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<'de> Deserialize<'de> for Expr

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Expr

Prints the expression in text syntax with the minimal parentheses that read back to the same tree.

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

Formats the value using the given formatter.

impl PartialEq for Expr

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

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