Enum Expr 

pub enum Expr {
    Const(Value),
    Key(String),
    Add(Vec<Expr>),
    Mul(Vec<Expr>),
    Sub(Box<Expr>, Box<Expr>),
    Div(Box<Expr>, Box<Expr>),
    Min(Vec<Expr>),
    Max(Vec<Expr>),
    Eq(Box<Expr>, Box<Expr>),
    Gt(Box<Expr>, Box<Expr>),
    Gte(Box<Expr>, Box<Expr>),
    Lt(Box<Expr>, Box<Expr>),
    Lte(Box<Expr>, Box<Expr>),
    All(Vec<Expr>),
    Any(Vec<Expr>),
    Not(Box<Expr>),
    If {
        when: Box<Expr>,
        then: Box<Expr>,
        otherwise: Box<Expr>,
    },
    Coalesce(Vec<Expr>),
    Concat(Vec<Expr>),
    CountTrue(Vec<String>),
}

A serializable expression over session state. See the module docs.

Variants

Const(Value)

A literal value.

Key(String)

Read a state key (with the derived: fallback of State::get).

Add(Vec<Expr>)

Numeric sum of all operands.

Mul(Vec<Expr>)

Numeric product of all operands.

Sub(Box<Expr>, Box<Expr>)

a - b.

Div(Box<Expr>, Box<Expr>)

a / b (None when b is zero).

Min(Vec<Expr>)

Numeric minimum of all operands.

Max(Vec<Expr>)

Numeric maximum of all operands.

Eq(Box<Expr>, Box<Expr>)

Structural equality of two values.

Gt(Box<Expr>, Box<Expr>)

a > b (numeric).

Gte(Box<Expr>, Box<Expr>)

a >= b (numeric).

Lt(Box<Expr>, Box<Expr>)

a < b (numeric).

Lte(Box<Expr>, Box<Expr>)

a <= b (numeric).

All(Vec<Expr>)

true when every operand is true (missing counts as false).

Any(Vec<Expr>)

true when any operand is true (missing counts as false).

Not(Box<Expr>)

Boolean negation (missing counts as false, so not of it is true).

If

Branch on a condition’s truthiness.

Fields

when: Box<Expr>

Condition (truthy = boolean true).

then: Box<Expr>

Value when the condition holds.

otherwise: Box<Expr>

Value otherwise.

Coalesce(Vec<Expr>)

The first operand that evaluates to a value.

Concat(Vec<Expr>)

String concatenation of all operands (numbers/booleans stringified; missing operands contribute nothing).

CountTrue(Vec<String>)

How many of the named state keys are true.

Implementations

impl Expr

pub fn eval(&self, state: &State) -> Option<Value>

Evaluate against state. None means “no value” — a computed variable skips its write for this cycle.

pub fn keys_read(&self) -> BTreeSet<String>

Every state key this expression reads, recursively — the dependency set of a computed variable, and the load-time read universe for validation.

pub fn describe(&self) -> String

A compact human-readable rendering, for diagnostics and UI labels.

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Expr

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Expr

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl PartialEq for Expr

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

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 Expr