stillwater 1.0.1

Pragmatic effect composition and validation for Rust - pure core, imperative shell
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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! BoxedWriterEffect for type erasure.

use std::future::Future;
use std::pin::Pin;

use crate::effect::writer::WriterEffect;
use crate::effect::Effect;
use crate::Monoid;

// Type alias for the boxed writer effect inner function type
type BoxedWriterFn<T, E, Env, W> = Box<
    dyn FnOnce(Env) -> Pin<Box<dyn Future<Output = (Result<T, E>, W)> + Send + 'static>>
        + Send
        + 'static,
>;

/// A type-erased WriterEffect for use in collections, match arms, or recursive functions.
///
/// Similar to `BoxedEffect`, this enables:
/// - Storing different writer effect types in `Vec` or `HashMap`
/// - Returning different effect types from match arms
/// - Breaking infinite types in recursive functions
///
/// # Example
///
/// ```rust
/// use stillwater::effect::writer::prelude::*;
/// use stillwater::effect::prelude::*;
///
/// # tokio_test::block_on(async {
/// // Store heterogeneous writer effects
/// let effects: Vec<BoxedWriterEffect<i32, String, (), Vec<String>>> = vec![
///     tell_one("a".to_string()).map(|_| 1).boxed_writer(),
///     tell_one("b".to_string()).map(|_| 2).boxed_writer(),
/// ];
///
/// let mut results = Vec::new();
/// let mut all_logs = Vec::new();
///
/// for effect in effects {
///     let (result, logs) = effect.run_writer(&()).await;
///     results.push(result.unwrap());
///     all_logs.extend(logs);
/// }
///
/// assert_eq!(results, vec![1, 2]);
/// assert_eq!(all_logs, vec!["a".to_string(), "b".to_string()]);
/// # });
/// ```
///
/// # Match Arms with Different Types
///
/// ```rust
/// use stillwater::effect::writer::prelude::*;
/// use stillwater::effect::prelude::*;
///
/// fn conditional_log(flag: bool) -> BoxedWriterEffect<i32, String, (), Vec<String>> {
///     if flag {
///         tell_one("enabled".to_string()).map(|_| 1).boxed_writer()
///     } else {
///         into_writer::<_, _, Vec<String>>(pure::<_, String, ()>(0)).boxed_writer()
///     }
/// }
///
/// # tokio_test::block_on(async {
/// let (result, logs) = conditional_log(true).run_writer(&()).await;
/// assert_eq!(result, Ok(1));
/// assert_eq!(logs, vec!["enabled".to_string()]);
/// # });
/// ```
pub struct BoxedWriterEffect<T, E, Env, W>
where
    Env: Clone + Send + Sync + 'static,
    W: Monoid + Send + 'static,
{
    inner: BoxedWriterFn<T, E, Env, W>,
}

impl<T, E, Env, W> std::fmt::Debug for BoxedWriterEffect<T, E, Env, W>
where
    Env: Clone + Send + Sync + 'static,
    W: Monoid + Send + 'static,
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("BoxedWriterEffect").finish_non_exhaustive()
    }
}

impl<T, E, Env, W> BoxedWriterEffect<T, E, Env, W>
where
    T: Send + 'static,
    E: Send + 'static,
    Env: Clone + Send + Sync + 'static,
    W: Monoid + Send + 'static,
{
    /// Create a new BoxedWriterEffect from a WriterEffect.
    pub fn new<Eff>(effect: Eff) -> Self
    where
        Eff: WriterEffect<Output = T, Error = E, Env = Env, Writes = W> + Send + 'static,
    {
        BoxedWriterEffect {
            inner: Box::new(move |env: Env| Box::pin(async move { effect.run_writer(&env).await })),
        }
    }
}

impl<T, E, Env, W> Effect for BoxedWriterEffect<T, E, Env, W>
where
    T: Send + 'static,
    E: Send + 'static,
    Env: Clone + Send + Sync + 'static,
    W: Monoid + Send + 'static,
{
    type Output = T;
    type Error = E;
    type Env = Env;

    async fn run(self, env: &Self::Env) -> Result<Self::Output, Self::Error> {
        let (result, _writes) = (self.inner)(env.clone()).await;
        result
    }
}

impl<T, E, Env, W> WriterEffect for BoxedWriterEffect<T, E, Env, W>
where
    T: Send + 'static,
    E: Send + 'static,
    Env: Clone + Send + Sync + 'static,
    W: Monoid + Send + 'static,
{
    type Writes = W;

    async fn run_writer(
        self,
        env: &Self::Env,
    ) -> (Result<Self::Output, Self::Error>, Self::Writes) {
        (self.inner)(env.clone()).await
    }
}