Enum ExprKind

pub enum ExprKind<T = ()> {
    Lit(Literal),
    Var(Var),
    Slot(SlotId),
    Unknown(Unknown),
    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>>,
    },
    ExtensionFunctionApp {
        fn_name: Name,
        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,
    },
    Is {
        expr: Arc<Expr<T>>,
        entity_type: EntityType,
    },
    Set(Arc<Vec<Expr<T>>>),
    Record(Arc<BTreeMap<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(Unknown)

Symbolic Unknown for partial-eval

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

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

fn_name: Name

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.

Is

Entity type test. Does the first argument have the entity type specified by the second argument.

Fields

expr: Arc<Expr<T>>

Expression to test. Must evaluate to an Entity.

entity_type: EntityType

The EntityType used for the type membership test.

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

Set (whose elements may be arbitrary expressions)

Record(Arc<BTreeMap<SmolStr, Expr<T>>>)

Anonymous record (whose elements may be arbitrary expressions)

Implementations

impl<T> ExprKind<T>

pub fn operator_description(self: &ExprKind<T>) -> String

Describe this operator for error messages.

Trait Implementations

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

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

Returns a copy 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>