Feature #708

Updated by sawa (Tsuyoshi Sawada) about 2 years ago

  There are a number of methods in `Enumerable` that Enumerable which build an `Array` Array of results from the entire collection: `map`, `select`, `take`, collection - e.g. map, select, take etc. 

  I propose that the `Enumerator` Enumerator class have its own implementations of these methods, which return another `Enumerator`. Enumerator. Enumerators can then be chained: 

 ```ruby { ... }.select { ... }.take(...).each { |x| puts x } 

  This runs horizontally, "horizontally": that is, each element is processed left to right. No intermediate arrays are created, and it works happily with sequences of arbitrary length. 

 infinite sequences. 
  There are precendents for `SomeClass#select` SomeClass#select behaving differently to `Enumerable#select`. Enumerable#select. For example, `Hash#select` Hash#select now returns a `Hash`. Hash. So I believe it would be reasonable for `Enumerator` 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` to_a or `each each { ... }`. 

     # Normal 

     res = (1..1_000_000).map { |x| x * 2 }.take(100) 

     # Lazy 

     res = (1..1_000_000) { |x| x * 2 }.take(100).to_a 

  I have attached a simple implementation of this for `select`, `map`, `take` select, map, take and a new method `skip`. skip. There are further methods like `take_while`, `zip` take_while, zip and so on which would also need to be implemented.