rbs 0.13.1 → 0.14.0

data/stdlib/builtin/object.rbs

@@ -1,68 +1,68 @@
 # Object is the default root of all Ruby objects.  Object inherits from
 # BasicObject which allows creating alternate object hierarchies.  Methods on
 # Object are available to all classes unless explicitly overridden.
-# 
+#
 # Object mixes in the Kernel module, making the built-in kernel functions
 # globally accessible.  Although the instance methods of Object are defined by
 # the Kernel module, we have chosen to document them here for clarity.
-# 
+#
 # When referencing constants in classes inheriting from Object you do not need
 # to use the full namespace.  For example, referencing `File` inside `YourClass`
 # will find the top-level File class.
-# 
+#
 # In the descriptions of Object's methods, the parameter *symbol* refers to a
 # symbol, which is either a quoted string or a Symbol (such as `:name`).
-# 
+#
 class Object < BasicObject
   include Kernel
 
   # Returns true if two objects do not match (using the *=~* method), otherwise
   # false.
-  # 
+  #
   def !~: (untyped) -> bool
 
   # 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?
 
   # 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
 
   # This method is deprecated.
-  # 
+  #
   # This is not only unuseful but also troublesome because it may hide a type
   # error.
-  # 
+  #
   def =~: (untyped) -> bool
 
   # Returns the class of *obj*. This method must always be called with an explicit
   # receiver, as `class` is also a reserved word in Ruby.
-  # 
+  #
   #     1.class      #=> Integer
   #     self.class   #=> Object
-  # 
+  #
   def `class`: () -> untyped
 
   # Produces a shallow copy of *obj*---the instance variables of *obj* are copied,
   # but not the objects they reference. `clone` copies the frozen (unless :freeze
   # keyword argument is given with a false value) and tainted state of *obj*. See
   # also the discussion under `Object#dup`.
-  # 
+  #
   #     class Klass
   #        attr_accessor :str
   #     end
@@ -72,16 +72,16 @@ class Object < BasicObject
   #     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
 
   # Defines a 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.
-  # 
+  #
   #     class A
   #       class << self
   #         def class_name
@@ -93,95 +93,95 @@ class Object < BasicObject
   #       "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!"
-  # 
+  #
   def define_singleton_method: (Symbol, Method | UnboundMethod) -> Symbol
                              | (Symbol) { (*untyped) -> untyped } -> Symbol
 
   # Prints *obj* on the given port (default `$>`). Equivalent to:
-  # 
+  #
   #     def display(port=$>)
   #       port.write self
   #       nil
   #     end
-  # 
+  #
   # For example:
-  # 
+  #
   #     1.display
   #     "cat".display
   #     [ 4, 5, 6 ].display
   #     puts
-  # 
+  #
   # *produces:*
-  # 
+  #
   #     1cat[4, 5, 6]
-  # 
+  #
   def display: (?_Writeable port) -> void
 
   # Produces a shallow copy of *obj*---the instance variables of *obj* are copied,
   # but not the objects they reference. `dup` copies the tainted state of *obj*.
-  # 
+  #
   # 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:0x401b3a38>
   #     s2.foo #=> "foo"
-  # 
+  #
   #     s3 = s1.dup #=> #<Klass:0x401b3a38>
   #     s3.foo #=> NoMethodError: undefined method `foo' for #<Klass:0x401b3a38>
-  # 
+  #
   def dup: () -> self
 
   # Creates a new Enumerator which will enumerate by calling `method` on `obj`,
   # passing `args` if any.
-  # 
+  #
   # 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)
-  # 
+  #
   # 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)
@@ -197,42 +197,42 @@ class Object < BasicObject
   #         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 args) ?{ (*untyped args) -> Integer } -> Enumerator[untyped, untyped]
               | (*untyped args) ?{ (*untyped args) -> Integer } -> Enumerator[untyped, untyped]
 
   # Creates a new Enumerator which will enumerate by calling `method` on `obj`,
   # passing `args` if any.
-  # 
+  #
   # 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)
-  # 
+  #
   # 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)
@@ -248,89 +248,89 @@ class Object < BasicObject
   #         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
