finding max from Vec<Enum> - using reduce()?

Question

I'm sure there is a better way to do this, but I do not know how to extract structure from Enum during reduce(). Assume ALL enums are identical in vector (but prob. solution needs to handle if this is not true also).

Simplest example:

#[derive(Debug)]
struct Data {
    d: u64,
}

#[derive(Debug)]
enum DataEnum {
    First(Data),
    Second,
}

fn main() {
    let v = vec![DataEnum::First(Data{d: 10}), DataEnum::First(Data{d: 5}), DataEnum::First(Data{d: 15}), DataEnum::First(Data{d: 13})];


    let mut vi = v.iter();
    let mut current = vi.next().unwrap();
    let mut max: u64;

    match current {
        DataEnum::First(data) => max = data.d,
        _ => panic!("dont know what to do with {:?}", current),
    }

    for next in vi {
        match next {
            DataEnum::First(data) => if max < data.d {
                current = next;
                max = data.d;
            },
            _ => panic!("dont know what to do with {:?}", next),
        }
    }

    println!("found max: {:?}", current);
}

Is there a better way to do this with fold or reduce?

Problem I have with reduce() is that I don't know how to handle the 'match' part inside closure properly (to extract and compare data.d).

Is there a reason you don't just #[derive(PartialOrd, PartialEq, Ord, Eq)] and .iter().max().unwrap() or .into_iter().max().unwrap()? — cafce25
– cafce25, Commented Sep 5, 2024 at 16:01
No particular reason than not realizing that would also work. Thx! — Igor Lautar
– Igor Lautar, Commented Sep 13, 2024 at 14:20

user4815162342 · Accepted Answer · 2024-09-05 20:41:16Z

You can certainly use reduce() in this kind of code. We start off by creating a utility function for just retrieving the data relevant for comparison, let's call it key:

fn key(e: &DataEnum) -> u64 {
    match e {
        DataEnum::First(data) => data.d,
        _ => panic!("dont know what to do with {:?}", e),
    }
}

The function returns u64, but it could return a tuple or similar (which is what you'd use to properly support heterogeneous enums in your collection). With this function in place, you can use reduce like this:

let max = v
    .iter()
    .reduce(|max, e| if key(e) > key(max) { e } else { max })
    .unwrap();

println!("found max: {:?}", max);

Playground

However, Rust already provides an iterator method that determines its maximum by applying a key, conveniently called max_by_key, so you can just use that:

let max = v.iter().max_by_key(|e| key(e)).unwrap();

Playground

Collectives™ on Stack Overflow

finding max from Vec<Enum> - using reduce()?

1 Answer 1

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Your Answer

Sign up or log in

Post as a guest

Related