Struct Store 

pub struct Store<T = StoreEntry> { /* private fields */ }

A keyed collection of entries shared across the pipeline lifecycle.

The store is the single source of truth for pipeline state. It holds draft-time variables, resolved step parameters, per-step global outputs, and the values produced by return blocks. The generic parameter T is the entry type — most stores hold StoreEntry values, but Store<Parameters> is used in draft/ready phases to hold the unresolved parameter bindings for each step.

Keys are flat dotted strings; nesting is modelled by the StoreEntry::Array and StoreEntry::Map variants, not by the store itself. Insertion is append-only through insert (errors on duplicate) or replacement-allowed through insert_or_replace.

Implementations

impl<T> Store<T>

pub fn new() -> Self

Constructs an empty store.

Examples found in repository

examples/extend_store_scalars.rs (line 11)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut store = Store::new();

    // define_var accepts any V: Into<Value>.
    // From impls exist for &str, String, bool, i64, f64, so you can pass
    // these directly without calling .into().
    store.define_var("name", "Alice")?;
    store.define_var("age", 30i64)?;
    store.define_var("active", true)?;
    store.define_var("score", 9.5f64)?;
    store.define_var("empty", Value::Null)?;

    // Reading back: Store::get returns &StoreEntry.
    // get_value() extracts the &Value from a Var entry.
    let name = store.get("name")?.get_value()?;
    println!("name = {name:?}");

    // as_var() returns (&Value, &Type) — useful when you need to inspect both.
    let (val, ty) = store.get("age")?.as_var()?;
    println!("age = {val:?} (type: {ty:?})");

    // Type is inferred from the value at define time.
    assert_eq!(store.get("active")?.as_var()?.1, &Type::Boolean);
    assert_eq!(store.get("score")?.as_var()?.1, &Type::Float);
    assert_eq!(store.get("empty")?.as_var()?.1, &Type::Null);

    // Duplicate names are rejected with StoreError::EntryAlreadyExists.
    let err = store.define_var("name", "Bob");
    println!("duplicate define_var: {err:?}");
    assert!(err.is_err());

    println!("store_scalars: ok");
    Ok(())
}

examples/extend_store_nested.rs (line 91)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut store = Store::new();

    // An Operation would call these to populate its output Store.
    write_query_results(&mut store)?;
    write_grouped_data(&mut store)?;
    write_nested_config(&mut store)?;

    // --- Reading results back via chained accessors ---

    // Query rows: array -> index -> key -> value
    let bob_status = store
        .get("rows")?
        .get_index(1)?
        .get_key("status")?
        .get_value()?;
    println!("rows[1].status = {bob_status:?}");
    assert_eq!(bob_status, &Value::Text("Failure".into()));

    let alice_attempts = store
        .get("rows")?
        .get_index(0)?
        .get_key("attempts")?
        .get_value()?;
    println!("rows[0].attempts = {alice_attempts:?}");
    assert_eq!(alice_attempts, &Value::Integer(1));

    // Grouped data: map -> key -> index -> value
    let high_count = store.get("by_severity")?.get_key("high")?.as_array()?.len();
    println!("by_severity.high: {high_count} incidents");
    assert_eq!(high_count, 2);

    let first_low = store
        .get("by_severity")?
        .get_key("low")?
        .get_index(0)?
        .get_value()?;
    println!("by_severity.low[0] = {first_low:?}");

    // Nested config: map -> key -> key -> key -> value
    let timeout = store
        .get("pipeline_config")?
        .get_key("source")?
        .get_key("options")?
        .get_key("timeout_secs")?
        .get_value()?;
    println!("pipeline_config.source.options.timeout_secs = {timeout:?}");
    assert_eq!(timeout, &Value::Integer(30));

    // Config outputs array: map -> key -> index -> key -> value
    let second_format = store
        .get("pipeline_config")?
        .get_key("outputs")?
        .get_index(1)?
        .get_key("format")?
        .get_value()?;
    println!("pipeline_config.outputs[1].format = {second_format:?}");
    assert_eq!(second_format, &Value::Text("csv".into()));

    println!("store_nested: ok");
    Ok(())
}

