Struct Env 

pub struct Env { /* private fields */ }

Unified environment for CEL expression processing.

The Env wraps the parser and checker, providing a high-level API for working with CEL expressions. It manages:

• Variable declarations with their types
• Function declarations (standard library + extensions)
• Container namespace for qualified name resolution
• Abbreviations for type name shortcuts

Example

use cel_core::Env;
use cel_core::CelType;

let env = Env::with_standard_library()
    .with_variable("x", CelType::Int);

let result = env.compile("x + 1");
assert!(result.is_ok());

Implementations

impl Env

pub fn new() -> Self

Create a new empty environment.

This environment has no functions or variables defined. Use with_standard_library() for a fully-featured environment.

pub fn with_standard_library() -> Self

Create a new environment with the CEL standard library.

This includes all standard operators, functions, and type constants.

Examples found in repository

examples/hello.rs (line 8)

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 9)

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 8)

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 8)

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/extensions.rs (line 13)

fn main() {
    // Enable all extensions (strings, math, encoders, optionals)
    // Extensions currently provide type declarations for the checker
    let env = Env::with_standard_library()
        .with_all_extensions()
        .with_variable("values", CelType::list(CelType::Int))
        .with_variable("text", CelType::String);

    // Math extension functions type-check correctly
    let ast = env.compile("math.greatest(values)").unwrap();
    println!("math.greatest(values) type: {:?}", ast.result_type());

    let ast = env.compile("math.least(values)").unwrap();
    println!("math.least(values) type:    {:?}", ast.result_type());

    let ast = env.compile("math.abs(-42)").unwrap();
    println!("math.abs(-42) type:         {:?}", ast.result_type());

    // String extension functions type-check correctly
    let ast = env.compile("text.split(' ')").unwrap();
    println!("text.split(' ') type:       {:?}", ast.result_type());

    let ast = env.compile("['a', 'b'].join('-')").unwrap();
    println!("['a','b'].join('-') type:   {:?}", ast.result_type());

    // Note: Runtime evaluation of extension functions is in progress.
    // For now, use standard library functions that are fully implemented:
    println!("\n=== Standard library (fully implemented) ===");

    let ast = env.compile("size(values)").unwrap();
    println!("size(values) type: {:?}", ast.result_type());

    let ast = env.compile("text.contains('hello')").unwrap();
    println!("text.contains type: {:?}", ast.result_type());

    let ast = env.compile("text.startsWith('h')").unwrap();
    println!("text.startsWith type: {:?}", ast.result_type());
}

examples/error_handling.rs (line 8)

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);
}

Additional examples can be found in:

• examples/extract_values.rs
• examples/time.rs

pub fn with_variable(self, name: impl Into<String>, cel_type: CelType) -> Self

Add a variable to the environment (builder pattern).

Example

use cel_core::Env;
use cel_core::CelType;

let env = Env::with_standard_library()
    .with_variable("x", CelType::Int)
    .with_variable("y", CelType::String);

Examples found in repository

examples/hello.rs (line 8)

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 10)

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 8)

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 9)

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/extensions.rs (line 15)

fn main() {
    // Enable all extensions (strings, math, encoders, optionals)
    // Extensions currently provide type declarations for the checker
    let env = Env::with_standard_library()
        .with_all_extensions()
        .with_variable("values", CelType::list(CelType::Int))
        .with_variable("text", CelType::String);

    // Math extension functions type-check correctly
    let ast = env.compile("math.greatest(values)").unwrap();
    println!("math.greatest(values) type: {:?}", ast.result_type());

    let ast = env.compile("math.least(values)").unwrap();
    println!("math.least(values) type:    {:?}", ast.result_type());

    let ast = env.compile("math.abs(-42)").unwrap();
    println!("math.abs(-42) type:         {:?}", ast.result_type());

    // String extension functions type-check correctly
    let ast = env.compile("text.split(' ')").unwrap();
    println!("text.split(' ') type:       {:?}", ast.result_type());

    let ast = env.compile("['a', 'b'].join('-')").unwrap();
    println!("['a','b'].join('-') type:   {:?}", ast.result_type());

    // Note: Runtime evaluation of extension functions is in progress.
    // For now, use standard library functions that are fully implemented:
    println!("\n=== Standard library (fully implemented) ===");

    let ast = env.compile("size(values)").unwrap();
    println!("size(values) type: {:?}", ast.result_type());

    let ast = env.compile("text.contains('hello')").unwrap();
    println!("text.contains type: {:?}", ast.result_type());

    let ast = env.compile("text.startsWith('h')").unwrap();
    println!("text.startsWith type: {:?}", ast.result_type());
}

examples/error_handling.rs (line 9)

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);
}

