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

#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};

/// A range with no upper or lower bound.
///
/// Generalizes over [`std::ops::RangeFull`].
///
/// While an `UnboundedRange` can be constructed directly, it will most likely
/// result from one or more range operations.
/// ```
/// use rangetools::{UnboundedRange, Rangetools};
///
/// let i = (..).intersection(..);
/// assert_eq!(i, UnboundedRange {});
/// ```
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
pub struct UnboundedRange;

impl From<std::ops::RangeFull> for UnboundedRange {
    fn from(_: std::ops::RangeFull) -> Self {
        Self
    }
}

impl From<UnboundedRange> for std::ops::RangeFull {
    fn from(_: UnboundedRange) -> Self {
        Self
    }
}

impl UnboundedRange {
    /// Constructs a new `UnboundedRange`.
    ///
    /// # Example
    /// ```
    /// use rangetools::UnboundedRange;
    ///
    /// let r = UnboundedRange::new();
    /// assert!(r.contains(42));
    /// ```
    pub fn new() -> Self {
        Self
    }

    /// Returns true if the range contains the given item.
    ///
    /// This function always returns true, but it's nice to have it for instances
    /// when you don't want to have to think about what type your range operation
    /// is returning.
    ///
    /// # Example
    /// ```
    /// use rangetools::Rangetools;
    ///
    /// let r = (..).intersection(..);
    /// assert!(r.contains(5));
    /// assert!(r.contains(3));
    /// ```
    pub fn contains<T>(&self, _: T) -> bool {
        true
    }
}