[ruby-dev:47045] [ruby-trunk - Feature #7877] E::Lazy#with_index needed

[ruby-dev:47045] [ruby-trunk - Feature #7877] E::Lazy#with_index needed

[nobu (Nobuyoshi Nakada)]

Issue #7877 has been updated by nobu (Nobuyoshi Nakada).

File 0001-enumerator.c-Enumerator-Lazy-with_index.patch added
Description updated


----------------------------------------
Feature #7877: E::Lazy#with_index needed
https://bugs.ruby-lang.org/issues/7877#change-36599

Author: shyouhei (Shyouhei Urabe)
Status: Assigned
Priority: Normal
Assignee: yhara (Yutaka HARA)
Category: core
Target version: next minor


=begin
なんかLazyの有効な例を出そうと思ってそうだライプニッツ級数だ!ということで

  def leibniz(n)
    (0..Float::INFINITY).lazy.with_index {|i, j| (-1 ** j) / (2*i+1).to_f }.take(n).reduce(:+)
  end

とかやっても動かない(いや動くけど。止まらん)。残念です。これあったほうが便利じゃないですかね。どうでしょう。

あ、もちろん2.0.0以降でOKです。
=end


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

[ruby-dev:47046] [ruby-trunk - Feature #7877] E::Lazy#with_index needed

[marcandre (Marc-Andre Lafortune)]

Issue #7877 has been updated by marcandre (Marc-Andre Lafortune).


See #7696 on how to handle state...
----------------------------------------
Feature #7877: E::Lazy#with_index needed
https://bugs.ruby-lang.org/issues/7877#change-36600

Author: shyouhei (Shyouhei Urabe)
Status: Assigned
Priority: Normal
Assignee: yhara (Yutaka HARA)
Category: core
Target version: next minor


=begin
なんかLazyの有効な例を出そうと思ってそうだライプニッツ級数だ!ということで

  def leibniz(n)
    (0..Float::INFINITY).lazy.with_index {|i, j| (-1 ** j) / (2*i+1).to_f }.take(n).reduce(:+)
  end

とかやっても動かない(いや動くけど。止まらん)。残念です。これあったほうが便利じゃないですかね。どうでしょう。

あ、もちろん2.0.0以降でOKです。
=end


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

[ruby-dev:47047] [ruby-trunk - Feature #7877] E::Lazy#with_index needed

[shyouhei (Shyouhei Urabe)]

Issue #7877 has been updated by shyouhei (Shyouhei Urabe).

Description updated

OK, so @marcandre is interested in.  I re-wrote the description in English.
----------------------------------------
Feature #7877: E::Lazy#with_index needed
https://bugs.ruby-lang.org/issues/7877#change-36605

Author: shyouhei (Shyouhei Urabe)
Status: Assigned
Priority: Normal
Assignee: yhara (Yutaka HARA)
Category: core
Target version: next minor


=begin
So I wanted some real benefit of being lazy.  I wrote a Leibniz formula:

  def leibniz(n)
    (0..Float::INFINITY).lazy.with_index {|i, j| (-1 ** j) / (2*i+1).to_f }.take(n).reduce(:+)
  end

But it doesn't work (well, it does, indeed. It just doesn't stop working).  I got frustrated.
How about it?  Don't you feel it nifty?

Of course I can wait for the release next to 2.0.0.
=end


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

[ruby-dev:47050] [ruby-trunk - Feature #7877] E::Lazy#with_index needed

[marcandre (Marc-Andre Lafortune)]

Issue #7877 has been updated by marcandre (Marc-Andre Lafortune).


Note that (thanks to #7715), you can use `with_index` without a block and follow it with `map`:

    def leibniz(n)
      (0..Float::INFINITY).lazy.with_index.map {|i, j| (-1 ** j) / (2*i+1).to_f }.take(n).reduce(:+)
    end

I'm neutral about this feature request. The problem I see is that it's too late for 2.0.0 and it would introduce potential incompatibility in next minor.
----------------------------------------
Feature #7877: E::Lazy#with_index needed
https://bugs.ruby-lang.org/issues/7877#change-36623

Author: shyouhei (Shyouhei Urabe)
Status: Assigned
Priority: Normal
Assignee: yhara (Yutaka HARA)
Category: core
Target version: next minor


=begin
So I wanted some real benefit of being lazy.  I wrote a Leibniz formula:

  def leibniz(n)
    (0..Float::INFINITY).lazy.with_index {|i, j| (-1 ** j) / (2*i+1).to_f }.take(n).reduce(:+)
  end

But it doesn't work (well, it does, indeed. It just doesn't stop working).  I got frustrated.
How about it?  Don't you feel it nifty?

Of course I can wait for the release next to 2.0.0.
=end


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

[ruby-dev:47056] [ruby-trunk - Feature #7877] E::Lazy#with_index needed

[shyouhei (Shyouhei Urabe)]

Issue #7877 has been updated by shyouhei (Shyouhei Urabe).


@marcandre oh, thank you!  You saved my day.

Still I want this though.


----------------------------------------
Feature #7877: E::Lazy#with_index needed
https://bugs.ruby-lang.org/issues/7877#change-36647

Author: shyouhei (Shyouhei Urabe)
Status: Assigned
Priority: Normal
Assignee: yhara (Yutaka HARA)
Category: core
Target version: next minor


=begin
So I wanted some real benefit of being lazy.  I wrote a Leibniz formula:

  def leibniz(n)
    (0..Float::INFINITY).lazy.with_index {|i, j| (-1 ** j) / (2*i+1).to_f }.take(n).reduce(:+)
  end

But it doesn't work (well, it does, indeed. It just doesn't stop working).  I got frustrated.
How about it?  Don't you feel it nifty?

Of course I can wait for the release next to 2.0.0.
=end


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

[ruby-dev:47225] [ruby-trunk - Feature #7877] E::Lazy#with_index needed

[zzak (Zachary Scott)]

Issue #7877 has been updated by zzak (Zachary Scott).


Propose to move this to next major?
----------------------------------------
Feature #7877: E::Lazy#with_index needed
https://bugs.ruby-lang.org/issues/7877#change-38245

Author: shyouhei (Shyouhei Urabe)
Status: Assigned
Priority: Normal
Assignee: yhara (Yutaka HARA)
Category: core
Target version: next minor


=begin
So I wanted some real benefit of being lazy.  I wrote a Leibniz formula:

  def leibniz(n)
    (0..Float::INFINITY).lazy.with_index {|i, j| (-1 ** j) / (2*i+1).to_f }.take(n).reduce(:+)
  end

But it doesn't work (well, it does, indeed. It just doesn't stop working).  I got frustrated.
How about it?  Don't you feel it nifty?

Of course I can wait for the release next to 2.0.0.
=end


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

[ruby-dev:47226] [ruby-trunk - Feature #7877] E::Lazy#with_index needed

[duerst (Martin Dürst)]

Issue #7877 has been updated by duerst (Martin Dürst).


zzak (Zachary Scott) wrote:
> Propose to move this to next major?

Do you mean because of "potential incompatibility" (https://bugs.ruby-lang.org/issues/7877#note-4)? What exactly would this incompatibility be? To me, it seems that lazy.with_index would just work, so we should just fix it. Next major seems way too long to wait.
----------------------------------------
Feature #7877: E::Lazy#with_index needed
https://bugs.ruby-lang.org/issues/7877#change-38252

Author: shyouhei (Shyouhei Urabe)
Status: Assigned
Priority: Normal
Assignee: yhara (Yutaka HARA)
Category: core
Target version: next minor


=begin
So I wanted some real benefit of being lazy.  I wrote a Leibniz formula:

  def leibniz(n)
    (0..Float::INFINITY).lazy.with_index {|i, j| (-1 ** j) / (2*i+1).to_f }.take(n).reduce(:+)
  end

But it doesn't work (well, it does, indeed. It just doesn't stop working).  I got frustrated.
How about it?  Don't you feel it nifty?

Of course I can wait for the release next to 2.0.0.
=end


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

[ruby-dev:47390] [ruby-trunk - Feature #7877] E::Lazy#with_index needed

[zzak (Zachary Scott)]

Issue #7877 has been updated by zzak (Zachary Scott).


@duerst You're probably right, since this feature was introduced in 2.0.0

If yhara-san wants to implement #with_index with a block then I see no problem with introducing this in 2.1.0
----------------------------------------
Feature #7877: E::Lazy#with_index needed
https://bugs.ruby-lang.org/issues/7877#change-39621

Author: shyouhei (Shyouhei Urabe)
Status: Assigned
Priority: Normal
Assignee: yhara (Yutaka HARA)
Category: core
Target version: next minor


=begin
So I wanted some real benefit of being lazy.  I wrote a Leibniz formula:

  def leibniz(n)
    (0..Float::INFINITY).lazy.with_index {|i, j| (-1 ** j) / (2*i+1).to_f }.take(n).reduce(:+)
  end

But it doesn't work (well, it does, indeed. It just doesn't stop working).  I got frustrated.
How about it?  Don't you feel it nifty?

Of course I can wait for the release next to 2.0.0.
=end


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

[ruby-dev:47392] [ruby-trunk - Bug #7877] E::Lazy#with_index should be lazy

[zzak (Zachary Scott)]

Issue #7877 has been updated by zzak (Zachary Scott).

Tracker changed from Feature to Bug
Subject changed from E::Lazy#with_index needed to E::Lazy#with_index should be lazy
Target version changed from next minor to current: 2.1.0
ruby -v set to 2.1.0-dev
Backport set to 2.0.0: UNKNOWN


----------------------------------------
Bug #7877: E::Lazy#with_index should be lazy
https://bugs.ruby-lang.org/issues/7877#change-39637

Author: shyouhei (Shyouhei Urabe)
Status: Assigned
Priority: Normal
Assignee: yhara (Yutaka HARA)
Category: core
Target version: current: 2.1.0
ruby -v: 2.1.0-dev
Backport: 2.0.0: UNKNOWN


=begin
So I wanted some real benefit of being lazy.  I wrote a Leibniz formula:

  def leibniz(n)
    (0..Float::INFINITY).lazy.with_index {|i, j| (-1 ** j) / (2*i+1).to_f }.take(n).reduce(:+)
  end

But it doesn't work (well, it does, indeed. It just doesn't stop working).  I got frustrated.
How about it?  Don't you feel it nifty?

Of course I can wait for the release next to 2.0.0.
=end


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

[ruby-dev:47932] [ruby-trunk - Bug #7877] E::Lazy#with_index should be lazy

[shibata.hiroshi]

Issue #7877 has been updated by Hiroshi SHIBATA.

Target version changed from 2.1.0 to current: 2.2.0

----------------------------------------
Bug #7877: E::Lazy#with_index should be lazy
https://bugs.ruby-lang.org/issues/7877#change-44758

* Author: Shyouhei Urabe
* Status: Assigned
* Priority: Normal
* Assignee: Yutaka HARA
* Category: core
* Target version: current: 2.2.0
* ruby -v: 2.1.0-dev
* Backport: 2.0.0: UNKNOWN
----------------------------------------
=begin
So I wanted some real benefit of being lazy.  I wrote a Leibniz formula:

  def leibniz(n)
    (0..Float::INFINITY).lazy.with_index {|i, j| (-1 ** j) / (2*i+1).to_f }.take(n).reduce(:+)
  end

But it doesn't work (well, it does, indeed. It just doesn't stop working).  I got frustrated.
How about it?  Don't you feel it nifty?

Of course I can wait for the release next to 2.0.0.
=end

---Files--------------------------------
0001-enumerator.c-Enumerator-Lazy-with_index.patch (3.33 KB)


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

[ruby-dev:48412] [ruby-trunk - Bug #7877] E::Lazy#with_index should be lazy

[nakilon]

Issue #7877 has been updated by Victor Maslov.


Is it related? http://stackoverflow.com/q/24782712/322020

----------------------------------------
Bug #7877: E::Lazy#with_index should be lazy
https://bugs.ruby-lang.org/issues/7877#change-47808

* Author: Shyouhei Urabe
* Status: Assigned
* Priority: Normal
* Assignee: Yutaka HARA
* Category: core
* Target version: current: 2.2.0
* ruby -v: 2.1.0-dev
* Backport: 2.0.0: UNKNOWN
----------------------------------------
=begin
So I wanted some real benefit of being lazy.  I wrote a Leibniz formula:

  def leibniz(n)
    (0..Float::INFINITY).lazy.with_index {|i, j| (-1 ** j) / (2*i+1).to_f }.take(n).reduce(:+)
  end

But it doesn't work (well, it does, indeed. It just doesn't stop working).  I got frustrated.
How about it?  Don't you feel it nifty?

Of course I can wait for the release next to 2.0.0.
=end

---Files--------------------------------
0001-enumerator.c-Enumerator-Lazy-with_index.patch (3.33 KB)


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

[ruby-dev:49751] [Ruby trunk Bug#7877] E::Lazy#with_index should be lazy

[shyouhei]

Issue #7877 has been updated by Shyouhei Urabe.


Is there reason this is not loved?  I'd like to have this.

----------------------------------------
Bug #7877: E::Lazy#with_index should be lazy
https://bugs.ruby-lang.org/issues/7877#change-59980

* Author: Shyouhei Urabe
* Status: Assigned
* Priority: Normal
* Assignee: Yutaka HARA
* ruby -v: 2.1.0-dev
* Backport: 2.0.0: UNKNOWN
----------------------------------------
=begin
So I wanted some real benefit of being lazy.  I wrote a Leibniz formula:

  def leibniz(n)
    (0..Float::INFINITY).lazy.with_index {|i, j| (-1 ** j) / (2*i+1).to_f }.take(n).reduce(:+)
  end

But it doesn't work (well, it does, indeed. It just doesn't stop working).  I got frustrated.
How about it?  Don't you feel it nifty?

Of course I can wait for the release next to 2.0.0.
=end

---Files--------------------------------
0001-enumerator.c-Enumerator-Lazy-with_index.patch (3.33 KB)


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

[ruby-dev:49834] [Ruby trunk Bug#7877] E::Lazy#with_index should be lazy

[shyouhei]

Issue #7877 has been updated by Shyouhei Urabe.

Assignee changed from Yutaka HARA to Nobuyoshi Nakada

----------------------------------------
Bug #7877: E::Lazy#with_index should be lazy
https://bugs.ruby-lang.org/issues/7877#change-60824

* Author: Shyouhei Urabe
* Status: Assigned
* Priority: Normal
* Assignee: Nobuyoshi Nakada
* ruby -v: 2.1.0-dev
* Backport: 2.0.0: UNKNOWN
----------------------------------------
=begin
So I wanted some real benefit of being lazy.  I wrote a Leibniz formula:

  def leibniz(n)
    (0..Float::INFINITY).lazy.with_index {|i, j| (-1 ** j) / (2*i+1).to_f }.take(n).reduce(:+)
  end

But it doesn't work (well, it does, indeed. It just doesn't stop working).  I got frustrated.
How about it?  Don't you feel it nifty?

Of course I can wait for the release next to 2.0.0.
=end

---Files--------------------------------
0001-enumerator.c-Enumerator-Lazy-with_index.patch (3.33 KB)


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

[ruby-dev:50829] [Ruby master Bug#7877] E::Lazy#with_index should be lazy

[merch-redmine]

Issue #7877 has been updated by jeremyevans0 (Jeremy Evans).

File lazy-with-index-block-7877.patch added

This bug is still present in the master branch.  I've updated nobu's patch to apply to the master branch, which required a significant rewrite.  The updated patch is attached.

----------------------------------------
Bug #7877: E::Lazy#with_index should be lazy
https://bugs.ruby-lang.org/issues/7877#change-80500

* Author: shyouhei (Shyouhei Urabe)
* Status: Assigned
* Priority: Normal
* Assignee: nobu (Nobuyoshi Nakada)
* Target version: 
* ruby -v: 2.1.0-dev
* Backport: 2.0.0: UNKNOWN
----------------------------------------
=begin
So I wanted some real benefit of being lazy.  I wrote a Leibniz formula:

  def leibniz(n)
    (0..Float::INFINITY).lazy.with_index {|i, j| (-1 ** j) / (2*i+1).to_f }.take(n).reduce(:+)
  end

But it doesn't work (well, it does, indeed. It just doesn't stop working).  I got frustrated.
How about it?  Don't you feel it nifty?

Of course I can wait for the release next to 2.0.0.
=end

---Files--------------------------------
0001-enumerator.c-Enumerator-Lazy-with_index.patch (3.33 KB)
lazy-with-index-block-7877.patch (4.08 KB)


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

[ruby-dev:50831] [Ruby master Bug#7877] E::Lazy#with_index should be lazy

[nobu]

Issue #7877 has been updated by nobu (Nobuyoshi Nakada).

Assignee changed from nobu (Nobuyoshi Nakada) to jeremyevans0 (Jeremy Evans)
Description updated

Thank you, I've missed it.

----------------------------------------
Bug #7877: E::Lazy#with_index should be lazy
https://bugs.ruby-lang.org/issues/7877#change-80515

* Author: shyouhei (Shyouhei Urabe)
* Status: Assigned
* Priority: Normal
* Assignee: jeremyevans0 (Jeremy Evans)
* Target version: 
* ruby -v: 2.1.0-dev
* Backport: 2.0.0: UNKNOWN
----------------------------------------
So I wanted some real benefit of being lazy.  I wrote a Leibniz formula:

```ruby
def leibniz(n)
  (0..Float::INFINITY).lazy.with_index {|i, j| (-1 ** j) / (2*i+1).to_f }.take(n).reduce(:+)
end
```

But it doesn't work (well, it does, indeed. It just doesn't stop working).  I got frustrated.
How about it?  Don't you feel it nifty?

Of course I can wait for the release next to 2.0.0.


---Files--------------------------------
0001-enumerator.c-Enumerator-Lazy-with_index.patch (3.33 KB)
lazy-with-index-block-7877.patch (4.08 KB)


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