-  # 
+  #
   alias to_enum enum_for
 
   # 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 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
 
   # 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
 
   # Prevents further modifications to *obj*. A `RuntimeError` 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
 
   # Returns the freeze status of *obj*.
-  # 
+  #
   #     a = [ "a", "b", "c" ]
   #     a.freeze    #=> ["a", "b", "c"]
   #     a.frozen?   #=> true
-  # 
+  #
   def frozen?: () -> bool
 
   def hash: () -> Integer
@@ -341,40 +341,40 @@ class Object < BasicObject
   # 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
 
   # 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
 
   # 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
@@ -384,7 +384,7 @@ class Object < BasicObject
   #     fred.instance_variable_defined?(:@a)    #=> true
   #     fred.instance_variable_defined?("@b")   #=> true
   #     fred.instance_variable_defined?("@c")   #=> false
-  # 
+  #
   def instance_variable_defined?: (String | Symbol var) -> bool
 
   # Returns the value of the given instance variable, or nil if the instance
@@ -392,7 +392,7 @@ class Object < BasicObject
   # 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
@@ -401,7 +401,7 @@ class Object < BasicObject
   #     fred = Fred.new('cat', 99)
   #     fred.instance_variable_get(:@a)    #=> "cat"
   #     fred.instance_variable_get("@b")   #=> 99
-  # 
+  #
   def instance_variable_get: (String | Symbol var) -> untyped
 
   # Sets the instance variable named by *symbol* to the given object, thereby
@@ -409,7 +409,7 @@ class Object < BasicObject
   # encapsulation. 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
@@ -419,12 +419,12 @@ class Object < BasicObject
   #     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] (String | Symbol var, X value) -> X
 
   # 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
@@ -432,67 +432,67 @@ class Object < BasicObject
   #       end
   #     end
   #     Fred.new.instance_variables   #=> [:@iv]
-  # 
+  #
   def instance_variables: () -> Array[Symbol]
 
   # 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
 
   # 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
-  # 
+  #
   alias kind_of? is_a?
 
   # Returns the receiver.
-  # 
+  #
   #     string = "my string"
   #     string.itself.object_id == string.object_id   #=> true
-  # 
+  #
   def `itself`: () -> self
 
   # 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
@@ -501,27 +501,27 @@ class Object < BasicObject
   #         "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: (String | Symbol name) -> Method
 
   # Returns a list of the names of public and protected methods of *obj*. This
@@ -529,7 +529,7 @@ class Object < BasicObject
   # parameter is `false`, it returns an array of *obj<i>'s public and protected
   # singleton methods, the array will not include methods in modules included in
   # <i>obj*.
-  # 
+  #
   #     class Klass
   #       def klass_method()
   #       end
@@ -539,69 +539,69 @@ class Object < BasicObject
   #                        #    :==~, :!, :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]
 
   # Only the object *nil* responds `true` to `nil?`.
-  # 
+  #
   #     Object.new.nil?   #=> false
   #     nil.nil?          #=> true
-  # 
+  #
   def `nil?`: () -> bool
 
   # 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.
-  # 
+  #
   # 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
 
   # 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]
 
   # 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]
 
   # Similar to *method*, searches public method only.
-  # 
+  #
   def public_method: (name name) -> Method
 
   # 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`: (name name, *untyped args) ?{ (*untyped) -> untyped } -> untyped
 
   # 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
@@ -615,29 +615,29 @@ class Object < BasicObject
   #     d.var      #=> 99
   #     d.remove   #=> 99
   #     d.var      #=> nil
-  # 
+  #
   def remove_instance_variable: (name name) -> untyped
 
   # 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?: (name name, ?bool include_all) -> bool
 
   # Invokes the method identified by *symbol*, passing it any arguments specified.
   # You can use `__send__` if the name `send` clashes with an existing method in
   # *obj*. When the method is identified by a string, the string is converted to a
   # symbol.
-  # 
+  #
   #     class Klass
   #       def hello(*args)
   #         "Hello " + args.join(' ')
@@ -645,24 +645,24 @@ class Object < BasicObject
   #     end
   #     k = Klass.new
   #     k.send :hello, "gentle", "readers"   #=> "Hello gentle readers"
