Struct EnvBuilder

pub struct EnvBuilder<'f, Fm: FnMarker = (), Rm: RuntimeMarker = ()> { /* private fields */ }

Builder for creating CEL environments.

The EnvBuilder allows you to configure a CEL environment by registering functions, declaring variables, and setting up runtime options before building the final environment.

Type Parameters

• 'f: Lifetime of functions that will be registered
• Fm: Function marker type indicating sync/async function support
• Rm: Runtime marker type indicating the async runtime (if any)

Examples

use cel_cxx::*;

let env = Env::builder()
    .register_global_function("double", |x: i64| -> i64 { x * 2 })?
    .declare_variable::<String>("message")?
    .build()?;

Implementations

impl<'f, Fm: FnMarker, Rm: RuntimeMarker> EnvBuilder<'f, Fm, Rm>

pub fn new() -> Self

Creates a new environment builder.

Examples

use cel_cxx::*;

let builder = EnvBuilder::<()>::new();

impl<'f, Fm: FnMarker, Rm: RuntimeMarker> EnvBuilder<'f, Fm, Rm>

pub fn register_function<F, Ffm, Args>( self, name: impl Into<String>, member: bool, f: F, ) -> Result<EnvBuilder<'f, <Ffm as FnMarkerAggr<Fm>>::Output, Rm>, Error>

where F: IntoFunction<'f, Ffm, Args>, Ffm: FnMarker + FnMarkerAggr<Fm>, Args: Arguments,

Registers a function (either global or member).

This method allows you to register custom functions that can be called from CEL expressions. The function can be either a global function or a member function of a type.

Function Registration Process

When you register a function, the system:

1. Extracts type information from the function signature
2. Creates type-safe conversion wrappers
3. Stores both the type signature and implementation
4. Updates the function marker type to track sync/async status

Zero-Annotation Benefits

Functions are registered without explicit type annotations:

• Argument types are automatically inferred
• Return types are automatically determined
• Error handling is automatically supported for Result<T, E> returns
• Reference parameters like &str are handled safely

Arguments

• name - The name of the function as it will appear in CEL expressions
• member - Whether this is a member function (true) or global function (false)
• f - The function implementation (function pointer, closure, etc.)

Type Parameters

• F - The function implementation type
• Ffm - The function marker type (sync/async) inferred from the function
• Args - The argument tuple type (automatically inferred)

Returns

A new EnvBuilder with updated function marker type. If this is the first async function registered, the marker changes from () to Async.

Member vs Global Functions

Global Functions

Called as function_name(args...):

max(a, b)           // max function with two arguments
calculate(x, y, z)  // calculate function with three arguments

Member Functions

Called as object.method(args...):

text.contains(substring)    // contains method on string
list.size()                // size method on list

Function Signature Support

Supports various function signatures:

• Simple functions: fn(T) -> U
• Functions with errors: fn(T) -> Result<U, E>
• Reference parameters: fn(&str, i64) -> String
• Multiple parameters: Up to 10 parameters supported
• Closures: Move closures that capture environment

Errors

Returns Error if:

• Function name conflicts with existing registration
• Function signature is invalid or unsupported
• Type inference fails

Examples

Basic Functions

use cel_cxx::*;

let builder = Env::builder()
    .register_function("add", false, |a: i64, b: i64| a + b)?
    .register_function("greet", false, |name: &str| format!("Hello, {}!", name))?;

Member Functions

use cel_cxx::*;

let builder = Env::builder()
    .register_function("contains", true, |text: &str, substr: &str| text.contains(substr))?
    .register_function("length", true, |text: &str| text.len() as i64)?;

// Usage in expressions:
// text.contains("hello")
// text.length()

Functions with Error Handling

use cel_cxx::*;

let builder = Env::builder()
    .register_function("divide", false, |a: f64, b: f64| -> Result<f64, Error> {
        if b == 0.0 {
            Err(Error::invalid_argument("division by zero"))
        } else {
            Ok(a / b)
        }
    })?;

Closures with Captured Data

use cel_cxx::*;

let multiplier = 5;
let threshold = 100.0;

let builder = Env::builder()
    .register_function("scale", false, move |x: i64| x * multiplier)?
    .register_function("check_limit", false, move |value: f64| value < threshold)?;

pub fn register_member_function<F, Ffm, Args>( self, name: impl Into<String>, f: F, ) -> Result<EnvBuilder<'f, <Ffm as FnMarkerAggr<Fm>>::Output, Rm>, Error>

where F: IntoFunction<'f, Ffm, Args>, Ffm: FnMarker + FnMarkerAggr<Fm>, Args: Arguments,

Registers a member function.

This is a convenience method for registering member functions, equivalent to calling register_function(name, true, f). Member functions are called using dot notation in CEL expressions: object.method(args...).

Arguments

• name - The method name as it will appear in CEL expressions
• f - The function implementation

Member Function Semantics

Member functions in CEL follow these patterns:

• First parameter is the “receiver” (the object before the dot)
• Additional parameters become method arguments
• Called as receiver.method(arg1, arg2, ...)

Examples

String Methods

use cel_cxx::*;

let builder = Env::builder()
    .register_member_function("upper", |s: &str| s.to_uppercase())?
    .register_member_function("contains", |s: &str, substr: &str| s.contains(substr))?
    .register_member_function("repeat", |s: &str, n: i64| s.repeat(n as usize))?;

// Usage in expressions:
// "hello".upper()           -> "HELLO"
// "hello world".contains("world") -> true
// "abc".repeat(3)           -> "abcabcabc"

Numeric Methods

use cel_cxx::*;

let builder = Env::builder()
    .register_member_function("abs", |x: f64| x.abs())?
    .register_member_function("pow", |x: f64, exp: f64| x.powf(exp))?;

// Usage in expressions:
// (-5.5).abs()     -> 5.5
// (2.0).pow(3.0)   -> 8.0

Examples found in repository

examples/comprehensive.rs (line 275)

fn demo3_opaque_member_functions() -> Result<(), Error> {
    println!("📌 Demo 3: Opaque Types & Member Functions");

    let env = Env::builder()
        .declare_variable::<Student>("student")?
        // ✨ Register struct methods directly using RustType::method_name syntax
        .register_member_function("get_name", Student::get_name)?
        .register_member_function("get_age", Student::get_age)?
        .register_member_function("get_grade", Student::get_grade)?
        .register_member_function("is_passing", Student::is_passing)?
        .register_member_function("has_subject", Student::has_subject)?
        .register_member_function("get_letter_grade", Student::get_letter_grade)?
        .build()?;

    let student = Student {
        name: "John Doe".to_string(),
        age: 18,
        grade: 87.5,
        subjects: vec!["Math".to_string(), "Physics".to_string()],
    };

    let activation = Activation::new().bind_variable("student", student)?;

    let test_expressions = vec![
        ("student.get_name()", "Get student name"),
        ("student.get_age()", "Get student age"),
        ("student.get_grade()", "Get numerical grade"),
        ("student.get_letter_grade()", "Get letter grade"),
        ("student.is_passing()", "Check if passing"),
        ("student.has_subject('Math')", "Check if has Math subject"),
        (
            "student.has_subject('Chemistry')",
            "Check if has Chemistry subject",
        ),
    ];

    for (expr, description) in test_expressions {
        let program = env.compile(expr)?;
        let result = program.evaluate(&activation)?;
        println!("  {} = {} ({})", expr, result, description);
    }

    println!();
    Ok(())
}

/// Demo 4: Type conversions and standard Rust types
fn demo4_type_conversions() -> Result<(), Error> {
    println!("📌 Demo 4: Type Conversions & Standard Rust Types");

    // Functions returning different types (both direct values and Results)
    fn return_string_direct() -> String {
        "hello world".to_string()
    }
    fn return_int_result() -> Result<i64, std::io::Error> {
        Ok(42)
    }
    fn return_list() -> Vec<i64> {
        vec![1, 2, 3, 4, 5]
    }
    fn return_map() -> HashMap<String, i64> {
        let mut map = HashMap::new();
        map.insert("key1".to_string(), 100);
        map.insert("key2".to_string(), 200);
        map
    }
    fn return_optional_some() -> Option<String> {
        Some("optional value".to_string())
    }
    fn return_optional_none() -> Option<String> {
        None
    }

    let env = Env::builder()
        .register_global_function("return_string_direct", return_string_direct)?
        .register_global_function("return_int_result", return_int_result)?
        .register_global_function("return_list", return_list)?
        .register_global_function("return_map", return_map)?
        .register_global_function("return_optional_some", return_optional_some)?
        .register_global_function("return_optional_none", return_optional_none)?
        .build()?;

    let test_cases = vec![
        ("return_string_direct()", "String conversion"),
        ("return_int_result()", "Result<i64> conversion"),
        ("return_list()", "Vec<i64> conversion"),
        ("return_map()", "HashMap conversion"),
        ("return_optional_some()", "Option<String> Some conversion"),
        ("return_optional_none()", "Option<String> None conversion"),
    ];

    for (expr, description) in test_cases {
        let program = env.compile(expr)?;
        let result = program.evaluate(())?;
        println!("  {} = {} ({})", expr, result, description);

        // Demonstrate type conversion back to Rust types
        match expr {
            "return_string_direct()" => {
                let rust_string: String = result
                    .try_into()
                    .map_err(|_| Error::invalid_argument("string conversion failed".to_string()))?;
                println!("    Converted back to Rust String: '{}'", rust_string);
            }
            "return_int_result()" => {
                let rust_int: i64 = result
                    .try_into()
                    .map_err(|_| Error::invalid_argument("int conversion failed".to_string()))?;
                println!("    Converted back to Rust i64: {}", rust_int);
            }
            "return_list()" => {
                let rust_list: Vec<i64> = result
                    .try_into()
                    .map_err(|_| Error::invalid_argument("list conversion failed".to_string()))?;
                println!("    Converted back to Rust Vec<i64>: {:?}", rust_list);
            }
            _ => {}
        }
    }

    println!();
    Ok(())
}

