MemoryStore -> impl Store

Author: nassor

README.md

@@ -41,7 +41,7 @@ impl Node<WorkflowState> for ProcessorNode {
     type PrepResult = String;
     type ExecResult = bool;
 
-    async fn prep(&self, store: &MemoryStore) -> Result<Self::PrepResult, CanoError> {
+    async fn prep(&self, store: &impl Store) -> Result<Self::PrepResult, CanoError> {
         let input: String = store.get("input").unwrap_or_default();
         Ok(input)
     }
@@ -51,7 +51,7 @@ impl Node<WorkflowState> for ProcessorNode {
         true // Success
     }
 
-    async fn post(&self, store: &MemoryStore, exec_res: Self::ExecResult) 
+    async fn post(&self, store: &impl Store, exec_res: Self::ExecResult) 
         -> Result<WorkflowState, CanoError> {
         if exec_res {
             store.put("result", "processed".to_string())?;
@@ -110,7 +110,7 @@ impl Node<String> for EmailProcessor {
     type PrepResult = String;
     type ExecResult = bool;
 
-    async fn prep(&self, store: &MemoryStore) -> Result<Self::PrepResult, CanoError> {
+    async fn prep(&self, store: &impl Store) -> Result<Self::PrepResult, CanoError> {
         // Load email data from store
         let email: String = store.get("email").unwrap_or_default();
         Ok(email)
@@ -122,7 +122,7 @@ impl Node<String> for EmailProcessor {
         true // Success
     }
 
-    async fn post(&self, store: &MemoryStore, success: Self::ExecResult) 
+    async fn post(&self, store: &impl Store, success: Self::ExecResult) 
         -> Result<String, CanoError> {
         // Store the result and return next action
         if success {

benches/flow_performance.rs

@@ -1,5 +1,5 @@
 use async_trait::async_trait;
-use cano::{CanoError, Flow, MemoryStore, Node};
+use cano::{CanoError, Flow, MemoryStore, Node, Store};
 use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
 
 /// Simple do-nothing node for benchmarking
@@ -35,7 +35,7 @@ impl Node<TestState> for DoNothingNode {
     type PrepResult = ();
     type ExecResult = ();
 
-    async fn prep(&self, _store: &MemoryStore) -> Result<Self::PrepResult, CanoError> {
+    async fn prep(&self, _store: &impl Store) -> Result<Self::PrepResult, CanoError> {
         Ok(())
     }
 
@@ -46,7 +46,7 @@ impl Node<TestState> for DoNothingNode {
 
     async fn post(
         &self,
-        _store: &MemoryStore,
+        _store: &impl Store,
         _exec_res: Self::ExecResult,
     ) -> Result<TestState, CanoError> {
         Ok(self.next_state.clone())

benches/node_performance.rs

@@ -1,5 +1,5 @@
 use async_trait::async_trait;
-use cano::store::StoreTrait;
+use cano::store::Store;
 use cano::{CanoError, DefaultParams, MemoryStore, Node};
 use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
 
@@ -29,7 +29,7 @@ impl Node<TestState> for DoNothingNode {
     type PrepResult = ();
     type ExecResult = ();
 
-    async fn prep(&self, _store: &MemoryStore) -> Result<Self::PrepResult, CanoError> {
+    async fn prep(&self, _store: &impl Store) -> Result<Self::PrepResult, CanoError> {
         Ok(())
     }
 
@@ -40,7 +40,7 @@ impl Node<TestState> for DoNothingNode {
 
     async fn post(
         &self,
-        _store: &MemoryStore,
+        _store: &impl Store,
         _exec_res: Self::ExecResult,
     ) -> Result<TestState, CanoError> {
         Ok(self.next_state.clone())
@@ -68,7 +68,7 @@ impl Node<TestState> for CpuIntensiveNode {
     type PrepResult = Vec<u64>;
     type ExecResult = u64;
 
-    async fn prep(&self, _store: &MemoryStore) -> Result<Self::PrepResult, CanoError> {
+    async fn prep(&self, _store: &impl Store) -> Result<Self::PrepResult, CanoError> {
         // Generate some data to process
         Ok((0..self.iterations as u64).collect())
     }
@@ -80,7 +80,7 @@ impl Node<TestState> for CpuIntensiveNode {
 
     async fn post(
         &self,
-        store: &MemoryStore,
+        store: &impl Store,
         exec_res: Self::ExecResult,
     ) -> Result<TestState, CanoError> {
         // Store the result
@@ -110,7 +110,7 @@ impl Node<TestState> for IoSimulationNode {
     type PrepResult = String;
     type ExecResult = String;
 
-    async fn prep(&self, _store: &MemoryStore) -> Result<Self::PrepResult, CanoError> {
+    async fn prep(&self, _store: &impl Store) -> Result<Self::PrepResult, CanoError> {
         // Simulate I/O delay
         tokio::time::sleep(tokio::time::Duration::from_millis(self.delay_ms)).await;
         Ok("prepared_data".to_string())
@@ -124,7 +124,7 @@ impl Node<TestState> for IoSimulationNode {
 
     async fn post(
         &self,
-        store: &MemoryStore,
+        store: &impl Store,
         exec_res: Self::ExecResult,
     ) -> Result<TestState, CanoError> {
         // Simulate I/O delay

benches/store_performance.rs

@@ -1,4 +1,4 @@
-use cano::{MemoryStore, store::StoreTrait};
+use cano::{MemoryStore, store::Store};
 use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
 
 fn bench_storage_operations(c: &mut Criterion) {

examples/book_prepositions.rs

@@ -23,7 +23,7 @@
 use async_trait::async_trait;
 use cano::error::CanoError;
 use cano::prelude::*;
-use cano::store::{MemoryStore, StoreTrait};
+use cano::store::{MemoryStore, Store};
 use futures::future::join_all;
 use std::collections::{HashMap, HashSet};
 use tokio::time::{Duration, timeout};
@@ -275,7 +275,7 @@ impl Node<BookPrepositionAction> for BookDownloaderNode {
     }
 
     /// Preparation: Get the list of books to download
-    async fn prep(&self, _store: &MemoryStore) -> Result<Self::PrepResult, CanoError> {
+    async fn prep(&self, _store: &impl Store) -> Result<Self::PrepResult, CanoError> {
         let book_list = Self::get_book_list();
         println!("📋 Prepared {} books for download", book_list.len());
         Ok(book_list)
@@ -322,7 +322,7 @@ impl Node<BookPrepositionAction> for BookDownloaderNode {
     /// Post-processing: Store downloaded books in memory
     async fn post(
         &self,
-        store: &MemoryStore,
+        store: &impl Store,
         exec_res: Self::ExecResult,
     ) -> Result<BookPrepositionAction, CanoError> {
         if exec_res.is_empty() {
@@ -415,7 +415,7 @@ impl Node<BookPrepositionAction> for PrepositionNode {
     }
 
     /// Preparation: Load downloaded books from memory
-    async fn prep(&self, store: &MemoryStore) -> Result<Self::PrepResult, CanoError> {
+    async fn prep(&self, store: &impl Store) -> Result<Self::PrepResult, CanoError> {
         let books: Vec<Book> = store
             .get("downloaded_books")
             .map_err(|e| CanoError::preparation(format!("Failed to load books: {e}")))?;
@@ -454,7 +454,7 @@ impl Node<BookPrepositionAction> for PrepositionNode {
     /// Post-processing: Store analysis results
     async fn post(
         &self,
-        store: &MemoryStore,
+        store: &impl Store,
         exec_res: Self::ExecResult,
     ) -> Result<BookPrepositionAction, CanoError> {
         if exec_res.is_empty() {
@@ -501,7 +501,7 @@ impl Node<BookPrepositionAction> for BookRankingByPrepositionNode {
     }
 
     /// Preparation: Load book analyses from memory
-    async fn prep(&self, store: &MemoryStore) -> Result<Self::PrepResult, CanoError> {
+    async fn prep(&self, store: &impl Store) -> Result<Self::PrepResult, CanoError> {
         let analyses: Vec<BookAnalysis> = store
             .get("book_analyses")
             .map_err(|e| CanoError::preparation(format!("Failed to load analyses: {e}")))?;
@@ -545,7 +545,7 @@ impl Node<BookPrepositionAction> for BookRankingByPrepositionNode {
     /// Post-processing: Store final rankings and display results
     async fn post(
         &self,
-        store: &MemoryStore,
+        store: &impl Store,
         exec_res: Self::ExecResult,
     ) -> Result<BookPrepositionAction, CanoError> {
         store.put("book_rankings", exec_res.clone())?;
@@ -711,7 +711,7 @@ async fn main() {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use cano::store::{MemoryStore, StoreTrait};
+    use cano::store::{MemoryStore, Store};
 
     #[tokio::test]
     async fn test_book_downloader_prep() {

examples/negotiation.rs

@@ -89,7 +89,7 @@ impl Node<NegotiationAction> for SellerNode {
     }
 
     /// Preparation phase: Load current negotiation state or initialize if first round
-    async fn prep(&self, store: &MemoryStore) -> Result<Self::PrepResult, CanoError> {
+    async fn prep(&self, store: &impl Store) -> Result<Self::PrepResult, CanoError> {
         match store.get::<NegotiationState>("negotiation_state") {
             Ok(state) => {
                 println!(
@@ -146,7 +146,7 @@ impl Node<NegotiationAction> for SellerNode {
     /// Post-processing phase: Store the updated offer for buyer evaluation
     async fn post(
         &self,
-        store: &MemoryStore,
+        store: &impl Store,
         exec_res: Self::ExecResult,
     ) -> Result<NegotiationAction, CanoError> {
         // Store the current negotiation state
@@ -204,7 +204,7 @@ impl Node<NegotiationAction> for BuyerNode {
     }
 
     /// Preparation phase: Load the current negotiation state
-    async fn prep(&self, store: &MemoryStore) -> Result<Self::PrepResult, CanoError> {
+    async fn prep(&self, store: &impl Store) -> Result<Self::PrepResult, CanoError> {
         let state: NegotiationState = store.get("negotiation_state").map_err(|e| {
             CanoError::preparation(format!("Failed to load negotiation state: {e}"))
         })?;
@@ -254,7 +254,7 @@ impl Node<NegotiationAction> for BuyerNode {
     /// Post-processing phase: Update state and determine next action
     async fn post(
         &self,
-        store: &MemoryStore,
+        store: &impl Store,
         exec_res: Self::ExecResult,
     ) -> Result<NegotiationAction, CanoError> {
         let (mut state, acceptable) = exec_res;

examples/simple.rs

@@ -54,7 +54,7 @@ impl Node<WorkflowAction> for GeneratorNode {
     }
 
     /// Preparation phase: Generate a random vector of u32 numbers (25 to 150 elements)
-    async fn prep(&self, _store: &MemoryStore) -> Result<Self::PrepResult, CanoError> {
+    async fn prep(&self, _store: &impl Store) -> Result<Self::PrepResult, CanoError> {
         let mut rng = rand::rng();
 
         // Generate random size between 25 and 150
@@ -85,7 +85,7 @@ impl Node<WorkflowAction> for GeneratorNode {
     /// Post-processing phase: Store the filtered vector in memory
     async fn post(
         &self,
-        store: &MemoryStore,
+        store: &impl Store,
         exec_res: Self::ExecResult,
     ) -> Result<WorkflowAction, CanoError> {
         // Store the filtered vector in memory
@@ -125,7 +125,7 @@ impl Node<WorkflowAction> for CounterNode {
     }
 
     /// Preparation phase: Load the filtered numbers from memory
-    async fn prep(&self, store: &MemoryStore) -> Result<Self::PrepResult, CanoError> {
+    async fn prep(&self, store: &impl Store) -> Result<Self::PrepResult, CanoError> {
         let numbers: Vec<u32> = store
             .get("filtered_numbers")
             .map_err(|e| CanoError::preparation(format!("Failed to load filtered numbers: {e}")))?;
@@ -147,7 +147,7 @@ impl Node<WorkflowAction> for CounterNode {
     /// Post-processing phase: Store count and clean up the original vector
     async fn post(
         &self,
-        store: &MemoryStore,
+        store: &impl Store,
         exec_res: Self::ExecResult,
     ) -> Result<WorkflowAction, CanoError> {
         // Store the count

src/error.rs

@@ -42,7 +42,7 @@
 //! This means store operations can seamlessly flow into the broader error system:
 //!
 //! ```rust
-//! use cano::{CanoResult, store::MemoryStore, store::StoreTrait};
+//! use cano::{CanoResult, store::MemoryStore, store::Store};
 //!
 //! fn example_function() -> CanoResult<String> {
 //!     let store = MemoryStore::new();