exhaust 0.2.3

Trait and derive macro for working with all possible values of a type (exhaustive enumeration).
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

//! `bool` is a sufficiently simple and common case that it seems worth manually writing the
//! optimal implementation, and it is not quite an enum so its implementation can’t
//! straightforwardly be generated by a macro that works for enums.
//!
//! This doesn't use the “remote derive” pattern because the derive does not support double-ended
//! iteration, and would produce a superfluous factory type.

impl crate::Exhaust for bool {
    type Iter = ExhaustBool;
    fn exhaust_factories() -> Self::Iter {
        ExhaustBool(State::FalseTrue)
    }
    crate::patterns::factory_is_self!();
}

#[derive(Clone, Debug)]
pub /*-in-private*/ struct ExhaustBool(State);

#[derive(Clone, Debug, Eq, PartialEq)]
enum State {
    /// Will yield `[false, true]`
    FalseTrue,
    /// Will yield `[false]`
    False,
    /// Will yield `[true]`
    True,
    /// Will yield `[]`
    Exhausted,
}

impl Iterator for ExhaustBool {
    type Item = bool;
    fn next(&mut self) -> Option<Self::Item> {
        use State::{Exhausted, False, FalseTrue, True};

        let (item, state) = match self.0 {
            FalseTrue => (Some(false), True),
            False => (Some(false), Exhausted),
            True => (Some(true), Exhausted),
            Exhausted => (None, Exhausted),
        };
        self.0 = state;
        item
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        let len = self.len();
        (len, Some(len))
    }

    fn fold<B, F>(mut self, init: B, mut f: F) -> B
    where
        F: FnMut(B, Self::Item) -> B,
    {
        let mut state = init;
        if matches!(self.0, State::False | State::FalseTrue) {
            state = f(state, false);
        }
        if matches!(self.0, State::True | State::FalseTrue) {
            state = f(state, true);
        }
        self.0 = State::Exhausted;
        state
    }
}

impl DoubleEndedIterator for ExhaustBool {
    fn next_back(&mut self) -> Option<Self::Item> {
        use State::{Exhausted, False, FalseTrue, True};

        let (item, state) = match self.0 {
            FalseTrue => (Some(true), False),
            False => (Some(false), Exhausted),
            True => (Some(true), Exhausted),
            Exhausted => (None, Exhausted),
        };
        self.0 = state;
        item
    }

    fn rfold<B, F>(mut self, init: B, mut f: F) -> B
    where
        F: FnMut(B, Self::Item) -> B,
    {
        let mut state = init;
        if matches!(self.0, State::True | State::FalseTrue) {
            state = f(state, true);
        }
        if matches!(self.0, State::False | State::FalseTrue) {
            state = f(state, false);
        }
        self.0 = State::Exhausted;
        state
    }
}

impl core::iter::ExactSizeIterator for ExhaustBool {
    fn len(&self) -> usize {
        match self.0 {
            State::FalseTrue => 2,
            State::False | State::True => 1,
            State::Exhausted => 0,
        }
    }
}

impl core::iter::FusedIterator for ExhaustBool {}