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/ > >