[ruby-core:92994] [Ruby trunk Feature#15901] Enumerator::Lazy#eager
From:
knu@...
Date:
2019-06-06 04:35:24 UTC
List:
ruby-core #92994
Issue #15901 has been updated by knu (Akinori MUSHA).
Suppose I want to pass the `enum` to another method that takes an Enumerable object where the passed object is expected to act eagerly. One of the most significant use cases is when the callee uses `take_while` on a given object expecting to receive the result as an array, where a normal Enumerable object that generates a list lazily is ideal.
My understanding is that Lazy is kind of a low-level tool for implementing efficient pipelines and not normally part of a method API, so being able to convert a lazy Enumerator to an eager Enumerator helps users write efficient code while not requiring library developers to support Lazy in each method that takes an Enumerable.
----------------------------------------
Feature #15901: Enumerator::Lazy#eager
https://bugs.ruby-lang.org/issues/15901#change-78372
* Author: knu (Akinori MUSHA)
* Status: Open
* Priority: Normal
* Assignee:
* Target version:
----------------------------------------
There are cases where you want to create and pass a normal Enumerable object to a consumer where the methods like map and select are expected to return an array, but the calculation would be so space costly without using Enumerator::Lazy because of intermediate arrays. In such cases, you would want to chain `lazy` and calculation methods like `flat_map` and `select`, then convert the lazy enumerator back to a normal Enumerator.
However, there is no direct method that converts a lazy Enumerator to an eager one, because the` to_enum` method returns a lazy Enumerator when the receiver is a lazy Enumerator. So, I propose this `eager` method as the missing piece for the said use case.
Here's the rdoc from the attached patch.
```C
/*
* call-seq:
* lzy.eager -> enum
*
* Returns a non-lazy Enumerator converted from the lazy enumerator.
*
* This is useful where a normal Enumerable object needs to be
* generated while lazy operation is still desired to avoid creating
* intermediate arrays.
*
* enum = huge_collection.lazy.flat_map(&:children).reject(&:disabled?).eager
* enum.map {|x| ...} # an array is returned
*/
```
---Files--------------------------------
0001-Implement-Enumerator-Lazy-eager.patch (2.32 KB)
--
https://bugs.ruby-lang.org/
Unsubscribe: <mailto:[email protected]?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>