rbs 0.13.1 → 0.14.0

data/stdlib/builtin/binding.rbs

@@ -4,10 +4,10 @@
 # in this context are all retained. Binding objects can be created using
 # Kernel#binding, and are made available to the callback of
 # Kernel#set_trace_func and instances of TracePoint.
-# 
+#
 # These binding objects can be passed as the second argument of the Kernel#eval
 # method, establishing an environment for the evaluation.
-# 
+#
 #     class Demo
 #       def initialize(n)
 #         @secret = n
@@ -16,39 +16,39 @@
 #         binding
 #       end
 #     end
-# 
+#
 #     k1 = Demo.new(99)
 #     b1 = k1.get_binding
 #     k2 = Demo.new(-3)
 #     b2 = k2.get_binding
-# 
+#
 #     eval("@secret", b1)   #=> 99
 #     eval("@secret", b2)   #=> -3
 #     eval("@secret")       #=> nil
-# 
+#
 # Binding objects have no class-specific methods.
-# 
+#
 class Binding
   public
 
   # Evaluates the Ruby expression(s) in *string*, in the *binding*'s context.  If
   # the optional *filename* and *lineno* parameters are present, they will be used
   # when reporting syntax errors.
-  # 
+  #
   #     def get_binding(param)
   #       binding
   #     end
   #     b = get_binding("hello")
   #     b.eval("param")   #=> "hello"
-  # 
+  #
   def eval: (String arg0, ?String filename, ?Integer lineno) -> untyped
 
   # Opens an IRB session where `binding.irb` is called which allows for
   # interactive debugging. You can call any methods or variables available in the
   # current scope, and mutate state if you need to.
-  # 
+  #
   # Given a Ruby file called `potato.rb` containing the following code:
-  # 
+  #
   #     class Potato
   #       def initialize
   #         @cooked = false
@@ -56,16 +56,16 @@ class Binding
   #         puts "Cooked potato: #{@cooked}"
   #       end
   #     end
-  # 
+  #
   #     Potato.new
-  # 
+  #
   # Running `ruby potato.rb` will open an IRB session where `binding.irb` is
   # called, and you will see the following:
-  # 
+  #
   #     $ ruby potato.rb
-  # 
+  #
   #     From: potato.rb @ line 4 :
-  # 
+  #
   #         1: class Potato
   #         2:   def initialize
   #         3:     @cooked = false
@@ -75,12 +75,12 @@ class Binding
   #         7: end
   #         8:
   #         9: Potato.new
-  # 
+  #
   #     irb(#<Potato:0x00007feea1916670>):001:0>
-  # 
+  #
   # You can type any valid Ruby code and it will be evaluated in the current
   # context. This allows you to debug without having to run your code repeatedly:
-  # 
+  #
   #     irb(#<Potato:0x00007feea1916670>):001:0> @cooked
   #     => false
   #     irb(#<Potato:0x00007feea1916670>):002:0> self.class
@@ -89,89 +89,89 @@ class Binding
   #     => ".../2.5.1/lib/ruby/2.5.0/irb/workspace.rb:85:in `eval'"
   #     irb(#<Potato:0x00007feea1916670>):004:0> @cooked = true
   #     => true
-  # 
+  #
   # You can exit the IRB session with the `exit` command. Note that exiting will
   # resume execution where `binding.irb` had paused it, as you can see from the
   # output printed to standard output in this example:
-  # 
+  #
   #     irb(#<Potato:0x00007feea1916670>):005:0> exit
   #     Cooked potato: true
-  # 
+  #
   # See IRB@IRB+Usage for more information.
-  # 
+  #
   def irb: () -> void
 
   # Returns `true` if a local variable `symbol` exists.
-  # 
+  #
   #     def foo
   #       a = 1
   #       binding.local_variable_defined?(:a) #=> true
   #       binding.local_variable_defined?(:b) #=> false
   #     end
-  # 
+  #
   # This method is the short version of the following code:
-  # 
+  #
   #     binding.eval("defined?(#{symbol}) == 'local-variable'")
-  # 
+  #
   def local_variable_defined?: (String | Symbol symbol) -> bool
 
   # Returns the value of the local variable `symbol`.
-  # 
+  #
   #     def foo
   #       a = 1
   #       binding.local_variable_get(:a) #=> 1
   #       binding.local_variable_get(:b) #=> NameError
   #     end
-  # 
+  #
   # This method is the short version of the following code:
-  # 
+  #
   #     binding.eval("#{symbol}")
-  # 
+  #
   def local_variable_get: (String | Symbol symbol) -> untyped
 
   # Set local variable named `symbol` as `obj`.
-  # 
+  #
   #     def foo
   #       a = 1
   #       bind = binding
   #       bind.local_variable_set(:a, 2) # set existing local variable `a'
   #       bind.local_variable_set(:b, 3) # create new local variable `b'
   #                                      # `b' exists only in binding
-  # 
+  #
   #       p bind.local_variable_get(:a)  #=> 2
   #       p bind.local_variable_get(:b)  #=> 3
   #       p a                            #=> 2
   #       p b                            #=> NameError
   #     end
-  # 
+  #
   # This method behaves similarly to the following code:
-  # 
+  #
   #     binding.eval("#{symbol} = #{obj}")
-  # 
+  #
   # if `obj` can be dumped in Ruby code.
-  # 
+  #
   def local_variable_set: [U] (String | Symbol symbol, U obj) -> U
 
   # Returns the names of the binding's local variables as symbols.
-  # 
+  #
   #     def foo
   #       a = 1
   #       2.times do |n|
   #         binding.local_variables #=> [:a, :n]
   #       end
   #     end
-  # 
+  #
   # This method is the short version of the following code:
-  # 
+  #
   #     binding.eval("local_variables")
-  # 
+  #
   def local_variables: () -> Array[Symbol]
 
   # Returns the bound receiver of the binding object.
-  # 
+  #
   def receiver: () -> untyped
 
   # Returns the Ruby source filename and line number of the binding object.
-  # 
+  #
   def source_location: () -> [ String, Integer ]
 end

data/stdlib/builtin/class.rbs

@@ -1,18 +1,18 @@
 # Extends any Class to include *json_creatable?* method.
 # Classes in Ruby are first-class objects---each is an instance of class Class.
-# 
+#
 # Typically, you create a new class by using:
-# 
+#
 #     class Name
 #      # some code describing the class behavior
 #     end
-# 
+#
 # When a new class is created, an object of type Class is initialized and
 # assigned to a global constant (Name in this case).
-# 
+#
 # When `Name.new` is called to create a new object, the #new method in Class is
 # run by default. This can be demonstrated by overriding #new in Class:
-# 
+#
 #     class Class
 #       alias old_new new
 #       def new(*args)
@@ -20,16 +20,16 @@
 #         old_new(*args)
 #       end
 #     end
-# 
+#
 #     class Name
 #     end
-# 
+#
 #     n = Name.new
-# 
+#
 # *produces:*
-# 
+#
 #     Creating a new Name
-# 
+#
 # Classes, modules, and objects are interrelated. In the diagram that follows,
 # the vertical arrows represent inheritance, and the parentheses metaclasses.
 # All metaclasses are instances of the class `Class'.
@@ -51,15 +51,15 @@
 #                  |       +---+         |        +----+
 #                  |                     |
 #     obj--->OtherClass---------->(OtherClass)-----------...
-# 
+#
 class Class < Module
   # Creates a new anonymous (unnamed) class with the given superclass (or Object
   # if no parameter is given). You can give a class a name by assigning the class
   # object to a constant.
-  # 
+  #
   # If a block is given, it is passed the class object, and the block is evaluated
   # in the context of this class like #class_eval.
-  # 
+  #
   #     fred = Class.new do
   #       def meth1
   #         "hello"
@@ -68,78 +68,78 @@ class Class < Module
   #         "bye"
   #       end
   #     end
-  # 
+  #
   #     a = fred.new     #=> #<#<Class:0x100381890>:0x100376b98>
   #     a.meth1          #=> "hello"
   #     a.meth2          #=> "bye"
-  # 
+  #
   # Assign the class to a constant (name starting uppercase) if you want to treat
   # it like a regular class.
-  # 
+  #
   def initialize: (?Class superclass) ?{ (Class newclass) -> void } -> void
 
   # Allocates space for a new object of *class*'s class and does not call
   # initialize on the new instance. The returned object must be an instance of
   # *class*.
-  # 
+  #
   #     klass = Class.new do
   #       def initialize(*args)
   #         @initialized = true
   #       end
-  # 
+  #
   #       def initialized?
   #         @initialized || false
   #       end
   #     end
-  # 
+  #
   #     klass.allocate.initialized? #=> false
