From: "Eregon (Benoit Daloze) via ruby-core" <ruby-core@...>
Date: 2025-12-14T10:08:28+00:00
Subject: [ruby-core:124194] [Ruby Bug#21780] Change the default size of Enumerator.produce back to infinity

Issue #21780 has been updated by Eregon (Benoit Daloze).


I disagree on this one, as written on https://bugs.ruby-lang.org/issues/21701#note-3

I think `Enumerator#size` should only be non-nil when it is known to be the exact size.
In this case it is not know if it is infinite, so returning `Float::INFINITY` for the size is "wrong".

One use case I know of for `Enumerator#size` is to do a progress bar while iterating the Enumerator.
That can only work reliably if the non-nil size is the exact size.
Returning `Float::INFINITY` when it is not would be misleading, though of course returning `nil` won't give the actual size, which might simply be not known.

BTW, your examples use `Enumerator.new` but the text seems to be about `Enumerator.produce`.
I think either way it applies to both the same way though.

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

* 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.new(1, size: Float::INFINITY, &:succ)

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

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

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



-- 
https://bugs.ruby-lang.org/
______________________________________________
 ruby-core mailing list -- ruby-core@ml.ruby-lang.org
 To unsubscribe send an email to ruby-core-leave@ml.ruby-lang.org
 ruby-core info -- https://ml.ruby-lang.org/mailman3/lists/ruby-core.ml.ruby-lang.org/