[ER] Array.max and min ?

[leonardo-m]

When you want to compute the max or min of three or more items you have various options:

fn main() {
    let (a, b, c, d) = (10, 20, 30, 40);
    let m0 = a.max(b).max(c).max(d);
    let m2: u32 = [a, b, c, d].iter().copied().max().unwrap();
}

You can also introduce a macro:

#![feature(min_const_generics)]

macro_rules! max {
    ($x:expr) => ($x);
    ($x:expr, $($xs:expr),+) => {
        {
            std::cmp::max($x, max!( $($xs),+ ))
        }
    };
}

fn main() {
    let (a, b, c, d) = (10, 20, 30, 40);
    let m1 = max!{a, b, c, d};
}

But an array method may solve the problem better, without macros (code untested) and without unwraps:

// This should statically require N > 0.
impl<T: Ord, const N: usize> [T; N] {
    fn max(self) -> T {
        let mut result = self[0];
        for &x in &self[1 .. ] {
            result = result.max(x);
        }
        result
    }
}

fn main() {
    let (a, b, c, d) = (10, 20, 30, 40);
    let m3a: u32 = [a, b, c, d].min();
    let m3b: u32 = [a, b, c, d].max();
}

[jyn514]

This will work: [1,2,3].iter().max().unwrap()

[jyn514]

Oh you said that already, sorry.

[jyn514]

This works on nightly: https://play.rust-lang.org/?version=nightly&mode=debug&edition=2018&gist=c2434427de054bbbb32950461920bb70. Not sure how to enforce the length is greater than 0.

[JulianKnodt]

I think this would compile efficiently(and is the same as jyn's with an added assert which might change compilation behavior):

#![feature(iterator_fold_self)]
fn arr_max<T: Ord, const N: usize>(v: [T; N]) -> T {
  assert(N > 0); // This should get compiled out when N > 0 and when N == 0 this will just be a panic.
  // I would think the unwrap would be compiled out but unsure.
  Array::into_iter(v).fold_first(|a, b| a.max(b)).unwrap()
}

[leonardo-m]

Now there are Nightly ways to enforce N > 0.
If the array::max() name is not available then array::array_max() and array::array_min() names could be acceptable.

A related function could be array::fold.

[sffc]

I've landed here multiple times looking for a method on array that lets me do reduction operations without an unwrap. It would be nice to start with a .reduce function defined on array lengths of at least 1 that is not fallible; then one could write:

let arr: [i32; 4] = [10, 20, 30, 40];
let max = arr.reduce(i32::max);