/// Demo 5: Generic functions and type annotations
fn demo5_generic_functions() -> Result<(), Error> {
    println!("📌 Demo 5: Generic Functions & Function Overloads");

    // Generic function that counts items in any Vec<T>
    fn count_items<T>(items: Vec<T>) -> i64 {
        items.len() as i64
    }

    // Generic function that processes maps
    fn get_map_size<K, V>(map: HashMap<K, V>) -> i64 {
        map.len() as i64
    }

    // Function working with references in containers
    fn join_strings(strings: Vec<&str>, separator: &str) -> String {
        strings.join(separator)
    }

    let env = Env::builder()
        .declare_variable::<Vec<String>>("string_list")?
        .declare_variable::<Vec<i64>>("int_list")?
        .declare_variable::<HashMap<String, i64>>("score_map")?
        .declare_variable::<Vec<f64>>("floats")?
        // Register generic functions with specific type annotations
        .register_global_function("count_strings", count_items::<String>)?
        .register_global_function("count_ints", count_items::<i64>)?
        .register_global_function("get_string_map_size", get_map_size::<String, i64>)?
        .register_global_function("join_strings", join_strings)?
        // Multiple functions with same name, different signatures (overloads)
        .register_global_function("process", |x: i64| x * 2)?
        .register_global_function("process", |x: f64| (x * 2.0).round())?
        .register_global_function("process", |x: String| x.to_uppercase())?
        // Overloaded member functions for different container types
        .register_member_function("sum", |numbers: Vec<i64>| numbers.iter().sum::<i64>())?
        .register_member_function("sum", |floats: Vec<f64>| floats.iter().sum::<f64>())?
        .build()?;

    let test_cases = vec![
        // Generic function tests
        ("count_strings(string_list)", "Count strings in list"),
        ("count_ints(int_list)", "Count integers in list"),
        ("get_string_map_size(score_map)", "Get map size"),
        ("join_strings(string_list, ' ')", "Join strings with space"),
        // Function overload tests
        ("process(42)", "Process integer (multiply by 2)"),
        ("process(3.14)", "Process float (multiply by 2, round)"),
        ("process('hello')", "Process string (uppercase)"),
        ("int_list.sum()", "Sum integers"),
        ("floats.sum()", "Sum floats"),
    ];

    let activation = Activation::new()
        .bind_variable(
            "string_list",
            vec!["hello".to_string(), "world".to_string(), "rust".to_string()],
        )?
        .bind_variable("int_list", vec![1, 2, 3, 4, 5, 6])?
        .bind_variable("floats", vec![1.5, 2.7, 3.143, 4.0])?
        .bind_variable("score_map", {
            let mut map = HashMap::new();
            map.insert("alice".to_string(), 95);
            map.insert("bob".to_string(), 87);
            map.insert("charlie".to_string(), 92);
            map
        })?;

    for (expr, description) in test_cases {
        let program = env.compile(expr)?;
        let result = program.evaluate(&activation)?;
        println!("  {} = {} ({})", expr, result, description);
    }

    println!();
    Ok(())
}

pub fn register_global_function<F, Ffm, Args>( self, name: impl Into<String>, f: F, ) -> Result<EnvBuilder<'f, <Ffm as FnMarkerAggr<Fm>>::Output, Rm>, Error>

where F: IntoFunction<'f, Ffm, Args>, Ffm: FnMarker + FnMarkerAggr<Fm>, Args: Arguments,

Registers a global function.

This is a convenience method for registering global functions, equivalent to calling register_function(name, false, f). Global functions are called directly by name in CEL expressions: function_name(args...).

Arguments

• name - The function name as it will appear in CEL expressions
• f - The function implementation

Global Function Characteristics

Global functions:

• Are called directly by name without a receiver object
• Can have 0 to 10 parameters
• Support all CEL-compatible parameter and return types
• Can capture environment variables (for closures)

Function Naming Guidelines

• Use clear, descriptive names: calculate_tax, format_date
• Follow CEL naming conventions (snake_case is recommended)
• Avoid conflicts with built-in CEL functions
• Consider namespacing for domain-specific functions: math_sqrt, string_trim

Examples

Mathematical Functions

use cel_cxx::*;

let builder = Env::builder()
    .register_global_function("add", |a: i64, b: i64| a + b)?
    .register_global_function("multiply", |a: f64, b: f64| a * b)?
    .register_global_function("max", |a: i64, b: i64| if a > b { a } else { b })?;

// Usage in expressions:
// add(10, 20)          -> 30
// multiply(2.5, 4.0)   -> 10.0
// max(15, 8)           -> 15

String Processing Functions

use cel_cxx::*;

let builder = Env::builder()
    .register_global_function("concat", |a: &str, b: &str| format!("{}{}", a, b))?
    .register_global_function("trim_prefix", |s: &str, prefix: &str| {
        s.strip_prefix(prefix).unwrap_or(s).to_string()
    })?;

// Usage in expressions:
// concat("Hello, ", "World!")     -> "Hello, World!"
// trim_prefix("prefixed_text", "prefixed_")  -> "text"

Business Logic Functions

use cel_cxx::*;

let builder = Env::builder()
    .register_global_function("calculate_discount", |price: f64, rate: f64| {
        price * (1.0 - rate.min(1.0).max(0.0))
    })?
    .register_global_function("is_valid_email", |email: &str| {
        email.contains('@') && email.contains('.')
    })?;

// Usage in expressions:
// calculate_discount(100.0, 0.15)     -> 85.0
// is_valid_email("user@domain.com")   -> true

Functions with Complex Logic

use cel_cxx::*;
use std::collections::HashMap;

// Function that processes collections
let builder = Env::builder()
    .register_global_function("sum_positive", |numbers: Vec<i64>| {
        numbers.iter().filter(|&x| *x > 0).sum::<i64>()
    })?;

// Usage in expressions:
// sum_positive([1, -2, 3, -4, 5])  -> 9

Examples found in repository

examples/basic.rs (line 14)

fn main() -> Result<(), Error> {
    println!("🚀 CEL-CXX Basic Example\n");

    // Create an environment with variables and functions
    let env = Env::builder()
        .declare_variable::<String>("name")?
        .declare_variable::<i64>("age")?
        .register_global_function("greet", |name: &str| format!("Hello, {}!", name))?
        .register_global_function("is_adult", |age: i64| age >= 18)?
        .build()?;

    // Compile and evaluate expressions
    let expressions = vec![
        "greet(name)",
        "is_adult(age)",
        "'Name: ' + name + ', Age: ' + string(age)",
        "age >= 18 ? 'adult' : 'minor'",
    ];

    let activation = Activation::new()
        .bind_variable("name", "Alice")?
        .bind_variable("age", 25i64)?;

    for expr in expressions {
        let program = env.compile(expr)?;
        let result = program.evaluate(&activation)?;
        println!("{} = {}", expr, result);
    }

    println!("\n✅ Basic example completed!");
    Ok(())
}

examples/comprehensive.rs (line 154)

fn demo1_basic_operations() -> Result<(), Error> {
    println!("📌 Demo 1: Basic Expressions & Zero-Annotation Functions");

    let env = Env::builder()
        .declare_variable::<String>("name")?
        .declare_variable::<i64>("age")?
        .declare_variable::<f64>("score")?
        // ✨ Zero-annotation functions - types automatically inferred!
        .register_global_function("greet", |name: &str| format!("Hello, {}!", name))?
        .register_global_function("is_adult", |age: i64| age >= 18)?
        .register_global_function("grade", |score: f64| -> String {
            match score {
                90.0..=100.0 => "A".to_string(),
                80.0..=89.9 => "B".to_string(),
                70.0..=79.9 => "C".to_string(),
                60.0..=69.9 => "D".to_string(),
                _ => "F".to_string(),
            }
        })?
        .register_global_function("calculate_discount", |age: i64, score: f64| -> f64 {
            let base_discount = if age >= 65 { 0.2 } else { 0.0 };
            let score_bonus = if score >= 90.0 { 0.1 } else { 0.0 };
            base_discount + score_bonus
        })?
        .build()?;

    // Test basic expressions including simple arithmetic
    let test_cases = vec![
        ("1 + 1", "Alice", 25i64, 95.0, "Simple arithmetic"),
        (
            "greet(name)",
            "Alice",
            25i64,
            95.0,
            "Function with string parameter",
        ),
        ("is_adult(age)", "Bob", 16i64, 85.0, "Boolean function"),
        (
            "grade(score)",
            "Charlie",
            30i64,
            78.5,
            "String return function",
        ),
        (
            "calculate_discount(age, score)",
            "Diana",
            67i64,
            92.0,
            "Multi-parameter function",
        ),
    ];

    for (expr, name, age, score, description) in test_cases {
        let program = env.compile(expr)?;
        let activation = Activation::new()
            .bind_variable("name", name)?
            .bind_variable("age", age)?
            .bind_variable("score", score)?;

        let result = program.evaluate(&activation)?;
        println!("  {} = {} ({})", expr, result, description);
    }

    println!();
    Ok(())
}

/// Demo 2: Variable binding and providers
fn demo2_variable_operations() -> Result<(), Error> {
    println!("📌 Demo 2: Variable Binding & Providers");

    let env = Env::builder()
        .declare_variable::<i64>("a")?
        .declare_variable::<i64>("b")?
        .declare_global_function::<fn() -> i64>("get_const")?
        .register_global_function("multiply", |x: i64, y: i64| x * y)?
        .build()?;

    // Test direct variable binding
    {
        println!("  Variable binding:");
        let program = env.compile("a + b")?;
        let activation = Activation::new()
            .bind_variable("a", 10)?
            .bind_variable("b", 20)?;
        let result = program.evaluate(&activation)?;
        println!("    a + b = {} (direct binding)", result);
    }

    // Test variable provider binding
    {
        println!("  Variable provider binding:");
        let program = env.compile("a * b")?;
        let activation = Activation::new()
            .bind_variable("a", 5)?
            .bind_variable_provider("b", || -> Result<i64, Error> {
                println!("    Provider called for variable 'b'");
                Ok(7)
            })?;
        let result = program.evaluate(&activation)?;
        println!("    a * b = {} (provider binding)", result);
    }

    // Test function declaration and binding
    {
        println!("  Function declaration & binding:");
        let program = env.compile("get_const() + multiply(a, 3)")?;
        let activation = Activation::new()
            .bind_variable("a", 4)?
            .bind_global_function("get_const", || -> Result<i64, Error> { Ok(100) })?;
        let result = program.evaluate(&activation)?;
        println!(
            "    get_const() + multiply(a, 3) = {} (function binding)",
            result
        );
    }

    println!();
    Ok(())
}

/// Demo 3: Opaque types with member functions
fn demo3_opaque_member_functions() -> Result<(), Error> {
    println!("📌 Demo 3: Opaque Types & Member Functions");

    let env = Env::builder()
        .declare_variable::<Student>("student")?
        // ✨ Register struct methods directly using RustType::method_name syntax
        .register_member_function("get_name", Student::get_name)?
        .register_member_function("get_age", Student::get_age)?
        .register_member_function("get_grade", Student::get_grade)?
        .register_member_function("is_passing", Student::is_passing)?
        .register_member_function("has_subject", Student::has_subject)?
        .register_member_function("get_letter_grade", Student::get_letter_grade)?
        .build()?;

    let student = Student {
        name: "John Doe".to_string(),
        age: 18,
        grade: 87.5,
        subjects: vec!["Math".to_string(), "Physics".to_string()],
    };

    let activation = Activation::new().bind_variable("student", student)?;

    let test_expressions = vec![
        ("student.get_name()", "Get student name"),
        ("student.get_age()", "Get student age"),
        ("student.get_grade()", "Get numerical grade"),
        ("student.get_letter_grade()", "Get letter grade"),
        ("student.is_passing()", "Check if passing"),
        ("student.has_subject('Math')", "Check if has Math subject"),
        (
            "student.has_subject('Chemistry')",
            "Check if has Chemistry subject",
        ),
    ];

    for (expr, description) in test_expressions {
        let program = env.compile(expr)?;
        let result = program.evaluate(&activation)?;
        println!("  {} = {} ({})", expr, result, description);
    }

    println!();
    Ok(())
}