examples/extend_store_collections.rs (line 10)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut store = Store::new();

    // --- Chainable push ---
    // push() accepts V: Into<StoreEntry>. The blanket impl
    // `From<T: Into<Value>> for StoreEntry` means primitives work directly.
    let mut arr = store.define_array("numbers")?.push(1)?.push(2)?.push(3)?;

    let items = store.get("numbers")?.as_array()?;
    println!("numbers: len={}", items.len());
    assert_eq!(items.len(), 3);

    // --- Chainable insert ---
    // insert() accepts K: Into<String> and V: Into<StoreEntry>.
    let mut map = store.define_map("config")?;
    map.insert("host", "localhost")?
        .insert("port", 8080i64)?
        .insert("debug", true)?;

    let host = store.get("config")?.get_key("host")?.get_value()?;
    println!("config.host = {host:?}");

    // --- Closure API on Store ---
    // with_array scopes the handle so you don't need an explicit drop.
    store.with_array("tags", |arr| {
        arr.push("rust")?.push("pipeline")?.push("store")?;
        Ok(())
    })?;

    let tags = store.get("tags")?.as_array()?;
    println!("tags: len={}", tags.len());

    store.with_map("metadata", |map| {
        map.insert("version", "0.1.0")?.insert("stable", false)?;
        Ok(())
    })?;

    let version = store.get("metadata")?.get_key("version")?.get_value()?;
    println!("metadata.version = {version:?}");

    // --- Nested construction via MapHandle closures ---
    // with_array and with_map on MapHandle let you build nested structures
    // without manually managing sub-handles.
    store.with_map("server", |map| {
        map.insert("name", "prod-01")?;

        map.with_array("ports", |arr| {
            arr.push(80)?.push(443)?;
            Ok(())
        })?;

        map.with_map("tls", |tls| {
            tls.insert("enabled", true)?
                .insert("cert_path", "/etc/ssl/cert.pem")?;
            Ok(())
        })?;

        Ok(())
    })?;

    let tls_enabled = store
        .get("server")?
        .get_key("tls")?
        .get_key("enabled")?
        .get_value()?;
    println!("server.tls.enabled = {tls_enabled:?}");

    // --- push_map on ArrayHandle ---
    // Builds an array of maps — the most common pattern for tabular results.
    let mut arr = store.define_array("users")?;
    {
        let mut user = arr.push_map()?;
        user.insert("name", "Alice")?.insert("role", "admin")?;
    }
    {
        let mut user = arr.push_map()?;
        user.insert("name", "Bob")?.insert("role", "viewer")?;
    }

    let bob_role = store
        .get("users")?
        .get_index(1)?
        .get_key("role")?
        .get_value()?;
    println!("users[1].role = {bob_role:?}");
    assert_eq!(bob_role, &Value::Text("viewer".into()));

    println!("store_collections: ok");
    Ok(())
}

pub fn get<N: AsRef<str>>(&self, name: N) -> Result<&T, StoreError>

Looks up an entry by name. Returns StoreError::EntryNotFound if the name is not in the store.

Examples found in repository

