iter-first-max 0.1.2

Iterator::max* returns the last for equal keys, this crate implements the return the first
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

#![doc = include_str!("../README.md")]
#![no_std]

use core::cmp::Ordering;

#[doc = include_str!("../README.md")]
pub trait IterFirstMaxExt: Iterator + Sized {
    /// Get max element, if equal, return the first equal element
    #[inline]
    fn first_max(self) -> Option<Self::Item>
    where Self::Item: Ord,
    {
        self.first_max_by(Ord::cmp)
    }

    /// Get max element, if equal, return the first equal element
    #[inline]
    fn first_max_by<F>(self, mut f: F) -> Option<Self::Item>
    where F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    {
        self.reduce(move |a, b| {
            if f(&a, &b).is_lt() {
                b
            } else {
                a
            }
        })
    }

    /// Get max element, if key equal, return the first key equal element
    #[inline]
    fn first_max_by_key<B, F>(self, mut f: F) -> Option<Self::Item>
    where F: FnMut(&Self::Item) -> B,
          B: Ord,
    {
        #[inline]
        fn cmp<B: Ord, T>((a, _): &(B, T), (b, _): &(B, T)) -> Ordering {
            a.cmp(b)
        }
        self.map(move |elem| (f(&elem), elem))
            .first_max_by(cmp)?
            .1
            .into()
    }
}
impl<I: Iterator> IterFirstMaxExt for I { }


/// Similar the [`IterFirstMaxExt`]
///
///
/// ```rust
/// use iter_first_max::IterLastMinExt as _;
///
/// let arr = [(1, 0), (1, 1), (1, 2), (2, 3), (2, 4)];
/// let first = arr.iter().min_by_key(|n| n.0);
/// let last  = arr.iter().last_min_by_key(|n| n.0);
///
/// assert_eq!(first, Some(&(1, 0)));
/// assert_eq!(last,  Some(&(1, 2)));
/// ```
pub trait IterLastMinExt: Iterator + Sized {
    /// Get min element, if equal, return the last equal element
    #[inline]
    fn last_min(self) -> Option<Self::Item>
    where Self::Item: Ord,
    {
        self.last_min_by(Ord::cmp)
    }

    /// Get min element, if equal, return the last equal element
    #[inline]
    fn last_min_by<F>(self, mut f: F) -> Option<Self::Item>
    where F: FnMut(&Self::Item, &Self::Item) -> Ordering,
    {
        self.reduce(move |a, b| {
            if f(&a, &b).is_ge() {
                b
            } else {
                a
            }
        })
    }

    /// Get min element, if key equal, return the last key equal element
    #[inline]
    fn last_min_by_key<B, F>(self, mut f: F) -> Option<Self::Item>
    where F: FnMut(&Self::Item) -> B,
          B: Ord,
    {
        #[inline]
        fn cmp<B: Ord, T>((a, _): &(B, T), (b, _): &(B, T)) -> Ordering {
            a.cmp(b)
        }
        self.map(move |elem| (f(&elem), elem))
            .last_min_by(cmp)?
            .1
            .into()
    }
}
impl<I: Iterator> IterLastMinExt for I { }