/// Demo 4: Type conversions and standard Rust types
fn demo4_type_conversions() -> Result<(), Error> {
    println!("📌 Demo 4: Type Conversions & Standard Rust Types");

    // Functions returning different types (both direct values and Results)
    fn return_string_direct() -> String {
        "hello world".to_string()
    }
    fn return_int_result() -> Result<i64, std::io::Error> {
        Ok(42)
    }
    fn return_list() -> Vec<i64> {
        vec![1, 2, 3, 4, 5]
    }
    fn return_map() -> HashMap<String, i64> {
        let mut map = HashMap::new();
        map.insert("key1".to_string(), 100);
        map.insert("key2".to_string(), 200);
        map
    }
    fn return_optional_some() -> Option<String> {
        Some("optional value".to_string())
    }
    fn return_optional_none() -> Option<String> {
        None
    }

    let env = Env::builder()
        .register_global_function("return_string_direct", return_string_direct)?
        .register_global_function("return_int_result", return_int_result)?
        .register_global_function("return_list", return_list)?
        .register_global_function("return_map", return_map)?
        .register_global_function("return_optional_some", return_optional_some)?
        .register_global_function("return_optional_none", return_optional_none)?
        .build()?;

    let test_cases = vec![
        ("return_string_direct()", "String conversion"),
        ("return_int_result()", "Result<i64> conversion"),
        ("return_list()", "Vec<i64> conversion"),
        ("return_map()", "HashMap conversion"),
        ("return_optional_some()", "Option<String> Some conversion"),
        ("return_optional_none()", "Option<String> None conversion"),
    ];

    for (expr, description) in test_cases {
        let program = env.compile(expr)?;
        let result = program.evaluate(())?;
        println!("  {} = {} ({})", expr, result, description);

        // Demonstrate type conversion back to Rust types
        match expr {
            "return_string_direct()" => {
                let rust_string: String = result
                    .try_into()
                    .map_err(|_| Error::invalid_argument("string conversion failed".to_string()))?;
                println!("    Converted back to Rust String: '{}'", rust_string);
            }
            "return_int_result()" => {
                let rust_int: i64 = result
                    .try_into()
                    .map_err(|_| Error::invalid_argument("int conversion failed".to_string()))?;
                println!("    Converted back to Rust i64: {}", rust_int);
            }
            "return_list()" => {
                let rust_list: Vec<i64> = result
                    .try_into()
                    .map_err(|_| Error::invalid_argument("list conversion failed".to_string()))?;
                println!("    Converted back to Rust Vec<i64>: {:?}", rust_list);
            }
            _ => {}
        }
    }

    println!();
    Ok(())
}

/// Demo 5: Generic functions and type annotations
fn demo5_generic_functions() -> Result<(), Error> {
    println!("📌 Demo 5: Generic Functions & Function Overloads");

    // Generic function that counts items in any Vec<T>
    fn count_items<T>(items: Vec<T>) -> i64 {
        items.len() as i64
    }

    // Generic function that processes maps
    fn get_map_size<K, V>(map: HashMap<K, V>) -> i64 {
        map.len() as i64
    }

    // Function working with references in containers
    fn join_strings(strings: Vec<&str>, separator: &str) -> String {
        strings.join(separator)
    }

    let env = Env::builder()
        .declare_variable::<Vec<String>>("string_list")?
        .declare_variable::<Vec<i64>>("int_list")?
        .declare_variable::<HashMap<String, i64>>("score_map")?
        .declare_variable::<Vec<f64>>("floats")?
        // Register generic functions with specific type annotations
        .register_global_function("count_strings", count_items::<String>)?
        .register_global_function("count_ints", count_items::<i64>)?
        .register_global_function("get_string_map_size", get_map_size::<String, i64>)?
        .register_global_function("join_strings", join_strings)?
        // Multiple functions with same name, different signatures (overloads)
        .register_global_function("process", |x: i64| x * 2)?
        .register_global_function("process", |x: f64| (x * 2.0).round())?
        .register_global_function("process", |x: String| x.to_uppercase())?
        // Overloaded member functions for different container types
        .register_member_function("sum", |numbers: Vec<i64>| numbers.iter().sum::<i64>())?
        .register_member_function("sum", |floats: Vec<f64>| floats.iter().sum::<f64>())?
        .build()?;

    let test_cases = vec![
        // Generic function tests
        ("count_strings(string_list)", "Count strings in list"),
        ("count_ints(int_list)", "Count integers in list"),
        ("get_string_map_size(score_map)", "Get map size"),
        ("join_strings(string_list, ' ')", "Join strings with space"),
        // Function overload tests
        ("process(42)", "Process integer (multiply by 2)"),
        ("process(3.14)", "Process float (multiply by 2, round)"),
        ("process('hello')", "Process string (uppercase)"),
        ("int_list.sum()", "Sum integers"),
        ("floats.sum()", "Sum floats"),
    ];

    let activation = Activation::new()
        .bind_variable(
            "string_list",
            vec!["hello".to_string(), "world".to_string(), "rust".to_string()],
        )?
        .bind_variable("int_list", vec![1, 2, 3, 4, 5, 6])?
        .bind_variable("floats", vec![1.5, 2.7, 3.143, 4.0])?
        .bind_variable("score_map", {
            let mut map = HashMap::new();
            map.insert("alice".to_string(), 95);
            map.insert("bob".to_string(), 87);
            map.insert("charlie".to_string(), 92);
            map
        })?;

    for (expr, description) in test_cases {
        let program = env.compile(expr)?;
        let result = program.evaluate(&activation)?;
        println!("  {} = {} ({})", expr, result, description);
    }

    println!();
    Ok(())
}

/// Demo 6: Error handling with different error types including Box<dyn std::error::Error>
fn demo6_error_handling() -> Result<(), Error> {
    println!("📌 Demo 6: Error Handling & Validation");

    let env = Env::builder()
        .declare_variable::<String>("input")?
        .declare_variable::<i64>("divisor")?
        .declare_variable::<String>("email")?
        // Functions returning different error types using thiserror-derived types
        .register_global_function("safe_parse", |s: &str| -> Result<i64, ValidationError> {
            s.parse::<i64>()
                .map_err(|e| ValidationError::ParseError(e.to_string()))
        })?
        .register_global_function(
            "safe_divide",
            |a: i64, b: i64| -> Result<f64, ValidationError> {
                if b == 0 {
                    Err(ValidationError::DivisionByZero)
                } else {
                    Ok(a as f64 / b as f64)
                }
            },
        )?
        // Additional validation functions with ValidationError
        .register_global_function(
            "validate_email",
            |email: &str| -> Result<bool, ValidationError> {
                if email.is_empty() {
                    return Err(ValidationError::EmailError(
                        "Email cannot be empty".to_string(),
                    ));
                }
                if !email.contains('@') {
                    return Err(ValidationError::EmailError(
                        "Email must contain @ symbol".to_string(),
                    ));
                }
                if !email.contains('.') {
                    return Err(ValidationError::EmailError(
                        "Email must contain . symbol".to_string(),
                    ));
                }
                let parts: Vec<&str> = email.split('@').collect();
                if parts.len() != 2 {
                    return Err(ValidationError::EmailError(
                        "Email must contain exactly one @ symbol".to_string(),
                    ));
                }
                if parts[0].is_empty() || parts[1].is_empty() {
                    return Err(ValidationError::EmailError(
                        "Email local and domain parts cannot be empty".to_string(),
                    ));
                }
                Ok(true)
            },
        )?
        .register_global_function(
            "validate_age",
            |age: i64| -> Result<String, ValidationError> {
                match age {
                    0..=17 => Ok("minor".to_string()),
                    18..=64 => Ok("adult".to_string()),
                    65..=120 => Ok("senior".to_string()),
                    _ => Err(ValidationError::AgeError(format!("Invalid age: {}", age))),
                }
            },
        )?
        .register_global_function(
            "validate_range",
            |x: i64, min: i64, max: i64| -> Result<i64, ValidationError> {
                if x < min || x > max {
                    Err(ValidationError::RangeError { value: x, min, max })
                } else {
                    Ok(x)
                }
            },
        )?
        .build()?;

    let test_cases = vec![
        // Success cases
        (
            "safe_parse('42')",
            "42",
            2i64,
            "valid@email.com",
            true,
            "Parse valid number",
        ),
        (
            "safe_divide(10, divisor)",
            "10",
            2i64,
            "test@example.com",
            true,
            "Safe division",
        ),
        (
            "validate_email(email)",
            "25",
            1i64,
            "user@domain.com",
            true,
            "Valid email",
        ),
        (
            "validate_age(safe_parse(input))",
            "25",
            1i64,
            "user@test.com",
            true,
            "Valid age",
        ),
        // Error cases
        (
            "safe_parse('invalid')",
            "invalid",
            2i64,
            "test@test.com",
            false,
            "Parse invalid number",
        ),
        (
            "safe_divide(10, divisor)",
            "10",
            0i64,
            "test@test.com",
            false,
            "Division by zero",
        ),
        (
            "validate_email(email)",
            "10",
            1i64,
            "invalid-email",
            false,
            "Invalid email format",
        ),
        (
            "validate_age(safe_parse(input))",
            "150",
            1i64,
            "test@test.com",
            false,
            "Invalid age",
        ),
        (
            "validate_range(safe_parse(input), 1, 100)",
            "150",
            2i64,
            "test@test.com",
            false,
            "Value out of range",
        ),
    ];

    for (expr, input, divisor, email, should_succeed, description) in test_cases {
        let program = env.compile(expr)?;
        let activation = Activation::new()
            .bind_variable("input", input)?
            .bind_variable("divisor", divisor)?
            .bind_variable("email", email)?;

        match program.evaluate(&activation) {
            Ok(result) => {
                println!("  {} = {} ✅ ({})", expr, result, description);
                if !should_succeed {
                    println!("    ⚠️  Expected this to fail!");
                }
            }
            Err(e) => {
                println!("  {} -> ERROR: {} ❌ ({})", expr, e, description);
                if should_succeed {
                    println!("    ⚠️  Expected this to succeed!");
                }
            }
        }
    }

    println!();
    Ok(())
}

