exhaust 0.2.1

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
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

use core::{fmt, iter};

use crate::iteration::{carry, peekable_exhaust};
use crate::patterns::{factory_is_self, impl_newtype_generic, impl_via_array, impl_via_range};
use crate::Exhaust;

impl Exhaust for () {
    type Iter = iter::Once<()>;
    fn exhaust_factories() -> Self::Iter {
        iter::once(())
    }
    factory_is_self!();
}

// Implement single-element tuples in the same way we implement other generic containers.
impl_newtype_generic!(T: [], (T,), |x| (x,));

// Generates tuple implementations from 2 to 12 items.
// 12 was chosen as the same size the standard library offers.
exhaust_macros::impl_exhaust_for_tuples!(12);

impl_via_array!(bool, [false, true]);

impl_via_range!(char, '\x00', char::MAX);
impl_via_range!(i8, i8::MIN, i8::MAX);
impl_via_range!(u8, u8::MIN, u8::MAX);
impl_via_range!(i16, i16::MIN, i16::MAX);
impl_via_range!(u16, u16::MIN, u16::MAX);
impl_via_range!(i32, i32::MIN, i32::MAX);
impl_via_range!(u32, u32::MIN, u32::MAX);
// i64 and larger sizes are not implemented because it is not feasible to exhaust them.
/// Note: The floats produced include many `NaN`s (all unequal in representation).
impl Exhaust for f32 {
    type Iter = <u32 as Exhaust>::Iter;
    type Factory = u32;
    fn exhaust_factories() -> Self::Iter {
        u32::exhaust_factories()
    }
    fn from_factory(factory: Self::Factory) -> Self {
        f32::from_bits(factory)
    }
}

impl<T: Exhaust, const N: usize> Exhaust for [T; N] {
    type Iter = ExhaustArray<T, N>;
    type Factory = [T::Factory; N];
    fn exhaust_factories() -> Self::Iter {
        ExhaustArray {
            state: [(); N].map(|()| peekable_exhaust::<T>()),
            done_zero: false,
        }
    }
    fn from_factory(factory: Self::Factory) -> Self {
        factory.map(T::from_factory)
    }
}

/// Iterator implementation of `[T; N]::exhaust()`.
pub struct ExhaustArray<T: Exhaust, const N: usize> {
    state: [iter::Peekable<T::Iter>; N],
    done_zero: bool,
}

impl<T, const N: usize> fmt::Debug for ExhaustArray<T, N>
where
    T: Exhaust<Iter: fmt::Debug, Factory: fmt::Debug>,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ExhaustArray")
            .field("state", &self.state)
            .field("done_zero", &self.done_zero)
            .finish()
    }
}

impl<T: Exhaust, const N: usize> Clone for ExhaustArray<T, N> {
    fn clone(&self) -> Self {
        Self {
            state: self.state.clone(),
            done_zero: self.done_zero,
        }
    }
}

impl<T: Exhaust, const N: usize> Iterator for ExhaustArray<T, N> {
    type Item = [T::Factory; N];

    fn next(&mut self) -> Option<Self::Item> {
        if N == 0 {
            return if self.done_zero {
                None
            } else {
                self.done_zero = true;
                // This is just `Some([])` in disguise
                Some([(); N].map(|()| unreachable!()))
            };
        }

        // Check if we have a next item
        let has_next = self
            .state
            .iter_mut()
            .all(|value_iter| value_iter.peek().is_some());

        if !has_next {
            return None;
        }

        // Gather that next item.
        // unwrap() cannot fail because we checked with peek().
        let mut i = 0;
        let item = [(); N].map(|()| {
            let element = if i == N - 1 {
                // Advance the "last digit".
                self.state[i].next().unwrap()
            } else {
                // Don't advance the others
                self.state[i].peek().unwrap().clone()
            };
            i += 1;
            element
        });

        // "Carry": if the rightmost iterator is exhausted, advance the one to the left,
        // and repeat for all but the leftmost. If the leftmost is exhausted, we'll stop
        // on the next iteration.
        for i in (1..N).rev() {
            let (high, low) = &mut self.state.split_at_mut(i);
            if !carry(high.last_mut().unwrap(), &mut low[0], peekable_exhaust::<T>) {
                break;
            }
        }

        Some(item)
    }
}

impl<T: Exhaust, const N: usize> iter::FusedIterator for ExhaustArray<T, N> {}