Mixing keyword argument and arguments with default values duplicates the hash?

Question

So i discovered this ruby behaviour, which kept me going crazy for over an hour. When I pass a hash to a function which has a default value for hash AND a keyword argument, it seems like the reference doesn't get passed correctly. As soon as I take away the default value OR the keyword argument, the function behaves as expected. Am I missing some obvious ruby rule here?

def change_hash(h={}, rand: om)
  h['hey'] = true
end

k = {}
change_hash(k)
k
#=> {}

---

It works fine as soon as I take out the default or the keyword arg.

def change_hash(h, rand: om)
  h['hey'] = true
end

k = {}
change_hash(k)
k
#=> {'hey' => true}

---

def change_hash(h={})
  h['hey'] = true
end

k = {}
change_hash(k)
k
#=> {'hey' => true}

EDIT

Thanks for your answers. Most of you pointed out that ruby parses the hash as a keyword argument in some cases. However, I am talking about the case when a hash has string keys. When I pass the hash, it seems like the value that gets passed is correct. But modifying the hash inside the function doesn't modify the original hash.

def change_hash(hash={}, another_arg: 300)
  puts "another_arg: #{another_arg}"
  puts "hash: #{hash}"
  hash['hey'] = 3
end

my_hash = {"o" => 3}
change_hash(my_hash)
puts my_hash 

Prints out

another_arg: 300
hash: {"o"=>3}
{"o"=>3}

Answer 1

TL;DR ruby allows passing hash as a keyword argument as well as “expanded inplace hash.” Since change_hash(rand: :om) must be routed to keyword argument, so should change_hash({rand: :om}) and, hence, change_hash({}).

---

Since ruby allows default arguments in any position, the parser takes care of default arguments in the first place. That means, that the default arguments are greedy and the most amount of defaults will take a place.

On the other hand, since ruby lacks pattern-matching feature for function clauses, parsing the given argument to decide whether it should be passed as double-splat or not would lead to huge performance penalties. Since the call with an explicit keyword argument (change_hash(rand: :om)) should definitely pass :om to keyword argument, and we are allowed to pass an explicit hash {rand: :om} as a keyword argument, Ruby has nothing to do but to accept any hash as a keyword argument.

---

Ruby will split the single hash argument between hash and rand:

k = {"a" => 42, rand: 42}
def change_hash(h={}, rand: :om)
  h[:foo] = 42
  puts h.inspect
end
change_hash(k);
puts k.inspect

#⇒ {"a"=>42, :foo=>42}
#⇒ {"a"=>42, :rand=>42}

That split feature requires the argument being cloned before passing. That is why the original hash is not being modified.