rangetools 0.1.4

Extending the Rust Range structs found in std::ops
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

use crate::{
    BoundedRange, BoundedSet, EmptyRange, LowerBound, LowerBoundedRange, LowerBoundedSet,
    Rangetools as _, UnboundedRange, UnboundedSet, UpperBound, UpperBoundedRange, UpperBoundedSet,
};

#[test]
fn range() {
    let r: std::ops::Range<i32> = 5..10;
    let c = UnboundedSet::new(
        UpperBoundedRange::new(UpperBound::excluded(5)),
        LowerBoundedRange::new(LowerBound::included(10)),
    );
    assert_eq!(r.complement(), c);
}

#[test]
fn range_inclusive() {
    let r: std::ops::RangeInclusive<i32> = 5..=10;
    let c = UnboundedSet::new(
        UpperBoundedRange::new(UpperBound::excluded(5)),
        LowerBoundedRange::new(LowerBound::excluded(10)),
    );
    assert_eq!(r.complement(), c);
}

#[test]
fn range_to() {
    let r: std::ops::RangeTo<i32> = ..4;
    let c = LowerBoundedRange::new(LowerBound::included(4));
    assert_eq!(r.complement(), c);
}

#[test]
fn range_to_inclusive() {
    let r: std::ops::RangeToInclusive<i32> = ..=4;
    let c = LowerBoundedRange::new(LowerBound::excluded(4));
    assert_eq!(r.complement(), c);
}

#[test]
fn range_from() {
    let r: std::ops::RangeFrom<i32> = 2..;
    let c = UpperBoundedRange::new(UpperBound::excluded(2));
    assert_eq!(r.complement(), c);
}

#[test]
fn range_full() {
    let r: std::ops::RangeFull = ..;
    let c = EmptyRange::<i32>::new();
    assert_eq!(r.complement(), c);
}

#[test]
fn bounded_range() {
    let r: BoundedRange<i128> = (1..3).to_inner();
    let c = UnboundedSet::new(
        UpperBoundedRange::new(UpperBound::excluded(1)),
        LowerBoundedRange::new(LowerBound::included(3)),
    );
    assert_eq!(r.complement(), c);
}

#[test]
fn lower_bounded_range() {
    let r: LowerBoundedRange<i32> = (1..).to_inner();
    let c = UpperBoundedRange::new(UpperBound::excluded(1));
    assert_eq!(r.complement(), c);
}

#[test]
fn upper_bounded_range() {
    let r: UpperBoundedRange<i32> = (..1).to_inner();
    let c = LowerBoundedRange::new(LowerBound::included(1));
    assert_eq!(r.complement(), c);
}

#[test]
fn unbounded_range() {
    let r: UnboundedRange = (..).to_inner();
    let c = EmptyRange::<i32>::new();
    assert_eq!(r.complement(), c);
}

#[test]
fn empty_range() {
    let r: EmptyRange<i32> = EmptyRange::new();
    let c = UnboundedRange::new();
    assert_eq!(r.complement(), c);
}

#[test]
fn bounded_set() {
    let s: BoundedSet<i32> = (1..3).union(5..10);
    let c = (..1).union(3..5).union(10..);
    assert_eq!(s.complement(), c);
}

#[test]
fn lower_bounded_set() {
    let s: LowerBoundedSet<i32> = (1..2).union(4..);
    let c = (..1).union(2..4);
    assert_eq!(s.complement(), c);
}

#[test]
fn upper_bounded_set() {
    let s: UpperBoundedSet<i32> = (..4).union(5..10);
    let c = (4..5).union(10..);
    assert_eq!(s.complement(), c);
}

#[test]
fn unbounded_set() {
    let s: UnboundedSet<i32> = (..1).union(3..5).union(10..);
    let c = (1..3).union(5..10);
    assert_eq!(s.complement(), c);
}