/// Demo 7: Program introspection and return types
fn demo7_program_introspection() -> Result<(), Error> {
    println!("📌 Demo 7: Program Introspection & Return Types");

    // Test with numeric expression
    {
        let env = Env::builder()
            .declare_variable::<i64>("a")?
            .declare_variable::<i64>("b")?
            .build()?;
        let program = env.compile("a + b")?;
        let return_type = program.return_type();
        println!("  Expression: 'a + b'");
        println!("    Return type: {}", return_type);

        let activation = Activation::new()
            .bind_variable("a", 10)?
            .bind_variable("b", 20)?;
        let result = program.evaluate(&activation)?;
        println!("    Result: {}", result);
    }

    // Test with string expression
    {
        let env = Env::builder()
            .declare_variable::<String>("a")?
            .declare_variable::<String>("b")?
            .build()?;
        let program = env.compile("a + b")?;
        let return_type = program.return_type();
        println!("  Expression: 'a + b' (strings)");
        println!("    Return type: {}", return_type);

        let activation = Activation::new()
            .bind_variable("a", "Hello ".to_string())?
            .bind_variable("b", "World!".to_string())?;
        let result = program.evaluate(&activation)?;
        println!("    Result: {}", result);
    }

    // Test with boolean expression
    {
        let env = Env::builder().declare_variable::<i64>("age")?.build()?;
        let program = env.compile("age >= 18")?;
        let return_type = program.return_type();
        println!("  Expression: 'age >= 18'");
        println!("    Return type: {}", return_type);

        let activation = Activation::new().bind_variable("age", 25i64)?;
        let result = program.evaluate(&activation)?;
        println!("    Result: {}", result);
    }

    println!();
    Ok(())
}

/// Demo 8: Advanced container operations and reference handling
fn demo8_container_operations() -> Result<(), Error> {
    println!("📌 Demo 8: Container Operations & Reference Handling");

    let env = Env::builder()
        .declare_variable::<Vec<&str>>("string_refs")?
        .declare_variable::<HashMap<i64, &str>>("lookup_table")?
        .declare_variable::<Option<&str>>("maybe_value")?
        .declare_variable::<Vec<User>>("users")?
        // Functions working with reference types
        .register_global_function("longest_string", |strings: Vec<&str>| -> Option<String> {
            strings
                .iter()
                .max_by_key(|s| s.len())
                .map(|s| s.to_string())
        })?
        .register_global_function(
            "lookup",
            |table: HashMap<i64, &str>, key: i64| -> Option<String> {
                table.get(&key).map(|s| s.to_string())
            },
        )?
        .register_global_function("string_length", |s: Option<&str>| -> i64 {
            s.map(|s| s.len() as i64).unwrap_or(0)
        })?
        // Advanced filtering and mapping
        .register_global_function("filter_adults", |users: Vec<User>| -> Vec<User> {
            users.into_iter().filter(|u| u.age >= 18).collect()
        })?
        .register_global_function(
            "group_by_age_range",
            |users: Vec<User>| -> HashMap<String, Vec<String>> {
                let mut groups: HashMap<String, Vec<String>> = HashMap::new();
                for user in users {
                    let range = match user.age {
                        0..=17 => "minor",
                        18..=64 => "adult",
                        _ => "senior",
                    };
                    groups.entry(range.to_string()).or_default().push(user.name);
                }
                groups
            },
        )?
        .build()?;

    // Prepare test data with proper lifetimes
    let source_strings = [
        "hello".to_string(),
        "world".to_string(),
        "rust".to_string(),
        "programming".to_string(),
    ];
    let string_refs: Vec<&str> = source_strings.iter().map(|s| s.as_str()).collect();

    let lookup_table: HashMap<i64, &str> = HashMap::from([(1, "one"), (2, "two"), (3, "three")]);

    let maybe_value: Option<&str> = Some("test string");

    let users = vec![
        User {
            id: 1,
            name: "Alice".to_string(),
            email: "alice@test.com".to_string(),
            age: 25,
            roles: vec![],
            metadata: HashMap::new(),
        },
        User {
            id: 2,
            name: "Bob".to_string(),
            email: "bob@test.com".to_string(),
            age: 16,
            roles: vec![],
            metadata: HashMap::new(),
        },
        User {
            id: 3,
            name: "Carol".to_string(),
            email: "carol@test.com".to_string(),
            age: 67,
            roles: vec![],
            metadata: HashMap::new(),
        },
    ];

    let test_expressions = vec![
        ("longest_string(string_refs)", "Find longest string"),
        ("lookup(lookup_table, 2)", "Lookup value by key"),
        ("string_length(maybe_value)", "Get optional string length"),
        ("filter_adults(users).size()", "Count adult users"),
        (
            "group_by_age_range(users).size()",
            "Group users by age range",
        ),
    ];

    let activation = Activation::new()
        .bind_variable("string_refs", string_refs)?
        .bind_variable("lookup_table", lookup_table)?
        .bind_variable("maybe_value", maybe_value)?
        .bind_variable("users", users)?;

    for (expr, description) in test_expressions {
        let program = env.compile(expr)?;
        let result = program.evaluate(&activation)?;
        println!("  {} = {} ({})", expr, result, description);
    }

    println!();
    Ok(())
}

pub fn declare_function<D>( self, name: impl Into<String>, member: bool, ) -> Result<Self, Error>

where D: FunctionDecl,

Declares a function signature without providing an implementation.

This is useful when you want to declare that a function exists for type checking purposes, but will provide the implementation later via activation bindings.

Arguments

• name - The name of the function
• member - Whether this is a member function (true) or global function (false)

Type Parameters

• D - The function declaration type that specifies the signature

pub fn declare_member_function<D>( self, name: impl Into<String>, ) -> Result<Self, Error>

where D: FunctionDecl,

Declares a member function signature without providing an implementation.

Arguments

• name - The name of the member function

Type Parameters

• D - The function declaration type that specifies the signature

pub fn declare_global_function<D>( self, name: impl Into<String>, ) -> Result<Self, Error>

where D: FunctionDecl,

Declares a global function signature without providing an implementation.

Arguments

• name - The name of the global function

Type Parameters

• D - The function declaration type that specifies the signature

Examples found in repository

examples/comprehensive.rs (line 221)

fn demo2_variable_operations() -> Result<(), Error> {
    println!("📌 Demo 2: Variable Binding & Providers");

    let env = Env::builder()
        .declare_variable::<i64>("a")?
        .declare_variable::<i64>("b")?
        .declare_global_function::<fn() -> i64>("get_const")?
        .register_global_function("multiply", |x: i64, y: i64| x * y)?
        .build()?;

    // Test direct variable binding
    {
        println!("  Variable binding:");
        let program = env.compile("a + b")?;
        let activation = Activation::new()
            .bind_variable("a", 10)?
            .bind_variable("b", 20)?;
        let result = program.evaluate(&activation)?;
        println!("    a + b = {} (direct binding)", result);
    }

    // Test variable provider binding
    {
        println!("  Variable provider binding:");
        let program = env.compile("a * b")?;
        let activation = Activation::new()
            .bind_variable("a", 5)?
            .bind_variable_provider("b", || -> Result<i64, Error> {
                println!("    Provider called for variable 'b'");
                Ok(7)
            })?;
        let result = program.evaluate(&activation)?;
        println!("    a * b = {} (provider binding)", result);
    }

    // Test function declaration and binding
    {
        println!("  Function declaration & binding:");
        let program = env.compile("get_const() + multiply(a, 3)")?;
        let activation = Activation::new()
            .bind_variable("a", 4)?
            .bind_global_function("get_const", || -> Result<i64, Error> { Ok(100) })?;
        let result = program.evaluate(&activation)?;
        println!(
            "    get_const() + multiply(a, 3) = {} (function binding)",
            result
        );
    }

    println!();
    Ok(())
}

pub fn define_constant<T>( self, name: impl Into<String>, value: T, ) -> Result<Self, Error>

where T: IntoConstant,

Defines a constant value that can be referenced in expressions.

Constants are immutable values that are resolved at compile time.

Arguments

• name - The name of the constant
• value - The constant value

Examples

use cel_cxx::*;

let builder = Env::builder()
    .define_constant("PI", 3.14159)
    .unwrap();

pub fn declare_variable<T>(self, name: impl Into<String>) -> Result<Self, Error>

where T: TypedValue,

Declares a variable of a specific type.

This declares that a variable of the given name and type may be provided during evaluation. The actual value must be bound in the activation when evaluating expressions.

Arguments

• name - The name of the variable

Type Parameters

• T - The type of the variable

Examples

use cel_cxx::*;

let builder = Env::builder()
    .declare_variable::<String>("user_name")?
    .declare_variable::<i64>("age")?;

Examples found in repository

examples/basic.rs (line 12)

fn main() -> Result<(), Error> {
    println!("🚀 CEL-CXX Basic Example\n");

    // Create an environment with variables and functions
    let env = Env::builder()
        .declare_variable::<String>("name")?
        .declare_variable::<i64>("age")?
        .register_global_function("greet", |name: &str| format!("Hello, {}!", name))?
        .register_global_function("is_adult", |age: i64| age >= 18)?
        .build()?;

    // Compile and evaluate expressions
    let expressions = vec![
        "greet(name)",
        "is_adult(age)",
        "'Name: ' + name + ', Age: ' + string(age)",
        "age >= 18 ? 'adult' : 'minor'",
    ];

    let activation = Activation::new()
        .bind_variable("name", "Alice")?
        .bind_variable("age", 25i64)?;

    for expr in expressions {
        let program = env.compile(expr)?;
        let result = program.evaluate(&activation)?;
        println!("{} = {}", expr, result);
    }

    println!("\n✅ Basic example completed!");
    Ok(())
}

examples/comprehensive.rs (line 150)

fn demo1_basic_operations() -> Result<(), Error> {
    println!("📌 Demo 1: Basic Expressions & Zero-Annotation Functions");

    let env = Env::builder()
        .declare_variable::<String>("name")?
        .declare_variable::<i64>("age")?
        .declare_variable::<f64>("score")?
        // ✨ Zero-annotation functions - types automatically inferred!
        .register_global_function("greet", |name: &str| format!("Hello, {}!", name))?
        .register_global_function("is_adult", |age: i64| age >= 18)?
        .register_global_function("grade", |score: f64| -> String {
            match score {
                90.0..=100.0 => "A".to_string(),
                80.0..=89.9 => "B".to_string(),
                70.0..=79.9 => "C".to_string(),
                60.0..=69.9 => "D".to_string(),
                _ => "F".to_string(),
            }
        })?
        .register_global_function("calculate_discount", |age: i64, score: f64| -> f64 {
            let base_discount = if age >= 65 { 0.2 } else { 0.0 };
            let score_bonus = if score >= 90.0 { 0.1 } else { 0.0 };
            base_discount + score_bonus
        })?
        .build()?;

    // Test basic expressions including simple arithmetic
    let test_cases = vec![
        ("1 + 1", "Alice", 25i64, 95.0, "Simple arithmetic"),
        (
            "greet(name)",
            "Alice",
            25i64,
            95.0,
            "Function with string parameter",
        ),
        ("is_adult(age)", "Bob", 16i64, 85.0, "Boolean function"),
        (
            "grade(score)",
            "Charlie",
            30i64,
            78.5,
            "String return function",
        ),
        (
            "calculate_discount(age, score)",
            "Diana",
            67i64,
            92.0,
            "Multi-parameter function",
        ),
    ];

    for (expr, name, age, score, description) in test_cases {
        let program = env.compile(expr)?;
        let activation = Activation::new()
            .bind_variable("name", name)?
            .bind_variable("age", age)?
            .bind_variable("score", score)?;

        let result = program.evaluate(&activation)?;
        println!("  {} = {} ({})", expr, result, description);
    }

    println!();
    Ok(())
}

