Returning mutable references

help
#1

I'm having trouble finding an ergonomic way to do the following:
I have a struct that contains a vector of items. I want to return a "best candidate" item by first filtering the vector and then sorting the vector. I also want the best candidate item to be a mutable reference.
Note: The filtering and sorting in this sample is just dummy code

struct Item {
    value: u8
}

struct Items {
    items: Vec<Item>
}

impl Items {
    fn get_mut_best_item(&mut self) -> Option<&mut Item> {
        let mut subset: Vec<&mut Item> = self.items.iter_mut().filter(|i| i.value % 2 == 0).collect();
        subset.sort_by(|lhs, rhs| lhs.value.partial_cmp(&rhs.value).unwrap());
        subset.first().map(|x| *x)
    }
}

The error I get is at the last line:
68 | subset.first().map(|x| *x)
| ^^ move occurs because *x has type &mut Item, which does not implement the Copy trait

I tried chaining rather than assigning to "subset", but "sort_by" doesn't return a reference to itself, so that didn't work.

1 Like
#2

This is because mutable references are guaranteed to be unique, and hence cannot be copied. So essentially, it fails for the same reason as why this fails:

fn foo() -> Option<String> {
    let strs = vec![
        "foo".to_string(),
        "bar".to_string(),
        "baz".to_string(),
    ];
    
    strs.first().map(|x| *x)
}

error[E0507]: cannot move out of `*x` which is behind a shared reference
 --> src/lib.rs:9:26
  |
9 |     strs.first().map(|x| *x)
  |                          ^^ move occurs because `*x` has type `String`, which does not implement the `Copy` trait

To fix this, you must take ownership of the vector's first item rather than borrowing it mutably. The easiest way to do that is to call .into_iter().next().

impl Items {
    fn get_mut_best_item(&mut self) -> Option<&mut Item> {
        let mut subset: Vec<&mut Item> = self.items.iter_mut().filter(|i| i.value % 2 == 0).collect();
        subset.sort_by(|lhs, rhs| lhs.value.partial_cmp(&rhs.value).unwrap());
        subset.into_iter().next()
    }
}
1 Like
#3

I believe this can be better expressed with:

subset.sort_by_key(|e| e.value);
2 Likes
#4

Thank you! I had been reading about the difference between iter() and into_iter(), but didn't make the connection.

#5

Ah, thank you! While this was dummy code, it still applied to my real code. Much more readable!

#6

And since looks like op just wants the minimum value it could also just do:

self.items.iter_mut().filter(|i| i.value % 2 == 0).min_by_key(|e| e.value)
2 Likes
#7

Even better!