Struct ExprBuilder

pub struct ExprBuilder<T> { /* private fields */ }

Builder for constructing Expr objects annotated with some data (possibly taking default value) and optionally a source_loc.

Implementations

impl<T> ExprBuilder<T>

where T: Default,

pub fn new() -> Self

Construct a new ExprBuilder where the data used for an expression takes a default value.

pub fn noteq(self, e1: Expr<T>, e2: Expr<T>) -> Expr<T>

Create a ‘!=’ expression. Defined only for T: Default because the caller would otherwise need to provide a data for the intermediate not Expr node.

impl<T> ExprBuilder<T>

pub fn with_data(data: T) -> Self

Construct a new ExprBuild where the specified data will be stored on the Expr. This constructor does not populate the source_loc field, so with_source_loc should be called if constructing an Expr where the source location is known.

pub fn with_source_loc(self, source_loc: Loc) -> Self

Update the ExprBuilder to build an expression with some known location in policy source code.

pub fn with_same_source_loc<U>(self, expr: &Expr<U>) -> Self

Utility used the validator to get an expression with the same source location as an existing expression. This is done when reconstructing the Expr with type information.

pub fn val(self, v: impl Into<Literal>) -> Expr<T>

Create an Expr that’s just a single Literal.

Note that you can pass this a Literal, an Integer, a String, etc.

pub fn unknown(self, u: Unknown) -> Expr<T>

Create an Unknown Expr

pub fn var(self, v: Var) -> Expr<T>

Create an Expr that’s just this literal Var

pub fn slot(self, s: SlotId) -> Expr<T>

Create an Expr that’s just this SlotId

pub fn ite( self, test_expr: Expr<T>, then_expr: Expr<T>, else_expr: Expr<T>, ) -> Expr<T>

Create a ternary (if-then-else) Expr.

test_expr must evaluate to a Bool type

pub fn ite_arc( self, test_expr: Arc<Expr<T>>, then_expr: Arc<Expr<T>>, else_expr: Arc<Expr<T>>, ) -> Expr<T>

Create a ternary (if-then-else) Expr. Takes Arcs instead of owned Exprs. test_expr must evaluate to a Bool type

pub fn not(self, e: Expr<T>) -> Expr<T>

Create a ‘not’ expression. e must evaluate to Bool type

pub fn is_eq(self, e1: Expr<T>, e2: Expr<T>) -> Expr<T>

Create a ‘==’ expression

pub fn and(self, e1: Expr<T>, e2: Expr<T>) -> Expr<T>

Create an ‘and’ expression. Arguments must evaluate to Bool type

pub fn or(self, e1: Expr<T>, e2: Expr<T>) -> Expr<T>

Create an ‘or’ expression. Arguments must evaluate to Bool type

pub fn less(self, e1: Expr<T>, e2: Expr<T>) -> Expr<T>

Create a ‘<’ expression. Arguments must evaluate to Long type

pub fn lesseq(self, e1: Expr<T>, e2: Expr<T>) -> Expr<T>

Create a ‘<=’ expression. Arguments must evaluate to Long type

pub fn add(self, e1: Expr<T>, e2: Expr<T>) -> Expr<T>

Create an ‘add’ expression. Arguments must evaluate to Long type

pub fn sub(self, e1: Expr<T>, e2: Expr<T>) -> Expr<T>

Create a ‘sub’ expression. Arguments must evaluate to Long type

pub fn mul(self, e1: Expr<T>, e2: Expr<T>) -> Expr<T>

Create a ‘mul’ expression. Arguments must evaluate to Long type

pub fn neg(self, e: Expr<T>) -> Expr<T>

Create a ‘neg’ expression. e must evaluate to Long type.

pub fn is_in(self, e1: Expr<T>, e2: Expr<T>) -> Expr<T>

Create an ‘in’ expression. First argument must evaluate to Entity type. Second argument must evaluate to either Entity type or Set type where all set elements have Entity type.

pub fn contains(self, e1: Expr<T>, e2: Expr<T>) -> Expr<T>

Create a ‘contains’ expression. First argument must have Set type.

pub fn contains_all(self, e1: Expr<T>, e2: Expr<T>) -> Expr<T>

