[ruby-core:121076] [Ruby master Bug#21142] Lazy enumerator `.each_with_index` ignores `.take(0)` before it
Issue #21142 has been reported by aaronkison (Aaron Kison). ---------------------------------------- Bug #21142: Lazy enumerator `.each_with_index` ignores `.take(0)` before it https://bugs.ruby-lang.org/issues/21142 * Author: aaronkison (Aaron Kison) * Status: Open * ruby -v: 3.2.7 * Backport: 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- Minimum code to produce problem: ``` class Numbers; def each; 100.times { yield _1 }; end; include Enumerable; end Numbers.new.lazy.take(0).each_with_index.map { _1 }.to_a ``` Output (at ruby 3.2.7, and 3.3.0): ``` [0, 1, ..., 99] ``` Expected output (and was as at ruby 3.1.4): ``` [] ``` It works when it opposite ordering: `Numbers.new.lazy.each_with_index.take(0).map { _1 }.to_a`. I suspect it may be related to the change here https://github.com/ruby/ruby/pull/11868/files but I'm not familiar with any of that code. It seems like it replaces an allocated index with a counting index, which my hunch is it works for every value except for 0. -- https://bugs.ruby-lang.org/
Issue #21142 has been updated by mame (Yusuke Endoh). Assignee set to alanwu (Alan Wu) @alanwu What do you think? cc/ @knu ---------------------------------------- Bug #21142: Lazy enumerator `.each_with_index` ignores `.take(0)` before it https://bugs.ruby-lang.org/issues/21142#change-112250 * Author: aaronkison (Aaron Kison) * Status: Open * Assignee: alanwu (Alan Wu) * ruby -v: 3.2.7 * Backport: 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- Minimum code to produce problem: ``` class Numbers; def each; 100.times { yield _1 }; end; include Enumerable; end Numbers.new.lazy.take(0).each_with_index.map { _1 }.to_a ``` Output (at ruby 3.2.7, and 3.3.0): ``` [0, 1, ..., 99] ``` Expected output (and was as at ruby 3.1.4): ``` [] ``` It works when it opposite ordering: `Numbers.new.lazy.each_with_index.take(0).map { _1 }.to_a`. I suspect it may be related to the change here https://github.com/ruby/ruby/pull/11868/files but I'm not familiar with any of that code. It seems like it replaces an allocated index with a counting index, which my hunch is it works for every value except for 0. -- https://bugs.ruby-lang.org/
Issue #21142 has been updated by alanwu (Alan Wu). Assignee deleted (alanwu (Alan Wu)) The pull request you point was released with 3.4, but the problem started with 3.2, so it's not due to the change in the pull request. ---------------------------------------- Bug #21142: Lazy enumerator `.each_with_index` ignores `.take(0)` before it https://bugs.ruby-lang.org/issues/21142#change-112258 * Author: aaronkison (Aaron Kison) * Status: Open * ruby -v: 3.2.7 * Backport: 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- Minimum code to produce problem: ``` class Numbers; def each; 100.times { yield _1 }; end; include Enumerable; end Numbers.new.lazy.take(0).each_with_index.map { _1 }.to_a ``` Output (at ruby 3.2.7, and 3.3.0): ``` [0, 1, ..., 99] ``` Expected output (and was as at ruby 3.1.4): ``` [] ``` It works when it opposite ordering: `Numbers.new.lazy.each_with_index.take(0).map { _1 }.to_a`. I suspect it may be related to the change here https://github.com/ruby/ruby/pull/11868/files but I'm not familiar with any of that code. It seems like it replaces an allocated index with a counting index, which my hunch is it works for every value except for 0. -- https://bugs.ruby-lang.org/
Issue #21142 has been updated by Hanmac (Hans Mackowiak). You might want a different function. `Enumerable#each_with_index` does reset the Enumerator, while `Enumerator#with_index` does not. ```ruby p 3.times.lazy.take(0).each_with_index.to_a #[[0, 0], [1, 1], [2, 2]] p 3.times.lazy.take(0).with_index.to_a #[] ``` ---------------------------------------- Bug #21142: Lazy enumerator `.each_with_index` ignores `.take(0)` before it https://bugs.ruby-lang.org/issues/21142#change-112259 * Author: aaronkison (Aaron Kison) * Status: Open * ruby -v: 3.2.7 * Backport: 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- Minimum code to produce problem: ``` class Numbers; def each; 100.times { yield _1 }; end; include Enumerable; end Numbers.new.lazy.take(0).each_with_index.map { _1 }.to_a ``` Output (at ruby 3.2.7, and 3.3.0): ``` [0, 1, ..., 99] ``` Expected output (and was as at ruby 3.1.4): ``` [] ``` It works when it opposite ordering: `Numbers.new.lazy.each_with_index.take(0).map { _1 }.to_a`. I suspect it may be related to the change here https://github.com/ruby/ruby/pull/11868/files but I'm not familiar with any of that code. It seems like it replaces an allocated index with a counting index, which my hunch is it works for every value except for 0. -- https://bugs.ruby-lang.org/
Issue #21142 has been updated by Hanmac (Hans Mackowiak). @nobu your opinion on this `take(0)` thing? ---------------------------------------- Bug #21142: Lazy enumerator `.each_with_index` ignores `.take(0)` before it https://bugs.ruby-lang.org/issues/21142#change-112332 * Author: aaronkison (Aaron Kison) * Status: Open * ruby -v: 3.2.7 * Backport: 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- Minimum code to produce problem: ``` class Numbers; def each; 100.times { yield _1 }; end; include Enumerable; end Numbers.new.lazy.take(0).each_with_index.map { _1 }.to_a ``` Output (at ruby 3.2.7, and 3.3.0): ``` [0, 1, ..., 99] ``` Expected output (and was as at ruby 3.1.4): ``` [] ``` It works when it opposite ordering: `Numbers.new.lazy.each_with_index.take(0).map { _1 }.to_a`. I suspect it may be related to the change here https://github.com/ruby/ruby/pull/11868/files but I'm not familiar with any of that code. It seems like it replaces an allocated index with a counting index, which my hunch is it works for every value except for 0. -- https://bugs.ruby-lang.org/
Issue #21142 has been updated by rwstauner (Randy Stauner). @nobu The above commit changed the behavior such that `lazy#each_with_index { ... }` is no longer running the block and just returning the enumerator. 4.0: ``` $ ruby -ve 'arr = []; p 3.times.lazy.each { |*a| arr << a }; p arr;' ruby 4.0.7 (2026-09-15 revision 229531a6cf) +PRISM [x86_64-linux] 3 [[0], [1], [2]] $ ruby -ve 'arr = []; p 3.times.lazy.each_with_index { |*a| arr << a }; p arr;' ruby 4.0.7 (2026-09-15 revision 229531a6cf) +PRISM [x86_64-linux] 3 [[0, 0], [1, 1], [2, 2]] ``` 4.1.0dev: ``` $ ruby -ve 'arr = []; p 3.times.lazy.each { |*a| arr << a }; p arr;' ruby 4.1.0dev (2026-10-28T17:51:51Z master 5127bd0dbc) +PRISM [x86_64-linux] 3 [[0], [1], [2]] $ ruby -ve 'arr = []; p 3.times.lazy.each_with_index { |*a| arr << a }; p arr;' ruby 4.1.0dev (2026-10-28T17:51:51Z master 5127bd0dbc) +PRISM [x86_64-linux] #<Enumerator::Lazy: #<Enumerator::Lazy: #<Enumerator: 3:times>>:each_with_index(0)> [] ``` This seems inconsistent and likely unintentional. We must be missing tests for this case. ---------------------------------------- Bug #21142: Lazy enumerator `.each_with_index` ignores `.take(0)` before it https://bugs.ruby-lang.org/issues/21142#change-119686 * Author: aaronkison (Aaron Kison) * Status: Closed * ruby -v: 3.2.7 * Backport: 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- Minimum code to produce problem: ``` class Numbers; def each; 100.times { yield _1 }; end; include Enumerable; end Numbers.new.lazy.take(0).each_with_index.map { _1 }.to_a ``` Output (at ruby 3.2.7, and 3.3.0): ``` [0, 1, ..., 99] ``` Expected output (and was as at ruby 3.1.4): ``` [] ``` It works when it opposite ordering: `Numbers.new.lazy.each_with_index.take(0).map { _1 }.to_a`. I suspect it may be related to the change here https://github.com/ruby/ruby/pull/11868/files but I'm not familiar with any of that code. It seems like it replaces an allocated index with a counting index, which my hunch is it works for every value except for 0. -- https://bugs.ruby-lang.org/
Issue #21142 has been updated by rwstauner (Randy Stauner). I opened a new ticket for this: https://bugs.ruby-lang.org/issues/22496 ---------------------------------------- Bug #21142: Lazy enumerator `.each_with_index` ignores `.take(0)` before it https://bugs.ruby-lang.org/issues/21142#change-119725 * Author: aaronkison (Aaron Kison) * Status: Closed * ruby -v: 3.2.7 * Backport: 3.1: UNKNOWN, 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN ---------------------------------------- Minimum code to produce problem: ``` class Numbers; def each; 100.times { yield _1 }; end; include Enumerable; end Numbers.new.lazy.take(0).each_with_index.map { _1 }.to_a ``` Output (at ruby 3.2.7, and 3.3.0): ``` [0, 1, ..., 99] ``` Expected output (and was as at ruby 3.1.4): ``` [] ``` It works when it opposite ordering: `Numbers.new.lazy.each_with_index.take(0).map { _1 }.to_a`. I suspect it may be related to the change here https://github.com/ruby/ruby/pull/11868/files but I'm not familiar with any of that code. It seems like it replaces an allocated index with a counting index, which my hunch is it works for every value except for 0. -- https://bugs.ruby-lang.org/
Issue #21142 has been updated by k0kubun (Takashi Kokubun). Backport changed from 3.2: REQUIRED, 3.3: REQUIRED, 3.4: REQUIRED, 4.0: REQUIRED to 3.2: REQUIRED, 3.3: REQUIRED, 3.4: REQUIRED, 4.0: DONE ruby_4_0 commit:e199fec7b983cb129ed3c79fbac065b2a2222e30 merged revision(s) commit:64f4b9ab83c4da368e6314c7ab8b74247894cada, commit:90dbced7956a677ed7efdec15d2de75ecc81eea2. ---------------------------------------- Bug #21142: Lazy enumerator `.each_with_index` ignores `.take(0)` before it https://bugs.ruby-lang.org/issues/21142#change-119992 * Author: aaronkison (Aaron Kison) * Status: Closed * ruby -v: 3.2.7 * Backport: 3.2: REQUIRED, 3.3: REQUIRED, 3.4: REQUIRED, 4.0: DONE ---------------------------------------- Minimum code to produce problem: ``` class Numbers; def each; 100.times { yield _1 }; end; include Enumerable; end Numbers.new.lazy.take(0).each_with_index.map { _1 }.to_a ``` Output (at ruby 3.2.7, and 3.3.0): ``` [0, 1, ..., 99] ``` Expected output (and was as at ruby 3.1.4): ``` [] ``` It works when it opposite ordering: `Numbers.new.lazy.each_with_index.take(0).map { _1 }.to_a`. I suspect it may be related to the change here https://github.com/ruby/ruby/pull/11868/files but I'm not familiar with any of that code. It seems like it replaces an allocated index with a counting index, which my hunch is it works for every value except for 0. -- https://bugs.ruby-lang.org/
Issue #21142 has been updated by nagachika (Tomoyuki Chikanaga). Backport changed from 3.2: REQUIRED, 3.3: REQUIRED, 3.4: REQUIRED, 4.0: DONE to 3.2: REQUIRED, 3.3: REQUIRED, 3.4: DONE, 4.0: DONE ruby_3_4 commit:f80b88d468a479ef6bd609aed9a924270db23081, commit:f4c1e92394d4ec449e8453e02a3fcf05f4972335, commit:e156f925c70e070682b842e7ea919a7491507531 merged revision(s) commit:90dbced7956a677ed7efdec15d2de75ecc81eea2. ---------------------------------------- Bug #21142: Lazy enumerator `.each_with_index` ignores `.take(0)` before it https://bugs.ruby-lang.org/issues/21142#change-120031 * Author: aaronkison (Aaron Kison) * Status: Closed * ruby -v: 3.2.7 * Backport: 3.2: REQUIRED, 3.3: REQUIRED, 3.4: DONE, 4.0: DONE ---------------------------------------- Minimum code to produce problem: ``` class Numbers; def each; 100.times { yield _1 }; end; include Enumerable; end Numbers.new.lazy.take(0).each_with_index.map { _1 }.to_a ``` Output (at ruby 3.2.7, and 3.3.0): ``` [0, 1, ..., 99] ``` Expected output (and was as at ruby 3.1.4): ``` [] ``` It works when it opposite ordering: `Numbers.new.lazy.each_with_index.take(0).map { _1 }.to_a`. I suspect it may be related to the change here https://github.com/ruby/ruby/pull/11868/files but I'm not familiar with any of that code. It seems like it replaces an allocated index with a counting index, which my hunch is it works for every value except for 0. -- https://bugs.ruby-lang.org/
participants (7)
-
aaronkison (Aaron Kison) -
alanwu (Alan Wu) -
Hanmac (Hans Mackowiak) -
k0kubun (Takashi Kokubun) -
mame (Yusuke Endoh) -
nagachika (Tomoyuki Chikanaga) -
rwstauner (Randy Stauner)