Issue #708 has been updated by Yusuke Endoh.

Priority changed from Low to Normal

Hello,

I think no one doubt if this feature is useful and actually needed.
In fact, there are some proposals for the same (or similar) motivation.

  - #4653 (focuses only map ?)
  - #4890 (a new class Enumerable::Lazy)
  - #5663 (focuses only select+map ?)

Especially, #5663 is recently discussed.  So it is too early to close
this ticket.


Once, I also created the similar proof-of-concept library [1].
It provides some methods like Enumerable#mapper, #selector, etc., which
are Enumerator-version of corresponding Enumerable methods.
Matz said in [2] that it can be accepted except the name convention
(*er).

[1] http://mamememo.blogspot.com/2009/11/enumerablerrb-enumerable-lazy-version.html
[2] http://d.hatena.ne.jp/ku-ma-me/20091111/p2 (sorry, in Japanese)


So it might be good to suggest another name convention.  In #4653, some
convention is proposed.

  - mapper
  - mapping
  - mapL
  - map_lz
  - lazy_map
  - enum_map
  - map_enum

Matz himself suggested enum_* (enum_map, enum_select, ...), though I
don't like it because it is too long.  I don't know if matz still like
it.

-- 
Yusuke Endoh <mame / tsg.ne.jp>
----------------------------------------
Feature #708: Lazy Enumerator#select, Enumerator#map etc.
https://bugs.ruby-lang.org/issues/708

Author: Brian Candler
Status: Assigned
Priority: Normal
Assignee: Yukihiro Matsumoto
Category: core
Target version: 2.0.0


=begin
 There are a number of methods in Enumerable which build an Array of results from the entire collection - e.g. map, select, take etc.
 
 I propose that the Enumerator class have its own implementations of these methods, which return another Enumerator. Enumerators can then be chained:
 
   seq.to_enum.map { ... }.select { ... }.take(...).each { |x| puts x }
 
 This runs "horizontally": that is, each element is processed left to right. No intermediate arrays are created, and it works happily with infinite sequences.
 
 There are precendents for SomeClass#select behaving differently to Enumerable#select. For example, Hash#select now returns a Hash. So I believe it would be reasonable for Enumerator to return another Enumerator.
 
 You can then choose between array-building or lazy evaluation, depending on whether there is an Enumerator in the chain. Of course, the last Enumerator has to be turned into something useful, e.g. by calling to_a or each { ... }.
 
    # Normal
    res = (1..1_000_000).map { |x| x * 2 }.take(100)
    # Lazy
    res = (1..1_000_000).to_enum.map { |x| x * 2 }.take(100).to_a
 
 I have attached a simple implementation of this for select, map, take and a new method skip. There are further methods like take_while, zip and so on which would also need to be implemented.
=end



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