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

//! EnsureWith combinator for validation with lazy error construction.

use crate::effect::Effect;

/// Validates with an error factory function.
///
/// Like `Ensure`, but the error is only constructed if the predicate fails.
/// The error function receives a reference to the value, allowing for
/// context-specific error messages.
///
/// # Example
///
/// ```rust,ignore
/// use stillwater::effect::prelude::*;
///
/// let effect = pure::<_, String, ()>(-5)
///     .ensure_with(
///         |x| *x > 0,
///         |x| format!("{} is not positive", x)
///     );
///
/// assert_eq!(effect.execute(&()).await, Err("-5 is not positive".to_string()));
/// ```
pub struct EnsureWith<E, P, F> {
    pub(crate) inner: E,
    pub(crate) predicate: P,
    pub(crate) error_fn: F,
}

impl<E, P, F> std::fmt::Debug for EnsureWith<E, P, F> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("EnsureWith")
            .field("inner", &"<effect>")
            .field("predicate", &"<function>")
            .field("error_fn", &"<function>")
            .finish()
    }
}

impl<E, P, F> EnsureWith<E, P, F> {
    /// Create a new EnsureWith combinator.
    pub fn new(inner: E, predicate: P, error_fn: F) -> Self {
        EnsureWith {
            inner,
            predicate,
            error_fn,
        }
    }
}

impl<E, P, F> Effect for EnsureWith<E, P, F>
where
    E: Effect,
    P: FnOnce(&E::Output) -> bool + Send,
    F: FnOnce(&E::Output) -> E::Error + Send,
{
    type Output = E::Output;
    type Error = E::Error;
    type Env = E::Env;

    async fn run(self, env: &Self::Env) -> Result<Self::Output, Self::Error> {
        let value = self.inner.run(env).await?;
        if (self.predicate)(&value) {
            Ok(value)
        } else {
            Err((self.error_fn)(&value))
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::effect::constructors::pure;
    use crate::effect::EffectExt;

    #[tokio::test]
    async fn test_ensure_with_lazy_error() {
        let effect =
            pure::<_, String, ()>(-5).ensure_with(|x| *x > 0, |x| format!("{} is not positive", x));
        assert_eq!(
            effect.execute(&()).await,
            Err("-5 is not positive".to_string())
        );
    }

    #[tokio::test]
    async fn test_ensure_with_passes() {
        let effect =
            pure::<_, String, ()>(5).ensure_with(|x| *x > 0, |x| format!("{} is not positive", x));
        assert_eq!(effect.execute(&()).await, Ok(5));
    }

    #[tokio::test]
    async fn test_ensure_with_error_not_called_on_success() {
        let mut called = false;
        let effect = pure::<_, String, ()>(5).ensure_with(
            |x| *x > 0,
            |_| {
                called = true;
                "error".to_string()
            },
        );
        assert_eq!(effect.execute(&()).await, Ok(5));
        // Note: In the actual implementation, we can't check 'called'
        // because error_fn is moved into the closure. This is just
        // documenting the behavior - error_fn is only called on failure.
    }
}