Create a ‘contains_all’ expression. Arguments must evaluate to Set type

pub fn contains_any(self, e1: Expr<T>, e2: Expr<T>) -> Expr<T>

Create an ‘contains_any’ expression. Arguments must evaluate to Set type

pub fn get_tag(self, expr: Expr<T>, tag: Expr<T>) -> Expr<T>

Create a ‘getTag’ expression. expr must evaluate to Entity type, tag must evaluate to String type.

pub fn has_tag(self, expr: Expr<T>, tag: Expr<T>) -> Expr<T>

Create a ‘hasTag’ expression. expr must evaluate to Entity type, tag must evaluate to String type.

pub fn set(self, exprs: impl IntoIterator<Item = Expr<T>>) -> Expr<T>

Create an Expr which evaluates to a Set of the given Exprs

pub fn record( self, pairs: impl IntoIterator<Item = (SmolStr, Expr<T>)>, ) -> Result<Expr<T>, ExpressionConstructionError>

Create an Expr which evaluates to a Record with the given (key, value) pairs.

pub fn record_arc(self, map: Arc<BTreeMap<SmolStr, Expr<T>>>) -> Expr<T>

Create an Expr which evalutes to a Record with the given key-value mapping.

If you have an iterator of pairs, generally prefer calling .record() instead of .collect()-ing yourself and calling this, potentially for efficiency reasons but also because .record() will properly handle duplicate keys but your own .collect() will not (by default).

pub fn call_extension_fn( self, fn_name: Name, args: impl IntoIterator<Item = Expr<T>>, ) -> Expr<T>

Create an Expr which calls the extension function with the given Name on args

pub fn unary_app(self, op: impl Into<UnaryOp>, arg: Expr<T>) -> Expr<T>

Create an application Expr which applies the given built-in unary operator to the given arg

pub fn binary_app( self, op: impl Into<BinaryOp>, arg1: Expr<T>, arg2: Expr<T>, ) -> Expr<T>

Create an application Expr which applies the given built-in binary operator to arg1 and arg2

pub fn get_attr(self, expr: Expr<T>, attr: SmolStr) -> Expr<T>

Create an Expr which gets a given attribute of a given Entity or record.

expr must evaluate to either Entity or Record type

pub fn has_attr(self, expr: Expr<T>, attr: SmolStr) -> Expr<T>

Create an Expr which tests for the existence of a given attribute on a given Entity or record.

expr must evaluate to either Entity or Record type

pub fn like( self, expr: Expr<T>, pattern: impl IntoIterator<Item = PatternElem>, ) -> Expr<T>

Create a ‘like’ expression.

expr must evaluate to a String type

pub fn is_entity_type(self, expr: Expr<T>, entity_type: EntityType) -> Expr<T>

Create an ‘is’ expression.

impl<T: Clone> ExprBuilder<T>

pub fn and_nary( self, first: Expr<T>, others: impl IntoIterator<Item = Expr<T>>, ) -> Expr<T>

Create an and expression that may have more than two subexpressions (A && B && C) or may have only one subexpression, in which case no && is performed at all. Arguments must evaluate to Bool type.

This may create multiple AST && nodes. If it does, all the nodes will have the same source location and the same T data (taken from this builder) unless overridden, e.g., with another call to with_source_loc().

pub fn or_nary( self, first: Expr<T>, others: impl IntoIterator<Item = Expr<T>>, ) -> Expr<T>

Create an or expression that may have more than two subexpressions (A || B || C) or may have only one subexpression, in which case no || is performed at all. Arguments must evaluate to Bool type.

This may create multiple AST || nodes. If it does, all the nodes will have the same source location and the same T data (taken from this builder) unless overridden, e.g., with another call to with_source_loc().

pub fn greater(self, e1: Expr<T>, e2: Expr<T>) -> Expr<T>

Create a ‘>’ expression. Arguments must evaluate to Long type

pub fn greatereq(self, e1: Expr<T>, e2: Expr<T>) -> Expr<T>

Create a ‘>=’ expression. Arguments must evaluate to Long type

Trait Implementations

impl<T: Debug> Debug for ExprBuilder<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for ExprBuilder<T>

fn default() -> Self

Returns the “default value” for a type.