intervalsets 0.1.0-alpha.2

The intervalsets crate provides bounded and unbounded intervals implemented as sets with all the associated set operations.
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
139
140
141
142
143
144

//! Control behavior of data types that comprise the elements of a set.

use crate::bound::Side;

/// Defines the zero value for a type.
///
/// This is intended to work identically to [`num_traits::Zero`].
/// The trait is duplicated in order to work with external
/// types.
pub trait LibZero {
    fn new_zero() -> Self;
}

/// Create [`LibZero`] impl(s) that delegate to [`num_traits::Zero`]
///
/// Example
/// ```
/// use intervalsets::numeric::LibZero;
/// use intervalsets::adapt_num_traits_zero_impl;
///
/// #[derive(Debug, Clone, PartialEq, Eq)]
/// struct MyInt(u8);
///
/// impl core::ops::Add for MyInt {
///     type Output = Self;
///     fn add(self, rhs: Self) -> Self {
///         MyInt(self.0 + rhs.0)
///     }
/// }
///
/// impl num_traits::Zero for MyInt {
///     fn zero() -> Self {
///         MyInt(0)
///     }
///
///     fn is_zero(&self) -> bool {
///         self.0 == 0
///     }
/// }
///
/// adapt_num_traits_zero_impl!(MyInt);
/// assert_eq!(MyInt::new_zero(), MyInt(0));
/// ```
#[macro_export]
macro_rules! adapt_num_traits_zero_impl {
    ( $($t:ty), +) => {
        $(
            impl $crate::numeric::LibZero for $t {
                fn new_zero() -> Self {
                    <$t as num_traits::Zero>::zero()
                }
            }
        )*
    };
}

adapt_num_traits_zero_impl!(u8, u16, u32, u64, u128, usize);
adapt_num_traits_zero_impl!(i8, i16, i32, i64, i128, isize);
adapt_num_traits_zero_impl!(f32, f64);

/// Defines the data types whose elements make up a Set.
///
/// `try_adjacent` determines whether the elements are
/// treated as continuous or discrete data.
pub trait Domain: Sized + Clone + PartialOrd + PartialEq {
    fn try_adjacent(&self, side: Side) -> Option<Self>;
}

/// Automatically implements [`Domain`] for a type.
///
/// [`Interval`] and [`IntervalSet`] expect their generic types to implement
/// the [`Domain`] trait. It's primary function is to help normalize **disrete**
/// data types.
///
/// For **continuous** data types, normalization is a **noop**, but the trait
/// still needs to be implemented to meet the trait bounds for Set types.
///
/// This macro provides a default impl for **continuous** types;
///
/// # Example
///
/// ```
/// use intervalsets::continuous_domain_impl;
/// use intervalsets::Interval;
/// use intervalsets::ops::Contains;
///
/// #[derive(Clone, PartialEq, PartialOrd)]
/// struct MyFloat(f64);
///
/// continuous_domain_impl!(MyFloat);
///
/// let x = Interval::closed(MyFloat(0.0), MyFloat(10.0));
/// assert_eq!(x.contains(&MyFloat(5.0)), true);
/// ```
#[macro_export]
macro_rules! continuous_domain_impl {
    ($t:ty) => {
        impl $crate::numeric::Domain for $t {
            #[inline]
            fn try_adjacent(&self, side: $crate::Side) -> Option<Self> {
                None
            }
        }
    };
}

continuous_domain_impl!(f32);
continuous_domain_impl!(f64);

macro_rules! integer_domain_impl {
    ($t:ty) => {
        impl $crate::numeric::Domain for $t {
            #[inline]
            fn try_adjacent(&self, side: Side) -> Option<Self> {
                match side {
                    Side::Right => <$t>::checked_add(*self, 1),
                    Side::Left => <$t>::checked_sub(*self, 1),
                }
            }
        }
    };
}

integer_domain_impl!(usize);
integer_domain_impl!(u8);
integer_domain_impl!(u16);
integer_domain_impl!(u32);
integer_domain_impl!(u64);
integer_domain_impl!(u128);

integer_domain_impl!(isize);
integer_domain_impl!(i8);
integer_domain_impl!(i16);
integer_domain_impl!(i32);
integer_domain_impl!(i64);
integer_domain_impl!(i128);

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_zeros() {}
}