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