ranges 0.4.0

This crate provides a generic alternative to core/std ranges, set-operations to work with them and a range set that can efficiently store them with the least amount of memory possible.
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

use core::{
    cmp::Ordering::{self, Equal, Greater, Less},
    ops::Bound,
};

use crate::Domain;

impl Domain for Ordering {
    const DISCRETE: bool = true;

    fn predecessor(&self) -> Option<Self> {
        match *self {
            Less => None,
            Equal => Some(Less),
            Greater => Some(Equal),
        }
    }

    fn successor(&self) -> Option<Self> {
        match *self {
            Less => Some(Equal),
            Equal => Some(Greater),
            Greater => None,
        }
    }

    fn minimum() -> Bound<Self> {
        Bound::Included(Less)
    }

    fn maximum() -> Bound<Self> {
        Bound::Included(Greater)
    }

    fn is_next_to(&self, other: &Self) -> bool {
        match (*self, *other) {
            (Less | Greater, Less | Greater) | (Equal, Equal) => false,
            (Less | Greater, Equal) | (Equal, Less | Greater) => true,
        }
    }

    fn shares_neighbour_with(&self, other: &Self) -> bool {
        match (*self, *other) {
            // when they're next to `Equal`
            | (Equal, _)
            | (_, Equal)
            // when they're equal
            | (Less, Less)
            | (Greater, Greater) => false,
            (Less, Greater) | (Greater, Less) => true,
        }
    }
}

#[cfg(test)]
mod tests {
    use core::cmp::Ordering::{Equal, Greater, Less};

    use crate::Domain;

    #[test]
    fn is_next_to() {
        assert!(!Less.is_next_to(&Less));
        assert!(Less.is_next_to(&Equal));
        assert!(!Less.is_next_to(&Greater));
        assert!(Equal.is_next_to(&Less));
        assert!(!Equal.is_next_to(&Equal));
        assert!(Equal.is_next_to(&Greater));
        assert!(!Greater.is_next_to(&Less));
        assert!(Greater.is_next_to(&Equal));
        assert!(!Greater.is_next_to(&Greater));
    }
    #[test]
    fn shares_neighbour_with() {
        assert!(!Less.shares_neighbour_with(&Less));
        assert!(!Less.shares_neighbour_with(&Equal));
        assert!(Less.shares_neighbour_with(&Greater));
        assert!(!Equal.shares_neighbour_with(&Less));
        assert!(!Equal.shares_neighbour_with(&Equal));
        assert!(!Equal.shares_neighbour_with(&Greater));
        assert!(Greater.shares_neighbour_with(&Less));
        assert!(!Greater.shares_neighbour_with(&Equal));
        assert!(!Greater.shares_neighbour_with(&Greater));
    }
    #[test]
    fn predecessor() {
        assert_eq!(Less.predecessor(), None);
        assert_eq!(Equal.predecessor(), Some(Less));
        assert_eq!(Greater.predecessor(), Some(Equal));
    }
    #[test]
    fn successor() {
        assert_eq!(Less.successor(), Some(Equal));
        assert_eq!(Equal.successor(), Some(Greater));
        assert_eq!(Greater.successor(), None);
    }
}