-  # 
+  #
   def allocate: () -> untyped
 
   # Callback invoked whenever a subclass of the current class is created.
-  # 
+  #
   # Example:
-  # 
+  #
   #     class Foo
   #       def self.inherited(subclass)
   #         puts "New subclass: #{subclass}"
   #       end
   #     end
-  # 
+  #
   #     class Bar < Foo
   #     end
-  # 
+  #
   #     class Baz < Bar
   #     end
-  # 
+  #
   # *produces:*
-  # 
+  #
   #     New subclass: Bar
   #     New subclass: Baz
-  # 
+  #
   def inherited: (Class arg0) -> untyped
 
   # Calls #allocate to create a new object of *class*'s class, then invokes that
   # object's #initialize method, passing it *args*.  This is the method that ends
   # up getting called whenever an object is constructed using `.new`.
-  # 
+  #
   def new: () -> untyped
 
   # Returns the superclass of *class*, or `nil`.
-  # 
+  #
   #     File.superclass          #=> IO
   #     IO.superclass            #=> Object
   #     Object.superclass        #=> BasicObject
   #     class Foo; end
   #     class Bar < Foo; end
   #     Bar.superclass           #=> Foo
-  # 
+  #
   # Returns nil when the given class does not have a parent class:
-  # 
+  #
   #     BasicObject.superclass   #=> nil
-  # 
+  #
   # # arglists
   #     class.superclass -> a_super_class or nil
-  # 
+  #
   def `superclass`: () -> Class?
 end

data/stdlib/builtin/complex.rbs

@@ -1,110 +1,110 @@
 # A complex number can be represented as a paired real number with imaginary
 # unit; a+bi.  Where a is real part, b is imaginary part and i is imaginary
 # unit.  Real a equals complex a+0i mathematically.
-# 
+#
 # Complex object can be created as literal, and also by using Kernel#Complex,
 # Complex::rect, Complex::polar or to_c method.
-# 
+#
 #     2+1i                 #=> (2+1i)
 #     Complex(1)           #=> (1+0i)
 #     Complex(2, 3)        #=> (2+3i)
 #     Complex.polar(2, 3)  #=> (-1.9799849932008908+0.2822400161197344i)
 #     3.to_c               #=> (3+0i)
-# 
+#
 # You can also create complex object from floating-point numbers or strings.
-# 
+#
 #     Complex(0.3)         #=> (0.3+0i)
 #     Complex('0.3-0.5i')  #=> (0.3-0.5i)
 #     Complex('2/3+3/4i')  #=> ((2/3)+(3/4)*i)
 #     Complex('1@2')       #=> (-0.4161468365471424+0.9092974268256817i)
-# 
+#
 #     0.3.to_c             #=> (0.3+0i)
 #     '0.3-0.5i'.to_c      #=> (0.3-0.5i)
 #     '2/3+3/4i'.to_c      #=> ((2/3)+(3/4)*i)
 #     '1@2'.to_c           #=> (-0.4161468365471424+0.9092974268256817i)
-# 
+#
 # A complex object is either an exact or an inexact number.
-# 
+#
 #     Complex(1, 1) / 2    #=> ((1/2)+(1/2)*i)
 #     Complex(1, 1) / 2.0  #=> (0.5+0.5i)
-# 
+#
 class Complex < Numeric
   # Returns a complex object which denotes the given polar form.
-  # 
+  #
   #     Complex.polar(3, 0)            #=> (3.0+0.0i)
   #     Complex.polar(3, Math::PI/2)   #=> (1.836909530733566e-16+3.0i)
   #     Complex.polar(3, Math::PI)     #=> (-3.0+3.673819061467132e-16i)
   #     Complex.polar(3, -Math::PI/2)  #=> (1.836909530733566e-16-3.0i)
-  # 
+  #
   def self.polar: (Numeric, ?Numeric) -> Complex
 
   # Returns a complex object which denotes the given rectangular form.
-  # 
+  #
   #     Complex.rectangular(1, 2)  #=> (1+2i)
-  # 
+  #
   def self.rect: (Numeric, ?Numeric) -> Complex
 
   # Returns a complex object which denotes the given rectangular form.
-  # 
+  #
   #     Complex.rectangular(1, 2)  #=> (1+2i)
-  # 
+  #
   alias self.rectangular self.rect
 
   public
 
   # Performs multiplication.