examples/extend_store_scalars.rs (line 24)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut store = Store::new();

    // define_var accepts any V: Into<Value>.
    // From impls exist for &str, String, bool, i64, f64, so you can pass
    // these directly without calling .into().
    store.define_var("name", "Alice")?;
    store.define_var("age", 30i64)?;
    store.define_var("active", true)?;
    store.define_var("score", 9.5f64)?;
    store.define_var("empty", Value::Null)?;

    // Reading back: Store::get returns &StoreEntry.
    // get_value() extracts the &Value from a Var entry.
    let name = store.get("name")?.get_value()?;
    println!("name = {name:?}");

    // as_var() returns (&Value, &Type) — useful when you need to inspect both.
    let (val, ty) = store.get("age")?.as_var()?;
    println!("age = {val:?} (type: {ty:?})");

    // Type is inferred from the value at define time.
    assert_eq!(store.get("active")?.as_var()?.1, &Type::Boolean);
    assert_eq!(store.get("score")?.as_var()?.1, &Type::Float);
    assert_eq!(store.get("empty")?.as_var()?.1, &Type::Null);

    // Duplicate names are rejected with StoreError::EntryAlreadyExists.
    let err = store.define_var("name", "Bob");
    println!("duplicate define_var: {err:?}");
    assert!(err.is_err());

    println!("store_scalars: ok");
    Ok(())
}

examples/extend_store_nested.rs (line 102)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut store = Store::new();

    // An Operation would call these to populate its output Store.
    write_query_results(&mut store)?;
    write_grouped_data(&mut store)?;
    write_nested_config(&mut store)?;

    // --- Reading results back via chained accessors ---

    // Query rows: array -> index -> key -> value
    let bob_status = store
        .get("rows")?
        .get_index(1)?
        .get_key("status")?
        .get_value()?;
    println!("rows[1].status = {bob_status:?}");
    assert_eq!(bob_status, &Value::Text("Failure".into()));

    let alice_attempts = store
        .get("rows")?
        .get_index(0)?
        .get_key("attempts")?
        .get_value()?;
    println!("rows[0].attempts = {alice_attempts:?}");
    assert_eq!(alice_attempts, &Value::Integer(1));

    // Grouped data: map -> key -> index -> value
    let high_count = store.get("by_severity")?.get_key("high")?.as_array()?.len();
    println!("by_severity.high: {high_count} incidents");
    assert_eq!(high_count, 2);

    let first_low = store
        .get("by_severity")?
        .get_key("low")?
        .get_index(0)?
        .get_value()?;
    println!("by_severity.low[0] = {first_low:?}");

    // Nested config: map -> key -> key -> key -> value
    let timeout = store
        .get("pipeline_config")?
        .get_key("source")?
        .get_key("options")?
        .get_key("timeout_secs")?
        .get_value()?;
    println!("pipeline_config.source.options.timeout_secs = {timeout:?}");
    assert_eq!(timeout, &Value::Integer(30));

    // Config outputs array: map -> key -> index -> key -> value
    let second_format = store
        .get("pipeline_config")?
        .get_key("outputs")?
        .get_index(1)?
        .get_key("format")?
        .get_value()?;
    println!("pipeline_config.outputs[1].format = {second_format:?}");
    assert_eq!(second_format, &Value::Text("csv".into()));

    println!("store_nested: ok");
    Ok(())
}