-  # 
+  #
   def `send`: (name name, *untyped args) ?{ (*untyped) -> untyped } -> untyped
 
   # 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
 
   # Similar to *method*, searches singleton method only.
-  # 
+  #
   #     class Demo
   #       def initialize(n)
   #         @iv = n
@@ -671,7 +671,7 @@ class Object < BasicObject
   #         "Hello, @iv = #{@iv}"
   #       end
   #     end
-  # 
+  #
   #     k = Demo.new(99)
   #     def k.hi
   #       "Hi, @iv = #{@iv}"
@@ -679,99 +679,99 @@ class Object < BasicObject
   #     m = k.singleton_method(:hi)
   #     m.call   #=> "Hi, @iv = 99"
   #     m = k.singleton_method(:hello) #=> NameError
-  # 
+  #
   def singleton_method: (name name) -> Method
 
   # 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]
 
   # Mark the object as tainted.
-  # 
+  #
   # Objects that are marked as tainted will be restricted from various built-in
   # methods. This is to prevent insecure data, such as command-line arguments or
   # strings read from Kernel#gets, from inadvertently compromising the user's
   # system.
-  # 
+  #
   # To check whether an object is tainted, use #tainted?.
-  # 
+  #
   # You should only untaint a tainted object if your code has inspected it and
   # determined that it is safe. To do so use #untaint.
-  # 
+  #
   def taint: () -> self
 
   # Deprecated method that is equivalent to #taint.
-  # 
+  #
   alias untrust taint
 
   # Returns true if the object is tainted.
-  # 
+  #
   # See #taint for more information.
-  # 
+  #
   def tainted?: () -> bool
 
   # Deprecated method that is equivalent to #tainted?.
-  # 
+  #
   alias untrusted? tainted?
 
   # 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
 
   # Yields self to the block and returns the result of the block.
-  # 
+  #
   #     3.next.then {|x| x**x }.to_s             #=> "256"
   #     "my string".yield_self {|s| s.upcase }   #=> "MY STRING"
-  # 
+  #
   # Good usage for `yield_self` is value piping in method chains:
-  # 
+  #
   #     require 'open-uri'
   #     require 'json'
-  # 
+  #
   #     construct_url(arguments).
   #       yield_self {|url| open(url).read }.
   #       yield_self {|response| JSON.parse(response) }
-  # 
+  #
   # When called without block, the method returns `Enumerator`, which can be used,
   # for example, for conditional circuit-breaking:
-  # 
+  #
   #     # meets condition, no-op
   #     1.yield_self.detect(&:odd?)            # => 1
   #     # does not meet condition, drop value
   #     2.yield_self.detect(&:odd?)            # => nil
-  # 
+  #
   def `yield_self`: [X] () { (self) -> X } -> X
                   | () -> Enumerator[self, untyped]
 
@@ -779,41 +779,41 @@ class Object < BasicObject
   # 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
 
   # Removes the tainted mark from the object.
-  # 
+  #
   # See #taint for more information.
-  # 
+  #
   def untaint: () -> self
 
   # Deprecated method that is equivalent to #untaint.
-  # 
+  #
   alias trust untaint
 
   # Yields self to the block and returns the result of the block.
-  # 
+  #
   #     3.next.then {|x| x**x }.to_s             #=> "256"
   #     "my string".yield_self {|s| s.upcase }   #=> "MY STRING"
-  # 
+  #
   # Good usage for `yield_self` is value piping in method chains:
-  # 
+  #
   #     require 'open-uri'
   #     require 'json'
-  # 
+  #
   #     construct_url(arguments).
   #       yield_self {|url| open(url).read }.
   #       yield_self {|response| JSON.parse(response) }
-  # 
+  #
   # When called without block, the method returns `Enumerator`, which can be used,
   # for example, for conditional circuit-breaking:
-  # 
+  #
   #     # meets condition, no-op
   #     1.yield_self.detect(&:odd?)            # => 1
   #     # does not meet condition, drop value
   #     2.yield_self.detect(&:odd?)            # => nil
-  # 
+  #
   alias then yield_self
 end