Enum Expression 

#[non_exhaustive]
pub enum Expression {
    String(String),
    Integer(i64),
    Float(f64),
    Boolean(bool),
    Nil,
    Variable(String),
    FieldAccess(Box<Expression>, String),
    Index(Box<Expression>, Box<Expression>),
    Call(String, Vec<Expression>),
    MethodCall(Box<Expression>, String, Vec<Expression>),
    Add(Box<Expression>, Box<Expression>),
    Subtract(Box<Expression>, Box<Expression>),
    Multiply(Box<Expression>, Box<Expression>),
    Divide(Box<Expression>, Box<Expression>),
    Modulo(Box<Expression>, Box<Expression>),
    BitAnd(Box<Expression>, Box<Expression>),
    BitOr(Box<Expression>, Box<Expression>),
    Equal(Box<Expression>, Box<Expression>),
    NotEqual(Box<Expression>, Box<Expression>),
    LessThan(Box<Expression>, Box<Expression>),
    LessEqual(Box<Expression>, Box<Expression>),
    GreaterThan(Box<Expression>, Box<Expression>),
    GreaterEqual(Box<Expression>, Box<Expression>),
    And(Box<Expression>, Box<Expression>),
    Or(Box<Expression>, Box<Expression>),
    Not(Box<Expression>),
    Assign(Box<Expression>, Box<Expression>),
}

Abstract Syntax Tree nodes for rule expressions

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

String(String)

A string literal.

Integer(i64)

An integer literal.

Float(f64)

A float literal.

Boolean(bool)

true or false.

Nil

nil.

Variable(String)

A fact, by name.

FieldAccess(Box<Expression>, String)

base.field.

Index(Box<Expression>, Box<Expression>)

base[index]: an array element by integer, or an object entry by key.

Call(String, Vec<Expression>)

Name(args): a built-in or registered function.

MethodCall(Box<Expression>, String, Vec<Expression>)

target.Name(args): a built-in or registered method.

Add(Box<Expression>, Box<Expression>)

left + right: addition, or string concatenation.

Subtract(Box<Expression>, Box<Expression>)

left - right.

Multiply(Box<Expression>, Box<Expression>)

left * right.

Divide(Box<Expression>, Box<Expression>)

left / right, always a float.

Modulo(Box<Expression>, Box<Expression>)

left % right, on integers.

BitAnd(Box<Expression>, Box<Expression>)

left & right, on integers.

BitOr(Box<Expression>, Box<Expression>)

left | right, on integers.

Equal(Box<Expression>, Box<Expression>)

left == right.

NotEqual(Box<Expression>, Box<Expression>)

left != right.

LessThan(Box<Expression>, Box<Expression>)

left < right.

LessEqual(Box<Expression>, Box<Expression>)

left <= right.

GreaterThan(Box<Expression>, Box<Expression>)

left > right.

GreaterEqual(Box<Expression>, Box<Expression>)

left >= right.

And(Box<Expression>, Box<Expression>)

left && right, short-circuiting.

Or(Box<Expression>, Box<Expression>)

left || right, short-circuiting.

Not(Box<Expression>)

!operand.

Assign(Box<Expression>, Box<Expression>)

target = value, as a rule action.

Implementations

impl Expression

pub fn assign(path: &[&str], value: Expression) -> Self

Builds an assignment to path, e.g. Expression::assign(&["car", "Speed"], value).

pub fn call(name: &str, args: Vec<Expression>) -> Self

Builds a call to a function, e.g. Expression::call("Retract", vec![...]).

pub fn is_assignable(&self) -> bool

Whether this expression can be assigned to.

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

Equality operator ==.

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

Inequality operator !=.

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