From: Nathan Broadbent Date: 2012-10-30T08:47:41+09:00 Subject: [ruby-core:48565] Re: [ruby-trunk - Feature #7241][Rejected] Enumerable#to_h proposal --e89a8f64354424083404cd3b4bb5 Content-Type: text/plain; charset=ISO-8859-1 OK, no problem! Thanks for your response! A bit unrelated, but is it strange that each_with_object and inject have a different order for the block params? [1,2,3].inject({}) {|obj, el| obj[el] = el * 2; obj } #=> {1=>2, 2=>4, 3=>6} [1,2,3].each_with_object({}) {|obj, el| obj[el] = el * 2 } #=> NoMethodError: undefined method `*' for {}:Hash [1,2,3].each_with_object({}) {|el, obj| obj[el] = el * 2 } #=> {1=>2, 2=>4, 3=>6} On Tue, Oct 30, 2012 at 12:37 PM, matz (Yukihiro Matsumoto) < matz@ruby-lang.org> wrote: > > Issue #7241 has been updated by matz (Yukihiro Matsumoto). > > Status changed from Open to Rejected > > > ---------------------------------------- > Feature #7241: Enumerable#to_h proposal > https://bugs.ruby-lang.org/issues/7241#change-31937 > > Author: nathan.f77 (Nathan Broadbent) > Status: Rejected > Priority: Normal > Assignee: > Category: core > Target version: > > > I often use the `inject` method to build a hash, but I always find it > annoying when I need to return the hash at the end of the block. > This means that I often write code like: > > [1,2,3,4,5].inject({}) {|hash, el| hash[el] = el * 2; hash } > > I'm proposing an `Enumerable#to_h` method that would let me write: > > [1,2,3,4,5].to_h {|h, el| h[el] = el * 2 } > > > I saw the proposal at http://bugs.ruby-lang.org/issues/666, but I would > not be in favor of his implementation. > I believe the implementation should be similar to `inject`, so that the > hash object and next element are passed to the block. The main difference > to the `inject` method is that we would be modifying the hash in place, > instead of relying on the block's return value. > > As well as providing support for the case above, I have also considered > other cases where the `to_h` method would be useful. > I thought it would be useful if symmetry were provided for the `Hash#to_a` > method, such that: > > hash.to_a.to_h == hash # => true > > (See example 2) > > > I've allowed developers to provide a symbol instead of a block, so that > each element in the collection will be passed to that named method. (See > example 3) > > Finally, hashes can be given a default value, or a Proc that returns the > default value. (See examples 4 & 5) > > > Heres an example implementation that I would be happy to rewrite in C if > necessary: > > > module Enumerable > def to_h(default_or_sym = nil) > if block_given? > hash = if Proc === default_or_sym > Hash.new(&default_or_sym) > else > Hash.new(default_or_sym) > end > self.each do |el| > yield hash, el > end > elsif !default_or_sym.nil? > hash = {} > self.each do |el| > hash[el] = el.send(default_or_sym) > end > else > return Hash[*self.to_a.flatten(1)] > end > hash > end > end > > > Examples > ---------------------------------------------- > > > # 1) Build a hash from array elements > > [1,2,3,4,5].to_h {|h, el| h[el] = el * 2 } > > => {1=>2, 2=>4, 3=>6, 4=>8, 5=>10} > > > # 2) Provides symmetry for Hash.to_a (i.e. you can call hash.to_a.to_h) > > [[1, 2], [3, 4], [5, 6]].to_h > > => {1=>2, 3=>4, 5=>6} > > > # 3) Build a hash by calling a method on each array element > > ["String", "Another String"].to_h(:size) > > => {"String"=>6, "Another String"=>14} > > > # 4) Hash with default value > > [4,5,6,5].to_h(0) {|h, el| h[el] += el } > > => {4=>4, 5=>10, 6=>6} > > > # 5) Hash with default value returned from Proc > > default_proc = -> hash, key { hash[key] = "go fish: #{key}" } > [4,5,6].to_h(default_proc) {|h, el| h[el].upcase! } > > => {4=>"GO FISH: 4", 5=>"GO FISH: 5", 6=>"GO FISH: 6"} > > > > Thanks for your time, and please let me know your thoughts! > > > Best, > Nathan Broadbent > > > -- > http://bugs.ruby-lang.org/ > > --e89a8f64354424083404cd3b4bb5 Content-Type: text/html; charset=ISO-8859-1 Content-Transfer-Encoding: quoted-printable OK, no problem! Thanks for your response!

A bit unrelate= d, but is it strange that each_with_object and inject have a different orde= r for the block params?

=A0 =A0 [1,2,3].injec= t({}) {|obj, el| obj[el] =3D el * 2; obj } =A0 =A0 =A0 #=3D> {1=3D>2,= 2=3D>4, 3=3D>6}

=A0 =A0 [1,2,3].each_with_object({}) {|obj, el| obj[el]= =3D el * 2 } =A0#=3D> NoMethodError: undefined method `*' for {}:Ha= sh

=A0 =A0 [1,2,3].each_with_object({}) {|el, obj|= obj[el] =3D el * 2 } =A0#=3D> {1=3D>2, 2=3D>4, 3=3D>6}



=A0 =A0=A0

On Tue, Oct 30, 2012 at 12:37 PM, matz (Yu= kihiro Matsumoto) <matz@ruby-lang.org> wrote:

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

Status changed from Open to Rejected


----------------------------------------
Feature #7241: Enumerable#to_h proposal
https://bugs.ruby-lang.org/issues/7241#change-31937

Author: nathan.f77 (Nathan Broadbent)
Status: Rejected
Priority: Normal
Assignee:
Category: core
Target version:


I often use the `inject` method to build a hash, but I always find it annoy= ing when I need to return the hash at the end of the block.
This means that I often write code like:

=A0 =A0 [1,2,3,4,5].inject({}) {|hash, el| hash[el] =3D el * 2; hash }

I'm proposing an `Enumerable#to_h` method that would let me write:

=A0 =A0 [1,2,3,4,5].to_h {|h, el| h[el] =3D el * 2 }


I saw the proposal at http://bugs.ruby-lang.org/issues/666, but I would not be = in favor of his implementation.
I believe the implementation should be similar to `inject`, so that the has= h object and next element are passed to the block. The main difference to t= he `inject` method is that we would be modifying the hash in place, instead= of relying on the block's return value.

As well as providing support for the case above, I have also considered oth= er cases where the `to_h` method would be useful.
I thought it would be useful if symmetry were provided for the `Hash#to_a` = method, such that:

=A0 =A0 hash.to_a.to_h =3D=3D hash =A0# =3D> true

(See example 2)


I've allowed developers to provide a symbol instead of a block, so that= each element in the collection will be passed to that named method. (See e= xample 3)

Finally, hashes can be given a default value, or a Proc that returns the de= fault value. (See examples 4 & 5)


Heres an example implementation that I would be happy to rewrite in C if ne= cessary:


=A0 =A0 module Enumerable
=A0 =A0 =A0 def to_h(default_or_sym =3D nil)
=A0 =A0 =A0 =A0 if block_given?
=A0 =A0 =A0 =A0 =A0 hash =3D if Proc =3D=3D=3D default_or_sym
=A0 =A0 =A0 =A0 =A0 =A0 Hash.new(&default_or_sym)
=A0 =A0 =A0 =A0 =A0 else
=A0 =A0 =A0 =A0 =A0 =A0 Hash.new(default_or_sym)
=A0 =A0 =A0 =A0 =A0 end
=A0 =A0 =A0 =A0 =A0 self.each do |el|
=A0 =A0 =A0 =A0 =A0 =A0 yield hash, el
=A0 =A0 =A0 =A0 =A0 end
=A0 =A0 =A0 =A0 elsif !default_or_sym.nil?
=A0 =A0 =A0 =A0 =A0 hash =3D {}
=A0 =A0 =A0 =A0 =A0 self.each do |el|
=A0 =A0 =A0 =A0 =A0 =A0 hash[el] =3D el.send(default_or_sym)
=A0 =A0 =A0 =A0 =A0 end
=A0 =A0 =A0 =A0 else
=A0 =A0 =A0 =A0 =A0 return Hash[*self.to_a.flatten(1)]
=A0 =A0 =A0 =A0 end
=A0 =A0 =A0 =A0 hash
=A0 =A0 =A0 end
=A0 =A0 end


Examples
----------------------------------------------


# 1) Build a hash from array elements

=A0 =A0 [1,2,3,4,5].to_h {|h, el| h[el] =3D el * 2 }

=3D> {1=3D>2, 2=3D>4, 3=3D>6, 4=3D>8, 5=3D>10}


# 2) Provides symmetry for Hash.to_a (i.e. you can call hash.to_a.to_h)

=A0 =A0 [[1, 2], [3, 4], [5, 6]].to_h

=3D> {1=3D>2, 3=3D>4, 5=3D>6}


# 3) Build a hash by calling a method on each array element

=A0 =A0 ["String", "Another String"].to_h(:size)

=3D> {"String"=3D>6, "Another String"=3D>14}

# 4) Hash with default value

=A0 =A0 [4,5,6,5].to_h(0) {|h, el| h[el] +=3D el }

=3D> {4=3D>4, 5=3D>10, 6=3D>6}


# 5) Hash with default value returned from Proc

=A0 =A0 default_proc =3D -> hash, key { hash[key] =3D "go fish: #{k= ey}" }
=A0 =A0 [4,5,6].to_h(default_proc) {|h, el| h[el].upcase! }

=3D> {4=3D>"GO FISH: 4", 5=3D>"GO FISH: 5", 6= =3D>"GO FISH: 6"}



Thanks for your time, and please let me know your thoughts!


Best,
Nathan Broadbent


--
http://bugs.ruby-l= ang.org/


--e89a8f64354424083404cd3b4bb5--