rs-store

A thread-safe Redux-style state management library implemented in Rust.

Overview

rs-store provides a predictable state container inspired by Redux, featuring thread-safe state management with support for reducers, subscribers, and async actions through Thunk. Unlike traditional Redux, rs-store's reducers can produce side effects, providing more flexibility in state management.

Features

🔒 Thread-safe state management
📢 Publisher/Subscriber pattern for state changes
🔄 Support for asynchronous operations via Thunk actions
📊 Side effect handling in reducers
📊 Middleware handles actions and effects
📊 Backpressure handling with configurable policies
🎯 Bounded channel size with sync channels
🧪 Comprehensive test coverage
📚 Selector support
📊 Metrics support
🔄 Decoupling state updates from notification delivery

Installation

Add this to your Cargo.toml:

[dependencies]
rs-store = "0.21.0"

with the notify-channel feature:

[dependencies]
rs-store = { version = "0.21.0", features = ["notify-channel"] }

Quick Start

use std::sync::Arc;
use rs_store::{DispatchOp, Dispatcher, FnReducer, FnSubscriber, StoreBuilder};

pub fn main() {
    // new store with reducer
    let store = StoreBuilder::default()
        .with_reducer(Box::new(FnReducer::from(|state: &i32, action: &i32| {
            println!("reducer: {} + {}", state, action);
            DispatchOp::Dispatch(state + action, None)
        })))
        .build()
        .unwrap();

    // add subscriber
    store.add_subscriber(Arc::new(FnSubscriber::from(|state: &i32, _action: &i32| {
        println!("subscriber: state: {}", state);
    })));

    // dispatch actions
    store.dispatch(41);
    store.dispatch(1);

    // stop the store
    store.stop();

    assert_eq!(store.get_state(), 42);
}

Side Effects in Reducers

Unlike traditional Redux implementations, rs-store allows reducers to produce side effects directly. This means reducers can produce asynchronous operations.

This design choice provides more flexibility while maintaining predictable state management.

Notification Channel feature

The notification channel feature provides a dedicated channel for state notifications to subscribers, separating the concerns of state updates and notification delivery. This can help improve performance and reliability by:

Decoupling state updates from notification delivery
Preventing slow subscribers from blocking state updates
Allowing independent backpressure handling for notifications
Supporting different threading models for notification delivery

Documentation

For detailed documentation, visit:

Implementation Status

In Progress 🚧

Latest state notification for new subscribers
Notification scheduler (CurrentThread, ThreadPool)
Stop store after all effects are scheduled
Stream-based pull model

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

License

This project is licensed under the MIT License - see the LICENSE file for details.

rs-store 0.21.0