[ruby-core:38154] [Ruby 1.9 - Feature #5044][Open] #zip with block return mapped results

[ruby-core:38154] [Ruby 1.9 - Feature #5044][Open] #zip with block return mapped results

[Thomas Sawyer]

Issue #5044 has been reported by Thomas Sawyer.

----------------------------------------
Feature #5044: #zip with block return mapped results
http://redmine.ruby-lang.org/issues/5044

Author: Thomas Sawyer
Status: Open
Priority: Normal
Assignee: 
Category: 
Target version: 


Is there any reason that #zip doesn't return results like map?

  [1,2,3].zip([1,2,3]){ |a,b| a + b }  #=> [2,4,6]

Currently, it just returns nil, which seems rather contrary to the return result of the non-block form.



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

[ruby-core:38165] [Ruby 1.9 - Feature #5044] #zip with block return mapped results

[Benoit Daloze]

Issue #5044 has been updated by Benoit Daloze.


Hi,

Please have a look at http://redmine.ruby-lang.org/issues/4539 (or [ruby-core:35613]).

The reason is explained by Yusuke in [ruby-core:35682]:

>2011/4/5 Benoit Daloze <eregontp@gmail.com>:
>> An unconditional nil is anyway not useful here, the only concern I see
>> might be the cost of creating this Array.
>
>It is actually a problem.
>I have used Array#zip with block for iteration many times.
>
> big_ary1.zip(big_ary2) do |x, y|
>   p [x, y]
> end
>
>The change requires some people (including me) to *rewrite*
>such a code as follows:
>
> big_ary1.size.times do |i|
>   x, y = big_ary1[i], big_ary2[i]
>   ...
> end
>
>So I like zip_with, if it is really needed.

That issue kind of got lost, it is probably a good idea to continue it.

For your example, we could have [1,2,3].zip_with([1,2,3], :+)
----------------------------------------
Feature #5044: #zip with block return mapped results
http://redmine.ruby-lang.org/issues/5044

Author: Thomas Sawyer
Status: Open
Priority: Normal
Assignee: 
Category: 
Target version: 


Is there any reason that #zip doesn't return results like map?

  [1,2,3].zip([1,2,3]){ |a,b| a + b }  #=> [2,4,6]

Currently, it just returns nil, which seems rather contrary to the return result of the non-block form.



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

[ruby-core:43653] [ruby-trunk - Feature #5044][Assigned] #zip with block return mapped results

[mame (Yusuke Endoh)]

Issue #5044 has been updated by mame (Yusuke Endoh).

Status changed from Open to Assigned
Assignee set to matz (Yukihiro Matsumoto)


----------------------------------------
Feature #5044: #zip with block return mapped results
https://bugs.ruby-lang.org/issues/5044#change-25153

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


Is there any reason that #zip doesn't return results like map?

  [1,2,3].zip([1,2,3]){ |a,b| a + b }  #=> [2,4,6]

Currently, it just returns nil, which seems rather contrary to the return result of the non-block form.



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

[ruby-core:43654] [ruby-trunk - Feature #5044] #zip with block return mapped results

[akr (Akira Tanaka)]

Issue #5044 has been updated by akr (Akira Tanaka).


Currently it can be implemented as follows.

  % ruby -e 'p [1,2,3].zip([1,2,3]).map {|a,b| a + b }'
  [2, 4, 6]
  % ruby -e 'p [1,2,3].lazy.zip([1,2,3]).map {|a,b| a + b }.to_a'
  [2, 4, 6]

----------------------------------------
Feature #5044: #zip with block return mapped results
https://bugs.ruby-lang.org/issues/5044#change-25152

Author: trans (Thomas Sawyer)
Status: Open
Priority: Normal
Assignee: 
Category: 
Target version: 


Is there any reason that #zip doesn't return results like map?

  [1,2,3].zip([1,2,3]){ |a,b| a + b }  #=> [2,4,6]

Currently, it just returns nil, which seems rather contrary to the return result of the non-block form.



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

[ruby-core:49720] [ruby-trunk - Feature #5044] #zip with block return mapped results

[mame (Yusuke Endoh)]

Issue #5044 has been updated by mame (Yusuke Endoh).

Target version set to next minor


----------------------------------------
Feature #5044: #zip with block return mapped results
https://bugs.ruby-lang.org/issues/5044#change-33247

Author: trans (Thomas Sawyer)
Status: Assigned
Priority: Normal
Assignee: matz (Yukihiro Matsumoto)
Category: 
Target version: next minor


Is there any reason that #zip doesn't return results like map?

  [1,2,3].zip([1,2,3]){ |a,b| a + b }  #=> [2,4,6]

Currently, it just returns nil, which seems rather contrary to the return result of the non-block form.



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

[ruby-core:85684] [Ruby trunk Feature#5044][Rejected] #zip with block return mapped results

[matz]

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

Status changed from Assigned to Rejected

We cannot change the behavior. The change would increase the memory consumption (and decrease the performance).

Matz.


----------------------------------------
Feature #5044: #zip with block return mapped results
https://bugs.ruby-lang.org/issues/5044#change-70484

* Author: trans (Thomas Sawyer)
* Status: Rejected
* Priority: Normal
* Assignee: matz (Yukihiro Matsumoto)
* Target version: 
----------------------------------------
Is there any reason that #zip doesn't return results like map?

  [1,2,3].zip([1,2,3]){ |a,b| a + b }  #=> [2,4,6]

Currently, it just returns nil, which seems rather contrary to the return result of the non-block form.




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

[ruby-core:93960] [Ruby master Feature#5044] #zip with block return mapped results

[foldes.laszlo2]

Issue #5044 has been updated by karatedog (Földes László).


A workaround can be achieved with #then:

`[1,2,3].zip([1,2,3]).then { |a| a.map {|a,b| a+b} }`

Tested in Ruby 2.6.2p47.

----------------------------------------
Feature #5044: #zip with block return mapped results
https://bugs.ruby-lang.org/issues/5044#change-80151

* Author: trans (Thomas Sawyer)
* Status: Rejected
* Priority: Normal
* Assignee: matz (Yukihiro Matsumoto)
* Target version: 
----------------------------------------
Is there any reason that #zip doesn't return results like map?

  [1,2,3].zip([1,2,3]){ |a,b| a + b }  #=> [2,4,6]

Currently, it just returns nil, which seems rather contrary to the return result of the non-block form.




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

Unsubscribe: <mailto:ruby-core-request@ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>