eventuals 0.6.7

Eventually consistent values
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

use crate::*;
use futures::Future;
use std::time::Duration;

/// Fluent style API extensions for any Eventual reader.
pub trait EventualExt: Sized + IntoReader {
    #[inline]
    fn map<F, O, Fut>(self, f: F) -> Eventual<O>
    where
        F: 'static + Send + FnMut(Self::Output) -> Fut,
        O: Value,
        Fut: Send + Future<Output = O>,
    {
        map(self, f)
    }

    #[inline]
    fn throttle(self, duration: Duration) -> Eventual<Self::Output> {
        throttle(self, duration)
    }

    #[inline]
    fn pipe<F>(self, f: F) -> PipeHandle
    where
        F: 'static + Send + FnMut(Self::Output),
    {
        pipe(self, f)
    }

    #[inline]
    fn pipe_async<F, Fut>(self, f: F) -> PipeHandle
    where
        F: 'static + Send + FnMut(Self::Output) -> Fut,
        Fut: Send + Future<Output = ()>,
    {
        pipe_async(self, f)
    }

    #[inline]
    fn map_with_retry<F, E, Ok, Err, Fut, FutE>(self, f: F, on_err: E) -> Eventual<Ok>
    where
        F: 'static + Send + FnMut(Self::Output) -> Fut,
        E: 'static + Send + Sync + FnMut(Err) -> FutE,
        Ok: Value,
        Err: Value,
        Fut: Send + Future<Output = Result<Ok, Err>>,
        FutE: Send + Future<Output = ()>,
    {
        map_with_retry(self, f, on_err)
    }

    #[inline]
    fn init_with(self, value: Self::Output) -> Eventual<Self::Output> {
        init_with(self, value)
    }
}

impl<E> EventualExt for E where E: IntoReader {}

pub trait TryEventualExt<Ok, Err>: Sized + IntoReader<Output = Result<Ok, Err>>
where
    Ok: Value,
    Err: Value,
{
    #[inline]
    #[deprecated = "Not deterministic. This is a special case of filter. Retry should be better"]
    fn handle_errors<F>(self, f: F) -> Eventual<Ok>
    where
        F: 'static + Send + FnMut(Err),
    {
        #[allow(deprecated)]
        handle_errors(self, f)
    }
}

impl<E, Ok, Err> TryEventualExt<Ok, Err> for E
where
    E: IntoReader<Output = Result<Ok, Err>>,
    Ok: Value,
    Err: Value,
{
}