[ruby-core:124276] [Ruby Bug#21780] Change the default size of Enumerator.produce back to infinity

17 Dec 2025

      Issue #21780 has been updated by zverok (Victor Shepelev).
...
Why revert to a buggy state?
I don't believe "buggy" is a fair description. I believe that Ruby users are intelligent enough to understand the "theoretically infinite, but might break at some point if done intently." And I believe that's a more useful description of the size of this enumerator than "nothing can be said about it." 

I don't believe that there would be a lot of people who would insist that it is a bug, if it is clearly documented.
...
If we do so, I believe Enumerator#size should be deprecated and renamed to something like Enumerator#size_hint or Enumerator#size_estimate.
But it always behaved this way for "hand-made" enumerators? As I demonstrated above:

```ruby
e = Enumerator.new(5) { |y| 2.times { y << it } }
e.size #=> 5
e.to_a.size #=> 2 -- ugh, 5 was just a hint after all
```
...
At the very least, the documentation should explicitly state "Do not trust the return value of this method."
This is fair, I'll work on adjusting the documentation wording to explain possible quirks.

----------------------------------------
Bug #21780: Change the default size of Enumerator.produce back to infinity
https://bugs.ruby-lang.org/issues/21780#change-115772

* Author: zverok (Victor Shepelev)
* Status: Open
* Backport: 3.2: UNKNOWN, 3.3: UNKNOWN, 3.4: UNKNOWN
----------------------------------------
In #21701 a new argument `size:` was introduced, and its default value is `nil` (unknown).

While I support the new argument, I'd argue that the default should be `Float::INFINITY`. 

**Reasoning:** By _design_, `Enumerator.produce` is infinite (there is no internal condition to stop iteration), and the simplest, most straightforward usages of the method would produce _definitely infinite_ iterators, which the user than can limit with `take`, or `take_while` or similar methods.

To produce the enumerator that will stop by itself requires explicit raising of `StopIteration`, which I expect to be a (slightly) advanced technique, and those who use it might be more inclined to provide additional arguments to clarify the semantics.

While `Enumerator#size` is hardly frequently used now (other than in `#to_set`, which started the discussion), it might be in the future, and I believe it is better to stick with more user-friendly defaults.

Now:
```ruby
# very trivial enumerator, but if you want it to have "proper" size, you need 
# to not forget to use an elaborate argument and type additional 21 characters
Enumerator.produce(1, size: Float::INFINITY, &:succ)

# already non-trivial enumerator, which is hardly frequently used, but the 
# current defaults correspond to its semantics:
Enumerator.produce(Date.today) {
  raise StopIteration if it.tuesday? && it.day.odd?
  it + 1
}
```

With my proposal:
```ruby
# trivial, most widespread case:
Enumerator.produce(1, &:succ).size #=> Infinity

# non-trivial case, with the enumerator designer clarifying their
# intention that "we are sure it stops somewhere":
Enumerator.produce(Date.today, size: nil) {
  raise StopIteration if it.tuesday? && it.day.odd?
  it + 1
}
```

-- 
https://bugs.ruby-lang.org/