File Manager
# 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]]
# 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 <: [A, B] (::Hash[A, B]) -> 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 <=: [A, B] (::Hash[A, B]) -> 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 >: [A, B] (::Hash[A, B]) -> 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 >=: [A, B] (::Hash[A, B]) -> 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) -> boolish } -> 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, V) -> boolish } -> 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, V) -> boolish } -> 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, V) -> boolish } -> 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?
# 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) -> boolish } -> 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
#
def key: (V) -> K?
# 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!: (*::Hash[K, V] other_hashes) -> self
| (*::Hash[K, V] other_hashes) { (K key, V oldval, V newval) -> (V) } -> self
# 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, V) -> boolish } -> self
# Equivalent to Hash#delete_if, but returns `nil` if no changes were made.
#
def reject!: () -> ::Enumerator[[ K, V ], self?]
| () { (K, V) -> boolish } -> 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: (Hash[K, V]) -> self
# 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"]
#
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
File Manager Version 1.0, Coded By Lucas
Email: hehe@yahoo.com