/// Demo 2: Variable binding and providers
fn demo2_variable_operations() -> Result<(), Error> {
    println!("📌 Demo 2: Variable Binding & Providers");

    let env = Env::builder()
        .declare_variable::<i64>("a")?
        .declare_variable::<i64>("b")?
        .declare_global_function::<fn() -> i64>("get_const")?
        .register_global_function("multiply", |x: i64, y: i64| x * y)?
        .build()?;

    // Test direct variable binding
    {
        println!("  Variable binding:");
        let program = env.compile("a + b")?;
        let activation = Activation::new()
            .bind_variable("a", 10)?
            .bind_variable("b", 20)?;
        let result = program.evaluate(&activation)?;
        println!("    a + b = {} (direct binding)", result);
    }

    // Test variable provider binding
    {
        println!("  Variable provider binding:");
        let program = env.compile("a * b")?;
        let activation = Activation::new()
            .bind_variable("a", 5)?
            .bind_variable_provider("b", || -> Result<i64, Error> {
                println!("    Provider called for variable 'b'");
                Ok(7)
            })?;
        let result = program.evaluate(&activation)?;
        println!("    a * b = {} (provider binding)", result);
    }

    // Test function declaration and binding
    {
        println!("  Function declaration & binding:");
        let program = env.compile("get_const() + multiply(a, 3)")?;
        let activation = Activation::new()
            .bind_variable("a", 4)?
            .bind_global_function("get_const", || -> Result<i64, Error> { Ok(100) })?;
        let result = program.evaluate(&activation)?;
        println!(
            "    get_const() + multiply(a, 3) = {} (function binding)",
            result
        );
    }

    println!();
    Ok(())
}

/// Demo 3: Opaque types with member functions
fn demo3_opaque_member_functions() -> Result<(), Error> {
    println!("📌 Demo 3: Opaque Types & Member Functions");

    let env = Env::builder()
        .declare_variable::<Student>("student")?
        // ✨ Register struct methods directly using RustType::method_name syntax
        .register_member_function("get_name", Student::get_name)?
        .register_member_function("get_age", Student::get_age)?
        .register_member_function("get_grade", Student::get_grade)?
        .register_member_function("is_passing", Student::is_passing)?
        .register_member_function("has_subject", Student::has_subject)?
        .register_member_function("get_letter_grade", Student::get_letter_grade)?
        .build()?;

    let student = Student {
        name: "John Doe".to_string(),
        age: 18,
        grade: 87.5,
        subjects: vec!["Math".to_string(), "Physics".to_string()],
    };

    let activation = Activation::new().bind_variable("student", student)?;

    let test_expressions = vec![
        ("student.get_name()", "Get student name"),
        ("student.get_age()", "Get student age"),
        ("student.get_grade()", "Get numerical grade"),
        ("student.get_letter_grade()", "Get letter grade"),
        ("student.is_passing()", "Check if passing"),
        ("student.has_subject('Math')", "Check if has Math subject"),
        (
            "student.has_subject('Chemistry')",
            "Check if has Chemistry subject",
        ),
    ];

    for (expr, description) in test_expressions {
        let program = env.compile(expr)?;
        let result = program.evaluate(&activation)?;
        println!("  {} = {} ({})", expr, result, description);
    }

    println!();
    Ok(())
}

/// Demo 4: Type conversions and standard Rust types
fn demo4_type_conversions() -> Result<(), Error> {
    println!("📌 Demo 4: Type Conversions & Standard Rust Types");

    // Functions returning different types (both direct values and Results)
    fn return_string_direct() -> String {
        "hello world".to_string()
    }
    fn return_int_result() -> Result<i64, std::io::Error> {
        Ok(42)
    }
    fn return_list() -> Vec<i64> {
        vec![1, 2, 3, 4, 5]
    }
    fn return_map() -> HashMap<String, i64> {
        let mut map = HashMap::new();
        map.insert("key1".to_string(), 100);
        map.insert("key2".to_string(), 200);
        map
    }
    fn return_optional_some() -> Option<String> {
        Some("optional value".to_string())
    }
    fn return_optional_none() -> Option<String> {
        None
    }

    let env = Env::builder()
        .register_global_function("return_string_direct", return_string_direct)?
        .register_global_function("return_int_result", return_int_result)?
        .register_global_function("return_list", return_list)?
        .register_global_function("return_map", return_map)?
        .register_global_function("return_optional_some", return_optional_some)?
        .register_global_function("return_optional_none", return_optional_none)?
        .build()?;

    let test_cases = vec![
        ("return_string_direct()", "String conversion"),
        ("return_int_result()", "Result<i64> conversion"),
        ("return_list()", "Vec<i64> conversion"),
        ("return_map()", "HashMap conversion"),
        ("return_optional_some()", "Option<String> Some conversion"),
        ("return_optional_none()", "Option<String> None conversion"),
    ];

    for (expr, description) in test_cases {
        let program = env.compile(expr)?;
        let result = program.evaluate(())?;
        println!("  {} = {} ({})", expr, result, description);

        // Demonstrate type conversion back to Rust types
        match expr {
            "return_string_direct()" => {
                let rust_string: String = result
                    .try_into()
                    .map_err(|_| Error::invalid_argument("string conversion failed".to_string()))?;
                println!("    Converted back to Rust String: '{}'", rust_string);
            }
            "return_int_result()" => {
                let rust_int: i64 = result
                    .try_into()
                    .map_err(|_| Error::invalid_argument("int conversion failed".to_string()))?;
                println!("    Converted back to Rust i64: {}", rust_int);
            }
            "return_list()" => {
                let rust_list: Vec<i64> = result
                    .try_into()
                    .map_err(|_| Error::invalid_argument("list conversion failed".to_string()))?;
                println!("    Converted back to Rust Vec<i64>: {:?}", rust_list);
            }
            _ => {}
        }
    }

    println!();
    Ok(())
}

/// Demo 5: Generic functions and type annotations
fn demo5_generic_functions() -> Result<(), Error> {
    println!("📌 Demo 5: Generic Functions & Function Overloads");

    // Generic function that counts items in any Vec<T>
    fn count_items<T>(items: Vec<T>) -> i64 {
        items.len() as i64
    }

    // Generic function that processes maps
    fn get_map_size<K, V>(map: HashMap<K, V>) -> i64 {
        map.len() as i64
    }

    // Function working with references in containers
    fn join_strings(strings: Vec<&str>, separator: &str) -> String {
        strings.join(separator)
    }

    let env = Env::builder()
        .declare_variable::<Vec<String>>("string_list")?
        .declare_variable::<Vec<i64>>("int_list")?
        .declare_variable::<HashMap<String, i64>>("score_map")?
        .declare_variable::<Vec<f64>>("floats")?
        // Register generic functions with specific type annotations
        .register_global_function("count_strings", count_items::<String>)?
        .register_global_function("count_ints", count_items::<i64>)?
        .register_global_function("get_string_map_size", get_map_size::<String, i64>)?
        .register_global_function("join_strings", join_strings)?
        // Multiple functions with same name, different signatures (overloads)
        .register_global_function("process", |x: i64| x * 2)?
        .register_global_function("process", |x: f64| (x * 2.0).round())?
        .register_global_function("process", |x: String| x.to_uppercase())?
        // Overloaded member functions for different container types
        .register_member_function("sum", |numbers: Vec<i64>| numbers.iter().sum::<i64>())?
        .register_member_function("sum", |floats: Vec<f64>| floats.iter().sum::<f64>())?
        .build()?;

    let test_cases = vec![
        // Generic function tests
        ("count_strings(string_list)", "Count strings in list"),
        ("count_ints(int_list)", "Count integers in list"),
        ("get_string_map_size(score_map)", "Get map size"),
        ("join_strings(string_list, ' ')", "Join strings with space"),
        // Function overload tests
        ("process(42)", "Process integer (multiply by 2)"),
        ("process(3.14)", "Process float (multiply by 2, round)"),
        ("process('hello')", "Process string (uppercase)"),
        ("int_list.sum()", "Sum integers"),
        ("floats.sum()", "Sum floats"),
    ];

    let activation = Activation::new()
        .bind_variable(
            "string_list",
            vec!["hello".to_string(), "world".to_string(), "rust".to_string()],
        )?
        .bind_variable("int_list", vec![1, 2, 3, 4, 5, 6])?
        .bind_variable("floats", vec![1.5, 2.7, 3.143, 4.0])?
        .bind_variable("score_map", {
            let mut map = HashMap::new();
            map.insert("alice".to_string(), 95);
            map.insert("bob".to_string(), 87);
            map.insert("charlie".to_string(), 92);
            map
        })?;

    for (expr, description) in test_cases {
        let program = env.compile(expr)?;
        let result = program.evaluate(&activation)?;
        println!("  {} = {} ({})", expr, result, description);
    }

    println!();
    Ok(())
}

