Enum Expression 

pub enum Expression {
    Literal {
        value: Literal,
    },
    Ref {
        name: ParameterName,
    },
    BinOp {
        op: BinOp,
        lhs: Box<Self>,
        rhs: Box<Self>,
    },
    UnOp {
        op: UnOp,
        arg: Box<Self>,
    },
    Call {
        func: BuiltinFn,
        args: Vec<Self>,
    },
    If {
        cond: Box<Self>,
        then_: Box<Self>,
        else_: Box<Self>,
    },
}

An expression tree. Serde-able end to end.

Variants

Literal

Literal value.

Fields

value: Literal

The literal.

Ref

Reference to a previously-bound parameter value.

Fields

name: ParameterName

The parameter name.

BinOp

Binary operation.

Fields

op: BinOp

Operator.

lhs: Box<Self>

Left operand.

rhs: Box<Self>

Right operand.

UnOp

Unary operation.

Fields

op: UnOp

Operator.

arg: Box<Self>

Operand.

Call

Built-in function call.

Fields

func: BuiltinFn

Builtin.

args: Vec<Self>

Arguments.

If

Conditional (ternary).

Fields

cond: Box<Self>

Boolean condition.

then_: Box<Self>

Value when cond is true.

else_: Box<Self>

Value when cond is false.

Implementations

impl Expression

pub const fn literal(lit: Literal) -> Self

Convenience constructor for a literal.

pub const fn reference(name: ParameterName) -> Self

Convenience constructor for a parameter reference.

pub fn binop(op: BinOp, lhs: Self, rhs: Self) -> Self

Convenience constructor for a binary operation.

pub fn unop(op: UnOp, arg: Self) -> Self

Convenience constructor for a unary operation.

pub const fn call(func: BuiltinFn, args: Vec<Self>) -> Self

Convenience constructor for a builtin call.

pub fn if_then_else(cond: Self, then_: Self, else_: Self) -> Self

Convenience constructor for an if-expression.

pub fn eval( &self, bindings: &ValueBindings, ) -> Result<EvalValue, DerivationError>

Evaluate this expression against the given bindings.

Trait Implementations

impl Clone for Expression

fn clone(&self) -> Expression

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expression

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Expression

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Expression

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

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 Expression