steep 0.16.0 → 0.16.1

data/vendor/ruby-signature/stdlib/builtin/gc.rbs

@@ -1,243 +0,0 @@
-# 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/vendor/ruby-signature/stdlib/builtin/hash.rbs

@@ -1,1029 +0,0 @@
-# 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