Struct ComprehensionExpr 

pub struct ComprehensionExpr {
    pub iter_var: String,
    pub iter_var2: String,
    pub iter_range: Expr,
    pub accu_var: String,
    pub accu_init: Expr,
    pub loop_condition: Expr,
    pub loop_step: Expr,
    pub result: Expr,
}

A comprehension expression for list/map processing.

Comprehensions are CEL’s powerful iteration construct, similar to list comprehensions in Python. They consist of iteration, accumulation, and result computation phases.

Structure

A comprehension has:

• One or two iteration variables that range over a collection
• An accumulator variable that maintains state across iterations
• A loop condition that determines when to continue
• A loop step that updates the accumulator
• A result expression that produces the final value

Examples

Single variable: [x * 2 | x in [1, 2, 3]]

• iter_var: "x"
• iter_range: [1, 2, 3]
• Result: [2, 4, 6]

Two variables (map iteration): [k | k, v in {"a": 1, "b": 2}, v > 1]

• iter_var: "k" (key)
• iter_var2: "v" (value)
• iter_range: {"a": 1, "b": 2}
• Result: ["b"]

Fields

iter_var: String

The first iteration variable name (required).

iter_var2: String

The second iteration variable name (empty string if not used).

iter_range: Expr

The expression providing the collection to iterate over.

accu_var: String

The accumulator variable name.

accu_init: Expr

The initial value of the accumulator.

loop_condition: Expr

The condition to continue iterating (often just true).

loop_step: Expr

The expression to update the accumulator each iteration.

result: Expr

The final expression computed from the accumulator.

Trait Implementations

impl Debug for ComprehensionExpr

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

Formats the value using the given formatter.

impl From<&ComprehensionExpr> for ComprehensionExpr

fn from(value: &ComprehensionExpr) -> Self

Converts to this type from the input type.

impl From<UniquePtr<ComprehensionExpr>> for ComprehensionExpr

fn from(value: UniquePtr<ComprehensionExpr>) -> Self

Converts to this type from the input type.