Imported From: https://issues.scala-lang.org/browse/SI-9624?orig=1
Reporter: @oxbowlakes
Affected Versions: 2.11.7

@szeiger said:
PR: scala/scala#4939

@Blaisorblade said:
Regarding the Traversable/Iterator difference (in the last point of the report): It is not addressed in the PR. But the case shown appears pretty understandable — I guess when the body runs, the iterator was consumed and is thus empty, while the Traversable doesn't get consumed and stays full. Annoying, but if you don't like that semantics in this case, don't use iterators I guess.
Is there a more complicated scenario where the behavior is harder to explain? Is the documentation on this behavior incomplete?

@szeiger said:
Right, I think that part simply works as expected. The difference is not due to isEmpty consuming an element. When you get to the first println, the only element of the Iterator has already been consumed (it's passed to your lambda after all), so the Iterator is empty at that point.

Similarly, the first part of this ticket (in the gist) also does the "right" thing but maybe that's because I didn't understand the reason for using a Traversable instead of a TraversableOnce there in the first place. If you implement a Traversable even though your source can only be traversed once and you do not cache the data, it will go wrong at some point. I would implement an Iterator in these cases but that's already the first recommendation in the scaladoc for TraversableOnce:

 *  Directly subclassing `TraversableOnce` is not recommended - instead,
 *  consider declaring an `Iterator` with a `next` and `hasNext` method,
 *  creating an `Iterator` with one of the methods on the `Iterator` object,
 *  or declaring a subclass of `Traversable`.

On second thought, maybe this comment should be changed to warn that the alternative of subclassing Traversable only applies if you really have a source that can be traversed repeatedly (even if all you need is the TraversableOnce part of it).