Enum ExprKind 

pub enum ExprKind<T = ()> {
    Lit(Literal),
    Var(Var),
    Slot(SlotId),
    Unknown {
        name: SmolStr,
        type_annotation: Option<Type>,
    },
    If {
        test_expr: Arc<Expr<T>>,
        then_expr: Arc<Expr<T>>,
        else_expr: Arc<Expr<T>>,
    },
    And {
        left: Arc<Expr<T>>,
        right: Arc<Expr<T>>,
    },
    Or {
        left: Arc<Expr<T>>,
        right: Arc<Expr<T>>,
    },
    UnaryApp {
        op: UnaryOp,
        arg: Arc<Expr<T>>,
    },
    BinaryApp {
        op: BinaryOp,
        arg1: Arc<Expr<T>>,
        arg2: Arc<Expr<T>>,
    },
    MulByConst {
        arg: Arc<Expr<T>>,
        constant: i64,
    },
    ExtensionFunctionApp {
        op: ExtensionFunctionOp,
        args: Arc<Vec<Expr<T>>>,
    },
    GetAttr {
        expr: Arc<Expr<T>>,
        attr: SmolStr,
    },
    HasAttr {
        expr: Arc<Expr<T>>,
        attr: SmolStr,
    },
    Like {
        expr: Arc<Expr<T>>,
        pattern: Pattern,
    },
    Set(Arc<Vec<Expr<T>>>),
    Record {
        pairs: Arc<Vec<(SmolStr, Expr<T>)>>,
    },
}

The possible expression variants. This enum should be matched on by code recursively traversing the AST.

Variants

Lit(Literal)

Literal value

Var(Var)

Variable

Slot(SlotId)

Template Slots

Unknown

Symbolic Unknown for partial-eval

Fields

name: SmolStr

The name of the unknown

type_annotation: Option<Type>

The type of the values that can be substituted in for the unknown If None, we have no type annotation, and thus a value of any type can be substituted.

If

Ternary expression

Fields

test_expr: Arc<Expr<T>>

Condition for the ternary expression. Must evaluate to Bool type

then_expr: Arc<Expr<T>>

Value if true

else_expr: Arc<Expr<T>>

Value if false

And

Boolean AND

Fields

left: Arc<Expr<T>>

Left operand, which will be eagerly evaluated

right: Arc<Expr<T>>

Right operand, which may not be evaluated due to short-circuiting

Or

Boolean OR

Fields

left: Arc<Expr<T>>

Left operand, which will be eagerly evaluated

right: Arc<Expr<T>>

Right operand, which may not be evaluated due to short-circuiting

UnaryApp

Application of a built-in unary operator (single parameter)

Fields

op: UnaryOp

Unary operator to apply

arg: Arc<Expr<T>>

Argument to apply operator to

BinaryApp

Application of a built-in binary operator (two parameters)

Fields

op: BinaryOp

Binary operator to apply

arg1: Arc<Expr<T>>

First arg

arg2: Arc<Expr<T>>

Second arg

MulByConst

Multiplication by constant

This isn’t just a BinaryOp because its arguments aren’t both expressions. (Similar to how like isn’t a BinaryOp and has its own AST node as well.)

Fields

arg: Arc<Expr<T>>

first argument, which may be an arbitrary expression, but must evaluate to Long type

constant: i64

second argument, which must be an integer constant

ExtensionFunctionApp

Application of an extension function to n arguments INVARIANT (MethodStyleArgs): if op.style is MethodStyle then args cannot be empty. The first element of args refers to the subject of the method call Ideally, we find some way to make this non-representable.

Fields

op: ExtensionFunctionOp

Extension function to apply

args: Arc<Vec<Expr<T>>>

Args to apply the function to

GetAttr

Get an attribute of an entity, or a field of a record

Fields

expr: Arc<Expr<T>>

Expression to get an attribute/field of. Must evaluate to either Entity or Record type

attr: SmolStr

Attribute or field to get

HasAttr

Does the given expr have the given attr?

Fields

expr: Arc<Expr<T>>

Expression to test. Must evaluate to either Entity or Record type

attr: SmolStr

Attribute or field to check for

Like

Regex-like string matching similar to IAM’s StringLike operator.

Fields

expr: Arc<Expr<T>>

Expression to test. Must evaluate to String type

pattern: Pattern

Pattern to match on; can include the wildcard *, which matches any string. To match a literal * in the test expression, users can use \*. Be careful the backslash in \* must not be another escape sequence. For instance, \\* matches a backslash plus an arbitrary string.

Set(Arc<Vec<Expr<T>>>)

Set (whose elements may be arbitrary expressions)

Record

Anonymous record (whose elements may be arbitrary expressions) This is a Vec for the same reason as above.

Fields

pairs: Arc<Vec<(SmolStr, Expr<T>)>>

key/value pairs

Trait Implementations

impl<T: Clone> Clone for ExprKind<T>

fn clone(&self) -> ExprKind<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for ExprKind<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for ExprKind<T>

where T: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Hash> Hash for ExprKind<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: PartialEq> PartialEq for ExprKind<T>

fn eq(&self, other: &ExprKind<T>) -> 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<T> Serialize for ExprKind<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Eq> Eq for ExprKind<T>

impl<T> StructuralPartialEq for ExprKind<T>