What is an idiomatic way to collect an iterator of &T into a collection of Ts?

Question

I need to collect an iterator over a slice of &strs into a collection of &strs. The problem is that the iterator yields &&strs.

I tried to map from &word to word, and while it works, I don't know if it is considered good or if there are better options available.

The problem:

use std::collections::HashSet;

fn main() {
    let words = &["hello", "world", "I'm", "a", "Rustacean!"];
    let hashset = words.iter().collect::<HashSet<&str>>();
}

Playground

error[E0277]: a collection of type `std::collections::HashSet<&str>` cannot be built from an iterator over elements of type `&&str`
 --> src/main.rs:5:32
  |
5 |     let hashset = words.iter().collect::<HashSet<&str>>();
  |                                ^^^^^^^ a collection of type `std::collections::HashSet<&str>` cannot be built from `std::iter::Iterator<Item=&&str>`
  |
  = help: the trait `std::iter::FromIterator<&&str>` is not implemented for `std::collections::HashSet<&str>`

My solution:

use std::collections::HashSet;

fn main() {
    let words = &["hello", "world", "I'm", "a", "Rustacean!"];
    let hashset = words.iter().map(|&w| w).collect::<HashSet<&str>>();
}

Playground

Answer 1

Is a bicycle an idiomatic way to get from one city to another? Like most things in software (and life), it depends.

If your type implements Copy

I'd prefer these in this order:

1. some_iter.copied()
2. some_iter.cloned()
3. some_iter.map(|&v| v)
4. some_iter.map(|v| *v)
5. some_iter.map(Clone::clone)
6. some_iter.map(|v| v.clone())

If your type implements Clone

I'd prefer these in this order:

1. some_iter.cloned()
2. some_iter.map(Clone::clone)
3. some_iter.map(|v| v.clone())

If your type doesn't implement Copy or Clone

Then you cannot trivially create an owned value. The type may implement ToOwned or there may be a bespoke function or method that you can call inside of map, or you may simply not be able to do anything.

---

In your case, I'd use words.iter().copied().collect::<HashSet<_>>().

See also:

• Iterating over a slice's values instead of references in Rust?
• What's the idiomatic way to copy from a primitive type reference by value?
• Why is "&&" being used in closure arguments?
• Why does the argument for the find closure need two ampersands?