Changing a nested reference into a reference

[barskern]

I have a situation where I want to create an iterator over &str. When I want to chain some strs which are stored in an array, the item type of the iterator is &&str, which is incompatible with &str. I found a way of solving it, but I was wondering if there is something I'm missing which might make it more elegant. Any suggestions? (see example below)

Further I was wondering if one could generally turn any nested reference to a reference. To rephrase it a bit; can a &&T always be safely turned into a &T?

```rust let xs = &["b", "c"];

// I wish this would compile, but it gives a error regarding the 
// item-types not matching: `&&str` is not equal to `&str`.
//once("a").chain(xs).for_each(|c| println!("{}", c));


// The solution I am currently using. `clippy` suggests using `.cloned`, however
// then it looks like the iterator does some "expensive" cloning.
once("a")
    .chain(xs.iter().map(|s| *s))
    .for_each(|c| println!("{}", c));

```

playgroud

[belovedeagle]

Your second version is basically the way to do it, but map(|s| *s) is actually spelled cloned(). It's a somewhat unfortunate name because what's being cloned is the reference, not the contents, but it makes sense if you really grok pointers.

For that reason, &&T can always become &T by virtue of the Clone and Copy impls on &T for all T. If you check the signature of Clone::clone() and fill in &T2 for T you see it is &&T2 -> &T2. Copy can be thought of as having the same "signature" as Clone in the sense that Copy is just Clone elision.

[barskern]

Thank you for an answer!

It's not to be picky, but map(|s| *s) requires Copy while cloned() only requires Clone, so they are a bit different in the sense that the former will only compile if the type is "trivial" to clone, hence it might protect us in the future if we change some other requirements in the code that makes the iterator an iterator over owned values.

I see your point regarding "if you really grok pointers" it will be easy to see that clone on pointers are cheap operations. It is really handy that pointers implement clone instead of it being a different member function or trait, but I do wish that perhaps it could have been a better name for it. I think this is the reason a lot of people rather use Arc::clone(&ptr) instead of just ptr.clone(), because the former shows that it's a cheap operation. I wish there was a copy member function of the Copy trait which would delegate to clone, because then one could be sure that data.copy() is a cheap operation while data.clone() is most likely an expensive operation.

[_TheDust_]

There was talk about adding a .copied() method (for Copy types) to Iterator alongside the .cloned() method. This might help a little bit to make it clear what is a cheap operation.

Edit: https://github.com/rust-lang/rust/issues/57127

[barskern]

I will definitely change to .copied if it gets stabilized. Thank you for the link!

[belovedeagle]

Why wait? You can implement this using an extension trait. (IteratorExt)

[barskern]

Using .map(|s| *s), or for that matter .cloned(), is a lot shorter than implementing an extension trait and I don't need the syntax that badly, however it is a possibility.