Yeah, I think so too.

However, the existing Hash::[] is good for hacks like that HOSTS thing from hoodlum/mouseHole.

So, I’m a bit torn. I kind of wish we could have both, but there would be some uncomfortable ambiguities.

>> require "hashslice" 
>> keys = ['a', 'b', 'c']
>> vals = [1, 2, 3]

>> h = {}
>> h[*keys] = *vals

=> {"a"=>1, "b"=>2, "c"=>3}

Heh.

 >> (h = {})[*keys] = *vals

Okay.

Like this?

or

class Hash
  alias old_ary_get []
  def [](*keys)
    if keys.size == 1
      old_ary_get(keys.first)
    else
      keys.map {|k| old_ary_get(k) }
    end
  end
  alias old_ary_set []=
  def []=(*args)
    case args.size
    when 0, 1
      raise ArgumentError.new("wrong number of arguments (#{args.size} for 2)")
    when 2
      old_ary_set(*args)
    else
      rhs = args.pop
      args.each_with_index {|key, i| old_ary_set(key, rhs[i]) }
    end
  end
end

Daniel: Yes, that would be good too. And very practical.

class Hash
  alias _get []
  alias _assign []=

  def []( *keys )
    case keys.size
    when 1
      _get keys.first
    when 0
      raise ArgumentError, "wrong number of arguments (0 for 1)
    else
      keys.map { |key| _get key }
    end
  end

  def []=( *keys )
    rhs = keys.pop
    values = rhs.to_a
    keys.each_with_index do |key, i|
      _assign key, values[i]
    end
    rhs
  end
end

Does that look about right?

Array slices would be nice too, but I’m not sure how well that would work with the two-argument forms of Array#[] and Array#[]=.

Bloody heck. I get up to take a break before posting and someone steals my brain.

Good show Dave. :)

Dave: how about we use my Hash#[] and your Hash#[]=? You forgot to return rhs in yours though…

Scary how close we both came, though. Variables and all.

In RedHanded, has why discovered the resonant frequency of the human brain!?

Are you prepared for the terrible secret of RUBY !?

Thinking about Array#[], the way you would have to use it for slicing would be somearray[[1, 2]] to avoid ambiguity with somearray[1, 2].

I wonder whether there’s a more consistent way to manage slicing between arrays and hashes?

If only we could have additional arguments for non-indexing setters… (a la somearray.section(1, 2) = 'a', 'b')

It’s not my code, btw. The “hashslice” package is by Michael Granger, available on the RAA .

I like ours better than Granger’s, MenTaLguY. Of course, the only real differences returning rhs (which Granger’s hashslice fails to do) and error throwing (I think a 0-length slice should be allowed, despite my []= code).

I just have to add that I think it’s cool you can do obj[foo, bar] = baz, quux and baz, quux will be arrayified.

http://groups.google.com/group/comp.lang.ruby/browse_frm/thread/8cd6f94516d054ac

Regarding the original: I think it is commonly done as Hash[*pairs.flatten] in Ruby.

flgr:

 class Enumerable
   alias_method :smash_deeply!, :flatten
 end

Dave Burt, MenTaLguY: You are miracles.

Nano Methods has just about all of these concepts, from slicingg with hash#[]= and array#[[]] to the orginal request in Hash.zipnew.

Improvements to implementations are great esteemed.

That’s funny! I just added a patch for this to rails the other day..

why: I dunno, I suggested Hash.from_assoc a while ago, IIRC .

Also kind of start/end-with: ar = [“abcc”, “abc”]; ar.delete_if { |i| /^a.c$/.match(i) }; puts ar (may be interesting to Ruby beginners)

jot: Sometimes it’s better to use [^ ] instead of . (which will also match a space)!

And don’t forget this one as well: rxp = Regexp.new(/ruby/, “i”); puts rxp.inspect