core/kernel.rbs in rbs-3.2.2 vs core/kernel.rbs in rbs-3.3.0.pre.1

- old
+ new

@@ -383,12 +383,10 @@ # 4. Therefore you should use spawn() instead of fork(). # def self?.fork: () -> Integer? | () { () -> void } -> Integer - def initialize_copy: (self object) -> self - # <!-- # rdoc-file=object.c # - Array(object) -> object or new_array # --> # Returns an array converted from `object`. @@ -402,12 +400,11 @@ # Returns `object` in an array, `[object]`, if `object` cannot be converted: # # Array(:foo) # => [:foo] # def self?.Array: (nil) -> [] - | [T] (Array[T] ary) -> Array[T] - | [T] (_ToAry[T] | _ToA[T] array_like) -> Array[T] + | [T] (array[T] | _ToA[T] array_like) -> Array[T] | [T] (T ele) -> [T] # <!-- # rdoc-file=complex.c # - Complex(x[, y], exception: true) -> numeric or nil @@ -446,11 +443,11 @@ # def self?.Complex: (_ToC complex_like, ?exception: true) -> Complex | (_ToC complex_like, exception: bool) -> Complex? | (Numeric | String real, ?Numeric | String imag, ?exception: true) -> Complex | (Numeric | String real, ?Numeric | String imag, exception: bool) -> Complex? - | (untyped, ?untyped, exception: false) -> nil + | (untyped, ?untyped, ?exception: bool) -> Complex? # <!-- # rdoc-file=kernel.rb # - Float(arg, exception: true) -> float or nil # --> @@ -466,11 +463,11 @@ # Float(nil) #=> TypeError: can't convert nil into Float # Float("123.0_badstring", exception: false) #=> nil # def self?.Float: (_ToF float_like, ?exception: true) -> Float | (_ToF float_like, exception: bool) -> Float? - | (untyped, exception: false) -> nil + | (untyped, ?exception: bool) -> Float? # <!-- # rdoc-file=object.c # - Hash(object) -> object or new_hash # --> @@ -491,11 +488,11 @@ # Hash({foo: 0, bar: 1}) # => {:foo=>0, :bar=>1} # Hash(nil) # => {} # Hash([]) # => {} # def self?.Hash: [K, V] (nil | [] _empty) -> Hash[K, V] - | [K, V] (_ToHash[K, V] hash_like) -> Hash[K, V] + | [K, V] (hash[K, V] hash_like) -> Hash[K, V] # <!-- # rdoc-file=object.c # - Integer(object, base = 0, exception: true) -> integer or nil # --> @@ -577,15 +574,15 @@ # # # With `exception` given as `false`, an exception of any kind is suppressed and # `nil` is returned. # - def self?.Integer: (_ToInt | _ToI int_like, ?exception: true) -> Integer - | (_ToInt | _ToI int_like, exception: bool) -> Integer? - | (string str, ?int base, ?exception: true) -> Integer - | (string str, ?int base, exception: bool) -> Integer? - | (untyped, ?untyped, exception: false) -> nil + def self?.Integer: (int | _ToI int_like, ?exception: true) -> Integer + | (int | _ToI int_like, exception: bool) -> Integer? + | (string str, int base, ?exception: true) -> Integer + | (string str, int base, exception: bool) -> Integer? + | (untyped, ?untyped, ?exception: bool) -> Integer? # <!-- # rdoc-file=rational.c # - Rational(x, y, exception: true) -> rational or nil # - Rational(arg, exception: true) -> rational or nil @@ -620,17 +617,17 @@ # digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ; # extra spaces = ? \s* ? ; # # See also String#to_r. # - def self?.Rational: (_ToInt | _ToR rational_like, ?exception: true) -> Rational - | (_ToInt | _ToR rational_like, exception: bool) -> Rational? - | (_ToInt | _ToR numer, ?_ToInt | _ToR denom, ?exception: true) -> Rational - | (_ToInt | _ToR numer, ?_ToInt | _ToR denom, exception: bool) -> Rational? + def self?.Rational: (int | _ToR rational_like, ?exception: true) -> Rational + | (int | _ToR rational_like, exception: bool) -> Rational? + | (int | _ToR numer, ?int | _ToR denom, ?exception: true) -> Rational + | (int | _ToR numer, ?int | _ToR denom, exception: bool) -> Rational? | [T] (Numeric&_RationalDiv[T] numer, Numeric denom, ?exception: bool) -> T | [T < Numeric] (T value, 1, ?exception: bool) -> T - | (untyped, ?untyped, exception: false) -> nil + | (untyped, ?untyped, ?exception: bool) -> Rational? interface _RationalDiv[T] def /: (Numeric) -> T end @@ -743,22 +740,22 @@ # autoload(:MyModule, "/usr/local/lib/modules/my_module.rb") # # If *const* is defined as autoload, the file name to be loaded is replaced with # *filename*. If *const* is defined but not as autoload, does nothing. # - def self?.autoload: (String | Symbol _module, String filename) -> NilClass + def self?.autoload: (interned _module, String filename) -> NilClass # <!-- # rdoc-file=load.c # - autoload?(name, inherit=true) -> String or nil # --> # Returns *filename* to be loaded if *name* is registered as `autoload`. # # autoload(:B, "b") # autoload?(:B) #=> "b" # - def self?.autoload?: (Symbol | String name) -> String? + def self?.autoload?: (interned name) -> String? # <!-- # rdoc-file=proc.c # - binding -> a_binding # --> @@ -844,11 +841,12 @@ # raise "Failed to create socket" # raise ArgumentError, "No parameters", caller # def self?.fail: () -> bot | (string message, ?cause: Exception?) -> bot - | (_Exception exception, ?_ToS? message, ?nil | String | Array[String] backtrace, ?cause: Exception?) -> bot + | (_Exception exception, ?_ToS? message, ?String | Array[String] | nil backtrace, ?cause: Exception?) -> bot + | (_Exception exception, ?cause: Exception?, **untyped) -> bot # <!-- # rdoc-file=eval.c # - raise # - raise(string, cause: $!) @@ -1566,11 +1564,11 @@ # Time.new #=> 2008-03-08 19:56:20 +0900 # sleep 1.9 #=> 2 # Time.new #=> 2008-03-08 19:56:22 +0900 # def self?.sleep: (?nil) -> bot - | ((Integer | Float | _Divmod) duration) -> Integer + | (Integer | Float | _Divmod duration) -> Integer interface _Divmod def divmod: (Numeric) -> [ Numeric, Numeric ] end @@ -2095,8 +2093,889 @@ # # See Kernel#exec for the standard shell. # def self?.system: (String command, *String args, ?unsetenv_others: boolish, ?pgroup: true | Integer, ?umask: Integer, ?in: redirect_fd, ?out: redirect_fd, ?err: redirect_fd, ?close_others: boolish, ?chdir: String) -> (NilClass | FalseClass | TrueClass) | (Hash[string, string?] env, String command, *String args, ?unsetenv_others: boolish, ?pgroup: true | Integer, ?umask: Integer, ?in: redirect_fd, ?out: redirect_fd, ?err: redirect_fd, ?close_others: boolish, ?chdir: String) -> (NilClass | FalseClass | TrueClass) + + # <!-- + # rdoc-file=object.c + # - obj !~ other -> true or false + # --> + # Returns true if two objects do not match (using the *=~* method), otherwise + # false. + # + def !~: (untyped) -> bool + + # <!-- + # rdoc-file=object.c + # - obj <=> other -> 0 or nil + # --> + # Returns 0 if `obj` and `other` are the same object or `obj == other`, + # otherwise nil. + # + # The #<=> is used by various methods to compare objects, for example + # Enumerable#sort, Enumerable#max etc. + # + # Your implementation of #<=> should return one of the following values: -1, 0, + # 1 or nil. -1 means self is smaller than other. 0 means self is equal to other. + # 1 means self is bigger than other. Nil means the two values could not be + # compared. + # + # When you define #<=>, you can include Comparable to gain the methods #<=, #<, + # #==, #>=, #> and #between?. + # + def <=>: (untyped) -> Integer? + + # <!-- + # rdoc-file=object.c + # - obj === other -> true or false + # --> + # Case Equality -- For class Object, effectively the same as calling `#==`, but + # typically overridden by descendants to provide meaningful semantics in `case` + # statements. + # + def ===: (untyped) -> bool + + # <!-- + # rdoc-file=kernel.rb + # - obj.clone(freeze: nil) -> an_object + # --> + # Produces a shallow copy of *obj*---the instance variables of *obj* are copied, + # but not the objects they reference. #clone copies the frozen value state of + # *obj*, unless the `:freeze` keyword argument is given with a false or true + # value. See also the discussion under Object#dup. + # + # class Klass + # attr_accessor :str + # end + # s1 = Klass.new #=> #<Klass:0x401b3a38> + # s1.str = "Hello" #=> "Hello" + # s2 = s1.clone #=> #<Klass:0x401b3998 @str="Hello"> + # s2.str[1,4] = "i" #=> "i" + # s1.inspect #=> "#<Klass:0x401b3a38 @str=\"Hi\">" + # s2.inspect #=> "#<Klass:0x401b3998 @str=\"Hi\">" + # + # This method may have class-specific behavior. If so, that behavior will be + # documented under the #`initialize_copy` method of the class. + # + def clone: (?freeze: bool?) -> self + + # <!-- + # rdoc-file=proc.c + # - define_singleton_method(symbol, method) -> symbol + # - define_singleton_method(symbol) { block } -> symbol + # --> + # Defines a public singleton method in the receiver. The *method* parameter can + # be a `Proc`, a `Method` or an `UnboundMethod` object. If a block is specified, + # it is used as the method body. If a block or a method has parameters, they're + # used as method parameters. + # + # class A + # class << self + # def class_name + # to_s + # end + # end + # end + # A.define_singleton_method(:who_am_i) do + # "I am: #{class_name}" + # end + # A.who_am_i # ==> "I am: A" + # + # guy = "Bob" + # guy.define_singleton_method(:hello) { "#{self}: Hello there!" } + # guy.hello #=> "Bob: Hello there!" + # + # chris = "Chris" + # chris.define_singleton_method(:greet) {|greeting| "#{greeting}, I'm Chris!" } + # chris.greet("Hi") #=> "Hi, I'm Chris!" + # + def define_singleton_method: (interned, Method | UnboundMethod | Proc method) -> Symbol + | (interned) { (*untyped) -> untyped } -> Symbol + + # <!-- + # rdoc-file=io.c + # - display(port = $>) -> nil + # --> + # Writes `self` on the given port: + # + # 1.display + # "cat".display + # [ 4, 5, 6 ].display + # puts + # + # Output: + # + # 1cat[4, 5, 6] + # + def display: (?_Writer port) -> void + + # <!-- + # rdoc-file=object.c + # - obj.dup -> an_object + # --> + # Produces a shallow copy of *obj*---the instance variables of *obj* are copied, + # but not the objects they reference. + # + # This method may have class-specific behavior. If so, that behavior will be + # documented under the #`initialize_copy` method of the class. + # + # ### on dup vs clone + # + # In general, #clone and #dup may have different semantics in descendant + # classes. While #clone is used to duplicate an object, including its internal + # state, #dup typically uses the class of the descendant object to create the + # new instance. + # + # When using #dup, any modules that the object has been extended with will not + # be copied. + # + # class Klass + # attr_accessor :str + # end + # + # module Foo + # def foo; 'foo'; end + # end + # + # s1 = Klass.new #=> #<Klass:0x401b3a38> + # s1.extend(Foo) #=> #<Klass:0x401b3a38> + # s1.foo #=> "foo" + # + # s2 = s1.clone #=> #<Klass:0x401be280> + # s2.foo #=> "foo" + # + # s3 = s1.dup #=> #<Klass:0x401c1084> + # s3.foo #=> NoMethodError: undefined method `foo' for #<Klass:0x401c1084> + # + def dup: () -> self + + # <!-- rdoc-file=enumerator.c --> + # Creates a new Enumerator which will enumerate by calling `method` on `obj`, + # passing `args` if any. What was *yielded* by method becomes values of + # enumerator. + # + # If a block is given, it will be used to calculate the size of the enumerator + # without the need to iterate it (see Enumerator#size). + # + # ### Examples + # + # str = "xyz" + # + # enum = str.enum_for(:each_byte) + # enum.each { |b| puts b } + # # => 120 + # # => 121 + # # => 122 + # + # # protect an array from being modified by some_method + # a = [1, 2, 3] + # some_method(a.to_enum) + # + # # String#split in block form is more memory-effective: + # very_large_string.split("|") { |chunk| return chunk if chunk.include?('DATE') } + # # This could be rewritten more idiomatically with to_enum: + # very_large_string.to_enum(:split, "|").lazy.grep(/DATE/).first + # + # It is typical to call to_enum when defining methods for a generic Enumerable, + # in case no block is passed. + # + # Here is such an example, with parameter passing and a sizing block: + # + # module Enumerable + # # a generic method to repeat the values of any enumerable + # def repeat(n) + # raise ArgumentError, "#{n} is negative!" if n < 0 + # unless block_given? + # return to_enum(__method__, n) do # __method__ is :repeat here + # sz = size # Call size and multiply by n... + # sz * n if sz # but return nil if size itself is nil + # end + # end + # each do |*val| + # n.times { yield *val } + # end + # end + # end + # + # %i[hello world].repeat(2) { |w| puts w } + # # => Prints 'hello', 'hello', 'world', 'world' + # enum = (1..14).repeat(3) + # # => returns an Enumerator when called without a block + # enum.first(4) # => [1, 1, 1, 2] + # enum.size # => 42 + # + def enum_for: (Symbol method, *untyped, **untyped) ?{ (*untyped, **untyped) -> Integer } -> Enumerator[untyped, untyped] + | () ?{ () -> Integer } -> Enumerator[untyped, self] + + %a{annotate:rdoc:skip} + alias to_enum enum_for + + # <!-- + # rdoc-file=object.c + # - obj == other -> true or false + # - obj.equal?(other) -> true or false + # - obj.eql?(other) -> true or false + # --> + # Equality --- At the Object level, #== returns `true` only if `obj` and `other` + # are the same object. Typically, this method is overridden in descendant + # classes to provide class-specific meaning. + # + # Unlike #==, the #equal? method should never be overridden by subclasses as it + # is used to determine object identity (that is, `a.equal?(b)` if and only if + # `a` is the same object as `b`): + # + # obj = "a" + # other = obj.dup + # + # obj == other #=> true + # obj.equal? other #=> false + # obj.equal? obj #=> true + # + # The #eql? method returns `true` if `obj` and `other` refer to the same hash + # key. This is used by Hash to test members for equality. For any pair of + # objects where #eql? returns `true`, the #hash value of both objects must be + # equal. So any subclass that overrides #eql? should also override #hash + # appropriately. + # + # For objects of class Object, #eql? is synonymous with #==. Subclasses + # normally continue this tradition by aliasing #eql? to their overridden #== + # method, but there are exceptions. Numeric types, for example, perform type + # conversion across #==, but not across #eql?, so: + # + # 1 == 1.0 #=> true + # 1.eql? 1.0 #=> false + # + def eql?: (untyped) -> bool + + # <!-- + # rdoc-file=eval.c + # - obj.extend(module, ...) -> obj + # --> + # Adds to *obj* the instance methods from each module given as a parameter. + # + # module Mod + # def hello + # "Hello from Mod.\n" + # end + # end + # + # class Klass + # def hello + # "Hello from Klass.\n" + # end + # end + # + # k = Klass.new + # k.hello #=> "Hello from Klass.\n" + # k.extend(Mod) #=> #<Klass:0x401b3bc8> + # k.hello #=> "Hello from Mod.\n" + # + def extend: (*Module) -> self + + # <!-- + # rdoc-file=object.c + # - obj.freeze -> obj + # --> + # Prevents further modifications to *obj*. A FrozenError will be raised if + # modification is attempted. There is no way to unfreeze a frozen object. See + # also Object#frozen?. + # + # This method returns self. + # + # a = [ "a", "b", "c" ] + # a.freeze + # a << "z" + # + # *produces:* + # + # prog.rb:3:in `<<': can't modify frozen Array (FrozenError) + # from prog.rb:3 + # + # Objects of the following classes are always frozen: Integer, Float, Symbol. + # + def freeze: () -> self + + # <!-- + # rdoc-file=kernel.rb + # - obj.frozen? -> true or false + # --> + # Returns the freeze status of *obj*. + # + # a = [ "a", "b", "c" ] + # a.freeze #=> ["a", "b", "c"] + # a.frozen? #=> true + # + def frozen?: () -> bool + + # <!-- + # rdoc-file=object.c + # - obj.hash -> integer + # --> + # Generates an Integer hash value for this object. This function must have the + # property that `a.eql?(b)` implies `a.hash == b.hash`. + # + # The hash value is used along with #eql? by the Hash class to determine if two + # objects reference the same hash key. Any hash value that exceeds the capacity + # of an Integer will be truncated before being used. + # + # The hash value for an object may not be identical across invocations or + # implementations of Ruby. If you need a stable identifier across Ruby + # invocations and implementations you will need to generate one with a custom + # method. + # + # Certain core classes such as Integer use built-in hash calculations and do not + # call the #hash method when used as a hash key. + # + # When implementing your own #hash based on multiple values, the best practice + # is to combine the class and any values using the hash code of an array: + # + # For example: + # + # def hash + # [self.class, a, b, c].hash + # end + # + # The reason for this is that the Array#hash method already has logic for safely + # and efficiently combining multiple hash values. + # + def hash: () -> Integer + + # <!-- + # rdoc-file=object.c + # - obj.inspect -> string + # --> + # Returns a string containing a human-readable representation of *obj*. The + # default #inspect shows the object's class name, an encoding of its memory + # address, and a list of the instance variables and their values (by calling + # #inspect on each of them). User defined classes should override this method + # to provide a better representation of *obj*. When overriding this method, it + # should return a string whose encoding is compatible with the default external + # encoding. + # + # [ 1, 2, 3..4, 'five' ].inspect #=> "[1, 2, 3..4, \"five\"]" + # Time.new.inspect #=> "2008-03-08 19:43:39 +0900" + # + # class Foo + # end + # Foo.new.inspect #=> "#<Foo:0x0300c868>" + # + # class Bar + # def initialize + # @bar = 1 + # end + # end + # Bar.new.inspect #=> "#<Bar:0x0300c868 @bar=1>" + # + def inspect: () -> String + + # <!-- + # rdoc-file=object.c + # - obj.instance_of?(class) -> true or false + # --> + # Returns `true` if *obj* is an instance of the given class. See also + # Object#kind_of?. + # + # class A; end + # class B < A; end + # class C < B; end + # + # b = B.new + # b.instance_of? A #=> false + # b.instance_of? B #=> true + # b.instance_of? C #=> false + # + def instance_of?: (Module) -> bool + + # <!-- + # rdoc-file=object.c + # - obj.instance_variable_defined?(symbol) -> true or false + # - obj.instance_variable_defined?(string) -> true or false + # --> + # Returns `true` if the given instance variable is defined in *obj*. String + # arguments are converted to symbols. + # + # class Fred + # def initialize(p1, p2) + # @a, @b = p1, p2 + # end + # end + # fred = Fred.new('cat', 99) + # fred.instance_variable_defined?(:@a) #=> true + # fred.instance_variable_defined?("@b") #=> true + # fred.instance_variable_defined?("@c") #=> false + # + def instance_variable_defined?: (interned var) -> bool + + # <!-- + # rdoc-file=object.c + # - obj.instance_variable_get(symbol) -> obj + # - obj.instance_variable_get(string) -> obj + # --> + # Returns the value of the given instance variable, or nil if the instance + # variable is not set. The `@` part of the variable name should be included for + # regular instance variables. Throws a NameError exception if the supplied + # symbol is not valid as an instance variable name. String arguments are + # converted to symbols. + # + # class Fred + # def initialize(p1, p2) + # @a, @b = p1, p2 + # end + # end + # fred = Fred.new('cat', 99) + # fred.instance_variable_get(:@a) #=> "cat" + # fred.instance_variable_get("@b") #=> 99 + # + def instance_variable_get: (interned var) -> untyped + + # <!-- + # rdoc-file=object.c + # - obj.instance_variable_set(symbol, obj) -> obj + # - obj.instance_variable_set(string, obj) -> obj + # --> + # Sets the instance variable named by *symbol* to the given object. This may + # circumvent the encapsulation intended by the author of the class, so it should + # be used with care. The variable does not have to exist prior to this call. If + # the instance variable name is passed as a string, that string is converted to + # a symbol. + # + # class Fred + # def initialize(p1, p2) + # @a, @b = p1, p2 + # end + # end + # fred = Fred.new('cat', 99) + # fred.instance_variable_set(:@a, 'dog') #=> "dog" + # fred.instance_variable_set(:@c, 'cat') #=> "cat" + # fred.inspect #=> "#<Fred:0x401b3da8 @a=\"dog\", @b=99, @c=\"cat\">" + # + def instance_variable_set: [X] (interned var, X value) -> X + + # <!-- + # rdoc-file=object.c + # - obj.instance_variables -> array + # --> + # Returns an array of instance variable names for the receiver. Note that simply + # defining an accessor does not create the corresponding instance variable. + # + # class Fred + # attr_accessor :a1 + # def initialize + # @iv = 3 + # end + # end + # Fred.new.instance_variables #=> [:@iv] + # + def instance_variables: () -> Array[Symbol] + + # <!-- rdoc-file=object.c --> + # Returns `true` if *class* is the class of *obj*, or if *class* is one of the + # superclasses of *obj* or modules included in *obj*. + # + # module M; end + # class A + # include M + # end + # class B < A; end + # class C < B; end + # + # b = B.new + # b.is_a? A #=> true + # b.is_a? B #=> true + # b.is_a? C #=> false + # b.is_a? M #=> true + # + # b.kind_of? A #=> true + # b.kind_of? B #=> true + # b.kind_of? C #=> false + # b.kind_of? M #=> true + # + def is_a?: (Module) -> bool + + %a{annotate:rdoc:skip} + alias kind_of? is_a? + + # <!-- + # rdoc-file=object.c + # - obj.itself -> obj + # --> + # Returns the receiver. + # + # string = "my string" + # string.itself.object_id == string.object_id #=> true + # + def itself: () -> self + + # <!-- + # rdoc-file=proc.c + # - obj.method(sym) -> method + # --> + # Looks up the named method as a receiver in *obj*, returning a Method object + # (or raising NameError). The Method object acts as a closure in *obj*'s object + # instance, so instance variables and the value of `self` remain available. + # + # class Demo + # def initialize(n) + # @iv = n + # end + # def hello() + # "Hello, @iv = #{@iv}" + # end + # end + # + # k = Demo.new(99) + # m = k.method(:hello) + # m.call #=> "Hello, @iv = 99" + # + # l = Demo.new('Fred') + # m = l.method("hello") + # m.call #=> "Hello, @iv = Fred" + # + # Note that Method implements `to_proc` method, which means it can be used with + # iterators. + # + # [ 1, 2, 3 ].each(&method(:puts)) # => prints 3 lines to stdout + # + # out = File.open('test.txt', 'w') + # [ 1, 2, 3 ].each(&out.method(:puts)) # => prints 3 lines to file + # + # require 'date' + # %w[2017-03-01 2017-03-02].collect(&Date.method(:parse)) + # #=> [#<Date: 2017-03-01 ((2457814j,0s,0n),+0s,2299161j)>, #<Date: 2017-03-02 ((2457815j,0s,0n),+0s,2299161j)>] + # + def method: (interned name) -> Method + + # <!-- + # rdoc-file=object.c + # - obj.methods(regular=true) -> array + # --> + # Returns a list of the names of public and protected methods of *obj*. This + # will include all the methods accessible in *obj*'s ancestors. If the optional + # parameter is `false`, it returns an array of *obj*'s public and protected + # singleton methods, the array will not include methods in modules included in + # *obj*. + # + # class Klass + # def klass_method() + # end + # end + # k = Klass.new + # k.methods[0..9] #=> [:klass_method, :nil?, :===, + # # :==~, :!, :eql? + # # :hash, :<=>, :class, :singleton_class] + # k.methods.length #=> 56 + # + # k.methods(false) #=> [] + # def k.singleton_method; end + # k.methods(false) #=> [:singleton_method] + # + # module M123; def m123; end end + # k.extend M123 + # k.methods(false) #=> [:singleton_method] + # + def methods: () -> Array[Symbol] + + # <!-- + # rdoc-file=object.c + # - obj.nil? -> true or false + # --> + # Only the object *nil* responds `true` to `nil?`. + # + # Object.new.nil? #=> false + # nil.nil? #=> true + # + def nil?: () -> bool + + # <!-- + # rdoc-file=gc.c + # - obj.__id__ -> integer + # - obj.object_id -> integer + # --> + # Returns an integer identifier for `obj`. + # + # The same number will be returned on all calls to `object_id` for a given + # object, and no two active objects will share an id. + # + # Note: that some objects of builtin classes are reused for optimization. This + # is the case for immediate values and frozen string literals. + # + # BasicObject implements +__id__+, Kernel implements `object_id`. + # + # Immediate values are not passed by reference but are passed by value: `nil`, + # `true`, `false`, Fixnums, Symbols, and some Floats. + # + # Object.new.object_id == Object.new.object_id # => false + # (21 * 2).object_id == (21 * 2).object_id # => true + # "hello".object_id == "hello".object_id # => false + # "hi".freeze.object_id == "hi".freeze.object_id # => true + # + def object_id: () -> Integer + + # <!-- + # rdoc-file=object.c + # - obj.private_methods(all=true) -> array + # --> + # Returns the list of private methods accessible to *obj*. If the *all* + # parameter is set to `false`, only those methods in the receiver will be + # listed. + # + def private_methods: () -> Array[Symbol] + + # <!-- + # rdoc-file=object.c + # - obj.protected_methods(all=true) -> array + # --> + # Returns the list of protected methods accessible to *obj*. If the *all* + # parameter is set to `false`, only those methods in the receiver will be + # listed. + # + def protected_methods: () -> Array[Symbol] + + # <!-- + # rdoc-file=proc.c + # - obj.public_method(sym) -> method + # --> + # Similar to *method*, searches public method only. + # + def public_method: (interned name) -> Method + + # <!-- + # rdoc-file=object.c + # - obj.public_methods(all=true) -> array + # --> + # Returns the list of public methods accessible to *obj*. If the *all* parameter + # is set to `false`, only those methods in the receiver will be listed. + # + def public_methods: (?boolish all) -> Array[Symbol] + + # <!-- + # rdoc-file=vm_eval.c + # - obj.public_send(symbol [, args...]) -> obj + # - obj.public_send(string [, args...]) -> obj + # --> + # Invokes the method identified by *symbol*, passing it any arguments specified. + # Unlike send, public_send calls public methods only. When the method is + # identified by a string, the string is converted to a symbol. + # + # 1.public_send(:puts, "hello") # causes NoMethodError + # + def public_send: (interned name, *untyped args) ?{ (*untyped) -> untyped } -> untyped + + # <!-- + # rdoc-file=object.c + # - obj.remove_instance_variable(symbol) -> obj + # - obj.remove_instance_variable(string) -> obj + # --> + # Removes the named instance variable from *obj*, returning that variable's + # value. String arguments are converted to symbols. + # + # class Dummy + # attr_reader :var + # def initialize + # @var = 99 + # end + # def remove + # remove_instance_variable(:@var) + # end + # end + # d = Dummy.new + # d.var #=> 99 + # d.remove #=> 99 + # d.var #=> nil + # + def remove_instance_variable: (interned name) -> untyped + + # <!-- + # rdoc-file=vm_method.c + # - obj.respond_to?(symbol, include_all=false) -> true or false + # - obj.respond_to?(string, include_all=false) -> true or false + # --> + # Returns `true` if *obj* responds to the given method. Private and protected + # methods are included in the search only if the optional second parameter + # evaluates to `true`. + # + # If the method is not implemented, as Process.fork on Windows, File.lchmod on + # GNU/Linux, etc., false is returned. + # + # If the method is not defined, `respond_to_missing?` method is called and the + # result is returned. + # + # When the method name parameter is given as a string, the string is converted + # to a symbol. + # + def respond_to?: (interned name, ?boolish include_all) -> bool + + # <!-- + # rdoc-file=vm_method.c + # - obj.respond_to_missing?(symbol, include_all) -> true or false + # - obj.respond_to_missing?(string, include_all) -> true or false + # --> + # DO NOT USE THIS DIRECTLY. + # + # Hook method to return whether the *obj* can respond to *id* method or not. + # + # When the method name parameter is given as a string, the string is converted + # to a symbol. + # + # See #respond_to?, and the example of BasicObject. + # + %a{annotate:rdoc:copy:Object#respond_to_missing?} + private def respond_to_missing?: (Symbol, bool) -> bool + + # <!-- + # rdoc-file=vm_eval.c + # - foo.send(symbol [, args...]) -> obj + # - foo.__send__(symbol [, args...]) -> obj + # - foo.send(string [, args...]) -> obj + # - foo.__send__(string [, args...]) -> obj + # --> + # Invokes the method identified by *symbol*, passing it any arguments specified. + # When the method is identified by a string, the string is converted to a + # symbol. + # + # BasicObject implements +__send__+, Kernel implements `send`. `__send__` is + # safer than `send` when *obj* has the same method name like `Socket`. See also + # `public_send`. + # + # class Klass + # def hello(*args) + # "Hello " + args.join(' ') + # end + # end + # k = Klass.new + # k.send :hello, "gentle", "readers" #=> "Hello gentle readers" + # + def send: (interned name, *untyped args) ?{ (*untyped) -> untyped } -> untyped + + # <!-- + # rdoc-file=object.c + # - obj.singleton_class -> class + # --> + # Returns the singleton class of *obj*. This method creates a new singleton + # class if *obj* does not have one. + # + # If *obj* is `nil`, `true`, or `false`, it returns NilClass, TrueClass, or + # FalseClass, respectively. If *obj* is an Integer, a Float or a Symbol, it + # raises a TypeError. + # + # Object.new.singleton_class #=> #<Class:#<Object:0xb7ce1e24>> + # String.singleton_class #=> #<Class:String> + # nil.singleton_class #=> NilClass + # + def singleton_class: () -> Class + + # <!-- + # rdoc-file=proc.c + # - obj.singleton_method(sym) -> method + # --> + # Similar to *method*, searches singleton method only. + # + # class Demo + # def initialize(n) + # @iv = n + # end + # def hello() + # "Hello, @iv = #{@iv}" + # end + # end + # + # k = Demo.new(99) + # def k.hi + # "Hi, @iv = #{@iv}" + # end + # m = k.singleton_method(:hi) + # m.call #=> "Hi, @iv = 99" + # m = k.singleton_method(:hello) #=> NameError + # + def singleton_method: (interned name) -> Method + + # <!-- + # rdoc-file=object.c + # - obj.singleton_methods(all=true) -> array + # --> + # Returns an array of the names of singleton methods for *obj*. If the optional + # *all* parameter is true, the list will include methods in modules included in + # *obj*. Only public and protected singleton methods are returned. + # + # module Other + # def three() end + # end + # + # class Single + # def Single.four() end + # end + # + # a = Single.new + # + # def a.one() + # end + # + # class << a + # include Other + # def two() + # end + # end + # + # Single.singleton_methods #=> [:four] + # a.singleton_methods(false) #=> [:two, :one] + # a.singleton_methods #=> [:two, :one, :three] + # + def singleton_methods: () -> Array[Symbol] + + # <!-- + # rdoc-file=kernel.rb + # - obj.tap {|x| block } -> obj + # --> + # Yields self to the block, and then returns self. The primary purpose of this + # method is to "tap into" a method chain, in order to perform operations on + # intermediate results within the chain. + # + # (1..10) .tap {|x| puts "original: #{x}" } + # .to_a .tap {|x| puts "array: #{x}" } + # .select {|x| x.even? } .tap {|x| puts "evens: #{x}" } + # .map {|x| x*x } .tap {|x| puts "squares: #{x}" } + # + def tap: () { (self) -> void } -> self + + # <!-- + # rdoc-file=object.c + # - obj.to_s -> string + # --> + # Returns a string representing *obj*. The default #to_s prints the object's + # class and an encoding of the object id. As a special case, the top-level + # object that is the initial execution context of Ruby programs returns + # ``main''. + # + def to_s: () -> String + + # <!-- + # rdoc-file=kernel.rb + # - obj.yield_self {|x| block } -> an_object + # --> + # Yields self to the block and returns the result of the block. + # + # "my string".yield_self {|s| s.upcase } #=> "MY STRING" + # + # Good usage for `then` is value piping in method chains: + # + # require 'open-uri' + # require 'json' + # + # construct_url(arguments). + # then {|url| URI(url).read }. + # then {|response| JSON.parse(response) } + # + def yield_self: [X] () { (self) -> X } -> X + | () -> Enumerator[self, untyped] + + %a{annotate:rdoc:skip} + alias then yield_self + + private def initialize_copy: (self object) -> self + + private def initialize_clone: (self object, ?freeze: bool?) -> self + + private def initialize_dup: (self object) -> self end Kernel::RUBYGEMS_ACTIVATION_MONITOR: untyped