rich_range 0.1.0

Range calculation helper.
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

//! Provider of [`Step`].

use crate::*;

/// Substitute for nightly only [`core::iter::Step`].
///
/// See original trait [document][doc] for details.
///
/// [doc]: core::iter::Step
pub trait Step: Clone + PartialOrd + Sized {
    /// Returns the bounds on the number of *successor* steps required
    /// to get from `start` to `end` like [`Iterator::size_hint()`].
    ///
    /// See original method [document][doc] for details.
    ///
    /// [doc]: core::iter::Step::steps_between
    fn steps_between(start: &Self, end: &Self) -> (usize, Option<usize>);

    /// Returns the value that would be obtained by
    /// taking the *successor* of `self` `count` times.
    ///
    /// See original method [document][doc] for details.
    ///
    /// [doc]: core::iter::Step::forward_checked
    fn forward_checked(start: Self, count: usize) -> Option<Self>;

    /// Returns the value that would be obtained by
    /// taking the *predecessor* of `self` `count` times.
    ///
    /// See original method [document][doc] for details.
    ///
    /// [doc]: core::iter::Step::backward_checked
    fn backward_checked(start: Self, count: usize) -> Option<Self>;

    /// Returns the value that would be obtained by
    /// taking the *successor* of `self` `count` times.
    ///
    /// See original method [document][doc] for details.
    ///
    /// [doc]: core::iter::Step::forward
    fn forward(start: Self, count: usize) -> Self {
        Step::forward_checked(start, count).expect(msg::NO_OVF)
    }

    /// Returns the value that would be obtained by
    /// taking the *predecessor* of `self` `count` times.
    ///
    /// See original method [document][doc] for details.
    ///
    /// [doc]: core::iter::Step::backward
    fn backward(start: Self, count: usize) -> Self {
        Step::backward_checked(start, count).expect(msg::NO_OVF)
    }
}

/// Implement [`Step`] for integer type.
macro_rules! impl_step_for_int {
    ($ty:ty as $mode:ident) => {
        impl Step for $ty {
            fn steps_between(start: &Self, end: &Self) -> (usize, Option<usize>) {
                if *start > *end {
                    (0, Some(0))
                } else {
                    let steps = usize::try_from(end.abs_diff(*start)).ok();
                    (steps.unwrap_or(usize::MAX), steps)
                }
            }

            fn forward_checked(start: Self, count: usize) -> Option<Self> {
                forward_checked!(start, count.try_into().ok()?, $mode)
            }

            fn backward_checked(start: Self, count: usize) -> Option<Self> {
                backward_checked!(start, count.try_into().ok()?, $mode)
            }
        }
    };
}

/// Implementation of [`Step::forward_checked`].
macro_rules! forward_checked {
    ($x:expr, $y:expr, signed) => {
        $x.checked_add_unsigned($y)
    };
    ($x:expr, $y:expr, unsigned) => {
        $x.checked_add($y)
    };
}

/// Implementation of [`Step::backward_checked`].
macro_rules! backward_checked {
    ($x:expr, $y:expr, signed) => {
        $x.checked_sub_unsigned($y)
    };
    ($x:expr, $y:expr, unsigned) => {
        $x.checked_sub($y)
    };
}

impl_step_for_int!(i8 as signed);
impl_step_for_int!(u8 as unsigned);
impl_step_for_int!(i16 as signed);
impl_step_for_int!(u16 as unsigned);
impl_step_for_int!(i32 as signed);
impl_step_for_int!(u32 as unsigned);
impl_step_for_int!(i64 as signed);
impl_step_for_int!(u64 as unsigned);
impl_step_for_int!(i128 as signed);
impl_step_for_int!(u128 as unsigned);
impl_step_for_int!(isize as signed);
impl_step_for_int!(usize as unsigned);