[ruby-core:118974] [Ruby master Feature#20664] Add `before` and `until` options to Enumerator.produce

["zverok (Victor Shepelev) via ruby-core" <ruby-core@ml.ruby-lang.org>]

Issue #20664 has been updated by zverok (Victor Shepelev).


About does/doesn’t include the last element, there is a related inconclusive discussion: #18136

Basically, I believe that both `take_while`/`take_until` might have pairs of use cases:
```ruby
# the last element not necessary
sequence.take_until(&:bad?)
# the last element is necessary: think `.` in a sentence
sequence.take_until(&:terminator?)

# the last element is not necessary
sequence.take_while(&:suitable?)
# the last element is necessary: think the last page on pagination
# (which doesn’t match the condition “have more pages” but is a meaningful element itself)
sequence.take_while(&:last_matching_element?)
```

(We have a `#take_while_after` in our `core_ext.rb`, and use it regularly.)

The `Enumerable#slice_after` and `#slice_before`, for example, recognize that it might be either, but not `take_while`.

----------------------------------------
Feature #20664: Add `before` and `until` options to Enumerator.produce
https://bugs.ruby-lang.org/issues/20664#change-109547

* Author: knu (Akinori MUSHA)
* Status: Open
----------------------------------------
Enumerator.produce provides a nice way to generate an infinite sequence but is a bit awkward to define how to end a sequence.  It lacks a simple and easy way to produce typical finite sequences in an intuitive syntax.

This proposal attempts to solve the problem by adding these two options to the method:

- `before`: when provided, it is used as a predicate to determine if an iteration should end before a generated value gets yielded.
- `until`: when provided, it is used as a predicate to determine if an iteration should end until after a generated value gets yielded.

Any value that responds to `to_proc` and returns a `Proc` object is accepted in these options.

A typical use case for the `before` option is traversing a tree structure to iterate over the ancestors or following/preceding siblings of a node.

The `until` option can be used when there is a clear definition of the "last" value to yield.

```ruby
enum = Enumerator.produce(File, before: :nil?, &:superclass)
enum.to_a #=> [File, IO, Object, BasicObject]

enum = Enumerator.produce(3, until: :zero?, &:pred)
enum_to_a #=> [3, 2, 1, 0]
```

---Files--------------------------------
0001-Add-before-and-until-options-to-Enumerator.produce.patch (10.7 KB)


-- 
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/