examples/extend_store_collections.rs (line 17)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut store = Store::new();

    // --- Chainable push ---
    // push() accepts V: Into<StoreEntry>. The blanket impl
    // `From<T: Into<Value>> for StoreEntry` means primitives work directly.
    let mut arr = store.define_array("numbers")?.push(1)?.push(2)?.push(3)?;

    let items = store.get("numbers")?.as_array()?;
    println!("numbers: len={}", items.len());
    assert_eq!(items.len(), 3);

    // --- Chainable insert ---
    // insert() accepts K: Into<String> and V: Into<StoreEntry>.
    let mut map = store.define_map("config")?;
    map.insert("host", "localhost")?
        .insert("port", 8080i64)?
        .insert("debug", true)?;

    let host = store.get("config")?.get_key("host")?.get_value()?;
    println!("config.host = {host:?}");

    // --- Closure API on Store ---
    // with_array scopes the handle so you don't need an explicit drop.
    store.with_array("tags", |arr| {
        arr.push("rust")?.push("pipeline")?.push("store")?;
        Ok(())
    })?;

    let tags = store.get("tags")?.as_array()?;
    println!("tags: len={}", tags.len());

    store.with_map("metadata", |map| {
        map.insert("version", "0.1.0")?.insert("stable", false)?;
        Ok(())
    })?;

    let version = store.get("metadata")?.get_key("version")?.get_value()?;
    println!("metadata.version = {version:?}");

    // --- Nested construction via MapHandle closures ---
    // with_array and with_map on MapHandle let you build nested structures
    // without manually managing sub-handles.
    store.with_map("server", |map| {
        map.insert("name", "prod-01")?;

        map.with_array("ports", |arr| {
            arr.push(80)?.push(443)?;
            Ok(())
        })?;

        map.with_map("tls", |tls| {
            tls.insert("enabled", true)?
                .insert("cert_path", "/etc/ssl/cert.pem")?;
            Ok(())
        })?;

        Ok(())
    })?;

    let tls_enabled = store
        .get("server")?
        .get_key("tls")?
        .get_key("enabled")?
        .get_value()?;
    println!("server.tls.enabled = {tls_enabled:?}");

    // --- push_map on ArrayHandle ---
    // Builds an array of maps — the most common pattern for tabular results.
    let mut arr = store.define_array("users")?;
    {
        let mut user = arr.push_map()?;
        user.insert("name", "Alice")?.insert("role", "admin")?;
    }
    {
        let mut user = arr.push_map()?;
        user.insert("name", "Bob")?.insert("role", "viewer")?;
    }

    let bob_role = store
        .get("users")?
        .get_index(1)?
        .get_key("role")?
        .get_value()?;
    println!("users[1].role = {bob_role:?}");
    assert_eq!(bob_role, &Value::Text("viewer".into()));

    println!("store_collections: ok");
    Ok(())
}

pub fn insert<N: Into<String>>( &mut self, name: N, entry: T, ) -> Result<(), StoreError>

Inserts an entry under name. Returns StoreError::EntryAlreadyExists if the name is already in use.

pub fn insert_or_replace<N: Into<String>>(&mut self, name: N, entry: T)

Inserts an entry under name, overwriting any existing entry with the same name. Used by the runtime when an operation rewrites its own outputs.

pub fn merge( &mut self, prefix_opt: Option<&str>, other: Store<T>, ) -> Result<(), StoreError>

Merges other into this store, optionally prefixing each incoming key with "{prefix}.". Fails on the first key collision with StoreError::EntryAlreadyExists.

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

Iterates over the names of every entry in the store.

pub fn iter(&self) -> impl Iterator<Item = (&String, &T)>

Iterates over (name, entry) pairs.

impl Store<StoreEntry>

pub fn define_var<N: Into<String>, V: Into<Value>>( &mut self, name: N, value: V, ) -> Result<(), StoreError>

Defines a new variable entry — a StoreEntry::Var wrapping the given Value and its derived Type. Fails with StoreError::EntryAlreadyExists if the name is already in use.

Examples found in repository

examples/extend_store_scalars.rs (line 16)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut store = Store::new();

    // define_var accepts any V: Into<Value>.
    // From impls exist for &str, String, bool, i64, f64, so you can pass
    // these directly without calling .into().
    store.define_var("name", "Alice")?;
    store.define_var("age", 30i64)?;
    store.define_var("active", true)?;
    store.define_var("score", 9.5f64)?;
    store.define_var("empty", Value::Null)?;

    // Reading back: Store::get returns &StoreEntry.
    // get_value() extracts the &Value from a Var entry.
    let name = store.get("name")?.get_value()?;
    println!("name = {name:?}");

    // as_var() returns (&Value, &Type) — useful when you need to inspect both.
    let (val, ty) = store.get("age")?.as_var()?;
    println!("age = {val:?} (type: {ty:?})");

    // Type is inferred from the value at define time.
    assert_eq!(store.get("active")?.as_var()?.1, &Type::Boolean);
    assert_eq!(store.get("score")?.as_var()?.1, &Type::Float);
    assert_eq!(store.get("empty")?.as_var()?.1, &Type::Null);

    // Duplicate names are rejected with StoreError::EntryAlreadyExists.
    let err = store.define_var("name", "Bob");
    println!("duplicate define_var: {err:?}");
    assert!(err.is_err());

    println!("store_scalars: ok");
    Ok(())
}