-  # 
+  #
   #     Complex(2, 3)  * Complex(2, 3)   #=> (-5+12i)
   #     Complex(900)   * Complex(1)      #=> (900+0i)
   #     Complex(-2, 9) * Complex(-9, 2)  #=> (0-85i)
   #     Complex(9, 8)  * 4               #=> (36+32i)
   #     Complex(20, 9) * 9.8             #=> (196.0+88.2i)
-  # 
+  #
   def *: (Numeric) -> Complex
 
   # Performs exponentiation.
-  # 
+  #
   #     Complex('i') ** 2              #=> (-1+0i)
   #     Complex(-8) ** Rational(1, 3)  #=> (1.0000000000000002+1.7320508075688772i)
-  # 
+  #
   def **: (Numeric) -> Complex
 
   # Performs addition.
-  # 
+  #
   #     Complex(2, 3)  + Complex(2, 3)   #=> (4+6i)
   #     Complex(900)   + Complex(1)      #=> (901+0i)
   #     Complex(-2, 9) + Complex(-9, 2)  #=> (-11+11i)
   #     Complex(9, 8)  + 4               #=> (13+8i)
   #     Complex(20, 9) + 9.8             #=> (29.8+9i)
-  # 
+  #
   def +: (Numeric) -> Complex
 
   def +@: () -> Complex
 
   # Performs subtraction.
-  # 
+  #
   #     Complex(2, 3)  - Complex(2, 3)   #=> (0+0i)
   #     Complex(900)   - Complex(1)      #=> (899+0i)
   #     Complex(-2, 9) - Complex(-9, 2)  #=> (7+7i)
   #     Complex(9, 8)  - 4               #=> (5+8i)
   #     Complex(20, 9) - 9.8             #=> (10.2+9i)
-  # 
+  #
   def -: (Numeric) -> Complex
 
   # Returns negation of the value.
-  # 
+  #
   #     -Complex(1, 2)  #=> (-1-2i)
-  # 
+  #
   def -@: () -> Complex
 
   # Performs division.
-  # 
+  #
   #     Complex(2, 3)  / Complex(2, 3)   #=> ((1/1)+(0/1)*i)
   #     Complex(900)   / Complex(1)      #=> ((900/1)+(0/1)*i)
   #     Complex(-2, 9) / Complex(-9, 2)  #=> ((36/85)-(77/85)*i)
   #     Complex(9, 8)  / 4               #=> ((9/4)+(2/1)*i)
   #     Complex(20, 9) / 9.8             #=> (2.0408163265306123+0.9183673469387754i)
-  # 
+  #
   def /: (Numeric) -> Complex
 
   def <: (Numeric) -> bot
@@ -114,23 +114,23 @@ class Complex < Numeric
   # If `cmp`'s imaginary part is zero, and `object` is also a real number (or a
   # Complex number where the imaginary part is zero), compare the real part of
   # `cmp` to object.  Otherwise, return nil.
-  # 
+  #
   #     Complex(2, 3)  <=> Complex(2, 3)   #=> nil
   #     Complex(2, 3)  <=> 1               #=> nil
   #     Complex(2)     <=> 1               #=> 1
   #     Complex(2)     <=> 2               #=> 0
   #     Complex(2)     <=> 3               #=> -1
-  # 
+  #
   def <=>: (Numeric) -> Integer?
 
   # Returns true if cmp equals object numerically.
-  # 
+  #
   #     Complex(2, 3)  == Complex(2, 3)   #=> true
   #     Complex(5)     == 5               #=> true
   #     Complex(0)     == 0.0             #=> true
   #     Complex('1/3') == 0.33            #=> false
   #     Complex('1/2') == '1/2'           #=> false
-  # 
+  #
   def ==: (untyped) -> bool
 
   def >: (Numeric) -> bot
@@ -138,29 +138,29 @@ class Complex < Numeric
   def >=: (Numeric) -> bot
 
   # Returns the absolute part of its polar form.
-  # 
+  #
   #     Complex(-1).abs         #=> 1
   #     Complex(3.0, -4.0).abs  #=> 5.0
-  # 
+  #
   def abs: () -> Numeric
 
   # Returns square of the absolute value.
-  # 
+  #
   #     Complex(-1).abs2         #=> 1
   #     Complex(3.0, -4.0).abs2  #=> 25.0
-  # 
+  #
   def abs2: () -> Numeric
 
   # Returns the angle part of its polar form.
