Current File : //opt/plesk/ruby/3.2.2/lib64/ruby/gems/3.2.0/gems/rbs-2.8.2/core/hash.rbs
# <!-- rdoc-file=hash.c -->
# A Hash maps each of its unique keys to a specific value.
#
# A Hash has certain similarities to an Array, but:
# * An Array index is always an Integer.
# * A Hash key can be (almost) any object.
#
#
# ### Hash Data Syntax
#
# The older syntax for Hash data uses the "hash rocket," `=>`:
#
# h = {:foo => 0, :bar => 1, :baz => 2}
# h # => {:foo=>0, :bar=>1, :baz=>2}
#
# Alternatively, but only for a Hash key that's a Symbol, you can use a newer
# JSON-style syntax, where each bareword becomes a Symbol:
#
# h = {foo: 0, bar: 1, baz: 2}
# h # => {:foo=>0, :bar=>1, :baz=>2}
#
# You can also use a String in place of a bareword:
#
# h = {'foo': 0, 'bar': 1, 'baz': 2}
# h # => {:foo=>0, :bar=>1, :baz=>2}
#
# And you can mix the styles:
#
# h = {foo: 0, :bar => 1, 'baz': 2}
# h # => {:foo=>0, :bar=>1, :baz=>2}
#
# But it's an error to try the JSON-style syntax for a key that's not a bareword
# or a String:
#
# # Raises SyntaxError (syntax error, unexpected ':', expecting =>):
# h = {0: 'zero'}
#
# Hash value can be omitted, meaning that value will be fetched from the context
# by the name of the key:
#
# x = 0
# y = 100
# h = {x:, y:}
# h # => {:x=>0, :y=>100}
#
# ### Common Uses
#
# You can use a Hash to give names to objects:
#
# person = {name: 'Matz', language: 'Ruby'}
# person # => {:name=>"Matz", :language=>"Ruby"}
#
# You can use a Hash to give names to method arguments:
#
# def some_method(hash)
# p hash
# end
# some_method({foo: 0, bar: 1, baz: 2}) # => {:foo=>0, :bar=>1, :baz=>2}
#
# Note: when the last argument in a method call is a Hash, the curly braces may
# be omitted:
#
# some_method(foo: 0, bar: 1, baz: 2) # => {:foo=>0, :bar=>1, :baz=>2}
#
# You can use a Hash to initialize an object:
#
# class Dev
# attr_accessor :name, :language
# def initialize(hash)
# self.name = hash[:name]
# self.language = hash[:language]
# end
# end
# matz = Dev.new(name: 'Matz', language: 'Ruby')
# matz # => #<Dev: @name="Matz", @language="Ruby">
#
# ### Creating a Hash
#
# You can create a Hash object explicitly with:
#
# * A [hash literal](doc/syntax/literals_rdoc.html#label-Hash+Literals).
#
#
# You can convert certain objects to Hashes with:
#
# * Method [Hash](Kernel.html#method-i-Hash).
#
#
# You can create a Hash by calling method Hash.new.
#
# Create an empty Hash:
#
# h = Hash.new
# h # => {}
# h.class # => Hash
#
# You can create a Hash by calling method Hash.[].
#
# Create an empty Hash:
#
# h = Hash[]
# h # => {}
#
# Create a Hash with initial entries:
#
# h = Hash[foo: 0, bar: 1, baz: 2]
# h # => {:foo=>0, :bar=>1, :baz=>2}
#
# You can create a Hash by using its literal form (curly braces).
#
# Create an empty Hash:
#
# h = {}
# h # => {}
#
# Create a Hash with initial entries:
#
# h = {foo: 0, bar: 1, baz: 2}
# h # => {:foo=>0, :bar=>1, :baz=>2}
#
# ### Hash Value Basics
#
# The simplest way to retrieve a Hash value (instance method #[]):
#
# h = {foo: 0, bar: 1, baz: 2}
# h[:foo] # => 0
#
# The simplest way to create or update a Hash value (instance method #[]=):
#
# h = {foo: 0, bar: 1, baz: 2}
# h[:bat] = 3 # => 3
# h # => {:foo=>0, :bar=>1, :baz=>2, :bat=>3}
# h[:foo] = 4 # => 4
# h # => {:foo=>4, :bar=>1, :baz=>2, :bat=>3}
#
# The simplest way to delete a Hash entry (instance method #delete):
#
# h = {foo: 0, bar: 1, baz: 2}
# h.delete(:bar) # => 1
# h # => {:foo=>0, :baz=>2}
#
# ### Entry Order
#
# A Hash object presents its entries in the order of their creation. This is
# seen in:
#
# * Iterative methods such as `each`, `each_key`, `each_pair`, `each_value`.
# * Other order-sensitive methods such as `shift`, `keys`, `values`.
# * The String returned by method `inspect`.
#
#
# A new Hash has its initial ordering per the given entries:
#
# h = Hash[foo: 0, bar: 1]
# h # => {:foo=>0, :bar=>1}
#
# New entries are added at the end:
#
# h[:baz] = 2
# h # => {:foo=>0, :bar=>1, :baz=>2}
#
# Updating a value does not affect the order:
#
# h[:baz] = 3
# h # => {:foo=>0, :bar=>1, :baz=>3}
#
# But re-creating a deleted entry can affect the order:
#
# h.delete(:foo)
# h[:foo] = 5
# h # => {:bar=>1, :baz=>3, :foo=>5}
#
# ### Hash Keys
#
# #### Hash Key Equivalence
#
# Two objects are treated as the same hash key when their `hash` value is
# identical and the two objects are `eql?` to each other.
#
# #### Modifying an Active Hash Key
#
# Modifying a Hash key while it is in use damages the hash's index.
#
# This Hash has keys that are Arrays:
#
# a0 = [ :foo, :bar ]
# a1 = [ :baz, :bat ]
# h = {a0 => 0, a1 => 1}
# h.include?(a0) # => true
# h[a0] # => 0
# a0.hash # => 110002110
#
# Modifying array element `a0[0]` changes its hash value:
#
# a0[0] = :bam
# a0.hash # => 1069447059
#
# And damages the Hash index:
#
# h.include?(a0) # => false
# h[a0] # => nil
#
# You can repair the hash index using method `rehash`:
#
# h.rehash # => {[:bam, :bar]=>0, [:baz, :bat]=>1}
# h.include?(a0) # => true
# h[a0] # => 0
#
# A String key is always safe. That's because an unfrozen String passed as a key
# will be replaced by a duplicated and frozen String:
#
# s = 'foo'
# s.frozen? # => false
# h = {s => 0}
# first_key = h.keys.first
# first_key.frozen? # => true
#
# #### User-Defined Hash Keys
#
# To be useable as a Hash key, objects must implement the methods `hash` and
# `eql?`. Note: this requirement does not apply if the Hash uses
# #compare_by_identity since comparison will then rely on the keys' object id
# instead of `hash` and `eql?`.
#
# Object defines basic implementation for `hash` and `eq?` that makes each
# object a distinct key. Typically, user-defined classes will want to override
# these methods to provide meaningful behavior, or for example inherit Struct
# that has useful definitions for these.
#
# 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 &&
# other.author == @author &&
# 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
#
# ### Default Values
#
# The methods #[], #values_at and #dig need to return the value associated to a
# certain key. When that key is not found, that value will be determined by its
# default proc (if any) or else its default (initially `nil`).
#
# You can retrieve the default value with method #default:
#
# h = Hash.new
# h.default # => nil
#
# You can set the default value by passing an argument to method Hash.new or
# with method #default=
#
# h = Hash.new(-1)
# h.default # => -1
# h.default = 0
# h.default # => 0
#
# This default value is returned for #[], #values_at and #dig when a key is not
# found:
#
# counts = {foo: 42}
# counts.default # => nil (default)
# counts[:foo] = 42
# counts[:bar] # => nil
# counts.default = 0
# counts[:bar] # => 0
# counts.values_at(:foo, :bar, :baz) # => [42, 0, 0]
# counts.dig(:bar) # => 0
#
# Note that the default value is used without being duplicated. It is not
# advised to set the default value to a mutable object:
#
# synonyms = Hash.new([])
# synonyms[:hello] # => []
# synonyms[:hello] << :hi # => [:hi], but this mutates the default!
# synonyms.default # => [:hi]
# synonyms[:world] << :universe
# synonyms[:world] # => [:hi, :universe], oops
# synonyms.keys # => [], oops
#
# To use a mutable object as default, it is recommended to use a default proc
#
# #### Default Proc
#
# When the default proc for a Hash is set (i.e., not `nil`), the default value
# returned by method #[] is determined by the default proc alone.
#
# You can retrieve the default proc with method #default_proc:
#
# h = Hash.new
# h.default_proc # => nil
#
# You can set the default proc by calling Hash.new with a block or calling the
# method #default_proc=
#
# h = Hash.new { |hash, key| "Default value for #{key}" }
# h.default_proc.class # => Proc
# h.default_proc = proc { |hash, key| "Default value for #{key.inspect}" }
# h.default_proc.class # => Proc
#
# When the default proc is set (i.e., not `nil`) and method #[] is called with
# with a non-existent key, #[] calls the default proc with both the Hash object
# itself and the missing key, then returns the proc's return value:
#
# h = Hash.new { |hash, key| "Default value for #{key}" }
# h[:nosuch] # => "Default value for nosuch"
#
# Note that in the example above no entry for key `:nosuch` is created:
#
# h.include?(:nosuch) # => false
#
# However, the proc itself can add a new entry:
#
# synonyms = Hash.new { |hash, key| hash[key] = [] }
# synonyms.include?(:hello) # => false
# synonyms[:hello] << :hi # => [:hi]
# synonyms[:world] << :universe # => [:universe]
# synonyms.keys # => [:hello, :world]
#
# Note that setting the default proc will clear the default value and vice
# versa.
#
# ### What's Here
#
# First, what's elsewhere. Class Hash:
#
# * Inherits from [class
# Object](Object.html#class-Object-label-What-27s+Here).
# * Includes [module
# Enumerable](Enumerable.html#module-Enumerable-label-What-27s+Here), which
# provides dozens of additional methods.
#
#
# Here, class Hash provides methods that are useful for:
#
# * [Creating a Hash](#class-Hash-label-Methods+for+Creating+a+Hash)
# * [Setting Hash State](#class-Hash-label-Methods+for+Setting+Hash+State)
# * [Querying](#class-Hash-label-Methods+for+Querying)
# * [Comparing](#class-Hash-label-Methods+for+Comparing)
# * [Fetching](#class-Hash-label-Methods+for+Fetching)
# * [Assigning](#class-Hash-label-Methods+for+Assigning)
# * [Deleting](#class-Hash-label-Methods+for+Deleting)
# * [Iterating](#class-Hash-label-Methods+for+Iterating)
# * [Converting](#class-Hash-label-Methods+for+Converting)
# * [Transforming Keys and
# Values](#class-Hash-label-Methods+for+Transforming+Keys+and+Values)
# * [And more....](#class-Hash-label-Other+Methods)
#
#
# Class Hash also includes methods from module Enumerable.
#
# #### Methods for Creating a Hash
#
# ::[]
# : Returns a new hash populated with given objects.
# ::new
# : Returns a new empty hash.
# ::try_convert
# : Returns a new hash created from a given object.
#
#
# #### Methods for Setting Hash State
#
# #compare_by_identity
# : Sets `self` to consider only identity in comparing keys.
# #default=
# : Sets the default to a given value.
# #default_proc=
# : Sets the default proc to a given proc.
# #rehash
# : Rebuilds the hash table by recomputing the hash index for each key.
#
#
# #### Methods for Querying
#
# #any?
# : Returns whether any element satisfies a given criterion.
# #compare_by_identity?
# : Returns whether the hash considers only identity when comparing keys.
# #default
# : Returns the default value, or the default value for a given key.
# #default_proc
# : Returns the default proc.
# #empty?
# : Returns whether there are no entries.
# #eql?
# : Returns whether a given object is equal to `self`.
# #hash
# : Returns the integer hash code.
# #has_value?
# : Returns whether a given object is a value in `self`.
# #include?, #has_key?, #member?, #key?
# : Returns whether a given object is a key in `self`.
# #length, #size
# : Returns the count of entries.
# #value?
# : Returns whether a given object is a value in `self`.
#
#
# #### Methods for Comparing
#
# [#<](#method-i-3C)
# : Returns whether `self` is a proper subset of a given object.
# [#<=](#method-i-3C-3D)
# : Returns whether `self` is a subset of a given object.
# [#==](#method-i-3D-3D)
# : Returns whether a given object is equal to `self`.
# [#>](#method-i-3E)
# : Returns whether `self` is a proper superset of a given object
# [#>=](#method-i-3E-3D)
# : Returns whether `self` is a proper superset of a given object.
#
#
# #### Methods for Fetching
#
# #[]
# : Returns the value associated with a given key.
# #assoc
# : Returns a 2-element array containing a given key and its value.
# #dig
# : Returns the object in nested objects that is specified by a given key and
# additional arguments.
# #fetch
# : Returns the value for a given key.
# #fetch_values
# : Returns array containing the values associated with given keys.
# #key
# : Returns the key for the first-found entry with a given value.
# #keys
# : Returns an array containing all keys in `self`.
# #rassoc
# : Returns a 2-element array consisting of the key and value of the
# first-found entry having a given value.
# #values
# : Returns an array containing all values in `self`/
# #values_at
# : Returns an array containing values for given keys.
#
#
# #### Methods for Assigning
#
# #[]=, #store
# : Associates a given key with a given value.
# #merge
# : Returns the hash formed by merging each given hash into a copy of `self`.
# #merge!, #update
# : Merges each given hash into `self`.
# #replace
# : Replaces the entire contents of `self` with the contents of a givan hash.
#
#
# #### Methods for Deleting
#
# These methods remove entries from `self`:
#
# #clear
# : Removes all entries from `self`.
# #compact!
# : Removes all `nil`-valued entries from `self`.
# #delete
# : Removes the entry for a given key.
# #delete_if
# : Removes entries selected by a given block.
# #filter!, #select!
# : Keep only those entries selected by a given block.
# #keep_if
# : Keep only those entries selected by a given block.
# #reject!
# : Removes entries selected by a given block.
# #shift
# : Removes and returns the first entry.
#
#
# These methods return a copy of `self` with some entries removed:
#
# #compact
# : Returns a copy of `self` with all `nil`-valued entries removed.
# #except
# : Returns a copy of `self` with entries removed for specified keys.
# #filter, #select
# : Returns a copy of `self` with only those entries selected by a given
# block.
# #reject
# : Returns a copy of `self` with entries removed as specified by a given
# block.
# #slice
# : Returns a hash containing the entries for given keys.
#
#
# #### Methods for Iterating
# #each, #each_pair
# : Calls a given block with each key-value pair.
# #each_key
# : Calls a given block with each key.
# #each_value
# : Calls a given block with each value.
#
#
# #### Methods for Converting
#
# #inspect, #to_s
# : Returns a new String containing the hash entries.
# #to_a
# : Returns a new array of 2-element arrays; each nested array contains a
# key-value pair from `self`.
# #to_h
# : Returns `self` if a Hash; if a subclass of Hash, returns a Hash containing
# the entries from `self`.
# #to_hash
# : Returns `self`.
# #to_proc
# : Returns a proc that maps a given key to its value.
#
#
# #### Methods for Transforming Keys and Values
#
# #transform_keys
# : Returns a copy of `self` with modified keys.
# #transform_keys!
# : Modifies keys in `self`
# #transform_values
# : Returns a copy of `self` with modified values.
# #transform_values!
# : Modifies values in `self`.
#
#
# #### Other Methods
# #flatten
# : Returns an array that is a 1-dimensional flattening of `self`.
# #invert
# : Returns a hash with the each key-value pair inverted.
#
class Hash[unchecked out K, unchecked out V] < Object
include Enumerable[[ K, V ]]
# <!--
# rdoc-file=hash.c
# - Hash[] -> new_empty_hash
# - Hash[hash] -> new_hash
# - Hash[ [*2_element_arrays] ] -> new_hash
# - Hash[*objects] -> new_hash
# -->
# Returns a new Hash object populated with the given objects, if any. See
# Hash::new.
#
# With no argument, returns a new empty Hash.
#
# When the single given argument is a Hash, returns a new Hash populated with
# the entries from the given Hash, excluding the default value or proc.
#
# h = {foo: 0, bar: 1, baz: 2}
# Hash[h] # => {:foo=>0, :bar=>1, :baz=>2}
#
# When the single given argument is an Array of 2-element Arrays, returns a new
# Hash object wherein each 2-element array forms a key-value entry:
#
# Hash[ [ [:foo, 0], [:bar, 1] ] ] # => {:foo=>0, :bar=>1}
#
# When the argument count is an even number; returns a new Hash object wherein
# each successive pair of arguments has become a key-value entry:
#
# Hash[:foo, 0, :bar, 1] # => {:foo=>0, :bar=>1}
#
# Raises an exception if the argument list does not conform to any of the above.
#
def self.[]: [U, V] (_ToHash[U, V]) -> ::Hash[U, V]
| [U, V] (Array[[ U, V ]]) -> ::Hash[U, V]
| (*untyped) -> ::Hash[untyped, untyped]
# <!--
# rdoc-file=hash.c
# - Hash.try_convert(obj) -> obj, new_hash, or nil
# -->
# If `obj` is a Hash object, returns `obj`.
#
# Otherwise if `obj` responds to `:to_hash`, calls `obj.to_hash` and returns the
# result.
#
# Returns `nil` if `obj` does not respond to `:to_hash`
#
# Raises an exception unless `obj.to_hash` returns a Hash object.
#
def self.try_convert: [U, V] (_ToHash[U, V]) -> ::Hash[U, V]
| (untyped) -> (::Hash[untyped, untyped] | nil)
public
# <!--
# rdoc-file=hash.c
# - hash < other_hash -> true or false
# -->
# Returns `true` if `hash` is a proper subset of `other_hash`, `false`
# otherwise:
# h1 = {foo: 0, bar: 1}
# h2 = {foo: 0, bar: 1, baz: 2}
# h1 < h2 # => true
# h2 < h1 # => false
# h1 < h1 # => false
#
def <: [A, B] (::Hash[A, B]) -> bool
# <!--
# rdoc-file=hash.c
# - hash <= other_hash -> true or false
# -->
# Returns `true` if `hash` is a subset of `other_hash`, `false` otherwise:
# h1 = {foo: 0, bar: 1}
# h2 = {foo: 0, bar: 1, baz: 2}
# h1 <= h2 # => true
# h2 <= h1 # => false
# h1 <= h1 # => true
#
def <=: [A, B] (::Hash[A, B]) -> bool
# <!--
# rdoc-file=hash.c
# - hash == object -> true or false
# -->
# Returns `true` if all of the following are true:
# * `object` is a Hash object.
# * `hash` and `object` have the same keys (regardless of order).
# * For each key `key`, `hash[key] == object[key]`.
#
#
# Otherwise, returns `false`.
#
# Equal:
# h1 = {foo: 0, bar: 1, baz: 2}
# h2 = {foo: 0, bar: 1, baz: 2}
# h1 == h2 # => true
# h3 = {baz: 2, bar: 1, foo: 0}
# h1 == h3 # => true
#
def ==: (untyped other) -> bool
# <!--
# rdoc-file=hash.c
# - hash > other_hash -> true or false
# -->
# Returns `true` if `hash` is a proper superset of `other_hash`, `false`
# otherwise:
# h1 = {foo: 0, bar: 1, baz: 2}
# h2 = {foo: 0, bar: 1}
# h1 > h2 # => true
# h2 > h1 # => false
# h1 > h1 # => false
#
def >: [A, B] (::Hash[A, B]) -> bool
# <!--
# rdoc-file=hash.c
# - hash >= other_hash -> true or false
# -->
# Returns `true` if `hash` is a superset of `other_hash`, `false` otherwise:
# h1 = {foo: 0, bar: 1, baz: 2}
# h2 = {foo: 0, bar: 1}
# h1 >= h2 # => true
# h2 >= h1 # => false
# h1 >= h1 # => true
#
def >=: [A, B] (::Hash[A, B]) -> bool
# <!--
# rdoc-file=hash.c
# - hash[key] -> value
# -->
# Returns the value associated with the given `key`, if found:
# h = {foo: 0, bar: 1, baz: 2}
# h[:foo] # => 0
#
# If `key` is not found, returns a default value (see [Default
# Values](#class-Hash-label-Default+Values)):
# h = {foo: 0, bar: 1, baz: 2}
# h[:nosuch] # => nil
#
def []: (K arg0) -> V
# <!--
# rdoc-file=hash.c
# - hash[key] = value -> value
# - hash.store(key, value)
# -->
# Hash#store is an alias for Hash#[]=.
#
# Associates the given `value` with the given `key`; returns `value`.
#
# If the given `key` exists, replaces its value with the given `value`; the
# ordering is not affected (see [Entry Order](#class-Hash-label-Entry+Order)):
# h = {foo: 0, bar: 1}
# h[:foo] = 2 # => 2
# h.store(:bar, 3) # => 3
# h # => {:foo=>2, :bar=>3}
#
# If `key` does not exist, adds the `key` and `value`; the new entry is last in
# the order (see [Entry Order](#class-Hash-label-Entry+Order)):
# h = {foo: 0, bar: 1}
# h[:baz] = 2 # => 2
# h.store(:bat, 3) # => 3
# h # => {:foo=>0, :bar=>1, :baz=>2, :bat=>3}
#
def []=: (K arg0, V arg1) -> V
# <!--
# rdoc-file=hash.c
# - hash.any? -> true or false
# - hash.any?(object) -> true or false
# - hash.any? {|key, value| ... } -> true or false
# -->
# Returns `true` if any element satisfies a given criterion; `false` otherwise.
#
# With no argument and no block, returns `true` if `self` is non-empty; `false`
# if empty.
#
# With argument `object` and no block, returns `true` if for any key `key`
# `h.assoc(key) == object`:
# h = {foo: 0, bar: 1, baz: 2}
# h.any?([:bar, 1]) # => true
# h.any?([:bar, 0]) # => false
# h.any?([:baz, 1]) # => false
#
# With no argument and a block, calls the block with each key-value pair;
# returns `true` if the block returns any truthy value, `false` otherwise:
# h = {foo: 0, bar: 1, baz: 2}
# h.any? {|key, value| value < 3 } # => true
# h.any? {|key, value| value > 3 } # => false
#
def any?: () -> bool
| (untyped pattern) -> bool
| () { (K, V) -> boolish } -> bool
# <!--
# rdoc-file=hash.c
# - hash.assoc(key) -> new_array or nil
# -->
# If the given `key` is found, returns a 2-element Array containing that key and
# its value:
# h = {foo: 0, bar: 1, baz: 2}
# h.assoc(:bar) # => [:bar, 1]
#
# Returns `nil` if key `key` is not found.
#
def assoc: (K arg0) -> [ K, V ]?
# <!--
# rdoc-file=hash.c
# - hash.clear -> self
# -->
# Removes all hash entries; returns `self`.
#
def clear: () -> self
# <!--
# rdoc-file=hash.c
# - hash.compact -> new_hash
# -->
# Returns a copy of `self` with all `nil`-valued entries removed:
# h = {foo: 0, bar: nil, baz: 2, bat: nil}
# h1 = h.compact
# h1 # => {:foo=>0, :baz=>2}
#
def compact: () -> ::Hash[K, V]
# <!--
# rdoc-file=hash.c
# - hash.compact! -> self or nil
# -->
# Returns `self` with all its `nil`-valued entries removed (in place):
# h = {foo: 0, bar: nil, baz: 2, bat: nil}
# h.compact! # => {:foo=>0, :baz=>2}
#
# Returns `nil` if no entries were removed.
#
def compact!: () -> self?
# <!--
# rdoc-file=hash.c
# - hash.compare_by_identity -> self
# -->
# Sets `self` to consider only identity in comparing keys; two keys are
# considered the same only if they are the same object; returns `self`.
#
# By default, these two object are considered to be the same key, so `s1` will
# overwrite `s0`:
# s0 = 'x'
# s1 = 'x'
# h = {}
# h.compare_by_identity? # => false
# h[s0] = 0
# h[s1] = 1
# h # => {"x"=>1}
#
# After calling #compare_by_identity, the keys are considered to be different,
# and therefore do not overwrite each other:
# h = {}
# h.compare_by_identity # => {}
# h.compare_by_identity? # => true
# h[s0] = 0
# h[s1] = 1
# h # => {"x"=>0, "x"=>1}
#
def compare_by_identity: () -> self
# <!--
# rdoc-file=hash.c
# - hash.compare_by_identity? -> true or false
# -->
# Returns `true` if #compare_by_identity has been called, `false` otherwise.
#
def compare_by_identity?: () -> bool
# <!--
# rdoc-file=hash.c
# - deconstruct_keys(p1)
# -->
#
def deconstruct_keys: (Array[K] | nil) -> self
# <!--
# rdoc-file=hash.c
# - hash.default -> object
# - hash.default(key) -> object
# -->
# Returns the default value for the given `key`. The returned value will be
# determined either by the default proc or by the default value. See [Default
# Values](#class-Hash-label-Default+Values).
#
# With no argument, returns the current default value:
# h = {}
# h.default # => nil
#
# If `key` is given, returns the default value for `key`, regardless of whether
# that key exists:
# h = Hash.new { |hash, key| hash[key] = "No key #{key}"}
# h[:foo] = "Hello"
# h.default(:foo) # => "No key foo"
#
def default: (?K arg0) -> V?
# <!--
# rdoc-file=hash.c
# - hash.default = value -> object
# -->
# Sets the default value to `value`; returns `value`:
# h = {}
# h.default # => nil
# h.default = false # => false
# h.default # => false
#
# See [Default Values](#class-Hash-label-Default+Values).
#
def default=: (V arg0) -> V
# <!--
# rdoc-file=hash.c
# - hash.default_proc -> proc or nil
# -->
# Returns the default proc for `self` (see [Default
# Values](#class-Hash-label-Default+Values)):
# h = {}
# h.default_proc # => nil
# h.default_proc = proc {|hash, key| "Default value for #{key}" }
# h.default_proc.class # => Proc
#
def default_proc: () -> (Proc | nil)
# <!--
# rdoc-file=hash.c
# - hash.default_proc = proc -> proc
# -->
# Sets the default proc for `self` to `proc`: (see [Default
# Values](#class-Hash-label-Default+Values)):
# h = {}
# h.default_proc # => nil
# h.default_proc = proc { |hash, key| "Default value for #{key}" }
# h.default_proc.class # => Proc
# h.default_proc = nil
# h.default_proc # => nil
#
def default_proc=: (Proc | _ToProc | nil) -> (Proc | _ToProc | nil)
# <!--
# rdoc-file=hash.c
# - hash.delete(key) -> value or nil
# - hash.delete(key) {|key| ... } -> object
# -->
# Deletes the entry for the given `key` and returns its associated value.
#
# If no block is given and `key` is found, deletes the entry and returns the
# associated value:
# h = {foo: 0, bar: 1, baz: 2}
# h.delete(:bar) # => 1
# h # => {:foo=>0, :baz=>2}
#
# If no block given and `key` is not found, returns `nil`.
#
# If a block is given and `key` is found, ignores the block, deletes the entry,
# and returns the associated value:
# h = {foo: 0, bar: 1, baz: 2}
# h.delete(:baz) { |key| raise 'Will never happen'} # => 2
# h # => {:foo=>0, :bar=>1}
#
# If a block is given and `key` is not found, calls the block and returns the
# block's return value:
# h = {foo: 0, bar: 1, baz: 2}
# h.delete(:nosuch) { |key| "Key #{key} not found" } # => "Key nosuch not found"
# h # => {:foo=>0, :bar=>1, :baz=>2}
#
def delete: (K arg0) -> V?
| [U] (K arg0) { (K arg0) -> U } -> (U | V)
# <!--
# rdoc-file=hash.c
# - hash.delete_if {|key, value| ... } -> self
# - hash.delete_if -> new_enumerator
# -->
# If a block given, calls the block with each key-value pair; deletes each entry
# for which the block returns a truthy value; returns `self`:
# h = {foo: 0, bar: 1, baz: 2}
# h.delete_if {|key, value| value > 0 } # => {:foo=>0}
#
# If no block given, returns a new Enumerator:
# h = {foo: 0, bar: 1, baz: 2}
# e = h.delete_if # => #<Enumerator: {:foo=>0, :bar=>1, :baz=>2}:delete_if>
# e.each { |key, value| value > 0 } # => {:foo=>0}
#
def delete_if: () { (K, V) -> boolish } -> self
| () -> ::Enumerator[[ K, V ], self]
# <!--
# rdoc-file=hash.c
# - hash.dig(key, *identifiers) -> object
# -->
# Finds and returns the object in nested objects that is specified by `key` and
# `identifiers`. The nested objects may be instances of various classes. See
# [Dig Methods](rdoc-ref:dig_methods.rdoc).
#
# Nested Hashes:
# h = {foo: {bar: {baz: 2}}}
# h.dig(:foo) # => {:bar=>{:baz=>2}}
# h.dig(:foo, :bar) # => {:baz=>2}
# h.dig(:foo, :bar, :baz) # => 2
# h.dig(:foo, :bar, :BAZ) # => nil
#
# Nested Hashes and Arrays:
# h = {foo: {bar: [:a, :b, :c]}}
# h.dig(:foo, :bar, 2) # => :c
#
# This method will use the [default values](#class-Hash-label-Default+Values)
# for keys that are not present:
# h = {foo: {bar: [:a, :b, :c]}}
# h.dig(:hello) # => nil
# h.default_proc = -> (hash, _key) { hash }
# h.dig(:hello, :world) # => h
# h.dig(:hello, :world, :foo, :bar, 2) # => :c
#
def dig: (K, *untyped) -> untyped
# <!-- rdoc-file=hash.c -->
# Hash#each is an alias for Hash#each_pair.
#
# Calls the given block with each key-value pair; returns `self`:
# h = {foo: 0, bar: 1, baz: 2}
# h.each_pair {|key, value| puts "#{key}: #{value}"} # => {:foo=>0, :bar=>1, :baz=>2}
#
# Output:
# foo: 0
# bar: 1
# baz: 2
#
# Returns a new Enumerator if no block given:
# h = {foo: 0, bar: 1, baz: 2}
# e = h.each_pair # => #<Enumerator: {:foo=>0, :bar=>1, :baz=>2}:each_pair>
# h1 = e.each {|key, value| puts "#{key}: #{value}"}
# h1 # => {:foo=>0, :bar=>1, :baz=>2}
#
# Output:
# foo: 0
# bar: 1
# baz: 2
#
def each: () { ([ K, V ] arg0) -> untyped } -> self
| () -> ::Enumerator[[ K, V ], self]
# <!--
# rdoc-file=hash.c
# - hash.each_key {|key| ... } -> self
# - hash.each_key -> new_enumerator
# -->
# Calls the given block with each key; returns `self`:
# h = {foo: 0, bar: 1, baz: 2}
# h.each_key {|key| puts key } # => {:foo=>0, :bar=>1, :baz=>2}
#
# Output:
# foo
# bar
# baz
#
# Returns a new Enumerator if no block given:
# h = {foo: 0, bar: 1, baz: 2}
# e = h.each_key # => #<Enumerator: {:foo=>0, :bar=>1, :baz=>2}:each_key>
# h1 = e.each {|key| puts key }
# h1 # => {:foo=>0, :bar=>1, :baz=>2}
#
# Output:
# foo
# bar
# baz
#
def each_key: () { (K arg0) -> untyped } -> ::Hash[K, V]
| () -> ::Enumerator[K, self]
# <!--
# rdoc-file=hash.c
# - hash.each {|key, value| ... } -> self
# - hash.each_pair {|key, value| ... } -> self
# - hash.each -> new_enumerator
# - hash.each_pair -> new_enumerator
# -->
# Hash#each is an alias for Hash#each_pair.
#
# Calls the given block with each key-value pair; returns `self`:
# h = {foo: 0, bar: 1, baz: 2}
# h.each_pair {|key, value| puts "#{key}: #{value}"} # => {:foo=>0, :bar=>1, :baz=>2}
#
# Output:
# foo: 0
# bar: 1
# baz: 2
#
# Returns a new Enumerator if no block given:
# h = {foo: 0, bar: 1, baz: 2}
# e = h.each_pair # => #<Enumerator: {:foo=>0, :bar=>1, :baz=>2}:each_pair>
# h1 = e.each {|key, value| puts "#{key}: #{value}"}
# h1 # => {:foo=>0, :bar=>1, :baz=>2}
#
# Output:
# foo: 0
# bar: 1
# baz: 2
#
alias each_pair each
# <!--
# rdoc-file=hash.c
# - hash.each_value {|value| ... } -> self
# - hash.each_value -> new_enumerator
# -->
# Calls the given block with each value; returns `self`:
# h = {foo: 0, bar: 1, baz: 2}
# h.each_value {|value| puts value } # => {:foo=>0, :bar=>1, :baz=>2}
#
# Output:
# 0
# 1
# 2
#
# Returns a new Enumerator if no block given:
# h = {foo: 0, bar: 1, baz: 2}
# e = h.each_value # => #<Enumerator: {:foo=>0, :bar=>1, :baz=>2}:each_value>
# h1 = e.each {|value| puts value }
# h1 # => {:foo=>0, :bar=>1, :baz=>2}
#
# Output:
# 0
# 1
# 2
#
def each_value: () { (V arg0) -> untyped } -> self
| () -> ::Enumerator[V, self]
# <!--
# rdoc-file=hash.c
# - hash.empty? -> true or false
# -->
# Returns `true` if there are no hash entries, `false` otherwise:
# {}.empty? # => true
# {foo: 0, bar: 1, baz: 2}.empty? # => false
#
def empty?: () -> bool
# <!--
# rdoc-file=hash.c
# - hash.eql? object -> true or false
# -->
# Returns `true` if all of the following are true:
# * `object` is a Hash object.
# * `hash` and `object` have the same keys (regardless of order).
# * For each key `key`, `h[key] eql? object[key]`.
#
#
# Otherwise, returns `false`.
#
# Equal:
# h1 = {foo: 0, bar: 1, baz: 2}
# h2 = {foo: 0, bar: 1, baz: 2}
# h1.eql? h2 # => true
# h3 = {baz: 2, bar: 1, foo: 0}
# h1.eql? h3 # => true
#
def eql?: (untyped) -> bool
# <!--
# rdoc-file=hash.c
# - hsh.except(*keys) -> a_hash
# -->
# Returns a new Hash excluding entries for the given `keys`:
# h = { a: 100, b: 200, c: 300 }
# h.except(:a) #=> {:b=>200, :c=>300}
#
# Any given `keys` that are not found are ignored.
#
def except: (*K) -> ::Hash[K, V]
# <!--
# rdoc-file=hash.c
# - hash.fetch(key) -> object
# - hash.fetch(key, default_value) -> object
# - hash.fetch(key) {|key| ... } -> object
# -->
# Returns the value for the given `key`, if found.
# h = {foo: 0, bar: 1, baz: 2}
# h.fetch(:bar) # => 1
#
# If `key` is not found and no block was given, returns `default_value`:
# {}.fetch(:nosuch, :default) # => :default
#
# If `key` is not found and a block was given, yields `key` to the block and
# returns the block's return value:
# {}.fetch(:nosuch) {|key| "No key #{key}"} # => "No key nosuch"
#
# Raises KeyError if neither `default_value` nor a block was given.
#
# Note that this method does not use the values of either #default or
# #default_proc.
#
def fetch: (K arg0) -> V
| [X] (K arg0, X arg1) -> (V | X)
| [X] (K arg0) { (K arg0) -> X } -> (V | X)
# <!--
# rdoc-file=hash.c
# - hash.fetch_values(*keys) -> new_array
# - hash.fetch_values(*keys) {|key| ... } -> new_array
# -->
# Returns a new Array containing the values associated with the given keys
# *keys:
# h = {foo: 0, bar: 1, baz: 2}
# h.fetch_values(:baz, :foo) # => [2, 0]
#
# Returns a new empty Array if no arguments given.
#
# When a block is given, calls the block with each missing key, treating the
# block's return value as the value for that key:
# h = {foo: 0, bar: 1, baz: 2}
# values = h.fetch_values(:bar, :foo, :bad, :bam) {|key| key.to_s}
# values # => [1, 0, "bad", "bam"]
#
# When no block is given, raises an exception if any given key is not found.
#
def fetch_values: (*K) -> ::Array[V]
| [X] (*K) { (K) -> X } -> ::Array[V | X]
# <!-- rdoc-file=hash.c -->
# Hash#filter is an alias for Hash#select.
#
# Returns a new Hash object whose entries are those for which the block returns
# a truthy value:
# h = {foo: 0, bar: 1, baz: 2}
# h.select {|key, value| value < 2 } # => {:foo=>0, :bar=>1}
#
# Returns a new Enumerator if no block given:
# h = {foo: 0, bar: 1, baz: 2}
# e = h.select # => #<Enumerator: {:foo=>0, :bar=>1, :baz=>2}:select>
# e.each {|key, value| value < 2 } # => {:foo=>0, :bar=>1}
#
def filter: () { (K, V) -> boolish } -> ::Hash[K, V]
| () -> ::Enumerator[[ K, V ], ::Hash[K, V]]
# <!-- rdoc-file=hash.c -->
# Hash#filter! is an alias for Hash#select!.
#
# Returns `self`, whose entries are those for which the block returns a truthy
# value:
# h = {foo: 0, bar: 1, baz: 2}
# h.select! {|key, value| value < 2 } => {:foo=>0, :bar=>1}
#
# Returns `nil` if no entries were removed.
#
# Returns a new Enumerator if no block given:
# h = {foo: 0, bar: 1, baz: 2}
# e = h.select! # => #<Enumerator: {:foo=>0, :bar=>1, :baz=>2}:select!>
# e.each { |key, value| value < 2 } # => {:foo=>0, :bar=>1}
#
def filter!: () { (K, V) -> boolish } -> self?
| () -> ::Enumerator[[ K, V ], self?]
# <!--
# rdoc-file=hash.c
# - hash.flatten -> new_array
# - hash.flatten(level) -> new_array
# -->
# Returns a new Array object that is a 1-dimensional flattening of `self`.
#
# ---
#
# By default, nested Arrays are not flattened:
# h = {foo: 0, bar: [:bat, 3], baz: 2}
# h.flatten # => [:foo, 0, :bar, [:bat, 3], :baz, 2]
#
# Takes the depth of recursive flattening from Integer argument `level`:
# h = {foo: 0, bar: [:bat, [:baz, [:bat, ]]]}
# h.flatten(1) # => [:foo, 0, :bar, [:bat, [:baz, [:bat]]]]
# h.flatten(2) # => [:foo, 0, :bar, :bat, [:baz, [:bat]]]
# h.flatten(3) # => [:foo, 0, :bar, :bat, :baz, [:bat]]
# h.flatten(4) # => [:foo, 0, :bar, :bat, :baz, :bat]
#
# When `level` is negative, flattens all nested Arrays:
# h = {foo: 0, bar: [:bat, [:baz, [:bat, ]]]}
# h.flatten(-1) # => [:foo, 0, :bar, :bat, :baz, :bat]
# h.flatten(-2) # => [:foo, 0, :bar, :bat, :baz, :bat]
#
# When `level` is zero, returns the equivalent of #to_a :
# h = {foo: 0, bar: [:bat, 3], baz: 2}
# h.flatten(0) # => [[:foo, 0], [:bar, [:bat, 3]], [:baz, 2]]
# h.flatten(0) == h.to_a # => true
#
def flatten: () -> ::Array[K | V]
| (1 level) -> ::Array[K | V]
| (Integer level) -> Array[untyped]
# <!-- rdoc-file=hash.c -->
# Methods #has_key?, #key?, and #member? are aliases for #include?.
#
# Returns `true` if `key` is a key in `self`, otherwise `false`.
#
def has_key?: (K arg0) -> bool
# <!--
# rdoc-file=hash.c
# - hash.has_value?(value) -> true or false
# - hash.value?(value) -> true or false
# -->
# Method #value? is an alias for #has_value?.
#
# Returns `true` if `value` is a value in `self`, otherwise `false`.
#
def has_value?: (V arg0) -> bool
# <!--
# rdoc-file=hash.c
# - hash.hash -> an_integer
# -->
# Returns the Integer hash-code for the hash.
#
# Two Hash objects have the same hash-code if their content is the same
# (regardless or order):
# h1 = {foo: 0, bar: 1, baz: 2}
# h2 = {baz: 2, bar: 1, foo: 0}
# h2.hash == h1.hash # => true
# h2.eql? h1 # => true
#
def hash: () -> Integer
# <!--
# rdoc-file=hash.c
# - hash.include?(key) -> true or false
# - hash.has_key?(key) -> true or false
# - hash.key?(key) -> true or false
# - hash.member?(key) -> true or false
# -->
# Methods #has_key?, #key?, and #member? are aliases for #include?.
#
# Returns `true` if `key` is a key in `self`, otherwise `false`.
#
alias include? has_key?
# <!--
# rdoc-file=hash.c
# - hash.inspect -> new_string
# -->
# Returns a new String containing the hash entries:
# h = {foo: 0, bar: 1, baz: 2}
# h.inspect # => "{:foo=>0, :bar=>1, :baz=>2}"
#
# Hash#to_s is an alias for Hash#inspect.
#
def inspect: () -> String
# <!--
# rdoc-file=hash.c
# - hash.invert -> new_hash
# -->
# Returns a new Hash object with the each key-value pair inverted:
# h = {foo: 0, bar: 1, baz: 2}
# h1 = h.invert
# h1 # => {0=>:foo, 1=>:bar, 2=>:baz}
#
# Overwrites any repeated new keys: (see [Entry
# Order](#class-Hash-label-Entry+Order)):
# h = {foo: 0, bar: 0, baz: 0}
# h.invert # => {0=>:baz}
#
def invert: () -> ::Hash[V, K]
# <!--
# rdoc-file=hash.c
# - hash.keep_if {|key, value| ... } -> self
# - hash.keep_if -> new_enumerator
# -->
# Calls the block for each key-value pair; retains the entry if the block
# returns a truthy value; otherwise deletes the entry; returns `self`.
# h = {foo: 0, bar: 1, baz: 2}
# h.keep_if { |key, value| key.start_with?('b') } # => {:bar=>1, :baz=>2}
#
# Returns a new Enumerator if no block given:
# h = {foo: 0, bar: 1, baz: 2}
# e = h.keep_if # => #<Enumerator: {:foo=>0, :bar=>1, :baz=>2}:keep_if>
# e.each { |key, value| key.start_with?('b') } # => {:bar=>1, :baz=>2}
#
def keep_if: () { (K, V) -> boolish } -> self
| () -> ::Enumerator[[ K, V ], self]
# <!--
# rdoc-file=hash.c
# - hash.key(value) -> key or nil
# -->
# Returns the key for the first-found entry with the given `value` (see [Entry
# Order](#class-Hash-label-Entry+Order)):
# h = {foo: 0, bar: 2, baz: 2}
# h.key(0) # => :foo
# h.key(2) # => :bar
#
# Returns `nil` if so such value is found.
#
def key: (V) -> K?
# <!-- rdoc-file=hash.c -->
# Methods #has_key?, #key?, and #member? are aliases for #include?.
#
# Returns `true` if `key` is a key in `self`, otherwise `false`.
#
alias key? has_key?
# <!--
# rdoc-file=hash.c
# - hash.keys -> new_array
# -->
# Returns a new Array containing all keys in `self`:
# h = {foo: 0, bar: 1, baz: 2}
# h.keys # => [:foo, :bar, :baz]
#
def keys: () -> ::Array[K]
# <!-- rdoc-file=hash.c -->
# Returns the count of entries in `self`:
# {foo: 0, bar: 1, baz: 2}.length # => 3
#
# Hash#length is an alias for Hash#size.
#
def length: () -> Integer
# <!-- rdoc-file=hash.c -->
# Methods #has_key?, #key?, and #member? are aliases for #include?.
#
# Returns `true` if `key` is a key in `self`, otherwise `false`.
#
alias member? has_key?
# <!--
# rdoc-file=hash.c
# - hash.merge -> copy_of_self
# - hash.merge(*other_hashes) -> new_hash
# - hash.merge(*other_hashes) { |key, old_value, new_value| ... } -> new_hash
# -->
# Returns the new Hash formed by merging each of `other_hashes` into a copy of
# `self`.
#
# Each argument in `other_hashes` must be a Hash.
#
# ---
#
# With arguments and no block:
# * Returns the new Hash object formed by merging each successive Hash in
# `other_hashes` into `self`.
# * Each new-key entry is added at the end.
# * Each duplicate-key entry's value overwrites the previous value.
#
#
# Example:
# h = {foo: 0, bar: 1, baz: 2}
# h1 = {bat: 3, bar: 4}
# h2 = {bam: 5, bat:6}
# h.merge(h1, h2) # => {:foo=>0, :bar=>4, :baz=>2, :bat=>6, :bam=>5}
#
# With arguments and a block:
# * Returns a new Hash object that is the merge of `self` and each given hash.
# * The given hashes are merged left to right.
# * Each new-key entry is added at the end.
# * For each duplicate key:
# * Calls the block with the key and the old and new values.
# * The block's return value becomes the new value for the entry.
#
#
#
# Example:
# h = {foo: 0, bar: 1, baz: 2}
# h1 = {bat: 3, bar: 4}
# h2 = {bam: 5, bat:6}
# h3 = h.merge(h1, h2) { |key, old_value, new_value| old_value + new_value }
# h3 # => {:foo=>0, :bar=>5, :baz=>2, :bat=>9, :bam=>5}
#
# With no arguments:
# * Returns a copy of `self`.
# * The block, if given, is ignored.
#
#
# Example:
# h = {foo: 0, bar: 1, baz: 2}
# h.merge # => {:foo=>0, :bar=>1, :baz=>2}
# h1 = h.merge { |key, old_value, new_value| raise 'Cannot happen' }
# h1 # => {:foo=>0, :bar=>1, :baz=>2}
#
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]
# <!-- rdoc-file=hash.c -->
# Merges each of `other_hashes` into `self`; returns `self`.
#
# Each argument in `other_hashes` must be a Hash.
#
# Method #update is an alias for #merge!.
#
# With arguments and no block:
# * Returns `self`, after the given hashes are merged into it.
# * The given hashes are merged left to right.
# * Each new entry is added at the end.
# * Each duplicate-key entry's value overwrites the previous value.
#
#
# Example:
# h = {foo: 0, bar: 1, baz: 2}
# h1 = {bat: 3, bar: 4}
# h2 = {bam: 5, bat:6}
# h.merge!(h1, h2) # => {:foo=>0, :bar=>4, :baz=>2, :bat=>6, :bam=>5}
#
# With arguments and a block:
# * Returns `self`, after the given hashes are merged.
# * The given hashes are merged left to right.
# * Each new-key entry is added at the end.
# * For each duplicate key:
# * Calls the block with the key and the old and new values.
# * The block's return value becomes the new value for the entry.
#
#
#
# Example:
# h = {foo: 0, bar: 1, baz: 2}
# h1 = {bat: 3, bar: 4}
# h2 = {bam: 5, bat:6}
# h3 = h.merge!(h1, h2) { |key, old_value, new_value| old_value + new_value }
# h3 # => {:foo=>0, :bar=>5, :baz=>2, :bat=>9, :bam=>5}
#
# With no arguments:
# * Returns `self`, unmodified.
# * The block, if given, is ignored.
#
#
# Example:
# h = {foo: 0, bar: 1, baz: 2}
# h.merge # => {:foo=>0, :bar=>1, :baz=>2}
# h1 = h.merge! { |key, old_value, new_value| raise 'Cannot happen' }
# h1 # => {:foo=>0, :bar=>1, :baz=>2}
#
def merge!: (*::Hash[K, V] other_hashes) -> self
| (*::Hash[K, V] other_hashes) { (K key, V oldval, V newval) -> V } -> self
# <!--
# rdoc-file=hash.c
# - hash.rassoc(value) -> new_array or nil
# -->
# Returns a new 2-element Array consisting of the key and value of the
# first-found entry whose value is `==` to value (see [Entry
# Order](#class-Hash-label-Entry+Order)):
# h = {foo: 0, bar: 1, baz: 1}
# h.rassoc(1) # => [:bar, 1]
#
# Returns `nil` if no such value found.
#
def rassoc: (V) -> [ K, V ]?
# <!--
# rdoc-file=hash.c
# - hash.rehash -> self
# -->
# Rebuilds the hash table by recomputing the hash index for each key; returns
# `self`.
#
# The hash table becomes invalid if the hash value of a key has changed after
# the entry was created. See [Modifying an Active Hash
# Key](#class-Hash-label-Modifying+an+Active+Hash+Key).
#
def rehash: () -> self
# <!--
# rdoc-file=hash.c
# - hash.reject {|key, value| ... } -> new_hash
# - hash.reject -> new_enumerator
# -->
# Returns a new Hash object whose entries are all those from `self` for which
# the block returns `false` or `nil`:
# h = {foo: 0, bar: 1, baz: 2}
# h1 = h.reject {|key, value| key.start_with?('b') }
# h1 # => {:foo=>0}
#
# Returns a new Enumerator if no block given:
# h = {foo: 0, bar: 1, baz: 2}
# e = h.reject # => #<Enumerator: {:foo=>0, :bar=>1, :baz=>2}:reject>
# h1 = e.each {|key, value| key.start_with?('b') }
# h1 # => {:foo=>0}
#
def reject: () -> ::Enumerator[[ K, V ], ::Hash[K, V]]
| () { (K, V) -> boolish } -> ::Hash[K, V]
# <!--
# rdoc-file=hash.c
# - hash.reject! {|key, value| ... } -> self or nil
# - hash.reject! -> new_enumerator
# -->
# Returns `self`, whose remaining entries are those for which the block returns
# `false` or `nil`:
# h = {foo: 0, bar: 1, baz: 2}
# h.reject! {|key, value| value < 2 } # => {:baz=>2}
#
# Returns `nil` if no entries are removed.
#
# Returns a new Enumerator if no block given:
# h = {foo: 0, bar: 1, baz: 2}
# e = h.reject! # => #<Enumerator: {:foo=>0, :bar=>1, :baz=>2}:reject!>
# e.each {|key, value| key.start_with?('b') } # => {:foo=>0}
#
def reject!: () -> ::Enumerator[[ K, V ], self?]
| () { (K, V) -> boolish } -> self?
# <!-- rdoc-file=hash.c -->
# Replaces the entire contents of `self` with the contents of `other_hash`;
# returns `self`:
# h = {foo: 0, bar: 1, baz: 2}
# h.replace({bat: 3, bam: 4}) # => {:bat=>3, :bam=>4}
#
def replace: (Hash[K, V]) -> self
# <!--
# rdoc-file=hash.c
# - hash.select {|key, value| ... } -> new_hash
# - hash.select -> new_enumerator
# -->
# Hash#filter is an alias for Hash#select.
#
# Returns a new Hash object whose entries are those for which the block returns
# a truthy value:
# h = {foo: 0, bar: 1, baz: 2}
# h.select {|key, value| value < 2 } # => {:foo=>0, :bar=>1}
#
# Returns a new Enumerator if no block given:
# h = {foo: 0, bar: 1, baz: 2}
# e = h.select # => #<Enumerator: {:foo=>0, :bar=>1, :baz=>2}:select>
# e.each {|key, value| value < 2 } # => {:foo=>0, :bar=>1}
#
alias select filter
# <!--
# rdoc-file=hash.c
# - hash.select! {|key, value| ... } -> self or nil
# - hash.select! -> new_enumerator
# -->
# Hash#filter! is an alias for Hash#select!.
#
# Returns `self`, whose entries are those for which the block returns a truthy
# value:
# h = {foo: 0, bar: 1, baz: 2}
# h.select! {|key, value| value < 2 } => {:foo=>0, :bar=>1}
#
# Returns `nil` if no entries were removed.
#
# Returns a new Enumerator if no block given:
# h = {foo: 0, bar: 1, baz: 2}
# e = h.select! # => #<Enumerator: {:foo=>0, :bar=>1, :baz=>2}:select!>
# e.each { |key, value| value < 2 } # => {:foo=>0, :bar=>1}
#
alias select! filter!
# <!--
# rdoc-file=hash.c
# - hash.shift -> [key, value] or default_value
# -->
# Removes the first hash entry (see [Entry
# Order](#class-Hash-label-Entry+Order)); returns a 2-element Array containing
# the removed key and value:
# h = {foo: 0, bar: 1, baz: 2}
# h.shift # => [:foo, 0]
# h # => {:bar=>1, :baz=>2}
#
# Returns the default value if the hash is empty (see [Default
# Values](#class-Hash-label-Default+Values)).
#
def shift: () -> [ K, V ]?
# <!--
# rdoc-file=hash.c
# - hash.length -> integer
# - hash.size -> integer
# -->
# Returns the count of entries in `self`:
# {foo: 0, bar: 1, baz: 2}.length # => 3
#
# Hash#length is an alias for Hash#size.
#
alias size length
# <!--
# rdoc-file=hash.c
# - hash.slice(*keys) -> new_hash
# -->
# Returns a new Hash object containing the entries for the given `keys`:
# h = {foo: 0, bar: 1, baz: 2}
# h.slice(:baz, :foo) # => {:baz=>2, :foo=>0}
#
# Any given `keys` that are not found are ignored.
#
def slice: (*K) -> ::Hash[K, V]
# <!-- rdoc-file=hash.c -->
# Hash#store is an alias for Hash#[]=.
#
# Associates the given `value` with the given `key`; returns `value`.
#
# If the given `key` exists, replaces its value with the given `value`; the
# ordering is not affected (see [Entry Order](#class-Hash-label-Entry+Order)):
# h = {foo: 0, bar: 1}
# h[:foo] = 2 # => 2
# h.store(:bar, 3) # => 3
# h # => {:foo=>2, :bar=>3}
#
# If `key` does not exist, adds the `key` and `value`; the new entry is last in
# the order (see [Entry Order](#class-Hash-label-Entry+Order)):
# h = {foo: 0, bar: 1}
# h[:baz] = 2 # => 2
# h.store(:bat, 3) # => 3
# h # => {:foo=>0, :bar=>1, :baz=>2, :bat=>3}
#
alias store []=
# <!--
# rdoc-file=hash.c
# - hash.to_a -> new_array
# -->
# Returns a new Array of 2-element Array objects; each nested Array contains a
# key-value pair from `self`:
# h = {foo: 0, bar: 1, baz: 2}
# h.to_a # => [[:foo, 0], [:bar, 1], [:baz, 2]]
#
def to_a: () -> ::Array[[ K, V ]]
# <!--
# rdoc-file=hash.c
# - hash.to_h -> self or new_hash
# - hash.to_h {|key, value| ... } -> new_hash
# -->
# For an instance of Hash, returns `self`.
#
# For a subclass of Hash, returns a new Hash containing the content of `self`.
#
# When a block is given, returns a new Hash object whose content is based on the
# block; the block should return a 2-element Array object specifying the
# key-value pair to be included in the returned Array:
# h = {foo: 0, bar: 1, baz: 2}
# h1 = h.to_h {|key, value| [value, key] }
# h1 # => {0=>:foo, 1=>:bar, 2=>:baz}
#
def to_h: () -> Hash[K, V]
| [A, B] () { (K, V) -> [ A, B ] } -> Hash[A, B]
# <!--
# rdoc-file=hash.c
# - hash.to_hash -> self
# -->
# Returns `self`.
#
def to_hash: () -> self
# <!--
# rdoc-file=hash.c
# - hash.to_proc -> proc
# -->
# Returns a Proc object that maps a key to its value:
# h = {foo: 0, bar: 1, baz: 2}
# proc = h.to_proc
# proc.class # => Proc
# proc.call(:foo) # => 0
# proc.call(:bar) # => 1
# proc.call(:nosuch) # => nil
#
def to_proc: () -> ^(K) -> V?
# <!-- rdoc-file=hash.c -->
# Returns a new String containing the hash entries:
# h = {foo: 0, bar: 1, baz: 2}
# h.inspect # => "{:foo=>0, :bar=>1, :baz=>2}"
#
# Hash#to_s is an alias for Hash#inspect.
#
alias to_s inspect
# <!--
# rdoc-file=hash.c
# - hash.transform_keys {|key| ... } -> new_hash
# - hash.transform_keys(hash2) -> new_hash
# - hash.transform_keys(hash2) {|other_key| ...} -> new_hash
# - hash.transform_keys -> new_enumerator
# -->
# Returns a new Hash object; each entry has:
# * A key provided by the block.
# * The value from `self`.
#
#
# An optional hash argument can be provided to map keys to new keys. Any key not
# given will be mapped using the provided block, or remain the same if no block
# is given.
#
# Transform keys:
# h = {foo: 0, bar: 1, baz: 2}
# h1 = h.transform_keys {|key| key.to_s }
# h1 # => {"foo"=>0, "bar"=>1, "baz"=>2}
#
# h.transform_keys(foo: :bar, bar: :foo)
# #=> {bar: 0, foo: 1, baz: 2}
#
# h.transform_keys(foo: :hello, &:to_s)
# #=> {:hello=>0, "bar"=>1, "baz"=>2}
#
# Overwrites values for duplicate keys:
# h = {foo: 0, bar: 1, baz: 2}
# h1 = h.transform_keys {|key| :bat }
# h1 # => {:bat=>2}
#
# Returns a new Enumerator if no block given:
# h = {foo: 0, bar: 1, baz: 2}
# e = h.transform_keys # => #<Enumerator: {:foo=>0, :bar=>1, :baz=>2}:transform_keys>
# h1 = e.each { |key| key.to_s }
# h1 # => {"foo"=>0, "bar"=>1, "baz"=>2}
#
def transform_keys: () -> Enumerator[K, Hash[untyped, V]]
| [A] () { (K) -> A } -> Hash[A, V]
# <!--
# rdoc-file=hash.c
# - hash.transform_keys! {|key| ... } -> self
# - hash.transform_keys!(hash2) -> self
# - hash.transform_keys!(hash2) {|other_key| ...} -> self
# - hash.transform_keys! -> new_enumerator
# -->
# Same as Hash#transform_keys but modifies the receiver in place instead of
# returning a new hash.
#
def transform_keys!: () -> Enumerator[K, self]
| () { (K) -> K } -> self
# <!--
# rdoc-file=hash.c
# - hash.transform_values {|value| ... } -> new_hash
# - hash.transform_values -> new_enumerator
# -->
# Returns a new Hash object; each entry has:
# * A key from `self`.
# * A value provided by the block.
#
#
# Transform values:
# h = {foo: 0, bar: 1, baz: 2}
# h1 = h.transform_values {|value| value * 100}
# h1 # => {:foo=>0, :bar=>100, :baz=>200}
#
# Returns a new Enumerator if no block given:
# h = {foo: 0, bar: 1, baz: 2}
# e = h.transform_values # => #<Enumerator: {:foo=>0, :bar=>1, :baz=>2}:transform_values>
# h1 = e.each { |value| value * 100}
# h1 # => {:foo=>0, :bar=>100, :baz=>200}
#
def transform_values: () -> Enumerator[V, Hash[K, untyped]]
| [A] () { (V) -> A } -> Hash[K, A]
# <!--
# rdoc-file=hash.c
# - hash.transform_values! {|value| ... } -> self
# - hash.transform_values! -> new_enumerator
# -->
# Returns `self`, whose keys are unchanged, and whose values are determined by
# the given block.
# h = {foo: 0, bar: 1, baz: 2}
# h.transform_values! {|value| value * 100} # => {:foo=>0, :bar=>100, :baz=>200}
#
# Returns a new Enumerator if no block given:
# h = {foo: 0, bar: 1, baz: 2}
# e = h.transform_values! # => #<Enumerator: {:foo=>0, :bar=>100, :baz=>200}:transform_values!>
# h1 = e.each {|value| value * 100}
# h1 # => {:foo=>0, :bar=>100, :baz=>200}
#
def transform_values!: () -> Enumerator[V, self]
| () { (V) -> V } -> self
# <!--
# rdoc-file=hash.c
# - hash.merge! -> self
# - hash.merge!(*other_hashes) -> self
# - hash.merge!(*other_hashes) { |key, old_value, new_value| ... } -> self
# -->
# Merges each of `other_hashes` into `self`; returns `self`.
#
# Each argument in `other_hashes` must be a Hash.
#
# Method #update is an alias for #merge!.
#
# With arguments and no block:
# * Returns `self`, after the given hashes are merged into it.
# * The given hashes are merged left to right.
# * Each new entry is added at the end.
# * Each duplicate-key entry's value overwrites the previous value.
#
#
# Example:
# h = {foo: 0, bar: 1, baz: 2}
# h1 = {bat: 3, bar: 4}
# h2 = {bam: 5, bat:6}
# h.merge!(h1, h2) # => {:foo=>0, :bar=>4, :baz=>2, :bat=>6, :bam=>5}
#
# With arguments and a block:
# * Returns `self`, after the given hashes are merged.
# * The given hashes are merged left to right.
# * Each new-key entry is added at the end.
# * For each duplicate key:
# * Calls the block with the key and the old and new values.
# * The block's return value becomes the new value for the entry.
#
#
#
# Example:
# h = {foo: 0, bar: 1, baz: 2}
# h1 = {bat: 3, bar: 4}
# h2 = {bam: 5, bat:6}
# h3 = h.merge!(h1, h2) { |key, old_value, new_value| old_value + new_value }
# h3 # => {:foo=>0, :bar=>5, :baz=>2, :bat=>9, :bam=>5}
#
# With no arguments:
# * Returns `self`, unmodified.
# * The block, if given, is ignored.
#
#
# Example:
# h = {foo: 0, bar: 1, baz: 2}
# h.merge # => {:foo=>0, :bar=>1, :baz=>2}
# h1 = h.merge! { |key, old_value, new_value| raise 'Cannot happen' }
# h1 # => {:foo=>0, :bar=>1, :baz=>2}
#
alias update merge!
# <!-- rdoc-file=hash.c -->
# Method #value? is an alias for #has_value?.
#
# Returns `true` if `value` is a value in `self`, otherwise `false`.
#
alias value? has_value?
# <!--
# rdoc-file=hash.c
# - hash.values -> new_array
# -->
# Returns a new Array containing all values in `self`:
# h = {foo: 0, bar: 1, baz: 2}
# h.values # => [0, 1, 2]
#
def values: () -> ::Array[V]
# <!--
# rdoc-file=hash.c
# - hash.values_at(*keys) -> new_array
# -->
# Returns a new Array containing values for the given `keys`:
# h = {foo: 0, bar: 1, baz: 2}
# h.values_at(:baz, :foo) # => [2, 0]
#
# The [default values](#class-Hash-label-Default+Values) are returned for any
# keys that are not found:
# h.values_at(:hello, :foo) # => [nil, 0]
#
def values_at: (*K arg0) -> ::Array[V?]
private
# <!--
# rdoc-file=hash.c
# - Hash.new(default_value = nil) -> new_hash
# - Hash.new {|hash, key| ... } -> new_hash
# -->
# Returns a new empty Hash object.
#
# The initial default value and initial default proc for the new hash depend on
# which form above was used. See [Default
# Values](#class-Hash-label-Default+Values).
#
# If neither an argument nor a block given, initializes both the default value
# and the default proc to `nil`:
# h = Hash.new
# h.default # => nil
# h.default_proc # => nil
#
# If argument `default_value` given but no block given, initializes the default
# value to the given `default_value` and the default proc to `nil`:
# h = Hash.new(false)
# h.default # => false
# h.default_proc # => nil
#
# If a block given but no argument, stores the block as the default proc and
# sets the default value to `nil`:
# h = Hash.new {|hash, key| "Default value for #{key}" }
# h.default # => nil
# h.default_proc.class # => Proc
# h[:nosuch] # => "Default value for nosuch"
#
def initialize: () -> void
| (untyped default) -> void
| [A, B] () { (Hash[A, B] hash, A key) -> B } -> void
# <!--
# rdoc-file=hash.c
# - hash.replace(other_hash) -> self
# -->
# Replaces the entire contents of `self` with the contents of `other_hash`;
# returns `self`:
# h = {foo: 0, bar: 1, baz: 2}
# h.replace({bat: 3, bam: 4}) # => {:bat=>3, :bam=>4}
#
def initialize_copy: (self object) -> self
end
Mini Shell