From: "marcandre (Marc-Andre Lafortune)" Date: 2013-01-22T04:44:15+09:00 Subject: [ruby-core:51551] [ruby-trunk - Bug #7696] Lazy enumerators with state can't be rewound Issue #7696 has been updated by marcandre (Marc-Andre Lafortune). shugo (Shugo Maeda) wrote: > So, the following behavior is intended, right? > > $ ruby1.9.3 -I ~/src/backports/lib -r backports -r backports/2.0.0/enumerable -e "a = (1..3).lazy.zip(('a'..'z').each); p a.to_a; p a.to_a" > [[1, "a"], [2, "b"], [3, "c"]] > [[1, "d"], [2, "e"], [3, "f"]] That's a very good question. It probably would be best to call `to_enum` instead of `each`. Calling `next|rewind` on an enumerator should really only affect other calls to `next`. With `to_enum`, we'll get the same result every time. Similarly, we expect `(1..3).zip(('a'..'z').each.tap(&:next))` to return `[[1, 'a'], ...`, and not `[[1, 'b'], ...` even though `next` was called on the given enumerator. > If the above behavior is intended, the patch looks acceptable. Thanks for reviewing it. I'll commit it, changing the call to `each` to `to_enum` (unless there are objections). I'll use the same technique to fix the other 3 lazy enumerators with state. > > For the public api, should there be a public Yielder#memo and a guarantee that there is exactly one yielder object per iteration? or instead an extra state yielded when required? > > It might be too late to introduce a new API for 2.0.0, so how about to move it to next minor? I understand. On the other hand, the API for Lazy.new was never decided upon and really should be finalized before 2.0.0! If we opt for the Yielder#memo way (and agree on the name), maybe we can convince mame to accept such a trivial change. In that case, the biggest "change" is the explicit guarantee of a different yielder per iteration. It's already the case (also for JRuby and rubinius), but AFAIK it's never been official. With the modified yielding way, it would be nice to include it in Lazy.new's api in this version, especially since it is still being finalized. At the very least, a note in the documentation about handling state would be needed for 2.0.0. ---------------------------------------- Bug #7696: Lazy enumerators with state can't be rewound https://bugs.ruby-lang.org/issues/7696#change-35516 Author: marcandre (Marc-Andre Lafortune) Status: Open Priority: High Assignee: Category: core Target version: 2.0.0 ruby -v: r38800 The 4 lazy enumerators requiring internal state, i.e. {take|drop}{_while}, don't work as expected after a couple `next` and a call to `rewind`. For example: e=(1..42).lazy.take(2) e.next # => 1 e.next # => 2 e.rewind e.next # => 1 e.next # => StopIteration: iteration reached an end, expected 2 This is related to #7691; the current API does not give an easy way to handle state. Either there's a dedicated callback to rewind, or data must be attached to the yielder. -- http://bugs.ruby-lang.org/