/// Demo 6: Error handling with different error types including Box<dyn std::error::Error>
fn demo6_error_handling() -> Result<(), Error> {
    println!("📌 Demo 6: Error Handling & Validation");

    let env = Env::builder()
        .declare_variable::<String>("input")?
        .declare_variable::<i64>("divisor")?
        .declare_variable::<String>("email")?
        // Functions returning different error types using thiserror-derived types
        .register_global_function("safe_parse", |s: &str| -> Result<i64, ValidationError> {
            s.parse::<i64>()
                .map_err(|e| ValidationError::ParseError(e.to_string()))
        })?
        .register_global_function(
            "safe_divide",
            |a: i64, b: i64| -> Result<f64, ValidationError> {
                if b == 0 {
                    Err(ValidationError::DivisionByZero)
                } else {
                    Ok(a as f64 / b as f64)
                }
            },
        )?
        // Additional validation functions with ValidationError
        .register_global_function(
            "validate_email",
            |email: &str| -> Result<bool, ValidationError> {
                if email.is_empty() {
                    return Err(ValidationError::EmailError(
                        "Email cannot be empty".to_string(),
                    ));
                }
                if !email.contains('@') {
                    return Err(ValidationError::EmailError(
                        "Email must contain @ symbol".to_string(),
                    ));
                }
                if !email.contains('.') {
                    return Err(ValidationError::EmailError(
                        "Email must contain . symbol".to_string(),
                    ));
                }
                let parts: Vec<&str> = email.split('@').collect();
                if parts.len() != 2 {
                    return Err(ValidationError::EmailError(
                        "Email must contain exactly one @ symbol".to_string(),
                    ));
                }
                if parts[0].is_empty() || parts[1].is_empty() {
                    return Err(ValidationError::EmailError(
                        "Email local and domain parts cannot be empty".to_string(),
                    ));
                }
                Ok(true)
            },
        )?
        .register_global_function(
            "validate_age",
            |age: i64| -> Result<String, ValidationError> {
                match age {
                    0..=17 => Ok("minor".to_string()),
                    18..=64 => Ok("adult".to_string()),
                    65..=120 => Ok("senior".to_string()),
                    _ => Err(ValidationError::AgeError(format!("Invalid age: {}", age))),
                }
            },
        )?
        .register_global_function(
            "validate_range",
            |x: i64, min: i64, max: i64| -> Result<i64, ValidationError> {
                if x < min || x > max {
                    Err(ValidationError::RangeError { value: x, min, max })
                } else {
                    Ok(x)
                }
            },
        )?
        .build()?;

    let test_cases = vec![
        // Success cases
        (
            "safe_parse('42')",
            "42",
            2i64,
            "valid@email.com",
            true,
            "Parse valid number",
        ),
        (
            "safe_divide(10, divisor)",
            "10",
            2i64,
            "test@example.com",
            true,
            "Safe division",
        ),
        (
            "validate_email(email)",
            "25",
            1i64,
            "user@domain.com",
            true,
            "Valid email",
        ),
        (
            "validate_age(safe_parse(input))",
            "25",
            1i64,
            "user@test.com",
            true,
            "Valid age",
        ),
        // Error cases
        (
            "safe_parse('invalid')",
            "invalid",
            2i64,
            "test@test.com",
            false,
            "Parse invalid number",
        ),
        (
            "safe_divide(10, divisor)",
            "10",
            0i64,
            "test@test.com",
            false,
            "Division by zero",
        ),
        (
            "validate_email(email)",
            "10",
            1i64,
            "invalid-email",
            false,
            "Invalid email format",
        ),
        (
            "validate_age(safe_parse(input))",
            "150",
            1i64,
            "test@test.com",
            false,
            "Invalid age",
        ),
        (
            "validate_range(safe_parse(input), 1, 100)",
            "150",
            2i64,
            "test@test.com",
            false,
            "Value out of range",
        ),
    ];

    for (expr, input, divisor, email, should_succeed, description) in test_cases {
        let program = env.compile(expr)?;
        let activation = Activation::new()
            .bind_variable("input", input)?
            .bind_variable("divisor", divisor)?
            .bind_variable("email", email)?;

        match program.evaluate(&activation) {
            Ok(result) => {
                println!("  {} = {} ✅ ({})", expr, result, description);
                if !should_succeed {
                    println!("    ⚠️  Expected this to fail!");
                }
            }
            Err(e) => {
                println!("  {} -> ERROR: {} ❌ ({})", expr, e, description);
                if should_succeed {
                    println!("    ⚠️  Expected this to succeed!");
                }
            }
        }
    }

    println!();
    Ok(())
}

/// Demo 7: Program introspection and return types
fn demo7_program_introspection() -> Result<(), Error> {
    println!("📌 Demo 7: Program Introspection & Return Types");

    // Test with numeric expression
    {
        let env = Env::builder()
            .declare_variable::<i64>("a")?
            .declare_variable::<i64>("b")?
            .build()?;
        let program = env.compile("a + b")?;
        let return_type = program.return_type();
        println!("  Expression: 'a + b'");
        println!("    Return type: {}", return_type);

        let activation = Activation::new()
            .bind_variable("a", 10)?
            .bind_variable("b", 20)?;
        let result = program.evaluate(&activation)?;
        println!("    Result: {}", result);
    }

    // Test with string expression
    {
        let env = Env::builder()
            .declare_variable::<String>("a")?
            .declare_variable::<String>("b")?
            .build()?;
        let program = env.compile("a + b")?;
        let return_type = program.return_type();
        println!("  Expression: 'a + b' (strings)");
        println!("    Return type: {}", return_type);

        let activation = Activation::new()
            .bind_variable("a", "Hello ".to_string())?
            .bind_variable("b", "World!".to_string())?;
        let result = program.evaluate(&activation)?;
        println!("    Result: {}", result);
    }

    // Test with boolean expression
    {
        let env = Env::builder().declare_variable::<i64>("age")?.build()?;
        let program = env.compile("age >= 18")?;
        let return_type = program.return_type();
        println!("  Expression: 'age >= 18'");
        println!("    Return type: {}", return_type);

        let activation = Activation::new().bind_variable("age", 25i64)?;
        let result = program.evaluate(&activation)?;
        println!("    Result: {}", result);
    }

    println!();
    Ok(())
}

/// Demo 8: Advanced container operations and reference handling
fn demo8_container_operations() -> Result<(), Error> {
    println!("📌 Demo 8: Container Operations & Reference Handling");

    let env = Env::builder()
        .declare_variable::<Vec<&str>>("string_refs")?
        .declare_variable::<HashMap<i64, &str>>("lookup_table")?
        .declare_variable::<Option<&str>>("maybe_value")?
        .declare_variable::<Vec<User>>("users")?
        // Functions working with reference types
        .register_global_function("longest_string", |strings: Vec<&str>| -> Option<String> {
            strings
                .iter()
                .max_by_key(|s| s.len())
                .map(|s| s.to_string())
        })?
        .register_global_function(
            "lookup",
            |table: HashMap<i64, &str>, key: i64| -> Option<String> {
                table.get(&key).map(|s| s.to_string())
            },
        )?
        .register_global_function("string_length", |s: Option<&str>| -> i64 {
            s.map(|s| s.len() as i64).unwrap_or(0)
        })?
        // Advanced filtering and mapping
        .register_global_function("filter_adults", |users: Vec<User>| -> Vec<User> {
            users.into_iter().filter(|u| u.age >= 18).collect()
        })?
        .register_global_function(
            "group_by_age_range",
            |users: Vec<User>| -> HashMap<String, Vec<String>> {
                let mut groups: HashMap<String, Vec<String>> = HashMap::new();
                for user in users {
                    let range = match user.age {
                        0..=17 => "minor",
                        18..=64 => "adult",
                        _ => "senior",
                    };
                    groups.entry(range.to_string()).or_default().push(user.name);
                }
                groups
            },
        )?
        .build()?;

    // Prepare test data with proper lifetimes
    let source_strings = [
        "hello".to_string(),
        "world".to_string(),
        "rust".to_string(),
        "programming".to_string(),
    ];
    let string_refs: Vec<&str> = source_strings.iter().map(|s| s.as_str()).collect();

    let lookup_table: HashMap<i64, &str> = HashMap::from([(1, "one"), (2, "two"), (3, "three")]);

    let maybe_value: Option<&str> = Some("test string");

    let users = vec![
        User {
            id: 1,
            name: "Alice".to_string(),
            email: "alice@test.com".to_string(),
            age: 25,
            roles: vec![],
            metadata: HashMap::new(),
        },
        User {
            id: 2,
            name: "Bob".to_string(),
            email: "bob@test.com".to_string(),
            age: 16,
            roles: vec![],
            metadata: HashMap::new(),
        },
        User {
            id: 3,
            name: "Carol".to_string(),
            email: "carol@test.com".to_string(),
            age: 67,
            roles: vec![],
            metadata: HashMap::new(),
        },
    ];

    let test_expressions = vec![
        ("longest_string(string_refs)", "Find longest string"),
        ("lookup(lookup_table, 2)", "Lookup value by key"),
        ("string_length(maybe_value)", "Get optional string length"),
        ("filter_adults(users).size()", "Count adult users"),
        (
            "group_by_age_range(users).size()",
            "Group users by age range",
        ),
    ];

    let activation = Activation::new()
        .bind_variable("string_refs", string_refs)?
        .bind_variable("lookup_table", lookup_table)?
        .bind_variable("maybe_value", maybe_value)?
        .bind_variable("users", users)?;

    for (expr, description) in test_expressions {
        let program = env.compile(expr)?;
        let result = program.evaluate(&activation)?;
        println!("  {} = {} ({})", expr, result, description);
    }

    println!();
    Ok(())
}

pub fn build(self) -> Result<Env<'f, Fm, Rm>, Error>

Builds the environment from the configured builder.

This method consumes the builder and creates the final Env instance that can be used to compile CEL expressions.

Returns

Returns a Result containing the built Env or an Error if the environment could not be created.

Examples

use cel_cxx::*;

let env = Env::builder()
    .declare_variable::<String>("name")?
    .build()?;

Errors

Returns an error if the environment configuration is invalid or if the underlying CEL environment cannot be created.

Examples found in repository

examples/basic.rs (line 16)

fn main() -> Result<(), Error> {
    println!("🚀 CEL-CXX Basic Example\n");

    // Create an environment with variables and functions
    let env = Env::builder()
        .declare_variable::<String>("name")?
        .declare_variable::<i64>("age")?
        .register_global_function("greet", |name: &str| format!("Hello, {}!", name))?
        .register_global_function("is_adult", |age: i64| age >= 18)?
        .build()?;

    // Compile and evaluate expressions
    let expressions = vec![
        "greet(name)",
        "is_adult(age)",
        "'Name: ' + name + ', Age: ' + string(age)",
        "age >= 18 ? 'adult' : 'minor'",
    ];

    let activation = Activation::new()
        .bind_variable("name", "Alice")?
        .bind_variable("age", 25i64)?;

    for expr in expressions {
        let program = env.compile(expr)?;
        let result = program.evaluate(&activation)?;
        println!("{} = {}", expr, result);
    }

    println!("\n✅ Basic example completed!");
    Ok(())
}

examples/comprehensive.rs (line 170)

fn demo1_basic_operations() -> Result<(), Error> {
    println!("📌 Demo 1: Basic Expressions & Zero-Annotation Functions");

    let env = Env::builder()
        .declare_variable::<String>("name")?
        .declare_variable::<i64>("age")?
        .declare_variable::<f64>("score")?
        // ✨ Zero-annotation functions - types automatically inferred!
        .register_global_function("greet", |name: &str| format!("Hello, {}!", name))?
        .register_global_function("is_adult", |age: i64| age >= 18)?
        .register_global_function("grade", |score: f64| -> String {
            match score {
                90.0..=100.0 => "A".to_string(),
                80.0..=89.9 => "B".to_string(),
                70.0..=79.9 => "C".to_string(),
                60.0..=69.9 => "D".to_string(),
                _ => "F".to_string(),
            }
        })?
        .register_global_function("calculate_discount", |age: i64, score: f64| -> f64 {
            let base_discount = if age >= 65 { 0.2 } else { 0.0 };
            let score_bonus = if score >= 90.0 { 0.1 } else { 0.0 };
            base_discount + score_bonus
        })?
        .build()?;

    // Test basic expressions including simple arithmetic
    let test_cases = vec![
        ("1 + 1", "Alice", 25i64, 95.0, "Simple arithmetic"),
        (
            "greet(name)",
            "Alice",
            25i64,
            95.0,
            "Function with string parameter",
        ),
        ("is_adult(age)", "Bob", 16i64, 85.0, "Boolean function"),
        (
            "grade(score)",
            "Charlie",
            30i64,
            78.5,
            "String return function",
        ),
        (
            "calculate_discount(age, score)",
            "Diana",
            67i64,
            92.0,
            "Multi-parameter function",
        ),
    ];

    for (expr, name, age, score, description) in test_cases {
        let program = env.compile(expr)?;
        let activation = Activation::new()
            .bind_variable("name", name)?
            .bind_variable("age", age)?
            .bind_variable("score", score)?;

        let result = program.evaluate(&activation)?;
        println!("  {} = {} ({})", expr, result, description);
    }

    println!();
    Ok(())
}

