Enum ExpressionKind

pub enum ExpressionKind {
    LoadConstant(Constant),
    ArithLog(ArithLogOp, Vec<Expression>),
    StreamAccess {
        target: StreamReference,
        parameters: Vec<Expression>,
        access_kind: StreamAccessKind,
    },
    ParameterAccess(StreamReference, usize),
    LambdaParameterAccess {
        wref: WindowReference,
        pref: usize,
    },
    Ite {
        condition: Box<Expression>,
        consequence: Box<Expression>,
        alternative: Box<Expression>,
    },
    Tuple(Vec<Expression>),
    TupleAccess(Box<Expression>, usize),
    Function(String, Vec<Expression>),
    Convert {
        expr: Box<Expression>,
    },
    Default {
        expr: Box<Expression>,
        default: Box<Expression>,
    },
}

This enum contains all possible kinds of expressions and their relevant information.

Variants

LoadConstant(Constant)

Load a constant value

ArithLog(ArithLogOp, Vec<Expression>)

Apply an arithmetic or logic operation. The function is monomorphized.

Note: Arguments never need to be coerced. Unary: 1st argument -> operand Binary: 1st argument -> lhs, 2nd argument -> rhs n-ary: kth argument -> kth operand

StreamAccess

Access another stream

Fields

target: StreamReference

The target stream to be accessed

parameters: Vec<Expression>

The parameters of the specific stream instance that is accessed.

If the stream behind target is not parametrized, this collection is empty.

access_kind: StreamAccessKind

The kind of access

ParameterAccess(StreamReference, usize)

Access to the parameter of a stream represented by a stream reference, referencing the target stream and the index of the parameter that should be accessed.

LambdaParameterAccess

Access to the lambda parameter in the filtered instance aggregation

Fields

wref: WindowReference

Reference to the instance aggregation using the lambda function

pref: usize

Reference to the parameter

Ite

A conditional (if-then-else) expression

Fields

condition: Box<Expression>

The condition under which either consequence or alternative is selected.

consequence: Box<Expression>

The consequence should be evaluated and returned if the condition evaluates to true.

alternative: Box<Expression>

The alternative should be evaluated and returned if the condition evaluates to false.

Tuple(Vec<Expression>)

A tuple expression

TupleAccess(Box<Expression>, usize)

Represents a tuple projections, i.e., it accesses a specific tuple element.

Function(String, Vec<Expression>)

Represents a function call. The function is monomorphized.

Note: Arguments never need to be coerced. Unary: 1st argument -> operand Binary: 1st argument -> lhs, 2nd argument -> rhs n-ary: kth argument -> kth operand

Convert

Converting a value to a different type

The result type is indicated in the expression with the Convert kind.

Fields

expr: Box<Expression>

The expression that produces a value. The type of the expression indicates the source of the conversion.

Default

Transforms an optional value into a definitive one

Fields

expr: Box<Expression>

The expression that results in an optional value.

default: Box<Expression>

An infallible expression providing the default value if expr fails to produce a value.

Trait Implementations

impl Clone for ExpressionKind

fn clone(&self) -> ExpressionKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExpressionKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExpressionKind

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ExpressionKind

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

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 ExpressionKind