总结

以下是如何创建和使用其中之一的基本方法

1. 创建一个结构体。使其继承Default。或者，您也可以向此结构体添加自己的属性/字段，并自己构建它，甚至提供构造函数。
   • 该特质为您提供默认构造函数 new()。
   • 只需按照此方法创建具有您自己属性的结构的构造函数即可。
2. 在您的结构体上实现 AsyncMiddleware、AsyncMiddlewareSpawns、AsyncReducer 或 AsyncSubscriber 特质。
3. 使用 add_middleware()、add_middleware_spawns()、add_reducer() 或 add_subscriber() 方法将此结构体注册到商店中。您可以注册任意数量的这些方法。
   • 如果您有一个没有属性的结构体，您可以直接使用默认的 ::new() 方法创建一个实例，并将其传递给 add_???() 方法。
   • 如果您有一个具有自定义属性的结构体，您可以实现自己的构造函数，或者将以下内容用作 add_???() 方法的参数：Box::new($YOUR_STRUCT))。

示例

💡 在此库的测试以及使用它构建的CLI 应用程序中有很多示例。

以下是如何使用它的示例。让我们从导入语句开始。

/// Imports.
use async_trait::async_trait;
use r3bl_rs_utils::redux::{
  AsyncMiddlewareSpawns, AsyncMiddleware, AsyncReducer,
  AsyncSubscriber, Store, StoreStateMachine,
};
use std::sync::{Arc, Mutex};
use tokio::sync::RwLock;

1. 请确保在您的 Cargo.toml 文件中安装了 tokio 和 async-trait 依赖项，以及 r3bl_rs_utils。
2. 以下是 Cargo.toml 的示例。

假设我们有一个以下动作枚举和状态结构体。

/// Action enum.
#[derive(Debug, PartialEq, Eq, Clone)]
pub enum Action {
  Add(i32, i32),
  AddPop(i32),
  Clear,
  MiddlewareCreateClearAction,
  Noop,
}

impl Default for Action {
  fn default() -> Self {
    Action::Noop
  }
}

/// State.
#[derive(Clone, Default, PartialEq, Debug)]
pub struct State {
  pub stack: Vec<i32>,
}

以下是减少函数的示例。

/// Reducer function (pure).
#[derive(Default)]
struct MyReducer;

#[async_trait]
impl AsyncReducer<State, Action> for MyReducer {
  async fn run(
    &self,
    action: &Action,
    state: &mut State,
  ) {
    match action {
      Action::Add(a, b) => {
        let sum = a + b;
        state.stack = vec![sum];
      }
      Action::AddPop(a) => {
        let sum = a + state.stack[0];
        state.stack = vec![sum];
      }
      Action::Clear => State {
        state.stack.clear();
      },
      _ => {}
    }
  }
}

以下是异步订阅者函数的示例（在派发动作后并行执行）。以下示例使用捕获共享对象的lambda表达式。这可能是您在创建在封闭块或作用域中共享状态的订阅者时可能会遇到的一种常见模式。

/// This shared object is used to collect results from the subscriber
/// function & test it later.
let shared_object = Arc::new(Mutex::new(Vec::<i32>::new()));

#[derive(Default)]
struct MySubscriber {
  pub shared_object_ref: Arc<Mutex<Vec<i32>>>,
}

#[async_trait]
impl AsyncSubscriber<State> for MySubscriber {
  async fn run(
    &self,
    state: State,
  ) {
    let mut stack = self
      .shared_object_ref
      .lock()
      .unwrap();
    if !state.stack.is_empty() {
      stack.push(state.stack[0]);
    }
  }
}

let my_subscriber = MySubscriber {
  shared_object_ref: shared_object_ref.clone(),
};

以下是两种异步中间件函数的类型。一种返回一个动作（在中间件返回时将派发），另一种不返回任何内容（如将当前动作输出到控制台的日志中间件）。请注意，这两个函数都共享上述 shared_object 引用。

/// This shared object is used to collect results from the subscriber
/// function & test it later.
#[derive(Default)]
struct MwExampleNoSpawn {
  pub shared_object_ref: Arc<Mutex<Vec<i32>>>,
}

#[async_trait]
impl AsyncMiddleware<State, Action> for MwExampleNoSpawn {
  async fn run(
    &self,
    action: Action,
    _store_ref: Arc<RwLock<StoreStateMachine<State, Action>>>,
  ) {
    let mut stack = self
      .shared_object_ref
      .lock()
      .unwrap();
    match action {
      Action::MwExampleNoSpawn_Add(_, _) => stack.push(-1),
      Action::MwExampleNoSpawn_AddPop(_) => stack.push(-2),
      Action::MwExampleNoSpawn_Clear => stack.push(-3),
      _ => {}
    }
    None
  }
}

let mw_example_no_spawn = MwExampleNoSpawn {
  shared_object_ref: shared_object_ref.clone(),
};

/// This shared object is used to collect results from the subscriber
/// function & test it later.
#[derive(Default)]
struct MwExampleSpawns {
  pub shared_object_ref: Arc<Mutex<Vec<i32>>>,
}

#[async_trait]
impl AsyncMiddlewareSpawns<State, Action> for MwExampleSpawns {
  async fn run(
    &self,
    action: Action,
    store_ref: Arc<RwLock<StoreStateMachine<State, Action>>>,
  ) -> JoinHandle<Option<Action>> {
    fire_and_forget!(
      {
        let mut stack = self
          .shared_object_ref
          .lock()
          .unwrap();
        match action {
          Action::MwExampleSpawns_ModifySharedObject_ResetState => {
            shared_vec.push(-4);
            return Action::Reset.into();
          }
          _ => {}
        }
        None
      }
    );
  }
}

let mw_example_spawns = MwExampleSpawns {
  shared_object_ref: shared_object_ref.clone(),
};

以下是设置具有上述减少器、中间件和订阅者函数的商店的方法。

// Setup store.
let mut store = Store::<State, Action>::default();
store
  .add_reducer(MyReducer::new()) // Note the use of `::new()` here.
  .await
  .add_subscriber(Box::new(         // We aren't using `::new()` here
    my_subscriber,                  // because the struct has properties.
  ))
  .await
  .add_middleware_spawns(Box::new(  // We aren't using `::new()` here
    mw_example_spawns,              // because the struct has properties.
  ))
  .await
  .add_middleware(Box::new(         // We aren't using `::new()` here
    mw_example_no_spawn,            // because the struct has properties.
  ))
  .await;

最后，以下是如何在测试中派发动作的示例。您可以使用 spawn_dispatch_action!() 并行派发动作，它是一种“点火并忘记”的操作，意味着调用者不会阻塞或等待 spawn_dispatch_action!() 返回。

// Test reducer and subscriber by dispatching `Add`, `AddPop`, `Clear` actions in parallel.
spawn_dispatch_action!( store, Action::Add(1, 2) );
assert_eq!(shared_object.lock().unwrap().pop(), Some(3));

spawn_dispatch_action!( store, Action::AddPop(1) );
assert_eq!(shared_object.lock().unwrap().pop(), Some(4));

spawn_dispatch_action!( store, Action::Clear );
assert_eq!(store.get_state().stack.len(), 0);

依赖于此的其它库

此包是以下包的依赖

1. r3bl_rs_utils 包（主库）

问题、评论、反馈和PR

如有任何问题，请向问题跟踪器报告。如果您有任何功能请求，也请随意添加👍。