Enum ILExpression 

pub enum ILExpression {
    Literal(Value),
    Variable {
        var_ref: u32,
    },
    Plan {
        plan: ILPlan,
    },
    Bind {
        bind: BindExpression,
    },
    If {
        if_expr: Box<IfExpression>,
    },
    Get {
        get: GetExpression,
    },
    Call {
        call: CallExpression,
    },
    MapOp {
        map: MapExpression,
    },
    FilterOp {
        filter: FilterExpression,
    },
    ReduceOp {
        reduce: ReduceExpression,
    },
}

Extended IL expressions for complete Cap’n Web protocol support Includes variable references, bindings, conditionals, and plans

Variants

Literal(Value)

Direct JSON value

Variable

Variable reference: [“var”, index]

Fields

var_ref: u32

Plan

Plan execution: [“plan”, …operations]

Fields

plan: ILPlan

Bind

Variable binding: [“bind”, value, body]

Fields

bind: BindExpression

If

Conditional: [“if”, condition, then_expr, else_expr]

Fields

if_expr: Box<IfExpression>

Get

Property access: [“get”, object, property]

Fields

get: GetExpression

Call

Function call: [“call”, target, method, …args]

Fields

call: CallExpression

MapOp

Array map operation: [“map”, array, function]

Fields

map: MapExpression

FilterOp

Filter operation: [“filter”, array, predicate]

Fields

filter: FilterExpression

ReduceOp

Reduce operation: [“reduce”, array, function, initial]

Fields

reduce: ReduceExpression

Implementations

impl ILExpression

pub fn var(index: u32) -> Self

Create a variable reference

pub fn literal(value: Value) -> Self

Create a literal value

pub fn bind(value: ILExpression, body: ILExpression) -> Self

Create a bind expression

pub fn if_expr( condition: ILExpression, then_branch: ILExpression, else_branch: ILExpression, ) -> Self

Create an if expression

pub fn get(object: ILExpression, property: String) -> Self

Create a property get expression

pub fn call( target: ILExpression, method: String, args: Vec<ILExpression>, ) -> Self

Create a method call expression

pub fn map(array: ILExpression, function: ILExpression) -> Self

Create a map expression for array transformation

Trait Implementations

impl Clone for ILExpression

fn clone(&self) -> ILExpression

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ILExpression

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ILExpression

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ILExpression

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

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 ILExpression