From: "matz (Yukihiro Matsumoto)" <matz@...>
Date: 2012-04-02T01:38:23+09:00
Subject: [ruby-core:44042] [ruby-trunk - Feature #6166] Enumerator::Lazy#pinch


Issue #6166 has been updated by matz (Yukihiro Matsumoto).


What happens when you call #pinch (or whatever) twice on same lazy sequence?

e.g.

  lz = (1..100).lazy
  lz.pinch(0,2)
  lz.pinch(0,2)

If second call to pinch gives [1,2], lazy sequence needs to keep all generated values inside (that makes lazy sequence very inefficient both in time and space-wise).
If it gives [3,4], I don't think it's the expected behavior for most of us.

#pinch implies offset which is not well fit with the concept of lazy sequence which is not always indexable.


Matz.

----------------------------------------
Feature #6166: Enumerator::Lazy#pinch
https://bugs.ruby-lang.org/issues/6166#change-25571

Author: trans (Thomas Sawyer)
Status: Rejected
Priority: Normal
Assignee: matz (Yukihiro Matsumoto)
Category: core
Target version: 


In previous issue #6158 it has been determined that Enumerator::Lazy#take should be lazy. But an eager form of #take would still be useful.

To this end I'll suggest `Enumerator::Lazy#pinch`. Examples of usage:

    e.lazy.pinch 1

    e.lazy.pinch 1..2

    e.lazy.pinch 1,2

It is basically equivalent to calling `to_a[index]`, but has the advantage of being a single invocation instead of two, and reads better.

The #pinch method would be strictly a Lazy method and have no counterpart in Enumerable.



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