Additional examples can be found in:

• examples/extract_values.rs
• examples/time.rs

pub fn add_variable(&mut self, name: impl Into<String>, cel_type: CelType)

Add a variable to the environment (mutable).

pub fn with_function(self, decl: FunctionDecl) -> Self

Add a function declaration to the environment (builder pattern).

pub fn add_function(&mut self, decl: FunctionDecl)

Add a function declaration to the environment (mutable).

If a function with the same name already exists, overloads are merged.

pub fn with_container(self, container: impl Into<String>) -> Self

Set the container namespace (builder pattern).

The container is used for qualified name resolution.

pub fn set_container(&mut self, container: impl Into<String>)

Set the container namespace (mutable).

pub fn container(&self) -> &str

Get the container namespace.

pub fn with_proto_registry(self, registry: Arc<dyn ProtoRegistry>) -> Self

Set the proto registry (builder pattern).

The proto registry is used for resolving protobuf types during type checking and evaluation. Pass an Arc<dyn ProtoRegistry> implementation such as ProstProtoRegistry from cel-core-proto.

pub fn proto_registry(&self) -> Option<&dyn ProtoRegistry>

Get the proto registry.

pub fn with_abbreviations(self, abbreviations: Abbreviations) -> Self

Set abbreviations for qualified name resolution (builder pattern).

Abbreviations allow short names to be used instead of fully-qualified type names in expressions. This is useful when working with protobuf types from multiple packages.

Example

use cel_core::{Env, Abbreviations};

let abbrevs = Abbreviations::new()
    .with_abbreviation("google.protobuf.Duration").unwrap();

let env = Env::with_standard_library()
    .with_abbreviations(abbrevs);

pub fn abbreviations(&self) -> &Abbreviations

Get the abbreviations.

pub fn with_legacy_enums(self) -> Self

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

By default, strong enum typing is enabled and enum values carry their fully-qualified type name. In legacy mode, enum values are represented as Value::Int, matching older CEL behavior.

pub fn strong_enums(&self) -> bool

Check if strong enum typing is enabled.

pub fn with_extension( self, extension: impl IntoIterator<Item = FunctionDecl>, ) -> Self

Add an extension library to the environment (builder pattern).

Extensions provide additional functions beyond the standard library. Each extension is a collection of FunctionDecl values.

Example

use cel_core::Env;
use cel_core::ext::string_extension;

let env = Env::with_standard_library()
    .with_extension(string_extension());

pub fn with_all_extensions(self) -> Self

Add all available extension libraries to the environment (builder pattern).

This is a convenience method that adds all standard extensions:

• String extension (charAt, indexOf, substring, etc.)
• Math extension (math.greatest, math.least, math.abs, etc.)
• Encoders extension (base64.encode, base64.decode)
• Optionals extension (optional.of, optional.none, hasValue, etc.)

Example

use cel_core::Env;

let env = Env::with_standard_library()
    .with_all_extensions();

Examples found in repository

examples/extensions.rs (line 14)

fn main() {
    // Enable all extensions (strings, math, encoders, optionals)
    // Extensions currently provide type declarations for the checker
    let env = Env::with_standard_library()
        .with_all_extensions()
        .with_variable("values", CelType::list(CelType::Int))
        .with_variable("text", CelType::String);

    // Math extension functions type-check correctly
    let ast = env.compile("math.greatest(values)").unwrap();
    println!("math.greatest(values) type: {:?}", ast.result_type());

    let ast = env.compile("math.least(values)").unwrap();
    println!("math.least(values) type:    {:?}", ast.result_type());

    let ast = env.compile("math.abs(-42)").unwrap();
    println!("math.abs(-42) type:         {:?}", ast.result_type());

    // String extension functions type-check correctly
    let ast = env.compile("text.split(' ')").unwrap();
    println!("text.split(' ') type:       {:?}", ast.result_type());

    let ast = env.compile("['a', 'b'].join('-')").unwrap();
    println!("['a','b'].join('-') type:   {:?}", ast.result_type());

    // Note: Runtime evaluation of extension functions is in progress.
    // For now, use standard library functions that are fully implemented:
    println!("\n=== Standard library (fully implemented) ===");

    let ast = env.compile("size(values)").unwrap();
    println!("size(values) type: {:?}", ast.result_type());

    let ast = env.compile("text.contains('hello')").unwrap();
    println!("text.contains type: {:?}", ast.result_type());

    let ast = env.compile("text.startsWith('h')").unwrap();
    println!("text.startsWith type: {:?}", ast.result_type());
}

pub fn variables(&self) -> &HashMap<String, CelType>

Get the variables map.

pub fn functions(&self) -> &HashMap<String, FunctionDecl>

