dbuff 0.1.0

Double-buffered state with async command chains, streaming, and keyed task pools for ratatui applications
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

use dbuff::*;
use std::time::Duration;

#[derive(Debug, Clone, Default)]
struct AppData {
    user_id: i32,
    post_count: usize,
    log: Vec<String>,
}

#[derive(Debug, Clone, wherror::Error)]
#[error(debug)]
struct CmdError;

/// Simulates fetching a user, returning their ID.
struct FetchUser(i32);

#[async_trait::async_trait]
impl Command<()> for FetchUser {
    type Output = i32;
    type Error = CmdError;

    async fn execute(self, _: ()) -> Result<Self::Output, Self::Error> {
        Ok(self.0)
    }
}

/// Simulates fetching posts for a given user ID, returning the count.
struct FetchPosts(i32);

#[async_trait::async_trait]
impl Command<()> for FetchPosts {
    type Output = usize;
    type Error = CmdError;

    async fn execute(self, _: ()) -> Result<Self::Output, Self::Error> {
        #[allow(clippy::cast_sign_loss)]
        Ok(self.0 as usize * 10)
    }
}

/// A logging command that produces a String.
struct Log(String);

#[async_trait::async_trait]
impl Command<()> for Log {
    type Output = String;
    type Error = CmdError;

    async fn execute(self, _: ()) -> Result<Self::Output, Self::Error> {
        Ok(self.0)
    }
}

#[tokio::main]
async fn main() {
    let rt = tokio::runtime::Handle::current();
    let (domain, write_handle) =
        SharedDomainData::with_coalesce(AppData::default(), Duration::from_millis(1));
    tokio::spawn(write_handle.run());

    // Data-passing chain:
    // 1. FetchUser(42) → gets user_id 42
    // 2. then_with: uses user_id to FetchPosts(42) → gets 420 posts
    // 3. exec: independent Log command
    let handle = domain
        .bind((), rt.clone())
        .exec(FetchUser(42), |d, id: &i32| d.user_id = *id)
        .then(
            |user_id: &i32| FetchPosts(*user_id),
            |d, count: &usize| d.post_count = *count,
        )
        .exec(Log("posts loaded".into()), |d, msg: &String| {
            d.log.push(msg.clone());
        })
        .go();

    let flow = handle.await.unwrap();
    assert_eq!(flow, ControlFlow::Continue);

    tokio::time::sleep(Duration::from_millis(10)).await;

    let guard = domain.read();
    assert_eq!(guard.user_id, 42);
    assert_eq!(guard.post_count, 420);
    assert_eq!(guard.log, vec!["posts loaded"]);
    println!(
        "user_id = {}, post_count = {}, log = {:?}",
        guard.user_id, guard.post_count, guard.log
    );
}