Struct Program 

pub struct Program { /* private fields */ }

A compiled CEL program ready for evaluation.

The program holds a reference to the AST and a function registry, providing a convenient interface for evaluating the expression against different variable bindings.

Implementations

impl Program

pub fn new(ast: Arc<Ast>, functions: Arc<FunctionRegistry>) -> Self

Create a new program from an AST and function registry.

pub fn with_proto_registry( ast: Arc<Ast>, functions: Arc<FunctionRegistry>, proto_registry: Arc<dyn ProtoRegistry>, ) -> Self

Create a new program with a type registry.

pub fn with_abbreviations( ast: Arc<Ast>, functions: Arc<FunctionRegistry>, abbreviations: HashMap<String, String>, ) -> Self

Create a new program with abbreviations.

pub fn with_proto_registry_and_abbreviations( ast: Arc<Ast>, functions: Arc<FunctionRegistry>, proto_registry: Arc<dyn ProtoRegistry>, abbreviations: HashMap<String, String>, ) -> Self

Create a new program with a type registry and abbreviations.

pub fn with_legacy_enums(self) -> Self

Use legacy (weak) enum mode where enum values are returned as plain integers.

pub fn ast(&self) -> &Ast

Get the AST for this program.

pub fn functions(&self) -> &FunctionRegistry

Get the function registry for this program.

pub fn eval(&self, activation: &dyn Activation) -> Value

Evaluate the program with the given variable bindings.

Examples found in repository

examples/hello.rs (line 16)

