From: "trans (Thomas Sawyer)" <transfire@...>
Date: 2012-04-02T18:23:22+09:00
Subject: [ruby-core:44063] [ruby-trunk - Feature #6166] Enumerator::Lazy#pinch


Issue #6166 has been updated by trans (Thomas Sawyer).


I don't understand what you mean by "So to make #pinch work as if "not acting in place", sequence needs to keep the values inside, everytime it generates." Pinch is no different than #to_a except that it does not need to "resolve" all elements of the enumerable, only the ones up to requested sentinel. 

In other words, you reject this b/c you say it "hinders the best benefit from "lazy" sequence." But the result is that end user must use #to_a instead (e.g. `enum.to_a[1..2]`), which makes lazy utterly pointless. Moreover, if pinch causes this issue, why doesn't `drop(b).first(e)` cause the same issue, since "pinch" is effectively just a convenience for the same?

I wonder if we are not thinking about the same idea. Maybe some code would clear things up. "Pinch", which as Marc-Andre points out is effectively #slice, can be implemented basically as:

    def slice(b, e=nil)
      if e
        drop(b).first(e)
      else
        case b
        when Range
          if b.exclude_end?
            drop(b.begin).first(b.end-1)
          else
            drop(b.begin).first(b.end)
          end
        else
          first(b).last
        end
      end
    end

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

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/