rehearse 0.3.0

Effect-aware operation planning with describe, dry-run, and execute modes.
Documentation
use super::value::PlanId;
use super::{NodeId, Value};
use crate::ValueError;
use std::any::{type_name, Any};
use std::collections::HashMap;
use std::sync::Arc;

pub type StoredValue = Arc<dyn Any + Send + Sync>;

#[derive(Debug)]
pub struct ValueStore {
    owner: PlanId,
    values: HashMap<NodeId, StoredValue>,
}

impl ValueStore {
    pub(crate) fn new(owner: PlanId) -> Self {
        Self {
            owner,
            values: HashMap::new(),
        }
    }

    pub fn contains(&self, node: NodeId) -> bool {
        self.values.contains_key(&node)
    }

    pub fn insert_erased(&mut self, node: NodeId, value: StoredValue) {
        self.values.insert(node, value);
    }

    pub fn erase<T>(value: T) -> StoredValue
    where
        T: Clone + Send + Sync + 'static,
    {
        Arc::new(value)
    }

    pub fn get<T>(&self, value: Value<T>) -> Result<Option<T>, ValueError>
    where
        T: Clone + Send + Sync + 'static,
    {
        if value.owner != self.owner {
            return Err(ValueError::ForeignPlan { node: value.node() });
        }
        let Some(stored) = self.values.get(&value.node()) else {
            return Ok(None);
        };
        let typed = Arc::clone(stored)
            .downcast::<T>()
            .map_err(|_| ValueError::TypeMismatch {
                node: value.node(),
                expected: type_name::<T>().to_owned(),
            })?;
        Ok(Some((*typed).clone()))
    }

    pub fn require<T>(&self, value: Value<T>) -> Result<T, ValueError>
    where
        T: Clone + Send + Sync + 'static,
    {
        self.get(value)?
            .ok_or_else(|| ValueError::Missing { node: value.node() })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn resolution_checks_owner_availability_and_type() {
        let owner = PlanId::new();
        let mut store = ValueStore::new(owner);
        let node = NodeId::new(0);
        let value = Value::<u32>::new(owner, node);
        assert_eq!(store.require(value), Err(ValueError::Missing { node }));
        store.insert_erased(node, ValueStore::erase("wrong type"));
        assert!(matches!(
            store.require(value),
            Err(ValueError::TypeMismatch { .. })
        ));
        store.insert_erased(node, ValueStore::erase(42_u32));
        assert_eq!(store.require(value), Ok(42));
        assert_eq!(
            store.require(Value::<u32>::new(PlanId::new(), node)),
            Err(ValueError::ForeignPlan { node })
        );
    }
}