rbs 0.2.0

data/stdlib/builtin/gc.rbs

@@ -0,0 +1,243 @@
+# The GC module provides an interface to Ruby's mark and sweep garbage
+# collection mechanism.
+#
+# Some of the underlying methods are also available via the ObjectSpace module.
+#
+# You may obtain information about the operation of the GC through GC::Profiler.
+#
+module GC
+  # The number of times GC occurred.
+  #
+  # It returns the number of times GC occurred since the process started.
+  #
+  def self.count: () -> Integer
+
+  # Disables garbage collection, returning `true` if garbage collection was
+  # already disabled.
+  #
+  #     GC.disable   #=> false
+  #     GC.disable   #=> true
+  #
+  def self.disable: () -> bool
+
+  # Enables garbage collection, returning `true` if garbage collection was
+  # previously disabled.
+  #
+  #     GC.disable   #=> false
+  #     GC.enable    #=> true
+  #     GC.enable    #=> false
+  #
+  def self.enable: () -> bool
+
+  # Initiates garbage collection, even if manually disabled.
+  #
+  # This method is defined with keyword arguments that default to true:
+  #
+  #     def GC.start(full_mark: true, immediate_sweep: true); end
+  #
+  # Use full_mark: false to perform a minor GC. Use immediate_sweep: false to
+  # defer sweeping (use lazy sweep).
+  #
+  # Note: These keyword arguments are implementation and version dependent. They
+  # are not guaranteed to be future-compatible, and may be ignored if the
+  # underlying implementation does not support them.
+  #
+  def self.start: (?immediate_sweep: bool immediate_sweep, ?immediate_mark: bool immediate_mark, ?full_mark: bool full_mark) -> nil
+
+  # Returns a Hash containing information about the GC.
+  #
+  # The hash includes information about internal statistics about GC such as:
+  #
+  #     {
+  #         :count=>0,
+  #         :heap_allocated_pages=>24,
+  #         :heap_sorted_length=>24,
+  #         :heap_allocatable_pages=>0,
+  #         :heap_available_slots=>9783,
+  #         :heap_live_slots=>7713,
+  #         :heap_free_slots=>2070,
+  #         :heap_final_slots=>0,
+  #         :heap_marked_slots=>0,
+  #         :heap_eden_pages=>24,
+  #         :heap_tomb_pages=>0,
+  #         :total_allocated_pages=>24,
+  #         :total_freed_pages=>0,
+  #         :total_allocated_objects=>7796,
+  #         :total_freed_objects=>83,
+  #         :malloc_increase_bytes=>2389312,
+  #         :malloc_increase_bytes_limit=>16777216,
+  #         :minor_gc_count=>0,
+  #         :major_gc_count=>0,
+  #         :remembered_wb_unprotected_objects=>0,
+  #         :remembered_wb_unprotected_objects_limit=>0,
+  #         :old_objects=>0,
+  #         :old_objects_limit=>0,
+  #         :oldmalloc_increase_bytes=>2389760,
+  #         :oldmalloc_increase_bytes_limit=>16777216
+  #     }
+  #
+  # The contents of the hash are implementation specific and may be changed in the
+  # future.
+  #
+  # This method is only expected to work on C Ruby.
+  #
+  def self.stat: (?::Hash[Symbol, Integer] arg0) -> ::Hash[Symbol, Integer]
+               | (?Symbol arg0) -> Integer
+
+  # Returns current status of GC stress mode.
+  #
+  def self.stress: () -> (Integer | TrueClass | FalseClass)
+
+  # Updates the GC stress mode.
+  #
+  # When stress mode is enabled, the GC is invoked at every GC opportunity: all
+  # memory and object allocations.
+  #
+  # Enabling stress mode will degrade performance, it is only for debugging.
+  #
+  # flag can be true, false, or an integer bit-ORed following flags.
+  #     0x01:: no major GC
+  #     0x02:: no immediate sweep
+  #     0x04:: full mark after malloc/calloc/realloc
+  #
+  def self.stress=: (Integer | TrueClass | FalseClass flag) -> (Integer | TrueClass | FalseClass)
+
+  def self.compact: () -> ::Hash[:considered | :moved, Hash[Symbol | Integer, Integer]]
+
+  # Verify compaction reference consistency.
+  #
+  # This method is implementation specific.  During compaction, objects that were
+  # moved are replaced with T_MOVED objects.  No object should have a reference to
+  # a T_MOVED object after compaction.
+  #
+  # This function doubles the heap to ensure room to move all objects, compacts
+  # the heap to make sure everything moves, updates all references, then performs
+  # a full GC.  If any object contains a reference to a T_MOVED object, that
+  # object should be pushed on the mark stack, and will make a SEGV.
+  #
+  def self.verify_compaction_references: () -> ::Hash[:considered | :moved, Hash[Symbol | Integer, Integer]]
+
+  # Verify internal consistency.
+  #
+  # This method is implementation specific. Now this method checks generational
+  # consistency if RGenGC is supported.
+  #
+  def self.verify_internal_consistency: () -> nil
+
+  def self.verify_transient_heap_internal_consistency: () -> nil
+
+  # Returns information about the most recent garbage collection.
+  #
+  def self.latest_gc_info: () -> ::Hash[::Symbol, untyped]
+                         | [K] (?Hash[K, untyped] hash) -> ::Hash[::Symbol | K, untyped]
+                         | (Symbol key) -> untyped
+
+  def garbage_collect: (?immediate_sweep: bool immediate_sweep, ?immediate_mark: bool immediate_mark, ?full_mark: bool full_mark) -> nil
+end
+
+# internal constants
+#
+#
+GC::INTERNAL_CONSTANTS: Hash[Symbol, Integer]
+
+# GC build options
+#
+#
+GC::OPTS: Array[String]
+
+# The GC profiler provides access to information on GC runs including time,
+# length and object space size.
+#
+# Example:
+#
+#     GC::Profiler.enable
+#
+#     require 'rdoc/rdoc'
+#
+#     GC::Profiler.report
+#
+#     GC::Profiler.disable
+#
+# See also GC.count, GC.malloc_allocated_size and GC.malloc_allocations
+#
+module GC::Profiler
+  # Clears the GC profiler data.
+  #
+  def self.clear: () -> void
+
+  # Stops the GC profiler.
+  #
+  def self.disable: () -> void
+
+  # Starts the GC profiler.
+  #
+  def self.enable: () -> void
+
+  # The current status of GC profile mode.
+  #
+  def self.enabled?: () -> bool
+
+  # Returns an Array of individual raw profile data Hashes ordered from earliest
+  # to latest by `:GC_INVOKE_TIME`.
+  #
+  # For example:
+  #
+  #     [
+  #       {
+  #          :GC_TIME=>1.3000000000000858e-05,
+  #          :GC_INVOKE_TIME=>0.010634999999999999,
+  #          :HEAP_USE_SIZE=>289640,
+  #          :HEAP_TOTAL_SIZE=>588960,
+  #          :HEAP_TOTAL_OBJECTS=>14724,
+  #          :GC_IS_MARKED=>false
+  #       },
+  #       # ...
+  #     ]
+  #
+  # The keys mean:
+  #
+  # `:GC_TIME`
+  # :   Time elapsed in seconds for this GC run
+  # `:GC_INVOKE_TIME`
+  # :   Time elapsed in seconds from startup to when the GC was invoked
+  # `:HEAP_USE_SIZE`
+  # :   Total bytes of heap used
+  # `:HEAP_TOTAL_SIZE`
+  # :   Total size of heap in bytes
+  # `:HEAP_TOTAL_OBJECTS`
+  # :   Total number of objects
+  # `:GC_IS_MARKED`
+  # :   Returns `true` if the GC is in mark phase
+  #
+  #
+  # If ruby was built with `GC_PROFILE_MORE_DETAIL`, you will also have access to
+  # the following hash keys:
+  #
+  # `:GC_MARK_TIME`
+  # `:GC_SWEEP_TIME`
+  # `:ALLOCATE_INCREASE`
+  # `:ALLOCATE_LIMIT`
+  # `:HEAP_USE_PAGES`
+  # `:HEAP_LIVE_OBJECTS`
+  # `:HEAP_FREE_OBJECTS`
+  # `:HAVE_FINALIZE`
+  # :   
+  #
+  def self.raw_data: () -> ::Array[::Hash[Symbol, untyped]]
+
+  # Writes the GC::Profiler.result to `$stdout` or the given IO object.
+  #
+  def self.report: (?IO io) -> void
+
+  # Returns a profile data report such as:
+  #
+  #     GC 1 invokes.
+  #     Index    Invoke Time(sec)       Use Size(byte)     Total Size(byte)         Total Object                    GC time(ms)
+  #         1               0.012               159240               212940                10647         0.00000000000001530000
+  #
+  def self.result: () -> String
+
+  # The total time used for garbage collection in seconds
+  #
+  def self.total_time: () -> Float
+end