pub fn define_array<N: Into<String>>( &mut self, name: N, ) -> Result<ArrayHandle<'_, StoreEntry>, StoreError>

Defines a new empty array entry and returns an ArrayHandle for populating it.

Examples found in repository

examples/extend_store_collections.rs (line 15)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut store = Store::new();

    // --- Chainable push ---
    // push() accepts V: Into<StoreEntry>. The blanket impl
    // `From<T: Into<Value>> for StoreEntry` means primitives work directly.
    let mut arr = store.define_array("numbers")?.push(1)?.push(2)?.push(3)?;

    let items = store.get("numbers")?.as_array()?;
    println!("numbers: len={}", items.len());
    assert_eq!(items.len(), 3);

    // --- Chainable insert ---
    // insert() accepts K: Into<String> and V: Into<StoreEntry>.
    let mut map = store.define_map("config")?;
    map.insert("host", "localhost")?
        .insert("port", 8080i64)?
        .insert("debug", true)?;

    let host = store.get("config")?.get_key("host")?.get_value()?;
    println!("config.host = {host:?}");

    // --- Closure API on Store ---
    // with_array scopes the handle so you don't need an explicit drop.
    store.with_array("tags", |arr| {
        arr.push("rust")?.push("pipeline")?.push("store")?;
        Ok(())
    })?;

    let tags = store.get("tags")?.as_array()?;
    println!("tags: len={}", tags.len());

    store.with_map("metadata", |map| {
        map.insert("version", "0.1.0")?.insert("stable", false)?;
        Ok(())
    })?;

    let version = store.get("metadata")?.get_key("version")?.get_value()?;
    println!("metadata.version = {version:?}");

    // --- Nested construction via MapHandle closures ---
    // with_array and with_map on MapHandle let you build nested structures
    // without manually managing sub-handles.
    store.with_map("server", |map| {
        map.insert("name", "prod-01")?;

        map.with_array("ports", |arr| {
            arr.push(80)?.push(443)?;
            Ok(())
        })?;

        map.with_map("tls", |tls| {
            tls.insert("enabled", true)?
                .insert("cert_path", "/etc/ssl/cert.pem")?;
            Ok(())
        })?;

        Ok(())
    })?;

    let tls_enabled = store
        .get("server")?
        .get_key("tls")?
        .get_key("enabled")?
        .get_value()?;
    println!("server.tls.enabled = {tls_enabled:?}");

    // --- push_map on ArrayHandle ---
    // Builds an array of maps — the most common pattern for tabular results.
    let mut arr = store.define_array("users")?;
    {
        let mut user = arr.push_map()?;
        user.insert("name", "Alice")?.insert("role", "admin")?;
    }
    {
        let mut user = arr.push_map()?;
        user.insert("name", "Bob")?.insert("role", "viewer")?;
    }

    let bob_role = store
        .get("users")?
        .get_index(1)?
        .get_key("role")?
        .get_value()?;
    println!("users[1].role = {bob_role:?}");
    assert_eq!(bob_role, &Value::Text("viewer".into()));

    println!("store_collections: ok");
    Ok(())
}

pub fn define_map<N: Into<String>>( &mut self, name: N, ) -> Result<MapHandle<'_, StoreEntry>, StoreError>

Defines a new empty map entry and returns a MapHandle for populating it.

Examples found in repository