-  # 
+  #
   #     Complex.polar(3, Math::PI/2).arg  #=> 1.5707963267948966
-  # 
+  #
   def angle: () -> Float
 
   # Returns the angle part of its polar form.
-  # 
+  #
   #     Complex.polar(3, Math::PI/2).arg  #=> 1.5707963267948966
-  # 
+  #
   alias arg angle
 
   def ceil: (*untyped) -> bot
@@ -170,21 +170,21 @@ class Complex < Numeric
   def coerce: (Numeric) -> [ Complex, Complex ]
 
   # Returns the complex conjugate.
-  # 
+  #
   #     Complex(1, 2).conjugate  #=> (1-2i)
-  # 
+  #
   def conj: () -> Complex
 
   # Returns the complex conjugate.
-  # 
+  #
   #     Complex(1, 2).conjugate  #=> (1-2i)
-  # 
+  #
   def conjugate: () -> Complex
 
   # Returns the denominator (lcm of both denominator - real and imag).
-  # 
+  #
   # See numerator.
-  # 
+  #
   def denominator: () -> Integer
 
   def div: (Numeric) -> bot
@@ -196,14 +196,14 @@ class Complex < Numeric
   def eql?: (untyped) -> bool
 
   # Performs division as each part is a float, never returns a float.
-  # 
+  #
   #     Complex(11, 22).fdiv(3)  #=> (3.6666666666666665+7.333333333333333i)
-  # 
+  #
   def fdiv: (Numeric) -> Complex
 
   # Returns `true` if `cmp`'s real and imaginary parts are both finite numbers,
   # otherwise returns `false`.
-  # 
+  #
   def finite?: () -> bool
 
   def floor: (?Integer) -> bot
@@ -213,46 +213,46 @@ class Complex < Numeric
   def i: () -> bot
 
   # Returns the imaginary part.
-  # 
+  #
   #     Complex(7).imaginary      #=> 0
   #     Complex(9, -4).imaginary  #=> -4
-  # 
+  #
   def imag: () -> Numeric
 
   # Returns the imaginary part.
-  # 
+  #
   #     Complex(7).imaginary      #=> 0
   #     Complex(9, -4).imaginary  #=> -4
-  # 
+  #
   def imaginary: () -> Numeric
 
   # Returns `1` if `cmp`'s real or imaginary part is an infinite number, otherwise
   # returns `nil`.
-  # 
+  #
   #     For example:
-  # 
+  #
   #        (1+1i).infinite?                   #=> nil
   #        (Float::INFINITY + 1i).infinite?   #=> 1
-  # 
+  #
   def infinite?: () -> Integer?
 
   # Returns the value as a string for inspection.
-  # 
+  #
   #     Complex(2).inspect                       #=> "(2+0i)"
   #     Complex('-8/6').inspect                  #=> "((-4/3)+0i)"
   #     Complex('1/2i').inspect                  #=> "(0+(1/2)*i)"
   #     Complex(0, Float::INFINITY).inspect      #=> "(0+Infinity*i)"
   #     Complex(Float::NAN, Float::NAN).inspect  #=> "(NaN+NaN*i)"
-  # 
+  #
   def inspect: () -> String
 
   def integer?: () -> bool
 
   # Returns the absolute part of its polar form.
-  # 
+  #
   #     Complex(-1).abs         #=> 1
   #     Complex(3.0, -4.0).abs  #=> 5.0
-  # 
+  #
   alias magnitude abs
 
   def modulo: (Numeric) -> bot
@@ -262,78 +262,78 @@ class Complex < Numeric
   def nonzero?: () -> self?
 
   # Returns the numerator.
-  # 
+  #
   #         1   2       3+4i  <-  numerator
   #         - + -i  ->  ----
   #         2   3        6    <-  denominator
-  # 
+  #
   #     c = Complex('1/2+2/3i')  #=> ((1/2)+(2/3)*i)
   #     n = c.numerator          #=> (3+4i)
   #     d = c.denominator        #=> 6
   #     n / d                    #=> ((1/2)+(2/3)*i)
   #     Complex(Rational(n.real, d), Rational(n.imag, d))
   #                              #=> ((1/2)+(2/3)*i)
-  # 
+  #
   # See denominator.
-  # 
+  #
   def numerator: () -> Complex
 
   # Returns the angle part of its polar form.
-  # 
+  #
   #     Complex.polar(3, Math::PI/2).arg  #=> 1.5707963267948966