data/stdlib/builtin/hash.rbs

@@ -0,0 +1,1029 @@
+# A Hash is a dictionary-like collection of unique keys and their values. Also
+# called associative arrays, they are similar to Arrays, but where an Array uses
+# integers as its index, a Hash allows you to use any object type.
+#
+# Hashes enumerate their values in the order that the corresponding keys were
+# inserted.
+#
+# A Hash can be easily created by using its implicit form:
+#
+#     grades = { "Jane Doe" => 10, "Jim Doe" => 6 }
+#
+# Hashes allow an alternate syntax for keys that are symbols. Instead of
+#
+#     options = { :font_size => 10, :font_family => "Arial" }
+#
+# You could write it as:
+#
+#     options = { font_size: 10, font_family: "Arial" }
+#
+# Each named key is a symbol you can access in hash:
+#
+#     options[:font_size]  # => 10
+#
+# A Hash can also be created through its ::new method:
+#
+#     grades = Hash.new
+#     grades["Dorothy Doe"] = 9
+#
+# Hashes have a *default value* that is returned when accessing keys that do not
+# exist in the hash. If no default is set `nil` is used. You can set the default
+# value by sending it as an argument to Hash.new:
+#
+#     grades = Hash.new(0)
+#
+# Or by using the #default= method:
+#
+#     grades = {"Timmy Doe" => 8}
+#     grades.default = 0
+#
+# Accessing a value in a Hash requires using its key:
+#
+#     puts grades["Jane Doe"] # => 0
+#
+# ### Common Uses
+#
+# Hashes are an easy way to represent data structures, such as
+#
+#     books         = {}
+#     books[:matz]  = "The Ruby Programming Language"
+#     books[:black] = "The Well-Grounded Rubyist"
+#
+# Hashes are also commonly used as a way to have named parameters in functions.
+# Note that no brackets are used below. If a hash is the last argument on a
+# method call, no braces are needed, thus creating a really clean interface:
+#
+#     Person.create(name: "John Doe", age: 27)
+#
+#     def self.create(params)
+#       @name = params[:name]
+#       @age  = params[:age]
+#     end
+#
+# ### Hash Keys
+#
+# Two objects refer to the same hash key when their `hash` value is identical
+# and the two objects are `eql?` to each other.
+#
+# A user-defined class may be used as a hash key if the `hash` and `eql?`
+# methods are overridden to provide meaningful behavior.  By default, separate
+# instances refer to separate hash keys.
+#
+# A typical implementation of `hash` is based on the object's data while `eql?`
+# is usually aliased to the overridden `==` method:
+#
+#     class Book
+#       attr_reader :author, :title
+#
+#       def initialize(author, title)
+#         @author = author
+#         @title = title
+#       end
+#
+#       def ==(other)
+#         self.class === other and
+#           other.author == @author and
+#           other.title == @title
+#       end
+#
+#       alias eql? ==
+#
+#       def hash
+#         @author.hash ^ @title.hash # XOR
+#       end
+#     end
+#
+#     book1 = Book.new 'matz', 'Ruby in a Nutshell'
+#     book2 = Book.new 'matz', 'Ruby in a Nutshell'
+#
+#     reviews = {}
+#
+#     reviews[book1] = 'Great reference!'
+#     reviews[book2] = 'Nice and compact!'
+#
+#     reviews.length #=> 1
+#
+# See also Object#hash and Object#eql?
+#
+class Hash[unchecked out K, unchecked out V] < Object
+  include Enumerable[[K, V], Hash[K, V]]
+
+  # Creates a new hash populated with the given objects.
+  #
+  # Similar to the literal `{ *key* => *value*, ... }`. In the first form, keys
+  # and values occur in pairs, so there must be an even number of arguments.
+  #
+  # The second and third form take a single argument which is either an array of
+  # key-value pairs or an object convertible to a hash.
+  #
+  #     Hash["a", 100, "b", 200]             #=> {"a"=>100, "b"=>200}
+  #     Hash[ [ ["a", 100], ["b", 200] ] ]   #=> {"a"=>100, "b"=>200}
+  #     Hash["a" => 100, "b" => 200]         #=> {"a"=>100, "b"=>200}
+  #
+  def self.[]: [U, V] (_ToHash[U, V]) -> ::Hash[U, V]
+             | [U, V] (Array[[ U, V ]]) -> ::Hash[U, V]
+             | (*untyped) -> ::Hash[untyped, untyped]
+
+  # Try to convert *obj* into a hash, using to_hash method. Returns converted hash
+  # or nil if *obj* cannot be converted for any reason.
+  #
+  #     Hash.try_convert({1=>2})   # => {1=>2}
+  #     Hash.try_convert("1=>2")   # => nil
+  #
+  def self.try_convert: [U, V] (_ToHash[U, V]) -> ::Hash[U, V]
+                      | (untyped) -> (::Hash[untyped, untyped] | nil)
+
+  public
+
+  # Returns `true` if *hash* is subset of *other*.
+  #
+  #     h1 = {a:1, b:2}
+  #     h2 = {a:1, b:2, c:3}
+  #     h1 < h2    #=> true
+  #     h2 < h1    #=> false
+  #     h1 < h1    #=> false
+  #
+  def <: (::Hash[K, V]) -> bool
+
+  # Returns `true` if *hash* is subset of *other* or equals to *other*.
+  #
+  #     h1 = {a:1, b:2}
+  #     h2 = {a:1, b:2, c:3}
+  #     h1 <= h2   #=> true
+  #     h2 <= h1   #=> false
+  #     h1 <= h1   #=> true
+  #
+  def <=: (::Hash[K, V]) -> bool
+
+  # Equality---Two hashes are equal if they each contain the same number of keys
+  # and if each key-value pair is equal to (according to Object#==) the
+  # corresponding elements in the other hash.
+  #
+  #     h1 = { "a" => 1, "c" => 2 }
+  #     h2 = { 7 => 35, "c" => 2, "a" => 1 }
+  #     h3 = { "a" => 1, "c" => 2, 7 => 35 }
+  #     h4 = { "a" => 1, "d" => 2, "f" => 35 }
+  #     h1 == h2   #=> false
+  #     h2 == h3   #=> true
+  #     h3 == h4   #=> false
+  #
+  # The orders of each hashes are not compared.
+  #
+  #     h1 = { "a" => 1, "c" => 2 }
+  #     h2 = { "c" => 2, "a" => 1 }
+  #     h1 == h2   #=> true
+  #
+  def ==: (untyped other) -> bool
+
+  # Returns `true` if *other* is subset of *hash*.
+  #
+  #     h1 = {a:1, b:2}
+  #     h2 = {a:1, b:2, c:3}
+  #     h1 > h2    #=> false
+  #     h2 > h1    #=> true
+  #     h1 > h1    #=> false
+  #
+  def >: (::Hash[K, V]) -> bool
+
+  # Returns `true` if *other* is subset of *hash* or equals to *hash*.
+  #
+  #     h1 = {a:1, b:2}
+  #     h2 = {a:1, b:2, c:3}
+  #     h1 >= h2   #=> false
+  #     h2 >= h1   #=> true
+  #     h1 >= h1   #=> true
+  #
+  def >=: (::Hash[K, V]) -> bool
+
+  # Element Reference---Retrieves the *value* object corresponding to the *key*
+  # object. If not found, returns the default value (see Hash::new for details).
+  #
+  #     h = { "a" => 100, "b" => 200 }
+  #     h["a"]   #=> 100
+  #     h["c"]   #=> nil
+  #
+  def []: (K arg0) -> V
+
+  # ## Element Assignment
+  #
+  # Associates the value given by `value` with the key given by `key`.
+  #
+  #     h = { "a" => 100, "b" => 200 }
+  #     h["a"] = 9
+  #     h["c"] = 4
+  #     h   #=> {"a"=>9, "b"=>200, "c"=>4}
+  #     h.store("d", 42) #=> 42
+  #     h   #=> {"a"=>9, "b"=>200, "c"=>4, "d"=>42}
+  #
+  # `key` should not have its value changed while it is in use as a key (an
+  # `unfrozen String` passed as a key will be duplicated and frozen).
+  #
+  #     a = "a"
+  #     b = "b".freeze
+  #     h = { a => 100, b => 200 }
+  #     h.key(100).equal? a #=> false
+  #     h.key(200).equal? b #=> true
+  #
+  def []=: (K arg0, V arg1) -> V
+
+  # See also Enumerable#any?
+  #
+  def any?: () -> bool
+          | (untyped pattern) -> bool
+          | () { (K, V) -> bool } -> bool
+
+  # Searches through the hash comparing *obj* with the key using `==`. Returns the
+  # key-value pair (two elements array) or `nil` if no match is found.  See
+  # Array#assoc.
+  #
+  #     h = {"colors"  => ["red", "blue", "green"],
+  #          "letters" => ["a", "b", "c" ]}
+  #     h.assoc("letters")  #=> ["letters", ["a", "b", "c"]]
+  #     h.assoc("foo")      #=> nil
+  #
+  def assoc: (K arg0) -> [K, V]?
+
+  # Removes all key-value pairs from *hsh*.
+  #
+  #     h = { "a" => 100, "b" => 200 }   #=> {"a"=>100, "b"=>200}
+  #     h.clear                          #=> {}
+  #
+  def clear: () -> self
+
+  # Returns a new hash with the nil values/key pairs removed
+  #
+  #     h = { a: 1, b: false, c: nil }
+  #     h.compact     #=> { a: 1, b: false }
+  #     h             #=> { a: 1, b: false, c: nil }
+  #
+  def compact: () -> self
+
+  # Removes all nil values from the hash. Returns nil if no changes were made,
+  # otherwise returns the hash.
+  #
+  #     h = { a: 1, b: false, c: nil }
+  #     h.compact!     #=> { a: 1, b: false }
+  #
+  def compact!: () -> self?
+
+  # Makes *hsh* compare its keys by their identity, i.e. it will consider exact
+  # same objects as same keys.
+  #
+  #     h1 = { "a" => 100, "b" => 200, :c => "c" }
+  #     h1["a"]        #=> 100
+  #     h1.compare_by_identity
+  #     h1.compare_by_identity? #=> true
+  #     h1["a".dup]    #=> nil  # different objects.
+  #     h1[:c]         #=> "c"  # same symbols are all same.
+  #
+  def compare_by_identity: () -> self
+
+  # Returns `true` if *hsh* will compare its keys by their identity.  Also see
+  # Hash#compare_by_identity.
+  #
+  def compare_by_identity?: () -> bool
+
+  def deconstruct_keys: (Array[K] | nil) -> self
+
+  # Returns the default value, the value that would be returned by *[hsh](key)* if
+  # *key* did not exist in *hsh*. See also Hash::new and Hash#default=.
+  #
+  #     h = Hash.new                            #=> {}
+  #     h.default                               #=> nil
+  #     h.default(2)                            #=> nil
+  #
+  #     h = Hash.new("cat")                     #=> {}
+  #     h.default                               #=> "cat"
+  #     h.default(2)                            #=> "cat"
+  #
+  #     h = Hash.new {|h,k| h[k] = k.to_i*10}   #=> {}
+  #     h.default                               #=> nil
+  #     h.default(2)                            #=> 20
+  #
+  def default: (?K arg0) -> V?
+
+  # Sets the default value, the value returned for a key that does not exist in
+  # the hash. It is not possible to set the default to a Proc that will be
+  # executed on each key lookup.
+  #
+  #     h = { "a" => 100, "b" => 200 }
+  #     h.default = "Go fish"
+  #     h["a"]     #=> 100
+  #     h["z"]     #=> "Go fish"
+  #     # This doesn't do what you might hope...
+  #     h.default = proc do |hash, key|
+  #       hash[key] = key + key
+  #     end
+  #     h[2]       #=> #<Proc:0x401b3948@-:6>
+  #     h["cat"]   #=> #<Proc:0x401b3948@-:6>
+  #
+  def default=: (V arg0) -> V
+
+  # If Hash::new was invoked with a block, return that block, otherwise return
+  # `nil`.
+  #
+  #     h = Hash.new {|h,k| h[k] = k*k }   #=> {}
+  #     p = h.default_proc                 #=> #<Proc:0x401b3d08@-:1>
+  #     a = []                             #=> []
+  #     p.call(a, 2)
+  #     a                                  #=> [nil, nil, 4]
+  #
+  def default_proc: () -> (Proc | nil)
+
+  # Sets the default proc to be executed on each failed key lookup.
+  #
+  #     h.default_proc = proc do |hash, key|
+  #       hash[key] = key + key
+  #     end
+  #     h[2]       #=> 4
+  #     h["cat"]   #=> "catcat"
+  #
+  def default_proc=: (Proc | _ToProc | nil) -> (Proc | _ToProc | nil)
+
+  # Deletes the key-value pair and returns the value from *hsh* whose key is equal
+  # to *key*. If the key is not found, it returns *nil*. If the optional code
+  # block is given and the key is not found, pass in the key and return the result
+  # of *block*.
+  #
+  #     h = { "a" => 100, "b" => 200 }
+  #     h.delete("a")                              #=> 100
+  #     h.delete("z")                              #=> nil
+  #     h.delete("z") { |el| "#{el} not found" }   #=> "z not found"
+  #
+  def delete: (K arg0) -> V?
+            | [U] (K arg0) { (K arg0) -> U } -> (U | V)
+
+  # Deletes every key-value pair from *hsh* for which *block* evaluates to `true`.
+  #
+  # If no block is given, an enumerator is returned instead.
+  #
+  #     h = { "a" => 100, "b" => 200, "c" => 300 }
+  #     h.delete_if {|key, value| key >= "b" }   #=> {"a"=>100}
+  #
+  def delete_if: () { (K arg0, V arg1) -> bool } -> self
+               | () -> ::Enumerator[[ K, V ], self]
+
+  # Extracts the nested value specified by the sequence of *key* objects by
+  # calling `dig` at each step, returning `nil` if any intermediate step is `nil`.
+  #
+  #     h = { foo: {bar: {baz: 1}}}
+  #
+  #     h.dig(:foo, :bar, :baz)     #=> 1
+  #     h.dig(:foo, :zot, :xyz)     #=> nil
+  #
+  #     g = { foo: [10, 11, 12] }
+  #     g.dig(:foo, 1)              #=> 11
+  #     g.dig(:foo, 1, 0)           #=> TypeError: Integer does not have #dig method
+  #     g.dig(:foo, :bar)           #=> TypeError: no implicit conversion of Symbol into Integer
+  #
+  def dig: (*untyped) -> untyped
+
+  # Calls *block* once for each key in *hsh*, passing the key-value pair as
+  # parameters.
+  #
+  # If no block is given, an enumerator is returned instead.
+  #
+  #     h = { "a" => 100, "b" => 200 }
+  #     h.each {|key, value| puts "#{key} is #{value}" }
+  #
+  # *produces:*
+  #
+  #     a is 100
+  #     b is 200
+  #
+  def each: () { ([ K, V ] arg0) -> untyped } -> self
+          | () -> ::Enumerator[[ K, V ], self]
+
+  # Calls *block* once for each key in *hsh*, passing the key as a parameter.
+  #
+  # If no block is given, an enumerator is returned instead.
+  #
+  #     h = { "a" => 100, "b" => 200 }
+  #     h.each_key {|key| puts key }
+  #
+  # *produces:*
+  #
+  #     a
+  #     b
+  #
+  def each_key: () { (K arg0) -> untyped } -> ::Hash[K, V]
+              | () -> ::Enumerator[K, self]
+
+  # Calls *block* once for each key in *hsh*, passing the key-value pair as
+  # parameters.
+  #
+  # If no block is given, an enumerator is returned instead.
+  #
+  #     h = { "a" => 100, "b" => 200 }
+  #     h.each {|key, value| puts "#{key} is #{value}" }
+  #
+  # *produces:*
+  #
+  #     a is 100
+  #     b is 200
+  #
+  alias each_pair each
+
+  # Calls *block* once for each key in *hsh*, passing the value as a parameter.
+  #
+  # If no block is given, an enumerator is returned instead.
+  #
+  #     h = { "a" => 100, "b" => 200 }
+  #     h.each_value {|value| puts value }
+  #
+  # *produces:*
+  #
+  #     100
+  #     200
+  #
+  def each_value: () { (V arg0) -> untyped } -> self
+                | () -> ::Enumerator[V, self]
+
+  # Returns `true` if *hsh* contains no key-value pairs.
+  #
+  #     {}.empty?   #=> true
+  #
+  def empty?: () -> bool
+
+  # Returns `true` if *hash* and *other* are both hashes with the same content.
+  # The orders of each hashes are not compared.
+  #
+  def eql?: (untyped) -> bool
+
+  # Returns a value from the hash for the given key. If the key can't be found,
+  # there are several options: With no other arguments, it will raise a KeyError
+  # exception; if *default* is given, then that will be returned; if the optional
+  # code block is specified, then that will be run and its result returned.
+  #
+  #     h = { "a" => 100, "b" => 200 }
+  #     h.fetch("a")                            #=> 100
+  #     h.fetch("z", "go fish")                 #=> "go fish"
+  #     h.fetch("z") { |el| "go fish, #{el}"}   #=> "go fish, z"
+  #
+  # The following example shows that an exception is raised if the key is not
+  # found and a default value is not supplied.
+  #
+  #     h = { "a" => 100, "b" => 200 }
+  #     h.fetch("z")
+  #
+  # *produces:*
+  #
+  #     prog.rb:2:in `fetch': key not found (KeyError)
+  #      from prog.rb:2
+  #
+  def fetch: (K arg0) -> V
+           | [X] (K arg0, X arg1) -> (V | X)
+           | [X] (K arg0) { (K arg0) -> X } -> (V | X)
+
+  # Returns an array containing the values associated with the given keys but also
+  # raises KeyError when one of keys can't be found. Also see Hash#values_at and
+  # Hash#fetch.
+  #
+  #     h = { "cat" => "feline", "dog" => "canine", "cow" => "bovine" }
+  #
+  #     h.fetch_values("cow", "cat")                   #=> ["bovine", "feline"]
+  #     h.fetch_values("cow", "bird")                  # raises KeyError
+  #     h.fetch_values("cow", "bird") { |k| k.upcase } #=> ["bovine", "BIRD"]
+  #
+  def fetch_values: (*K) -> Array[V]
+                  | [X] (*K) { (K) -> X } -> (V | X)
+
+  # Returns a new hash consisting of entries for which the block returns true.
+  #
+  # If no block is given, an enumerator is returned instead.
+  #
+  #     h = { "a" => 100, "b" => 200, "c" => 300 }
+  #     h.select {|k,v| k > "a"}  #=> {"b" => 200, "c" => 300}
+  #     h.select {|k,v| v < 200}  #=> {"a" => 100}
+  #
+  # Hash#filter is an alias for Hash#select.
+  #
+  def filter: () { (K arg0, V arg1) -> bool } -> self
+            | () -> ::Enumerator[[ K, V ], self]
+
+  # Equivalent to Hash#keep_if, but returns `nil` if no changes were made.
+  #
+  # Hash#filter! is an alias for Hash#select!.
+  #
+  def filter!: () { (K arg0, V arg1) -> bool } -> self?
+             | () -> ::Enumerator[[ K, V ], self?]
+
+  # Returns a new array that is a one-dimensional flattening of this hash. That
+  # is, for every key or value that is an array, extract its elements into the new
+  # array.  Unlike Array#flatten, this method does not flatten recursively by
+  # default.  The optional *level* argument determines the level of recursion to
+  # flatten.
+  #
+  #     a =  {1=> "one", 2 => [2,"two"], 3 => "three"}
+  #     a.flatten    # => [1, "one", 2, [2, "two"], 3, "three"]
+  #     a.flatten(2) # => [1, "one", 2, 2, "two", 3, "three"]
+  #
+  def flatten: () -> ::Array[K | V]
+             | (1 level) -> ::Array[K | V]
+             | (Integer level) -> Array[untyped]
+
+  # Returns `true` if the given key is present in *hsh*.
+  #
+  #     h = { "a" => 100, "b" => 200 }
+  #     h.has_key?("a")   #=> true
+  #     h.has_key?("z")   #=> false
+  #
+  # Note that #include? and #member? do not test member equality using `==` as do
+  # other Enumerables.
+  #
+  # See also Enumerable#include?
+  #
+  def has_key?: (K arg0) -> bool
+
+  # Returns `true` if the given value is present for some key in *hsh*.
+  #
+  #     h = { "a" => 100, "b" => 200 }
+  #     h.value?(100)   #=> true
+  #     h.value?(999)   #=> false
+  #
+  def has_value?: (V arg0) -> bool
+
+  # Compute a hash-code for this hash. Two hashes with the same content will have
+  # the same hash code (and will compare using `eql?`).
+  #
+  # See also Object#hash.
+  #
+  def hash: () -> Integer
+
+  # Returns `true` if the given key is present in *hsh*.
+  #
+  #     h = { "a" => 100, "b" => 200 }
+  #     h.has_key?("a")   #=> true
+  #     h.has_key?("z")   #=> false
+  #
+  # Note that #include? and #member? do not test member equality using `==` as do
+  # other Enumerables.
+  #
+  # See also Enumerable#include?
+  #
+  alias include? has_key?
+
+  def index: (V) -> K?
+
+  # Return the contents of this hash as a string.
+  #
+  #     h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300  }
+  #     h.to_s   #=> "{\"c\"=>300, \"a\"=>100, \"d\"=>400}"
+  #
+  def inspect: () -> String
+
+  # Returns a new hash created by using *hsh*'s values as keys, and the keys as
+  # values. If a key with the same value already exists in the *hsh*, then the
+  # last one defined will be used, the earlier value(s) will be discarded.
+  #
+  #     h = { "n" => 100, "m" => 100, "y" => 300, "d" => 200, "a" => 0 }
+  #     h.invert   #=> {0=>"a", 100=>"m", 200=>"d", 300=>"y"}
+  #
+  # If there is no key with the same value, Hash#invert is involutive.
+  #
+  #     h = { a: 1, b: 3, c: 4 }
+  #     h.invert.invert == h #=> true
+  #
+  # The condition, no key with the same value, can be tested by comparing the size
+  # of inverted hash.
+  #
+  #     # no key with the same value
+  #     h = { a: 1, b: 3, c: 4 }
+  #     h.size == h.invert.size #=> true
+  #
+  #     # two (or more) keys has the same value
+  #     h = { a: 1, b: 3, c: 1 }
+  #     h.size == h.invert.size #=> false
+  #
+  def invert: () -> ::Hash[V, K]
+
+  # Deletes every key-value pair from *hsh* for which *block* evaluates to
+  # `false`.
+  #
+  # If no block is given, an enumerator is returned instead.
+  #
+  # See also Hash#select!.
+  #
+  def keep_if: () { (K, V) -> bool } -> self
+             | () -> ::Enumerator[[ K, V ], self]
+
+  # Returns the key of an occurrence of a given value. If the value is not found,
+  # returns `nil`.
+  #
+  #     h = { "a" => 100, "b" => 200, "c" => 300, "d" => 300 }
+  #     h.key(200)   #=> "b"
+  #     h.key(300)   #=> "c"
+  #     h.key(999)   #=> nil
+  #
+  alias key index
+
+  # Returns `true` if the given key is present in *hsh*.
+  #
+  #     h = { "a" => 100, "b" => 200 }
+  #     h.has_key?("a")   #=> true
+  #     h.has_key?("z")   #=> false
+  #
+  # Note that #include? and #member? do not test member equality using `==` as do
+  # other Enumerables.
+  #
+  # See also Enumerable#include?
+  #
+  alias key? has_key?
+
+  # Returns a new array populated with the keys from this hash. See also
+  # Hash#values.
+  #
+  #     h = { "a" => 100, "b" => 200, "c" => 300, "d" => 400 }
+  #     h.keys   #=> ["a", "b", "c", "d"]
+  #
+  def keys: () -> ::Array[K]
+
+  # Returns the number of key-value pairs in the hash.
+  #
+  #     h = { "d" => 100, "a" => 200, "v" => 300, "e" => 400 }
+  #     h.size          #=> 4
+  #     h.delete("a")   #=> 200
+  #     h.size          #=> 3
+  #     h.length        #=> 3
+  #
+  # Hash#length is an alias for Hash#size.
+  #
+  def length: () -> Integer
+
+  # Returns `true` if the given key is present in *hsh*.
+  #
+  #     h = { "a" => 100, "b" => 200 }
+  #     h.has_key?("a")   #=> true
+  #     h.has_key?("z")   #=> false
+  #
+  # Note that #include? and #member? do not test member equality using `==` as do
+  # other Enumerables.
+  #
+  # See also Enumerable#include?
+  #
+  alias member? has_key?
+
+  # Returns a new hash that combines the contents of the receiver and the contents
+  # of the given hashes.
+  #
+  # If no block is given, entries with duplicate keys are overwritten with the
+  # values from each `other_hash` successively, otherwise the value for each
+  # duplicate key is determined by calling the block with the key, its value in
+  # the receiver and its value in each `other_hash`.
+  #
+  # When called without any argument, returns a copy of the receiver.
+  #
+  #     h1 = { "a" => 100, "b" => 200 }
+  #     h2 = { "b" => 246, "c" => 300 }
+  #     h3 = { "b" => 357, "d" => 400 }
+  #     h1.merge          #=> {"a"=>100, "b"=>200}
+  #     h1.merge(h2)      #=> {"a"=>100, "b"=>246, "c"=>300}
+  #     h1.merge(h2, h3)  #=> {"a"=>100, "b"=>357, "c"=>300, "d"=>400}
+  #     h1.merge(h2) {|key, oldval, newval| newval - oldval}
+  #                       #=> {"a"=>100, "b"=>46,  "c"=>300}
+  #     h1.merge(h2, h3) {|key, oldval, newval| newval - oldval}
+  #                       #=> {"a"=>100, "b"=>311, "c"=>300, "d"=>400}
+  #     h1                #=> {"a"=>100, "b"=>200}
+  #
+  def merge: [A, B] (*::Hash[A, B] other_hashes) -> ::Hash[A | K, B | V]
+           | [A, B, C] (*::Hash[A, B] other_hashes) { (K key, V oldval, B newval) -> (C) } -> ::Hash[A | K, B | V | C]
+
+  # Adds the contents of the given hashes to the receiver.
+  #
+  # If no block is given, entries with duplicate keys are overwritten with the
+  # values from each `other_hash` successively, otherwise the value for each
+  # duplicate key is determined by calling the block with the key, its value in
+  # the receiver and its value in each `other_hash`.
+  #
+  #     h1 = { "a" => 100, "b" => 200 }
+  #     h1.merge!          #=> {"a"=>100, "b"=>200}
+  #     h1                 #=> {"a"=>100, "b"=>200}
+  #
+  #     h1 = { "a" => 100, "b" => 200 }
+  #     h2 = { "b" => 246, "c" => 300 }
+  #     h1.merge!(h2)      #=> {"a"=>100, "b"=>246, "c"=>300}
+  #     h1                 #=> {"a"=>100, "b"=>246, "c"=>300}
+  #
+  #     h1 = { "a" => 100, "b" => 200 }
+  #     h2 = { "b" => 246, "c" => 300 }
+  #     h3 = { "b" => 357, "d" => 400 }
+  #     h1.merge!(h2, h3)
+  #                        #=> {"a"=>100, "b"=>357, "c"=>300, "d"=>400}
+  #     h1                 #=> {"a"=>100, "b"=>357, "c"=>300, "d"=>400}
+  #
+  #     h1 = { "a" => 100, "b" => 200 }
+  #     h2 = { "b" => 246, "c" => 300 }
+  #     h3 = { "b" => 357, "d" => 400 }
+  #     h1.merge!(h2, h3) {|key, v1, v2| v1 }
+  #                        #=> {"a"=>100, "b"=>200, "c"=>300, "d"=>400}
+  #     h1                 #=> {"a"=>100, "b"=>200, "c"=>300, "d"=>400}
+  #
+  # Hash#update is an alias for Hash#merge!.
+  #
+  def merge!: [A, B] (*::Hash[A, B] other_hashes) -> ::Hash[A | K, B | V]
+            | [A, B, C] (*::Hash[A, B] other_hashes) { (K key, V oldval, B newval) -> (C) } -> ::Hash[A | K, B | V | C]
+
+  # Searches through the hash comparing *obj* with the value using `==`. Returns
+  # the first key-value pair (two-element array) that matches. See also
+  # Array#rassoc.
+  #
+  #     a = {1=> "one", 2 => "two", 3 => "three", "ii" => "two"}
+  #     a.rassoc("two")    #=> [2, "two"]
+  #     a.rassoc("four")   #=> nil
+  #
+  def rassoc: (V) -> [K, V]?
+
+  # Rebuilds the hash based on the current hash values for each key. If values of
+  # key objects have changed since they were inserted, this method will reindex
+  # *hsh*. If Hash#rehash is called while an iterator is traversing the hash, a
+  # RuntimeError will be raised in the iterator.
+  #
+  #     a = [ "a", "b" ]
+  #     c = [ "c", "d" ]
+  #     h = { a => 100, c => 300 }
+  #     h[a]       #=> 100
+  #     a[0] = "z"
+  #     h[a]       #=> nil
+  #     h.rehash   #=> {["z", "b"]=>100, ["c", "d"]=>300}
+  #     h[a]       #=> 100
+  #
+  def rehash: () -> self
+
+  # Returns a new hash consisting of entries for which the block returns false.
+  #
+  # If no block is given, an enumerator is returned instead.
+  #
+  #     h = { "a" => 100, "b" => 200, "c" => 300 }
+  #     h.reject {|k,v| k < "b"}  #=> {"b" => 200, "c" => 300}
+  #     h.reject {|k,v| v > 100}  #=> {"a" => 100}
+  #
+  def reject: () -> ::Enumerator[[ K, V ], self]
+            | () { (K arg0, V arg1) -> bool } -> self
+
+  # Equivalent to Hash#delete_if, but returns `nil` if no changes were made.
+  #
+  def reject!: () -> ::Enumerator[[ K, V ], self?]
+            | () { (K arg0, V arg1) -> bool } -> self?
+
+  # Replaces the contents of *hsh* with the contents of *other_hash*.
+  #
+  #     h = { "a" => 100, "b" => 200 }
+  #     h.replace({ "c" => 300, "d" => 400 })   #=> {"c"=>300, "d"=>400}
+  #
+  def replace: [A, B] (Hash[A, B] | _ToHash[A, B]) -> Hash[A, B]
+
+  # Returns a new hash consisting of entries for which the block returns true.
+  #
+  # If no block is given, an enumerator is returned instead.
+  #
+  #     h = { "a" => 100, "b" => 200, "c" => 300 }
+  #     h.select {|k,v| k > "a"}  #=> {"b" => 200, "c" => 300}
+  #     h.select {|k,v| v < 200}  #=> {"a" => 100}
+  #
+  # Hash#filter is an alias for Hash#select.
+  #
+  alias select filter
+
+  # Equivalent to Hash#keep_if, but returns `nil` if no changes were made.
+  #
+  # Hash#filter! is an alias for Hash#select!.
+  #
+  alias select! filter!
+
+  # Removes a key-value pair from *hsh* and returns it as the two-item array `[`
+  # *key, value* `]`, or the hash's default value if the hash is empty.
+  #
+  #     h = { 1 => "a", 2 => "b", 3 => "c" }
+  #     h.shift   #=> [1, "a"]
+  #     h         #=> {2=>"b", 3=>"c"}
+  #
+  def shift: () -> [ K, V ]?
+
+  # Returns the number of key-value pairs in the hash.
+  #
+  #     h = { "d" => 100, "a" => 200, "v" => 300, "e" => 400 }
+  #     h.size          #=> 4
+  #     h.delete("a")   #=> 200
+  #     h.size          #=> 3
+  #     h.length        #=> 3
+  #
+  # Hash#length is an alias for Hash#size.
+  #
+  alias size length
+
+  # Returns a hash containing only the given keys and their values.
+  #
+  #     h = { a: 100, b: 200, c: 300 }
+  #     h.slice(:a)           #=> {:a=>100}
+  #     h.slice(:b, :c, :d)   #=> {:b=>200, :c=>300}
+  #
+  def slice: (*K) -> self
+
+  # ## Element Assignment
+  #
+  # Associates the value given by `value` with the key given by `key`.
+  #
+  #     h = { "a" => 100, "b" => 200 }
+  #     h["a"] = 9
+  #     h["c"] = 4
+  #     h   #=> {"a"=>9, "b"=>200, "c"=>4}
+  #     h.store("d", 42) #=> 42
+  #     h   #=> {"a"=>9, "b"=>200, "c"=>4, "d"=>42}
+  #
+  # `key` should not have its value changed while it is in use as a key (an
+  # `unfrozen String` passed as a key will be duplicated and frozen).
+  #
+  #     a = "a"
+  #     b = "b".freeze
+  #     h = { a => 100, b => 200 }
+  #     h.key(100).equal? a #=> false
+  #     h.key(200).equal? b #=> true
+  #
+  alias store []=
+
+  # Converts *hsh* to a nested array of `[` *key, value* `]` arrays.
+  #
+  #     h = { "c" => 300, "a" => 100, "d" => 400, "c" => 300  }
+  #     h.to_a   #=> [["c", 300], ["a", 100], ["d", 400]]
+  #
+  def to_a: () -> ::Array[[ K, V ]]
+
+  # Returns `self`. If called on a subclass of Hash, converts the receiver to a
+  # Hash object.
+  #
+  # If a block is given, the results of the block on each pair of the receiver
+  # will be used as pairs.
+  #
+  def to_h: () -> Hash[K, V]
+          | [A, B] () { (K, V) -> [ A, B ] } -> Hash[A, B]
+
+  # Returns `self`.
+  #
+  def to_hash: () -> ::Hash[K, V]
+
+  # Returns a Proc which maps keys to values.
+  #
+  #     h = {a:1, b:2}
+  #     hp = h.to_proc
+  #     hp.call(:a)          #=> 1
+  #     hp.call(:b)          #=> 2
+  #     hp.call(:c)          #=> nil
+  #     [:a, :b, :c].map(&h) #=> [1, 2, nil]
+  #
+  def to_proc: () -> ^(K) -> V?
+
+  alias to_s inspect
+
+  # Returns a new hash with the results of running the block once for every key.
+  # This method does not change the values.
+  #
+  #     h = { a: 1, b: 2, c: 3 }
+  #     h.transform_keys {|k| k.to_s }  #=> { "a" => 1, "b" => 2, "c" => 3 }
+  #     h.transform_keys(&:to_s)        #=> { "a" => 1, "b" => 2, "c" => 3 }
+  #     h.transform_keys.with_index {|k, i| "#{k}.#{i}" }
+  #                                     #=> { "a.0" => 1, "b.1" => 2, "c.2" => 3 }
+  #
+  # If no block is given, an enumerator is returned instead.
+  #
+  def transform_keys: () -> Enumerator[K, Hash[untyped, V]]
+                    | [A] () { (K) -> A } -> Hash[A, V]
+
+  # Invokes the given block once for each key in *hsh*, replacing it with the new
+  # key returned by the block, and then returns *hsh*. This method does not change
+  # the values.
+  #
+  #     h = { a: 1, b: 2, c: 3 }
+  #     h.transform_keys! {|k| k.to_s }  #=> { "a" => 1, "b" => 2, "c" => 3 }
+  #     h.transform_keys!(&:to_sym)      #=> { a: 1, b: 2, c: 3 }
+  #     h.transform_keys!.with_index {|k, i| "#{k}.#{i}" }
+  #                                      #=> { "a.0" => 1, "b.1" => 2, "c.2" => 3 }
+  #
+  # If no block is given, an enumerator is returned instead.
+  #
+  def transform_keys!: () -> Enumerator[K, Hash[untyped, V]]
+                     | () { (K) -> K } -> Hash[K, V]
+
+  # Returns a new hash with the results of running the block once for every value.
+  # This method does not change the keys.
+  #
+  #     h = { a: 1, b: 2, c: 3 }
+  #     h.transform_values {|v| v * v + 1 }  #=> { a: 2, b: 5, c: 10 }
+  #     h.transform_values(&:to_s)           #=> { a: "1", b: "2", c: "3" }
+  #     h.transform_values.with_index {|v, i| "#{v}.#{i}" }
+  #                                          #=> { a: "1.0", b: "2.1", c: "3.2" }
+  #
+  # If no block is given, an enumerator is returned instead.
+  #
+  def transform_values: () -> Enumerator[K, Hash[K, untyped]]
+                      | [A] () { (V) -> A } -> Hash[K, A]
+
+  # Invokes the given block once for each value in *hsh*, replacing it with the
+  # new value returned by the block, and then returns *hsh*. This method does not
+  # change the keys.
+  #
+  #     h = { a: 1, b: 2, c: 3 }
+  #     h.transform_values! {|v| v * v + 1 }  #=> { a: 2, b: 5, c: 10 }
+  #     h.transform_values!(&:to_s)           #=> { a: "2", b: "5", c: "10" }
+  #     h.transform_values!.with_index {|v, i| "#{v}.#{i}" }
+  #                                           #=> { a: "2.0", b: "5.1", c: "10.2" }
+  #
+  # If no block is given, an enumerator is returned instead.
+  #
+  def transform_values!: () -> Enumerator[K, Hash[K, untyped]]
+                       | () { (V) -> V } -> Hash[K, V]
+
+  # Adds the contents of the given hashes to the receiver.
+  #
+  # If no block is given, entries with duplicate keys are overwritten with the
+  # values from each `other_hash` successively, otherwise the value for each
+  # duplicate key is determined by calling the block with the key, its value in
+  # the receiver and its value in each `other_hash`.
+  #
+  #     h1 = { "a" => 100, "b" => 200 }
+  #     h1.merge!          #=> {"a"=>100, "b"=>200}
+  #     h1                 #=> {"a"=>100, "b"=>200}
+  #
+  #     h1 = { "a" => 100, "b" => 200 }
+  #     h2 = { "b" => 246, "c" => 300 }
+  #     h1.merge!(h2)      #=> {"a"=>100, "b"=>246, "c"=>300}
+  #     h1                 #=> {"a"=>100, "b"=>246, "c"=>300}
+  #
+  #     h1 = { "a" => 100, "b" => 200 }
+  #     h2 = { "b" => 246, "c" => 300 }
+  #     h3 = { "b" => 357, "d" => 400 }
+  #     h1.merge!(h2, h3)
+  #                        #=> {"a"=>100, "b"=>357, "c"=>300, "d"=>400}
+  #     h1                 #=> {"a"=>100, "b"=>357, "c"=>300, "d"=>400}
+  #
+  #     h1 = { "a" => 100, "b" => 200 }
+  #     h2 = { "b" => 246, "c" => 300 }
+  #     h3 = { "b" => 357, "d" => 400 }
+  #     h1.merge!(h2, h3) {|key, v1, v2| v1 }
+  #                        #=> {"a"=>100, "b"=>200, "c"=>300, "d"=>400}
+  #     h1                 #=> {"a"=>100, "b"=>200, "c"=>300, "d"=>400}
+  #
+  # Hash#update is an alias for Hash#merge!.
+  #
+  alias update merge!
+
+  # Returns `true` if the given value is present for some key in *hsh*.
+  #
+  #     h = { "a" => 100, "b" => 200 }
+  #     h.value?(100)   #=> true
+  #     h.value?(999)   #=> false
+  #
+  alias value? has_value?
+
+  # Returns a new array populated with the values from *hsh*. See also Hash#keys.
+  #
+  #     h = { "a" => 100, "b" => 200, "c" => 300 }
+  #     h.values   #=> [100, 200, 300]
+  #
+  def values: () -> ::Array[V]
+
+  # Return an array containing the values associated with the given keys. Also see
+  # Hash.select.
+  #
+  #     h = { "cat" => "feline", "dog" => "canine", "cow" => "bovine" }
+  #     h.values_at("cow", "cat")  #=> ["bovine", "feline"]
+  #
+  def values_at: (*K arg0) -> ::Array[V?]
+
+  private
+
+  # Returns a new, empty hash. If this hash is subsequently accessed by a key that
+  # doesn't correspond to a hash entry, the value returned depends on the style of
+  # `new` used to create the hash. In the first form, the access returns `nil`. If
+  # *obj* is specified, this single object will be used for all *default values*.
+  # If a block is specified, it will be called with the hash object and the key,
+  # and should return the default value. It is the block's responsibility to store
+  # the value in the hash if required.
+  #
+  #     h = Hash.new("Go Fish")
+  #     h["a"] = 100
+  #     h["b"] = 200
+  #     h["a"]           #=> 100
+  #     h["c"]           #=> "Go Fish"
+  #     # The following alters the single default object
+  #     h["c"].upcase!   #=> "GO FISH"
+  #     h["d"]           #=> "GO FISH"
+  #     h.keys           #=> ["a", "b"]
+  #
+  #     # While this creates a new default object each time
+  #     h = Hash.new { |hash, key| hash[key] = "Go Fish: #{key}" }
+  #     h["c"]           #=> "Go Fish: c"
+  #     h["c"].upcase!   #=> "GO FISH: C"
+  #     h["d"]           #=> "Go Fish: d"
+  #     h.keys           #=> ["c", "d"]
+  #
+  incompatible def initialize: () -> void
+                             | (untyped default) -> void
+                             | [A, B] () { (Hash[A, B] hash, A key) -> B } -> void
+
+  # Replaces the contents of *hsh* with the contents of *other_hash*.
+  #
+  #     h = { "a" => 100, "b" => 200 }
+  #     h.replace({ "c" => 300, "d" => 400 })   #=> {"c"=>300, "d"=>400}
+  #
+  def initialize_copy: (self object) -> self
+end