examples/extend_store_collections.rs (line 23)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut store = Store::new();

    // --- Chainable push ---
    // push() accepts V: Into<StoreEntry>. The blanket impl
    // `From<T: Into<Value>> for StoreEntry` means primitives work directly.
    let mut arr = store.define_array("numbers")?.push(1)?.push(2)?.push(3)?;

    let items = store.get("numbers")?.as_array()?;
    println!("numbers: len={}", items.len());
    assert_eq!(items.len(), 3);

    // --- Chainable insert ---
    // insert() accepts K: Into<String> and V: Into<StoreEntry>.
    let mut map = store.define_map("config")?;
    map.insert("host", "localhost")?
        .insert("port", 8080i64)?
        .insert("debug", true)?;

    let host = store.get("config")?.get_key("host")?.get_value()?;
    println!("config.host = {host:?}");

    // --- Closure API on Store ---
    // with_array scopes the handle so you don't need an explicit drop.
    store.with_array("tags", |arr| {
        arr.push("rust")?.push("pipeline")?.push("store")?;
        Ok(())
    })?;

    let tags = store.get("tags")?.as_array()?;
    println!("tags: len={}", tags.len());

    store.with_map("metadata", |map| {
        map.insert("version", "0.1.0")?.insert("stable", false)?;
        Ok(())
    })?;

    let version = store.get("metadata")?.get_key("version")?.get_value()?;
    println!("metadata.version = {version:?}");

    // --- Nested construction via MapHandle closures ---
    // with_array and with_map on MapHandle let you build nested structures
    // without manually managing sub-handles.
    store.with_map("server", |map| {
        map.insert("name", "prod-01")?;

        map.with_array("ports", |arr| {
            arr.push(80)?.push(443)?;
            Ok(())
        })?;

        map.with_map("tls", |tls| {
            tls.insert("enabled", true)?
                .insert("cert_path", "/etc/ssl/cert.pem")?;
            Ok(())
        })?;

        Ok(())
    })?;

    let tls_enabled = store
        .get("server")?
        .get_key("tls")?
        .get_key("enabled")?
        .get_value()?;
    println!("server.tls.enabled = {tls_enabled:?}");

    // --- push_map on ArrayHandle ---
    // Builds an array of maps — the most common pattern for tabular results.
    let mut arr = store.define_array("users")?;
    {
        let mut user = arr.push_map()?;
        user.insert("name", "Alice")?.insert("role", "admin")?;
    }
    {
        let mut user = arr.push_map()?;
        user.insert("name", "Bob")?.insert("role", "viewer")?;
    }

    let bob_role = store
        .get("users")?
        .get_index(1)?
        .get_key("role")?
        .get_value()?;
    println!("users[1].role = {bob_role:?}");
    assert_eq!(bob_role, &Value::Text("viewer".into()));

    println!("store_collections: ok");
    Ok(())
}

pub fn with_array<N: Into<String>, F>( &mut self, name: N, body: F, ) -> Result<(), StoreError>

