min_by/max_by on iterators

[phimuemue]

It seems that there is min, max (simple computation of min/max), min_by_key, max_by_key (min/max by comparing mapped values) but no min_by and max_by (min/max according to comparison function). However, e.g. on vectors or slices there is sort, sort_by_key and sort_by.

Wouldn't it be convenient to have min_by/max_by on iterators?

[phimuemue]

As far as I could tell, we might reuse select_fold1 as follows:

/// Returns the element that gives the maximum value from the
/// specified comparison function.
///
/// Returns the rightmost element if the comparison determines two elements
/// to be equally maximum.
///
/// # Examples
///
/// ```
/// let a = [-3_i32, 0, 1, 5, -10];
/// assert_eq!(*a.iter().max_by(|x, y| x.cmp(y)).unwrap(), 5);
/// ```
#[inline]
#[unstable(feature = "iter_max_by", issue="1722")]
fn max_by<F>(self, mut compare: F) -> Option<Self::Item>
    where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
{
    select_fold1(self,
                 |_| (),
                 // switch to y even if it is only equal, to preserve
                 // stability.
                 |_, x, _, y| Ordering::Greater != compare(x, y))
        .map(|(_, x)| x)
}

/// Returns the element that gives the minimum value from the
/// specified comparison function.
///
/// Returns the latest element if the comparison determines two elements
/// to be equally minimum.
///
/// # Examples
///
/// ```
/// let a = [-3_i32, 0, 1, 5, -10];
/// assert_eq!(*a.iter().min_by(|x, y| x.cmp(y)).unwrap(), -10);
/// ```
#[inline]
#[unstable(feature = "iter_min_by", issue="1722")]
fn min_by<F>(self, mut compare: F) -> Option<Self::Item>
    where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
{
    select_fold1(self,
                 |_| (),
                 // switch to y even if it is strictly smaller, to
                 // preserve stability.
                 |_, x, _, y| Ordering::Greater == compare(x, y))
        .map(|(_, x)| x)
}

[SimonSapin]

Given that all of these are already in the standard library:

• Iterator::min
• Iterator::min_by_key
• Iterator::max
• Iterator::max_by_key
• [T]::sort
• [T]::sort_by
• [T]::sort_by_key
• [T]::binary_search
• [T]::binary_search_by
• [T]::binary_search_by_key

I think it’s clear that Iterator::min_by and max_by belong there as well and don’t need to go through the full RFC process. Feel free to make pull request on rust-lang/rust to add them.

[brson]

Agree with @SimonSapin. Closing in favor of rust-lang/rust#35856. Thanks @phimuemue.