-  # 
+  #
   alias phase angle
 
   # Returns an array; [cmp.abs, cmp.arg].
-  # 
+  #
   #     Complex(1, 2).polar  #=> [2.23606797749979, 1.1071487177940904]
-  # 
+  #
   def polar: () -> [Numeric, Float]
 
   def positive?: () -> bot
 
   # Performs division.
-  # 
+  #
   #     Complex(2, 3)  / Complex(2, 3)   #=> ((1/1)+(0/1)*i)
   #     Complex(900)   / Complex(1)      #=> ((900/1)+(0/1)*i)
   #     Complex(-2, 9) / Complex(-9, 2)  #=> ((36/85)-(77/85)*i)
   #     Complex(9, 8)  / 4               #=> ((9/4)+(2/1)*i)
   #     Complex(20, 9) / 9.8             #=> (2.0408163265306123+0.9183673469387754i)
-  # 
+  #
   def quo: (Numeric) -> Complex
 
   # Returns the value as a rational if possible (the imaginary part should be
   # exactly zero).
-  # 
+  #
   #     Complex(1.0/3, 0).rationalize  #=> (1/3)
   #     Complex(1, 0.0).rationalize    # RangeError
   #     Complex(1, 2).rationalize      # RangeError
-  # 
+  #
   # See to_r.
-  # 
+  #
   def rationalize: (?Numeric eps) -> Rational
 
   # Returns the real part.
-  # 
+  #
   #     Complex(7).real      #=> 7
   #     Complex(9, -4).real  #=> 9
-  # 
+  #
   def real: () -> Numeric
 
   # Returns false, even if the complex number has no imaginary part.
-  # 
+  #
   def real?: () -> false
 
   # Returns an array; [cmp.real, cmp.imag].
-  # 
+  #
   #     Complex(1, 2).rectangular  #=> [1, 2]
-  # 
+  #
   def rect: () -> [Numeric, Numeric]
 
   # Returns an array; [cmp.real, cmp.imag].
-  # 
+  #
   #     Complex(1, 2).rectangular  #=> [1, 2]
-  # 
+  #
   alias rectangular rect
 
   def reminder: (Numeric) -> bot
@@ -343,51 +343,51 @@ class Complex < Numeric
   def step: (*untyped) ?{ (*untyped) -> untyped } -> bot
 
   # Returns self.
-  # 
+  #
   #     Complex(2).to_c      #=> (2+0i)
   #     Complex(-8, 6).to_c  #=> (-8+6i)
-  # 
+  #
   def to_c: () -> Complex
 
   # Returns the value as a float if possible (the imaginary part should be exactly
   # zero).
-  # 
+  #
   #     Complex(1, 0).to_f    #=> 1.0
   #     Complex(1, 0.0).to_f  # RangeError
   #     Complex(1, 2).to_f    # RangeError
-  # 
+  #
   def to_f: () -> Float
 
   # Returns the value as an integer if possible (the imaginary part should be
   # exactly zero).
-  # 
+  #
   #     Complex(1, 0).to_i    #=> 1
   #     Complex(1, 0.0).to_i  # RangeError
   #     Complex(1, 2).to_i    # RangeError
-  # 
+  #
   def to_i: () -> Integer
 
   alias to_int to_i
 
   # Returns the value as a rational if possible (the imaginary part should be
   # exactly zero).
-  # 
+  #
   #     Complex(1, 0).to_r    #=> (1/1)
   #     Complex(1, 0.0).to_r  # RangeError
   #     Complex(1, 2).to_r    # RangeError
-  # 
+  #
   # See rationalize.
-  # 
+  #
   def to_r: () -> Rational
 
   # Returns the value as a string.
-  # 
+  #
   #     Complex(2).to_s                       #=> "2+0i"
   #     Complex('-8/6').to_s                  #=> "-4/3+0i"
   #     Complex('1/2i').to_s                  #=> "0+1/2i"
   #     Complex(0, Float::INFINITY).to_s      #=> "0+Infinity*i"
   #     Complex(Float::NAN, Float::NAN).to_s  #=> "NaN+NaN*i"
-  # 
+  #
   def to_s: () -> String
 
   def truncate: (?Integer) -> bot
@@ -396,5 +396,5 @@ class Complex < Numeric
 end
 
 # The imaginary unit.
-# 
+#
 Complex::I: Complex