class Hash

def assoc(key)
  val = fetch(key) do
    return find do |k, v|
      [k, v] if k == key
    end
  end
  [key, val]
end

def default_proc=(proc)
  if proc == nil # nil accepted in Ruby 2.0
    self.default = nil
    self
  else
    replace(Hash.new(&Backports.coerce_to(proc, Proc, :to_proc)).merge!(self))
  end
end

def default_proc_with_nil=(proc)
  if proc == nil
    self.default = nil
    self
  else
    self.default_proc_without_nil=(proc)
  end
end

def eql?(other)
  other.is_a?(Hash) &&
    size == other.size &&
    all? do |key, value|
      value.eql?(other.fetch(key){return false})
    end
end unless {}.eql?({})

def hash
  h = 0
  each do |key, value|
    h ^= key.hash ^ value.hash
  end
  h
end unless {}.hash == {}.hash

def keep_if
  return to_enum(:keep_if) unless block_given?
  delete_if{|key, value| ! yield key, value}
end

def rassoc(value)
  k = key(value)
  v = fetch(k){return nil}
  [k, fetch(k)] if k || v == value
end

def reverse_merge(other_hash)
  other_hash.merge(self)
end unless method_defined? :reverse_merge

def reverse_merge!(other_hash)
  replace(reverse_merge(other_hash))
end unless method_defined? :reverse_merge!

def select!
  return to_enum(:select!) unless block_given?
  raise "can't modify frozen hash" if frozen? # reject! won't do it for empty hashes...
  reject!{|key, value| ! yield key, value}
end

def select_with_hash_return
  return to_enum(:select) unless block_given?
  Hash[select_without_hash_return{|k, v| yield [k, v]}]
end

def stringify_keys
  Hash[map{|key,value| [key.to_s, value] }]
end unless method_defined? :stringify_keys

def stringify_keys!
  self.replace(self.stringify_keys)
end unless method_defined? :stringify_keys!

def symbolize_keys
  Hash[map{|key,value| [(key.to_sym rescue key) || key, value] }]
end unless method_defined? :symbolize_keys

def symbolize_keys!
  self.replace(self.symbolize_keys)
end unless method_defined? :symbolize_keys!

def to_h
  self.class == Hash ? self : {}.replace(self)
end