/// Demo 2: Variable binding and providers
fn demo2_variable_operations() -> Result<(), Error> {
    println!("📌 Demo 2: Variable Binding & Providers");

    let env = Env::builder()
        .declare_variable::<i64>("a")?
        .declare_variable::<i64>("b")?
        .declare_global_function::<fn() -> i64>("get_const")?
        .register_global_function("multiply", |x: i64, y: i64| x * y)?
        .build()?;

    // Test direct variable binding
    {
        println!("  Variable binding:");
        let program = env.compile("a + b")?;
        let activation = Activation::new()
            .bind_variable("a", 10)?
            .bind_variable("b", 20)?;
        let result = program.evaluate(&activation)?;
        println!("    a + b = {} (direct binding)", result);
    }

    // Test variable provider binding
    {
        println!("  Variable provider binding:");
        let program = env.compile("a * b")?;
        let activation = Activation::new()
            .bind_variable("a", 5)?
            .bind_variable_provider("b", || -> Result<i64, Error> {
                println!("    Provider called for variable 'b'");
                Ok(7)
            })?;
        let result = program.evaluate(&activation)?;
        println!("    a * b = {} (provider binding)", result);
    }

    // Test function declaration and binding
    {
        println!("  Function declaration & binding:");
        let program = env.compile("get_const() + multiply(a, 3)")?;
        let activation = Activation::new()
            .bind_variable("a", 4)?
            .bind_global_function("get_const", || -> Result<i64, Error> { Ok(100) })?;
        let result = program.evaluate(&activation)?;
        println!(
            "    get_const() + multiply(a, 3) = {} (function binding)",
            result
        );
    }

    println!();
    Ok(())
}

/// Demo 3: Opaque types with member functions
fn demo3_opaque_member_functions() -> Result<(), Error> {
    println!("📌 Demo 3: Opaque Types & Member Functions");

    let env = Env::builder()
        .declare_variable::<Student>("student")?
        // ✨ Register struct methods directly using RustType::method_name syntax
        .register_member_function("get_name", Student::get_name)?
        .register_member_function("get_age", Student::get_age)?
        .register_member_function("get_grade", Student::get_grade)?
        .register_member_function("is_passing", Student::is_passing)?
        .register_member_function("has_subject", Student::has_subject)?
        .register_member_function("get_letter_grade", Student::get_letter_grade)?
        .build()?;

    let student = Student {
        name: "John Doe".to_string(),
        age: 18,
        grade: 87.5,
        subjects: vec!["Math".to_string(), "Physics".to_string()],
    };

    let activation = Activation::new().bind_variable("student", student)?;

    let test_expressions = vec![
        ("student.get_name()", "Get student name"),
        ("student.get_age()", "Get student age"),
        ("student.get_grade()", "Get numerical grade"),
        ("student.get_letter_grade()", "Get letter grade"),
        ("student.is_passing()", "Check if passing"),
        ("student.has_subject('Math')", "Check if has Math subject"),
        (
            "student.has_subject('Chemistry')",
            "Check if has Chemistry subject",
        ),
    ];

    for (expr, description) in test_expressions {
        let program = env.compile(expr)?;
        let result = program.evaluate(&activation)?;
        println!("  {} = {} ({})", expr, result, description);
    }

    println!();
    Ok(())
}

/// Demo 4: Type conversions and standard Rust types
fn demo4_type_conversions() -> Result<(), Error> {
    println!("📌 Demo 4: Type Conversions & Standard Rust Types");

    // Functions returning different types (both direct values and Results)
    fn return_string_direct() -> String {
        "hello world".to_string()
    }
    fn return_int_result() -> Result<i64, std::io::Error> {
        Ok(42)
    }
    fn return_list() -> Vec<i64> {
        vec![1, 2, 3, 4, 5]
    }
    fn return_map() -> HashMap<String, i64> {
        let mut map = HashMap::new();
        map.insert("key1".to_string(), 100);
        map.insert("key2".to_string(), 200);
        map
    }
    fn return_optional_some() -> Option<String> {
        Some("optional value".to_string())
    }
    fn return_optional_none() -> Option<String> {
        None
    }

    let env = Env::builder()
        .register_global_function("return_string_direct", return_string_direct)?
        .register_global_function("return_int_result", return_int_result)?
        .register_global_function("return_list", return_list)?
        .register_global_function("return_map", return_map)?
        .register_global_function("return_optional_some", return_optional_some)?
        .register_global_function("return_optional_none", return_optional_none)?
        .build()?;

    let test_cases = vec![
        ("return_string_direct()", "String conversion"),
        ("return_int_result()", "Result<i64> conversion"),
        ("return_list()", "Vec<i64> conversion"),
        ("return_map()", "HashMap conversion"),
        ("return_optional_some()", "Option<String> Some conversion"),
        ("return_optional_none()", "Option<String> None conversion"),
    ];

    for (expr, description) in test_cases {
        let program = env.compile(expr)?;
        let result = program.evaluate(())?;
        println!("  {} = {} ({})", expr, result, description);

        // Demonstrate type conversion back to Rust types
        match expr {
            "return_string_direct()" => {
                let rust_string: String = result
                    .try_into()
                    .map_err(|_| Error::invalid_argument("string conversion failed".to_string()))?;
                println!("    Converted back to Rust String: '{}'", rust_string);
            }
            "return_int_result()" => {
                let rust_int: i64 = result
                    .try_into()
                    .map_err(|_| Error::invalid_argument("int conversion failed".to_string()))?;
                println!("    Converted back to Rust i64: {}", rust_int);
            }
            "return_list()" => {
                let rust_list: Vec<i64> = result
                    .try_into()
                    .map_err(|_| Error::invalid_argument("list conversion failed".to_string()))?;
                println!("    Converted back to Rust Vec<i64>: {:?}", rust_list);
            }
            _ => {}
        }
    }

    println!();
    Ok(())
}

/// Demo 5: Generic functions and type annotations
fn demo5_generic_functions() -> Result<(), Error> {
    println!("📌 Demo 5: Generic Functions & Function Overloads");

    // Generic function that counts items in any Vec<T>
    fn count_items<T>(items: Vec<T>) -> i64 {
        items.len() as i64
    }

    // Generic function that processes maps
    fn get_map_size<K, V>(map: HashMap<K, V>) -> i64 {
        map.len() as i64
    }

    // Function working with references in containers
    fn join_strings(strings: Vec<&str>, separator: &str) -> String {
        strings.join(separator)
    }

    let env = Env::builder()
        .declare_variable::<Vec<String>>("string_list")?
        .declare_variable::<Vec<i64>>("int_list")?
        .declare_variable::<HashMap<String, i64>>("score_map")?
        .declare_variable::<Vec<f64>>("floats")?
        // Register generic functions with specific type annotations
        .register_global_function("count_strings", count_items::<String>)?
        .register_global_function("count_ints", count_items::<i64>)?
        .register_global_function("get_string_map_size", get_map_size::<String, i64>)?
        .register_global_function("join_strings", join_strings)?
        // Multiple functions with same name, different signatures (overloads)
        .register_global_function("process", |x: i64| x * 2)?
        .register_global_function("process", |x: f64| (x * 2.0).round())?
        .register_global_function("process", |x: String| x.to_uppercase())?
        // Overloaded member functions for different container types
        .register_member_function("sum", |numbers: Vec<i64>| numbers.iter().sum::<i64>())?
        .register_member_function("sum", |floats: Vec<f64>| floats.iter().sum::<f64>())?
        .build()?;

    let test_cases = vec![
        // Generic function tests
        ("count_strings(string_list)", "Count strings in list"),
        ("count_ints(int_list)", "Count integers in list"),
        ("get_string_map_size(score_map)", "Get map size"),
        ("join_strings(string_list, ' ')", "Join strings with space"),
        // Function overload tests
        ("process(42)", "Process integer (multiply by 2)"),
        ("process(3.14)", "Process float (multiply by 2, round)"),
        ("process('hello')", "Process string (uppercase)"),
        ("int_list.sum()", "Sum integers"),
        ("floats.sum()", "Sum floats"),
    ];

    let activation = Activation::new()
        .bind_variable(
            "string_list",
            vec!["hello".to_string(), "world".to_string(), "rust".to_string()],
        )?
        .bind_variable("int_list", vec![1, 2, 3, 4, 5, 6])?
        .bind_variable("floats", vec![1.5, 2.7, 3.143, 4.0])?
        .bind_variable("score_map", {
            let mut map = HashMap::new();
            map.insert("alice".to_string(), 95);
            map.insert("bob".to_string(), 87);
            map.insert("charlie".to_string(), 92);
            map
        })?;

    for (expr, description) in test_cases {
        let program = env.compile(expr)?;
        let result = program.evaluate(&activation)?;
        println!("  {} = {} ({})", expr, result, description);
    }

    println!();
    Ok(())
}