fn main() {
    let env = Env::with_standard_library().with_variable("name", CelType::String);

    let ast = env.compile(r#""Hello, " + name + "!""#).unwrap();
    let program = env.program(&ast).unwrap();

    let mut activation = MapActivation::new();
    activation.insert("name", "World");

    let result = program.eval(&activation);
    println!("{}", result);
}

examples/quickstart.rs (line 27)

fn main() {
    // 1. Create an environment with the standard library and declare variables
    let env = Env::with_standard_library()
        .with_variable("user", CelType::String)
        .with_variable("age", CelType::Int);

    // 2. Compile the expression (parse + type-check)
    let ast = env
        .compile("age >= 21 && user.startsWith('admin')")
        .unwrap();

    // 3. Create a program from the compiled AST
    let program = env.program(&ast).unwrap();

    // 4. Set up variable bindings for evaluation
    let mut activation = MapActivation::new();
    activation.insert("user", "admin_alice"); // &str converts automatically
    activation.insert("age", 25); // integers widen automatically

    // 5. Evaluate the expression
    let result = program.eval(&activation);
    assert_eq!(result, Value::Bool(true));

    println!("Expression: age >= 21 && user.startsWith('admin')");
    println!("Result: {}", result);
}

examples/lists.rs (line 16)

fn main() {
    let env = Env::with_standard_library().with_variable("numbers", CelType::list(CelType::Int));

    let mut activation = MapActivation::new();
    activation.insert("numbers", Value::list([1, 5, 3, 8, 2]));

    // Filter: keep only values > 3
    let ast = env.compile("numbers.filter(x, x > 3)").unwrap();
    let program = env.program(&ast).unwrap();
    let result = program.eval(&activation);
    println!("filter(x, x > 3): {}", result);

    // Map: double each value
    let ast = env.compile("numbers.map(x, x * 2)").unwrap();
    let program = env.program(&ast).unwrap();
    let result = program.eval(&activation);
    println!("map(x, x * 2):    {}", result);

    // Exists: any value > 7?
    let ast = env.compile("numbers.exists(x, x > 7)").unwrap();
    let program = env.program(&ast).unwrap();
    let result = program.eval(&activation);
    println!("exists(x, x > 7): {}", result);

    // All: all values > 0?
    let ast = env.compile("numbers.all(x, x > 0)").unwrap();
    let program = env.program(&ast).unwrap();
    let result = program.eval(&activation);
    println!("all(x, x > 0):    {}", result);

    // Size
    let ast = env.compile("numbers.size()").unwrap();
    let program = env.program(&ast).unwrap();
    let result = program.eval(&activation);
    println!("size():           {}", result);

    // Contains (using 'in' operator)
    let ast = env.compile("5 in numbers").unwrap();
    let program = env.program(&ast).unwrap();
    let result = program.eval(&activation);
    println!("5 in numbers:     {}", result);
}

examples/maps.rs (line 24)

fn main() {
    let env = Env::with_standard_library()
        .with_variable("user", CelType::map(CelType::String, CelType::Dyn));

    // Mixed value types require explicit Value::from()
    let user = Value::map([
        ("name", Value::from("Alice")),
        ("age", Value::from(30)), // i32 automatically widens to i64
        ("active", Value::from(true)),
    ]);

    let mut activation = MapActivation::new();
    activation.insert("user", user);

    // Field access
    let ast = env.compile("user.name").unwrap();
    let program = env.program(&ast).unwrap();
    let result = program.eval(&activation);
    println!("user.name:     {}", result);

    // Index access
    let ast = env.compile(r#"user["age"]"#).unwrap();
    let program = env.program(&ast).unwrap();
    let result = program.eval(&activation);
    println!(r#"user["age"]:   {}"#, result);

    // Check field existence with 'in'
    let ast = env.compile(r#""name" in user"#).unwrap();
    let program = env.program(&ast).unwrap();
    let result = program.eval(&activation);
    println!(r#""name" in user: {}"#, result);

    // Check field existence with has()
    let ast = env.compile("has(user.email)").unwrap();
    let program = env.program(&ast).unwrap();
    let result = program.eval(&activation);
    println!("has(user.email): {}", result);

    // Combine conditions
    let ast = env.compile(r#"user.active && user.age >= 21"#).unwrap();
    let program = env.program(&ast).unwrap();
    let result = program.eval(&activation);
    println!("active && age >= 21: {}", result);
}

examples/error_handling.rs (line 19)

fn main() {
    let env = Env::with_standard_library()
        .with_variable("x", CelType::Int)
        .with_variable("items", CelType::list(CelType::Int));

    let mut activation = MapActivation::new();

    // Division by zero returns an error value
    println!("=== Division by zero ===");
    activation.insert("x", 0);
    let ast = env.compile("10 / x").unwrap();
    let program = env.program(&ast).unwrap();
    let result = program.eval(&activation);

    match &result {
        Value::Error(err) => println!("Error: {}", err),
        other => println!("Result: {}", other),
    }

    // Index out of bounds
    println!("\n=== Index out of bounds ===");
    activation.insert("items", Value::list([1, 2, 3]));
    let ast = env.compile("items[10]").unwrap();
    let program = env.program(&ast).unwrap();
    let result = program.eval(&activation);

    match &result {
        Value::Error(err) => println!("Error: {}", err),
        other => println!("Result: {}", other),
    }

    // Key not found in map
    println!("\n=== Key not found ===");
    let env = Env::with_standard_library()
        .with_variable("config", CelType::map(CelType::String, CelType::String));
    let mut activation = MapActivation::new();
    activation.insert("config", Value::map([("host", "localhost")]));

    let ast = env.compile("config.missing_key").unwrap();
    let program = env.program(&ast).unwrap();
    let result = program.eval(&activation);

    match &result {
        Value::Error(err) => println!("Error: {}", err),
        other => println!("Result: {}", other),
    }

    // Use has() to safely check field existence
    println!("\n=== Safe field access with has() ===");
    let ast = env
        .compile("has(config.missing_key) ? config.missing_key : 'default'")
        .unwrap();
    let program = env.program(&ast).unwrap();
    let result = program.eval(&activation);
    println!("Result: {}", result);
}

examples/extract_values.rs (line 24)

fn main() {
    let env = Env::with_standard_library()
        .with_variable("count", CelType::Int)
        .with_variable("items", CelType::list(CelType::Int))
        .with_variable("config", CelType::map(CelType::String, CelType::String));

    let mut activation = MapActivation::new();
    activation.insert("count", 42); // i32 automatically widens to i64
    activation.insert("items", Value::list([1, 2, 3]));
    activation.insert(
        "config",
        Value::map([("host", "localhost"), ("port", "8080")]),
    );

    // Extract i64
    let ast = env.compile("count * 2").unwrap();
    let program = env.program(&ast).unwrap();
    let result = program.eval(&activation);

    let value: i64 = (&result).try_into().expect("expected int");
    println!("i64: {}", value);

    // Extract bool
    let ast = env.compile("count > 10").unwrap();
    let program = env.program(&ast).unwrap();
    let result = program.eval(&activation);

    let value: bool = (&result).try_into().expect("expected bool");
    println!("bool: {}", value);

    // Extract &str
    let ast = env.compile("config.host").unwrap();
    let program = env.program(&ast).unwrap();
    let result = program.eval(&activation);

    let value: &str = (&result).try_into().expect("expected string");
    println!("&str: {}", value);

    // Extract &[Value] (list)
    let ast = env.compile("items.filter(x, x > 1)").unwrap();
    let program = env.program(&ast).unwrap();
    let result = program.eval(&activation);

    let list: &[Value] = (&result).try_into().expect("expected list");
    println!("list length: {}", list.len());
    for (i, v) in list.iter().enumerate() {
        let n: i64 = v.try_into().expect("expected int");
        println!("  [{}] = {}", i, n);
    }

    // Extract &ValueMap
    let ast = env.compile("config").unwrap();
    let program = env.program(&ast).unwrap();
    let result = program.eval(&activation);

    let map: &ValueMap = (&result).try_into().expect("expected map");
    println!("map size: {}", map.len());
    for (k, v) in map.iter() {
        println!("  {:?} = {}", k, v);
    }

    // Handle errors gracefully
    let result = Value::from("not an int");
    let attempt: Result<i64, _> = (&result).try_into();
    match attempt {
        Ok(v) => println!("got: {}", v),
        Err(e) => println!("conversion error: {}", e),
    }

    // Extract &OptionalValue
    let opt_result = Value::optional_some(Value::from(99));
    let opt: &OptionalValue = (&opt_result).try_into().expect("expected optional");
    if opt.is_present() {
        let inner: i64 = opt.as_value().unwrap().try_into().expect("expected int");
        println!("optional value: {}", inner);
    }
}

Additional examples can be found in:

• examples/time.rs

pub fn eval_with_container( &self, activation: &dyn Activation, container: &str, ) -> Value

Evaluate the program with the given variable bindings and container namespace.

The container is used for resolving unqualified type names following C++ namespace rules. For example, with container “cel.expr.conformance.proto3” and type name “TestAllTypes”, resolution tries:

1. cel.expr.conformance.proto3.TestAllTypes
2. cel.expr.conformance.TestAllTypes
3. cel.expr.TestAllTypes
4. cel.TestAllTypes
5. TestAllTypes

pub fn eval_empty(&self) -> Value

Evaluate the program with no variable bindings.

Trait Implementations

impl Clone for Program

fn clone(&self) -> Program

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Program

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

Formats the value using the given formatter.