functora 0.1.10

Missing pieces of the Rust standard library.
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

#![doc = include_str!("../README.md")]

pub use std::ops::ControlFlow;

pub fn id<T>(x: T) -> T {
    x
}

pub fn ok<E>() -> Result<(), E> {
    Ok(())
}

pub trait Void {
    fn void(&self);
}

impl<T> Void for T {
    fn void(&self) {}
}

pub fn void<T>(_: T) {}

pub trait Tweak
where
    Self: Sized,
{
    fn tweak(&mut self, f: impl FnOnce(&Self) -> Self);
    fn try_tweak<E>(&mut self, f: impl FnOnce(&Self) -> Result<Self, E>) -> Result<(), E>;
}

impl<T> Tweak for T {
    fn tweak(&mut self, f: impl FnOnce(&T) -> T) {
        *self = f(self);
    }
    fn try_tweak<E>(&mut self, f: impl FnOnce(&T) -> Result<Self, E>) -> Result<(), E> {
        f(self).and_then(|x| {
            *self = x;
            ok()
        })
    }
}

pub trait Guard<E>
where
    Self: Sized,
{
    fn guard(self, e: E) -> Result<(), E> {
        self.guard_then(|| e)
    }
    fn guard_then(self, f: impl FnOnce() -> E) -> Result<(), E>;
}

impl<E> Guard<E> for bool {
    fn guard_then(self, f: impl FnOnce() -> E) -> Result<(), E> {
        if self { ok() } else { Err(f()) }
    }
}

impl<T, E> Guard<E> for Option<T>
where
    T: Guard<E>,
{
    fn guard_then(self, f: impl FnOnce() -> E) -> Result<(), E> {
        match self {
            None => Err(f()),
            Some(x) => x.guard_then(f),
        }
    }
}

impl<T, EOuter, EInner> Guard<EOuter> for Result<T, EInner>
where
    T: Guard<EOuter>,
    EOuter: From<EInner>,
{
    fn guard_then(self, f: impl FnOnce() -> EOuter) -> Result<(), EOuter> {
        self?.guard_then(f)
    }
}

pub fn guard<T, E>(x: T, e: E) -> Result<(), E>
where
    T: Guard<E>,
{
    x.guard(e)
}

pub fn guard_then<T, E>(x: T, f: impl FnOnce() -> E) -> Result<(), E>
where
    T: Guard<E>,
{
    x.guard_then(f)
}

pub fn from_control_flow<T>(cf: ControlFlow<T, T>) -> T {
    match cf {
        ControlFlow::Continue(x) | ControlFlow::Break(x) => x,
    }
}

#[cfg(feature = "futures")]
mod futures;
#[cfg(feature = "futures")]
pub use crate::futures::*;