/// Demo 6: Error handling with different error types including Box<dyn std::error::Error>
fn demo6_error_handling() -> Result<(), Error> {
    println!("📌 Demo 6: Error Handling & Validation");

    let env = Env::builder()
        .declare_variable::<String>("input")?
        .declare_variable::<i64>("divisor")?
        .declare_variable::<String>("email")?
        // Functions returning different error types using thiserror-derived types
        .register_global_function("safe_parse", |s: &str| -> Result<i64, ValidationError> {
            s.parse::<i64>()
                .map_err(|e| ValidationError::ParseError(e.to_string()))
        })?
        .register_global_function(
            "safe_divide",
            |a: i64, b: i64| -> Result<f64, ValidationError> {
                if b == 0 {
                    Err(ValidationError::DivisionByZero)
                } else {
                    Ok(a as f64 / b as f64)
                }
            },
        )?
        // Additional validation functions with ValidationError
        .register_global_function(
            "validate_email",
            |email: &str| -> Result<bool, ValidationError> {
                if email.is_empty() {
                    return Err(ValidationError::EmailError(
                        "Email cannot be empty".to_string(),
                    ));
                }
                if !email.contains('@') {
                    return Err(ValidationError::EmailError(
                        "Email must contain @ symbol".to_string(),
                    ));
                }
                if !email.contains('.') {
                    return Err(ValidationError::EmailError(
                        "Email must contain . symbol".to_string(),
                    ));
                }
                let parts: Vec<&str> = email.split('@').collect();
                if parts.len() != 2 {
                    return Err(ValidationError::EmailError(
                        "Email must contain exactly one @ symbol".to_string(),
                    ));
                }
                if parts[0].is_empty() || parts[1].is_empty() {
                    return Err(ValidationError::EmailError(
                        "Email local and domain parts cannot be empty".to_string(),
                    ));
                }
                Ok(true)
            },
        )?
        .register_global_function(
            "validate_age",
            |age: i64| -> Result<String, ValidationError> {
                match age {
                    0..=17 => Ok("minor".to_string()),
                    18..=64 => Ok("adult".to_string()),
                    65..=120 => Ok("senior".to_string()),
                    _ => Err(ValidationError::AgeError(format!("Invalid age: {}", age))),
                }
            },
        )?
        .register_global_function(
            "validate_range",
            |x: i64, min: i64, max: i64| -> Result<i64, ValidationError> {
                if x < min || x > max {
                    Err(ValidationError::RangeError { value: x, min, max })
                } else {
                    Ok(x)
                }
            },
        )?
        .build()?;

    let test_cases = vec![
        // Success cases
        (
            "safe_parse('42')",
            "42",
            2i64,
            "valid@email.com",
            true,
            "Parse valid number",
        ),
        (
            "safe_divide(10, divisor)",
            "10",
            2i64,
            "test@example.com",
            true,
            "Safe division",
        ),
        (
            "validate_email(email)",
            "25",
            1i64,
            "user@domain.com",
            true,
            "Valid email",
        ),
        (
            "validate_age(safe_parse(input))",
            "25",
            1i64,
            "user@test.com",
            true,
            "Valid age",
        ),
        // Error cases
        (
            "safe_parse('invalid')",
            "invalid",
            2i64,
            "test@test.com",
            false,
            "Parse invalid number",
        ),
        (
            "safe_divide(10, divisor)",
            "10",
            0i64,
            "test@test.com",
            false,
            "Division by zero",
        ),
        (
            "validate_email(email)",
            "10",
            1i64,
            "invalid-email",
            false,
            "Invalid email format",
        ),
        (
            "validate_age(safe_parse(input))",
            "150",
            1i64,
            "test@test.com",
            false,
            "Invalid age",
        ),
        (
            "validate_range(safe_parse(input), 1, 100)",
            "150",
            2i64,
            "test@test.com",
            false,
            "Value out of range",
        ),
    ];

    for (expr, input, divisor, email, should_succeed, description) in test_cases {
        let program = env.compile(expr)?;
        let activation = Activation::new()
            .bind_variable("input", input)?
            .bind_variable("divisor", divisor)?
            .bind_variable("email", email)?;

        match program.evaluate(&activation) {
            Ok(result) => {
                println!("  {} = {} ✅ ({})", expr, result, description);
                if !should_succeed {
                    println!("    ⚠️  Expected this to fail!");
                }
            }
            Err(e) => {
                println!("  {} -> ERROR: {} ❌ ({})", expr, e, description);
                if should_succeed {
                    println!("    ⚠️  Expected this to succeed!");
                }
            }
        }
    }

    println!();
    Ok(())
}

/// Demo 7: Program introspection and return types
fn demo7_program_introspection() -> Result<(), Error> {
    println!("📌 Demo 7: Program Introspection & Return Types");

    // Test with numeric expression
    {
        let env = Env::builder()
            .declare_variable::<i64>("a")?
            .declare_variable::<i64>("b")?
            .build()?;
        let program = env.compile("a + b")?;
        let return_type = program.return_type();
        println!("  Expression: 'a + b'");
        println!("    Return type: {}", return_type);

        let activation = Activation::new()
            .bind_variable("a", 10)?
            .bind_variable("b", 20)?;
        let result = program.evaluate(&activation)?;
        println!("    Result: {}", result);
    }

    // Test with string expression
    {
        let env = Env::builder()
            .declare_variable::<String>("a")?
            .declare_variable::<String>("b")?
            .build()?;
        let program = env.compile("a + b")?;
        let return_type = program.return_type();
        println!("  Expression: 'a + b' (strings)");
        println!("    Return type: {}", return_type);

        let activation = Activation::new()
            .bind_variable("a", "Hello ".to_string())?
            .bind_variable("b", "World!".to_string())?;
        let result = program.evaluate(&activation)?;
        println!("    Result: {}", result);
    }

    // Test with boolean expression
    {
        let env = Env::builder().declare_variable::<i64>("age")?.build()?;
        let program = env.compile("age >= 18")?;
        let return_type = program.return_type();
        println!("  Expression: 'age >= 18'");
        println!("    Return type: {}", return_type);

        let activation = Activation::new().bind_variable("age", 25i64)?;
        let result = program.evaluate(&activation)?;
        println!("    Result: {}", result);
    }

    println!();
    Ok(())
}

/// Demo 8: Advanced container operations and reference handling
fn demo8_container_operations() -> Result<(), Error> {
    println!("📌 Demo 8: Container Operations & Reference Handling");

    let env = Env::builder()
        .declare_variable::<Vec<&str>>("string_refs")?
        .declare_variable::<HashMap<i64, &str>>("lookup_table")?
        .declare_variable::<Option<&str>>("maybe_value")?
        .declare_variable::<Vec<User>>("users")?
        // Functions working with reference types
        .register_global_function("longest_string", |strings: Vec<&str>| -> Option<String> {
            strings
                .iter()
                .max_by_key(|s| s.len())
                .map(|s| s.to_string())
        })?
        .register_global_function(
            "lookup",
            |table: HashMap<i64, &str>, key: i64| -> Option<String> {
                table.get(&key).map(|s| s.to_string())
            },
        )?
        .register_global_function("string_length", |s: Option<&str>| -> i64 {
            s.map(|s| s.len() as i64).unwrap_or(0)
        })?
        // Advanced filtering and mapping
        .register_global_function("filter_adults", |users: Vec<User>| -> Vec<User> {
            users.into_iter().filter(|u| u.age >= 18).collect()
        })?
        .register_global_function(
            "group_by_age_range",
            |users: Vec<User>| -> HashMap<String, Vec<String>> {
                let mut groups: HashMap<String, Vec<String>> = HashMap::new();
                for user in users {
                    let range = match user.age {
                        0..=17 => "minor",
                        18..=64 => "adult",
                        _ => "senior",
                    };
                    groups.entry(range.to_string()).or_default().push(user.name);
                }
                groups
            },
        )?
        .build()?;

    // Prepare test data with proper lifetimes
    let source_strings = [
        "hello".to_string(),
        "world".to_string(),
        "rust".to_string(),
        "programming".to_string(),
    ];
    let string_refs: Vec<&str> = source_strings.iter().map(|s| s.as_str()).collect();

    let lookup_table: HashMap<i64, &str> = HashMap::from([(1, "one"), (2, "two"), (3, "three")]);

    let maybe_value: Option<&str> = Some("test string");

    let users = vec![
        User {
            id: 1,
            name: "Alice".to_string(),
            email: "alice@test.com".to_string(),
            age: 25,
            roles: vec![],
            metadata: HashMap::new(),
        },
        User {
            id: 2,
            name: "Bob".to_string(),
            email: "bob@test.com".to_string(),
            age: 16,
            roles: vec![],
            metadata: HashMap::new(),
        },
        User {
            id: 3,
            name: "Carol".to_string(),
            email: "carol@test.com".to_string(),
            age: 67,
            roles: vec![],
            metadata: HashMap::new(),
        },
    ];

    let test_expressions = vec![
        ("longest_string(string_refs)", "Find longest string"),
        ("lookup(lookup_table, 2)", "Lookup value by key"),
        ("string_length(maybe_value)", "Get optional string length"),
        ("filter_adults(users).size()", "Count adult users"),
        (
            "group_by_age_range(users).size()",
            "Group users by age range",
        ),
    ];

    let activation = Activation::new()
        .bind_variable("string_refs", string_refs)?
        .bind_variable("lookup_table", lookup_table)?
        .bind_variable("maybe_value", maybe_value)?
        .bind_variable("users", users)?;

    for (expr, description) in test_expressions {
        let program = env.compile(expr)?;
        let result = program.evaluate(&activation)?;
        println!("  {} = {} ({})", expr, result, description);
    }

    println!();
    Ok(())
}

impl<'f, Rm: RuntimeMarker> EnvBuilder<'f, (), Rm>

pub fn force_async(self) -> EnvBuilder<'f, Async, Rm>

Available on crate feature async only.

Forces conversion to an async environment builder.

This method converts a synchronous environment builder to an asynchronous one, allowing it to register async functions and build async environments.

Examples

use cel_cxx::*;

let async_builder = Env::builder().force_async();

impl<'f, Fm: FnMarker> EnvBuilder<'f, Fm, ()>

pub fn use_runtime<Rt: Runtime>(self) -> EnvBuilder<'f, Fm, Rt>

Available on crate feature async only.

Sets the async runtime for the environment builder.

This method specifies which async runtime should be used by environments built from this builder.

Type Parameters

• Rt - The runtime type to use (must implement Runtime)

Examples

use cel_cxx::*;

let builder = Env::builder().use_runtime::<Tokio>();

pub fn use_tokio(self) -> EnvBuilder<'f, Fm, Tokio>

Available on crate features async and tokio only.

Configures the builder to use the Tokio async runtime.

This is a convenience method for setting the runtime to Tokio. Requires the tokio feature to be enabled.

Examples

use cel_cxx::*;

let builder = Env::builder().use_tokio();

pub fn use_async_std(self) -> EnvBuilder<'f, Fm, AsyncStd>

Available on crate features async and async-std only.

Configures the builder to use the async-std runtime.

This is a convenience method for setting the runtime to async-std. Requires the async-std feature to be enabled.

Examples

use cel_cxx::*;

let builder = Env::builder().use_async_std();

pub fn use_smol(self) -> EnvBuilder<'f, Fm, Smol>

Available on crate features async and smol only.

Configures the builder to use the smol runtime.

This is a convenience method for setting the runtime to smol. Requires the smol feature to be enabled.

Examples

use cel_cxx::*;

let builder = Env::builder().use_smol();

Trait Implementations

impl<'f, Fm: FnMarker, Rm: RuntimeMarker> Debug for EnvBuilder<'f, Fm, Rm>

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

Formats the value using the given formatter.

impl<'f, Fm: FnMarker, Rm: RuntimeMarker> Default for EnvBuilder<'f, Fm, Rm>

fn default() -> Self

Returns the “default value” for a type.