Get the functions map.

pub fn methods_for_type(&self, receiver: &CelType) -> Vec<(&str, &OverloadDecl)>

Get all member functions compatible with a given receiver type.

Returns (function_name, overload) pairs where at least one member overload has a receiver type that is assignable from the given type. Handles generic type parameters (e.g., list(T)) by treating them as wildcards.

pub fn standalone_functions(&self) -> Vec<&str>

Get all standalone (non-operator) function names.

Filters out internal operator functions (like _+_, _-_) and other internal functions that start with _ or contain @.

pub fn parse(&self, source: &str) -> ParseResult

Parse a CEL expression.

This delegates to the parser. The returned ParseResult may contain both a partial AST and errors if parsing partially succeeded.

pub fn check(&self, expr: &SpannedExpr) -> CheckResult

Type-check a parsed expression.

This delegates to the checker with the environment’s variables, functions, container, and abbreviations.

pub fn compile(&self, source: &str) -> Result<Ast, CompileError>

Parse and type-check a CEL expression, returning a checked Ast.

This is the primary entry point for compiling CEL expressions. Returns a checked Ast that can be used for evaluation.

Example

use cel_core::Env;
use cel_core::CelType;

let env = Env::with_standard_library()
    .with_variable("x", CelType::Int);

let ast = env.compile("x + 1").unwrap();
assert!(ast.is_checked());
assert_eq!(ast.result_type(), Some(&CelType::Int));

Examples found in repository

examples/hello.rs (line 10)

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 15)

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 14)

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 22)

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/extensions.rs (line 19)

fn main() {
    // Enable all extensions (strings, math, encoders, optionals)
    // Extensions currently provide type declarations for the checker
    let env = Env::with_standard_library()
        .with_all_extensions()
        .with_variable("values", CelType::list(CelType::Int))
        .with_variable("text", CelType::String);

    // Math extension functions type-check correctly
    let ast = env.compile("math.greatest(values)").unwrap();
    println!("math.greatest(values) type: {:?}", ast.result_type());

    let ast = env.compile("math.least(values)").unwrap();
    println!("math.least(values) type:    {:?}", ast.result_type());

    let ast = env.compile("math.abs(-42)").unwrap();
    println!("math.abs(-42) type:         {:?}", ast.result_type());

    // String extension functions type-check correctly
    let ast = env.compile("text.split(' ')").unwrap();
    println!("text.split(' ') type:       {:?}", ast.result_type());

    let ast = env.compile("['a', 'b'].join('-')").unwrap();
    println!("['a','b'].join('-') type:   {:?}", ast.result_type());

    // Note: Runtime evaluation of extension functions is in progress.
    // For now, use standard library functions that are fully implemented:
    println!("\n=== Standard library (fully implemented) ===");

    let ast = env.compile("size(values)").unwrap();
    println!("size(values) type: {:?}", ast.result_type());

    let ast = env.compile("text.contains('hello')").unwrap();
    println!("text.contains type: {:?}", ast.result_type());

    let ast = env.compile("text.startsWith('h')").unwrap();
    println!("text.startsWith type: {:?}", ast.result_type());
}

examples/error_handling.rs (line 17)

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);
}

Additional examples can be found in:

• examples/extract_values.rs
• examples/time.rs

pub fn parse_only(&self, source: &str) -> Result<Ast, CompileError>

Parse a CEL expression without type-checking, returning an unchecked Ast.

This is useful when you want to parse an expression but don’t need type information, or when you want to defer type-checking.

Example

use cel_core::Env;

let env = Env::with_standard_library();

let ast = env.parse_only("1 + 2").unwrap();
assert!(!ast.is_checked());
assert_eq!(ast.to_cel_string(), "1 + 2");

pub fn program(&self, ast: &Ast) -> Result<Program, CompileError>

Create a program from a compiled AST.

The program contains the AST and a function registry with implementations for all functions registered in this environment.

Example

use cel_core::{Env, CelType};
use cel_core::{Value, MapActivation, Activation};

let env = Env::with_standard_library()
    .with_variable("x", CelType::Int);

let ast = env.compile("x + 1").unwrap();
let program = env.program(&ast).unwrap();

let mut activation = MapActivation::new();
activation.insert("x", Value::Int(41));

let result = program.eval(&activation);
assert_eq!(result, Value::Int(42));

Examples found in repository

examples/hello.rs (line 11)

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 19)

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 15)

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 23)

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 18)

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 23)

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

Trait Implementations

impl Clone for Env

fn clone(&self) -> Env

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Env

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

Formats the value using the given formatter.

impl Default for Env

fn default() -> Self

Returns the “default value” for a type.