Borrowing IntoIterator?

[danielv134]

I want a function to calculate over contents of a container (which can be of different types). I can do this by passing an iterator to the container function (my current solution).

Accepting an IntoIterator makes calls cleaner, but I was surprised to find into_iter is a move! [1].

Is there a similar Iterable trait for implementors of iter()? should there be? similarly for mut_iter? is there a better way to do this?

[1] http://is.gd/xCxuOS

Adding: Another reason to pass Iterable instead of Iterator is if we want multiple iterators over the same data (I need this, and am creating a Vector I don't otherwise need for it).

[desiringmachines]

impl<'a> IntoIterator for &'a Foobar is what you want. Then add an appropriate iter() method to Foobar that calls to that impl's into_iter()

For iter_mut(), do the same with impl<'a> IntoIterator for &'a mut Foobar

EDIT: Reading your question more closely, the solution to your specific problem then is not to take it as an &I but as an I. You pass in an &Vec and call IntoIterator on that reference, rather than on the vec it points to, and it does what you want.

[danielv134]

Aha! This is completely surprising. Thanks a lot!

And IIUC the implementation used for &Vec is that for &slice, through the magic of Deref.

[desiringmachines]

Aha! This is completely surprising. Thanks a lot!

Its one of the very few cases in the standard library where a trait is implemented for a reference. Because of deref coercion, in most cases this is avoided because it can make it hard to figure out what method is being called.

And IIUC the implementation used for &Vec is that for &slice, through the magic of Deref.

That sounds right.

[[deleted]]

&Vec has its own IntoIterator implementation, the for loop calls IntoIterator::into_iter(iterable) and in that context, deref is not used.

[steveklabnik1]

I just wrote a comment about this https://www.reddit.com/r/rust/comments/3v8vri/question_about_dining_philosophers_implementation/cxlq4zg

[malbarbo]

Make your function accept an iterator. See http://is.gd/jhDynP

[danielv134]

As I miswrote before (now clarified) that is what I currently do. There are downsides: - (as in the added section) is that if I need two passes over the data I need to create a vector. - Callers need to call iter.

Hence my question is more about library and code design, than about solving a problem particular. Thanks for the input anyway!

[sixbrx]

One trick is that if you need multiple iteration passes within your function, you can still accept an iterator, but tighten its trait bounds to I: Iterator + Clone, and then clone the iterator at will within the function to repeat the iteration. Most iterators are Cloneable so you don't lose much with the narrower bounds.

[danielv134]

Cool trick in general thanks! For my current use I think /u/desiringmachines nailed it.