where F: FnOnce(&mut ArrayHandle<'_, StoreEntry>) -> Result<(), StoreError>,

Defines a new array entry and passes a handle to a closure for population. Convenience wrapper over define_array when the nested structure would otherwise force awkward temporaries.

Examples found in repository

examples/extend_store_nested.rs (lines 11-27)

fn write_query_results(store: &mut Store) -> Result<(), Box<dyn std::error::Error>> {
    store.with_array("rows", |rows| {
        // Row 1 — all fields inserted via chaining, no .into() needed.
        let mut row = rows.push_map()?;
        row.insert("user", "alice@contoso.com")?
            .insert("ip", "10.0.0.1")?
            .insert("status", "Success")?
            .insert("attempts", 1i64)?;

        // Row 2
        let mut row = rows.push_map()?;
        row.insert("user", "bob@contoso.com")?
            .insert("ip", "192.168.1.50")?
            .insert("status", "Failure")?
            .insert("attempts", 3i64)?;

        Ok(())
    })?;

    Ok(())
}

examples/extend_store_collections.rs (lines 33-36)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut store = Store::new();

    // --- Chainable push ---
    // push() accepts V: Into<StoreEntry>. The blanket impl
    // `From<T: Into<Value>> for StoreEntry` means primitives work directly.
    let mut arr = store.define_array("numbers")?.push(1)?.push(2)?.push(3)?;

    let items = store.get("numbers")?.as_array()?;
    println!("numbers: len={}", items.len());
    assert_eq!(items.len(), 3);

    // --- Chainable insert ---
    // insert() accepts K: Into<String> and V: Into<StoreEntry>.
    let mut map = store.define_map("config")?;
    map.insert("host", "localhost")?
        .insert("port", 8080i64)?
        .insert("debug", true)?;

    let host = store.get("config")?.get_key("host")?.get_value()?;
    println!("config.host = {host:?}");

    // --- Closure API on Store ---
    // with_array scopes the handle so you don't need an explicit drop.
    store.with_array("tags", |arr| {
        arr.push("rust")?.push("pipeline")?.push("store")?;
        Ok(())
    })?;

    let tags = store.get("tags")?.as_array()?;
    println!("tags: len={}", tags.len());

    store.with_map("metadata", |map| {
        map.insert("version", "0.1.0")?.insert("stable", false)?;
        Ok(())
    })?;

    let version = store.get("metadata")?.get_key("version")?.get_value()?;
    println!("metadata.version = {version:?}");

    // --- Nested construction via MapHandle closures ---
    // with_array and with_map on MapHandle let you build nested structures
    // without manually managing sub-handles.
    store.with_map("server", |map| {
        map.insert("name", "prod-01")?;

        map.with_array("ports", |arr| {
            arr.push(80)?.push(443)?;
            Ok(())
        })?;

        map.with_map("tls", |tls| {
            tls.insert("enabled", true)?
                .insert("cert_path", "/etc/ssl/cert.pem")?;
            Ok(())
        })?;

        Ok(())
    })?;

    let tls_enabled = store
        .get("server")?
        .get_key("tls")?
        .get_key("enabled")?
        .get_value()?;
    println!("server.tls.enabled = {tls_enabled:?}");

    // --- push_map on ArrayHandle ---
    // Builds an array of maps — the most common pattern for tabular results.
    let mut arr = store.define_array("users")?;
    {
        let mut user = arr.push_map()?;
        user.insert("name", "Alice")?.insert("role", "admin")?;
    }
    {
        let mut user = arr.push_map()?;
        user.insert("name", "Bob")?.insert("role", "viewer")?;
    }

    let bob_role = store
        .get("users")?
        .get_index(1)?
        .get_key("role")?
        .get_value()?;
    println!("users[1].role = {bob_role:?}");
    assert_eq!(bob_role, &Value::Text("viewer".into()));

    println!("store_collections: ok");
    Ok(())
}

pub fn with_map<N: Into<String>, F>( &mut self, name: N, body: F, ) -> Result<(), StoreError>

