Struct ValueMap 

pub struct ValueMap { /* private fields */ }

A CEL map with heterogeneous keys.

Uses a BTreeMap with a custom key type for deterministic iteration order.

Implementations

impl ValueMap

pub fn new() -> Self

Create a new empty map.

pub fn from_entries(entries: impl IntoIterator<Item = (MapKey, Value)>) -> Self

Create a map from an iterator of key-value pairs.

pub fn get(&self, key: &MapKey) -> Option<&Value>

Get a value by key.

pub fn insert(&mut self, key: MapKey, value: Value)

Insert a key-value pair.

pub fn contains_key(&self, key: &MapKey) -> bool

Check if a key exists.

pub fn get_with_numeric_coercion(&self, key: &MapKey) -> Option<&Value>

Get a value by key with cross-type numeric coercion. Tries exact match first, then Int↔UInt coercion for in-range values.

pub fn contains_key_with_numeric_coercion(&self, key: &MapKey) -> bool

Check if a key exists with cross-type numeric coercion.

pub fn len(&self) -> usize

Get the number of entries.

Examples found in repository

examples/extract_values.rs (line 63)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn is_empty(&self) -> bool

Check if the map is empty.

pub fn iter(&self) -> impl Iterator<Item = (&MapKey, &Value)>

Iterate over entries.

Examples found in repository

examples/extract_values.rs (line 64)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn keys(&self) -> impl Iterator<Item = &MapKey>

Iterate over keys.

pub fn values(&self) -> impl Iterator<Item = &Value>

Iterate over values.

Trait Implementations

impl Clone for ValueMap

fn clone(&self) -> ValueMap

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ValueMap

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

Formats the value using the given formatter.

impl Default for ValueMap

fn default() -> ValueMap

Returns the “default value” for a type.

impl<'a> TryFrom<&'a Value> for &'a ValueMap

type Error = ValueError

The type returned in the event of a conversion error.

fn try_from(v: &'a Value) -> Result<Self, Self::Error>

Performs the conversion.