class ActiveSupport::HashWithIndifferentAccess

def update(*other_hashes, &block)

Experimental RBS support (using type sampling data from the type_fusion project). 

type ActiveSupport__HashWithIndifferentAccess_update_other_hashes = Array[Hash, ] | Array[Hash, authenticity_token, String, user, Hash, email, String, password, String, remember_me, String, commit, String] | Array[Hash, controller, String, action, String] | Array[Hash, _method, String]

def update: (*ActiveSupport__HashWithIndifferentAccess_update_other_hashes other_hashes, ) -> untyped

This signature was generated using 5 samples from 1 application.

hash_1.update(hash_2) { |key, old, new| old + new } # => {"key"=>22}
hash_2['key'] = 12
hash_1[:key] = 10

keys follow the semantics of indifferent access:
in the receiver, and the value in +other_hash+. The rules for duplicated
by the result of invoking the block with the duplicated key, the value
When given a block, the value for duplicated keys will be determined

of the values end up in the receiver, but which one is unspecified.
If the argument is a regular hash with keys +:key+ and "key" only one

In either case the merge respects the semantics of indifferent access.
ActiveSupport::HashWithIndifferentAccess or a regular +Hash+.
The arguments can be either an

hash.update({ "a" => 1 }, { "b" => 2 }) # => { "a" => 1, "b" => 2 }
hash = ActiveSupport::HashWithIndifferentAccess.new

hash_1.update(hash_2) # => {"key"=>"New Value!"}

hash_2[:key] = 'New Value!'
hash_2 = ActiveSupport::HashWithIndifferentAccess.new

hash_1[:key] = 'value'
hash_1 = ActiveSupport::HashWithIndifferentAccess.new

Updates the receiver in-place, merging in the hashes passed as arguments: 
def update(*other_hashes, &block)
  if other_hashes.size == 1
    update_with_single_argument(other_hashes.first, block)
  else
    other_hashes.each do |other_hash|
      update_with_single_argument(other_hash, block)
    end
  end
  self
end