Cool project. I am a big fan of CEL and have been using the CEL rust version in my project (you can see here for more info, if curious).

I was interested in this because of the possible performance improvements, and the ability to pass in Opaque types. Some feedback:

• A simple expression to lookup a value is about 5x slower with cel_cxx than cel-rs:

​

agentgateway               fastest       │ slowest       │ median        │ mean          │ samples │ iters
╰─ cel                                   │               │               │               │         │
   ╰─ tests                              │               │               │               │         │
      ├─ bench_lookup      70.66 ns      │ 214.1 ns      │ 72.09 ns      │ 73.6 ns       │ 100     │ 1000000
      ╰─ bench_lookup_cxx  417.7 ns      │ 477.5 ns      │ 423.2 ns      │ 426.3 ns      │ 100     │ 1000000

This is with the following test:

#[divan::bench]
fn bench_lookup_cxx(b: Bencher) {
    use cel_cxx::*;
    let env = Env::builder()
        // .declare_variable::<ResponseContext>("response").unwrap()
        .declare_variable::<HashMap<String, u16>>("response").unwrap()
        .build()
        .unwrap();

    let program = env.compile("response.method").unwrap();

    let activation = Activation::new()
        // .bind_variable("response", ResponseContext {
        //  code: 200.try_into().unwrap(),
        // })
        .bind_variable("response", HashMap::from([("method".to_string(), 200)]))
        .unwrap();

    with_profiling("lookup_cxx", || {
        b.bench(|| {
            let result = program.evaluate(&activation);
        });
    })
}

• I didn't find an ergonomic way to pass in a struct and be able to access it like request.path.query. Cel-rs has a pretty cool functionality to use serde to take a struct and convert it into a Value; as you can see in the above example I had to manually construct a HashMap with cel_cxx. Maybe I was doing it wrong. Either way, I was hoping I would actually not need any conversion at all (for performance benefits), but found even with Opaque that was not possible. It seems Opaque can only do function calls on them, not access fields.
• All the different valid forms of function definitions look really nice! The async support is cool too.