Enum ExprNoExt 

pub enum ExprNoExt {
    Value(CedarValueJson),
    Var(Var),
    Slot(SlotId),
    Not {
        arg: Arc<Expr>,
    },
    Neg {
        arg: Arc<Expr>,
    },
    Eq {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    NotEq {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    In {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    Less {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    LessEq {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    Greater {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    GreaterEq {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    And {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    Or {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    Add {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    Sub {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    Mul {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    Contains {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    ContainsAll {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    ContainsAny {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    IsEmpty {
        arg: Arc<Expr>,
    },
    GetTag {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    HasTag {
        left: Arc<Expr>,
        right: Arc<Expr>,
    },
    GetAttr {
        left: Arc<Expr>,
        attr: SmolStr,
    },
    HasAttr(HasAttrRepr),
    Like {
        left: Arc<Expr>,
        pattern: Vec<PatternElem>,
    },
    Is {
        left: Arc<Expr>,
        entity_type: SmolStr,
        in_expr: Option<Arc<Expr>>,
    },
    If {
        cond_expr: Arc<Expr>,
        then_expr: Arc<Expr>,
        else_expr: Arc<Expr>,
    },
    Set(Vec<Expr>),
    Record(BTreeMap<SmolStr, Expr>),
    Error(AstExprErrorKind),
}

Serde JSON structure for [any Cedar expression other than an extension function call] in the EST format

Variants

Value(CedarValueJson)

Literal value (including anything that’s legal to express in the attribute-value JSON format)

Var(Var)

Var

Slot(SlotId)

Template slot

Not

!

Fields

arg: Arc<Expr>

Argument

Neg

-

Fields

arg: Arc<Expr>

Argument

Eq

==

Fields

left: Arc<Expr>

Left-hand argument

right: Arc<Expr>

Right-hand argument

NotEq

!=

Fields

left: Arc<Expr>

Left-hand argument

right: Arc<Expr>

Right-hand argument

In

in

Fields

left: Arc<Expr>

Left-hand argument

right: Arc<Expr>

Right-hand argument

Less

<

Fields

left: Arc<Expr>

Left-hand argument

right: Arc<Expr>

Right-hand argument

LessEq

<=

Fields

left: Arc<Expr>

Left-hand argument

right: Arc<Expr>

Right-hand argument

Greater

>

Fields

left: Arc<Expr>

Left-hand argument

right: Arc<Expr>

Right-hand argument

GreaterEq

>=

Fields

left: Arc<Expr>

Left-hand argument

right: Arc<Expr>

Right-hand argument

And

&&

Fields

left: Arc<Expr>

Left-hand argument

right: Arc<Expr>

Right-hand argument

Or

||

Fields

left: Arc<Expr>

Left-hand argument

right: Arc<Expr>

Right-hand argument

Add

+

Fields

left: Arc<Expr>

Left-hand argument

right: Arc<Expr>

Right-hand argument

Sub

-

Fields

left: Arc<Expr>

Left-hand argument

right: Arc<Expr>

Right-hand argument

Mul

*

Fields

left: Arc<Expr>

Left-hand argument

right: Arc<Expr>

Right-hand argument

Contains

contains()

Fields

left: Arc<Expr>

Left-hand argument (receiver)

right: Arc<Expr>

Right-hand argument (inside the ())

ContainsAll

containsAll()

Fields

left: Arc<Expr>

Left-hand argument (receiver)

right: Arc<Expr>

Right-hand argument (inside the ())

ContainsAny

containsAny()

Fields

left: Arc<Expr>

Left-hand argument (receiver)

right: Arc<Expr>

Right-hand argument (inside the ())

IsEmpty

isEmpty()

Fields

arg: Arc<Expr>

Argument

GetTag

getTag()

Fields

left: Arc<Expr>

Left-hand argument (receiver)

right: Arc<Expr>

Right-hand argument (inside the ())

HasTag

hasTag()

Fields

left: Arc<Expr>

Left-hand argument (receiver)

right: Arc<Expr>

Right-hand argument (inside the ())

GetAttr

Get-attribute

Fields

left: Arc<Expr>

Left-hand argument

attr: SmolStr

Attribute name

HasAttr(HasAttrRepr)

has

Like

like

Fields

left: Arc<Expr>

Left-hand argument

pattern: Vec<PatternElem>

Pattern

Is

<entity> is <entity_type> in <entity_or_entity_set>

Fields

left: Arc<Expr>

Left-hand entity argument

entity_type: SmolStr

Entity type

in_expr: Option<Arc<Expr>>

Entity or entity set

If

Ternary

Fields

cond_expr: Arc<Expr>

Condition

then_expr: Arc<Expr>

then expression

else_expr: Arc<Expr>

else expression

Set(Vec<Expr>)

Set literal, whose elements may be arbitrary expressions (which is why we need this case specifically and can’t just use Expr::Value)

Record(BTreeMap<SmolStr, Expr>)

Record literal, whose elements may be arbitrary expressions (which is why we need this case specifically and can’t just use Expr::Value)

Error(AstExprErrorKind)

Available on crate feature tolerant-ast only.

AST Error node - this represents a parsing error in a partially generated AST

Trait Implementations

impl BoundedDisplay for ExprNoExt

fn fmt(&self, f: &mut impl Write, n: Option<usize>) -> Result

Write self to the writer f, truncating set elements or key-value pairs if necessary based on n

fn fmt_bounded(&self, f: &mut impl Write, n: usize) -> Result

Convenience method, equivalent to fmt() with n as Some.

fn fmt_unbounded(&self, f: &mut impl Write) -> Result

Convenience method, equivalent to fmt() with n as None.

impl Clone for ExprNoExt

fn clone(&self) -> ExprNoExt

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExprNoExt

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExprNoExt

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ExprNoExt

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

Formats the value using the given formatter.

impl PartialEq for ExprNoExt

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

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 ExprNoExt