where F: FnOnce(&mut MapHandle<'_, StoreEntry>) -> Result<(), StoreError>,

Defines a new map entry and passes a handle to a closure for population.

Examples found in repository

examples/extend_store_nested.rs (lines 33-50)

fn write_grouped_data(store: &mut Store) -> Result<(), Box<dyn std::error::Error>> {
    store.with_map("by_severity", |groups| {
        groups.with_array("high", |arr| {
            arr.push("INC-001")?.push("INC-004")?;
            Ok(())
        })?;

        groups.with_array("medium", |arr| {
            arr.push("INC-002")?;
            Ok(())
        })?;

        groups.with_array("low", |arr| {
            arr.push("INC-003")?.push("INC-005")?.push("INC-006")?;
            Ok(())
        })?;

        Ok(())
    })?;

    Ok(())
}

fn write_nested_config(store: &mut Store) -> Result<(), Box<dyn std::error::Error>> {
    store.with_map("pipeline_config", |cfg| {
        cfg.insert("name", "signin_analysis")?;

        cfg.with_map("source", |src| {
            src.insert("type", "kql")?
                .insert("workspace", "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx")?;

            src.with_map("options", |opts| {
                opts.insert("timeout_secs", 30i64)?
                    .insert("max_rows", 10_000i64)?;
                Ok(())
            })?;

            Ok(())
        })?;

        cfg.with_array("outputs", |outputs| {
            let mut o = outputs.push_map()?;
            o.insert("format", "json")?
                .insert("path", "/tmp/results.json")?;

            let mut o = outputs.push_map()?;
            o.insert("format", "csv")?
                .insert("path", "/tmp/results.csv")?;

            Ok(())
        })?;

        Ok(())
    })?;

    Ok(())
}

examples/extend_store_collections.rs (lines 41-44)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut store = Store::new();

    // --- Chainable push ---
    // push() accepts V: Into<StoreEntry>. The blanket impl
    // `From<T: Into<Value>> for StoreEntry` means primitives work directly.
    let mut arr = store.define_array("numbers")?.push(1)?.push(2)?.push(3)?;

    let items = store.get("numbers")?.as_array()?;
    println!("numbers: len={}", items.len());
    assert_eq!(items.len(), 3);

    // --- Chainable insert ---
    // insert() accepts K: Into<String> and V: Into<StoreEntry>.
    let mut map = store.define_map("config")?;
    map.insert("host", "localhost")?
        .insert("port", 8080i64)?
        .insert("debug", true)?;

    let host = store.get("config")?.get_key("host")?.get_value()?;
    println!("config.host = {host:?}");

    // --- Closure API on Store ---
    // with_array scopes the handle so you don't need an explicit drop.
    store.with_array("tags", |arr| {
        arr.push("rust")?.push("pipeline")?.push("store")?;
        Ok(())
    })?;

    let tags = store.get("tags")?.as_array()?;
    println!("tags: len={}", tags.len());

    store.with_map("metadata", |map| {
        map.insert("version", "0.1.0")?.insert("stable", false)?;
        Ok(())
    })?;

    let version = store.get("metadata")?.get_key("version")?.get_value()?;
    println!("metadata.version = {version:?}");

    // --- Nested construction via MapHandle closures ---
    // with_array and with_map on MapHandle let you build nested structures
    // without manually managing sub-handles.
    store.with_map("server", |map| {
        map.insert("name", "prod-01")?;

        map.with_array("ports", |arr| {
            arr.push(80)?.push(443)?;
            Ok(())
        })?;

        map.with_map("tls", |tls| {
            tls.insert("enabled", true)?
                .insert("cert_path", "/etc/ssl/cert.pem")?;
            Ok(())
        })?;

        Ok(())
    })?;

    let tls_enabled = store
        .get("server")?
        .get_key("tls")?
        .get_key("enabled")?
        .get_value()?;
    println!("server.tls.enabled = {tls_enabled:?}");

    // --- push_map on ArrayHandle ---
    // Builds an array of maps — the most common pattern for tabular results.
    let mut arr = store.define_array("users")?;
    {
        let mut user = arr.push_map()?;
        user.insert("name", "Alice")?.insert("role", "admin")?;
    }
    {
        let mut user = arr.push_map()?;
        user.insert("name", "Bob")?.insert("role", "viewer")?;
    }

    let bob_role = store
        .get("users")?
        .get_index(1)?
        .get_key("role")?
        .get_value()?;
    println!("users[1].role = {bob_role:?}");
    assert_eq!(bob_role, &Value::Text("viewer".into()));

    println!("store_collections: ok");
    Ok(())
}

Trait Implementations

impl<T: Clone> Clone for Store<T>

fn clone(&self) -> Store<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Store<T>

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

Formats the value using the given formatter.

impl Default for Store<StoreEntry>

fn default() -> Self

Returns the “default value” for a type.

impl<T> IntoIterator for Store<T>

type Item = (String, T)

The type of the elements being iterated over.

type IntoIter = IntoIter<String, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.