steep 0.11.1 → 0.12.0

data/vendor/ruby-signature/stdlib/builtin/builtin.rbs

@@ -0,0 +1,35 @@
+interface _ToI
+  def to_i: -> Integer
+end
+
+interface _ToInt
+  def to_int: -> Integer
+end
+
+interface _ToS
+  def to_s: -> String
+end
+
+interface _ToStr
+  def to_str: () -> String
+end
+
+interface _ToHash[K, V]
+  def to_hash: () -> Hash[K, V]
+end
+
+interface _ToProc
+  def to_proc: () -> untyped
+end
+
+interface _Each[out A, out B]
+  def each: { (A) -> void } -> B
+end
+
+class BigDecimal
+end
+
+type int = Integer | _ToInt
+type real = Integer | Float | Rational
+
+type string = String | _ToStr

data/vendor/ruby-signature/stdlib/builtin/class.rbs

@@ -0,0 +1,145 @@
+# 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)
+#         print "Creating a new ", self.name, "\n"
+#         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'.
+#                              +---------+             +-...
+#                              |         |             |
+#              BasicObject-----|-->(BasicObject)-------|-...
+#                  ^           |         ^             |
+#                  |           |         |             |
+#               Object---------|----->(Object)---------|-...
+#                  ^           |         ^             |
+#                  |           |         |             |
+#                  +-------+   |         +--------+    |
+#                  |       |   |         |        |    |
+#                  |    Module-|---------|--->(Module)-|-...
+#                  |       ^   |         |        ^    |
+#                  |       |   |         |        |    |
+#                  |     Class-|---------|---->(Class)-|-...
+#                  |       ^   |         |        ^    |
+#                  |       +---+         |        +----+
+#                  |                     |
+#     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"
+  #       end
+  #       def meth2
+  #         "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/vendor/ruby-signature/stdlib/builtin/comparable.rbs

@@ -0,0 +1,116 @@
+# The Comparable mixin is used by classes whose objects may be ordered. The
+# class must define the `<=>` operator, which compares the receiver against
+# another object, returning a value less than 0, returning 0, or returning a
+# value greater than 0, depending on whether the receiver is less than, equal
+# to, or greater than the other object. If the other object is not comparable
+# then the `<=>` operator should return `nil`. Comparable uses `<=>` to
+# implement the conventional comparison operators (`<`, `<=`, `==`, `>=`, and
+# `>`) and the method `between?`.
+#
+#     class SizeMatters
+#       include Comparable
+#       attr :str
+#       def <=>(other)
+#         str.size <=> other.str.size
+#       end
+#       def initialize(str)
+#         @str = str
+#       end
+#       def inspect
+#         @str
+#       end
+#     end
+#
+#     s1 = SizeMatters.new("Z")
+#     s2 = SizeMatters.new("YY")
+#     s3 = SizeMatters.new("XXX")
+#     s4 = SizeMatters.new("WWWW")
+#     s5 = SizeMatters.new("VVVVV")
+#
+#     s1 < s2                       #=> true
+#     s4.between?(s1, s3)           #=> false
+#     s4.between?(s3, s5)           #=> true
+#     [ s3, s2, s5, s4, s1 ].sort   #=> [Z, YY, XXX, WWWW, VVVVV]
+#
+module Comparable : _WithSpaceshipOperator
+  # Compares two objects based on the receiver's `<=>` method, returning true if
+  # it returns a value less than 0.
+  #
+  def <: (untyped other) -> bool
+
+  # Compares two objects based on the receiver's `<=>` method, returning true if
+  # it returns a value less than or equal to 0.
+  #
+  def <=: (untyped other) -> bool
+
+  # Compares two objects based on the receiver's `<=>` method, returning true if
+  # it returns 0. Also returns true if *obj* and *other* are the same object.
+  #
+  def ==: (untyped other) -> bool
+
+  # Compares two objects based on the receiver's `<=>` method, returning true if
+  # it returns a value greater than 0.
+  #
+  def >: (untyped other) -> bool
+
+  # Compares two objects based on the receiver's `<=>` method, returning true if
+  # it returns a value greater than or equal to 0.
+  #
+  def >=: (untyped other) -> bool
+
+  # Returns `false` if *obj* `<=>` *min* is less than zero or if *obj* `<=>` *max*
+  # is greater than zero, `true` otherwise.
+  #
+  #     3.between?(1, 5)               #=> true
+  #     6.between?(1, 5)               #=> false
+  #     'cat'.between?('ant', 'dog')   #=> true
+  #     'gnu'.between?('ant', 'dog')   #=> false
+  #
+  def between?: (untyped min, untyped max) -> bool
+
+  # In `(min, max)` form, returns *min* if *obj* `<=>` *min* is less than zero,
+  # *max* if *obj* `<=>` *max* is greater than zero, and *obj* otherwise.
+  #
+  #     12.clamp(0, 100)         #=> 12
+  #     523.clamp(0, 100)        #=> 100
+  #     -3.123.clamp(0, 100)     #=> 0
+  #
+  #     'd'.clamp('a', 'f')      #=> 'd'
+  #     'z'.clamp('a', 'f')      #=> 'f'
+  #
+  # In `(range)` form, returns *range.begin* if *obj* `<=>` *range.begin* is less
+  # than zero, *range.end* if *obj* `<=>` *range.end* is greater than zero, and
+  # *obj* otherwise.
+  #
+  #     12.clamp(0..100)         #=> 12
+  #     523.clamp(0..100)        #=> 100
+  #     -3.123.clamp(0..100)     #=> 0
+  #
+  #     'd'.clamp('a'..'f')      #=> 'd'
+  #     'z'.clamp('a'..'f')      #=> 'f'
+  #
+  # If *range.begin* is `nil`, it is considered smaller than *obj*, and if
+  # *range.end* is `nil`, it is considered greater than *obj*.
+  #
+  #     -20.clamp(0..)           #=> 0
+  #     523.clamp(..100)         #=> 100
+  #
+  # When *range.end* is excluded and not `nil`, an exception is raised.
+  #
+  #     100.clamp(0...100)       # ArgumentError
+  #
+  def clamp: [A, B] (A min, B max) -> (self | A | B)
+           | [A] (Range[A]) -> (self | A)
+end
+
+# This interface defines the condition for Comparable mixin.
+#
+interface Comparable::_WithSpaceshipOperator
+  # `<=>` operator must return Integer or `nil`.
+  # If `other` is greater than `self`, it returns a positive Integer.
+  # If `other` equals to `self`, it returns zero.
+  # If `other` is less than `self`, it returns a positive Integer.
+  # If no comparison is defined with `other` and `self`, it returns `nil`.
+  #
+  def <=>: (untyped other) -> Integer?
+end

data/vendor/ruby-signature/stdlib/builtin/complex.rbs

@@ -0,0 +1,400 @@
+# 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
+
+  def <=: (Numeric) -> bot
+
+  # 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
+
+  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
+
+  def clone: (?freeze: bool) -> self
+
+  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
+
+  def divmod: (Numeric) -> bot
+
+  def dup: () -> self
+
+  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
+
+  def hash: () -> Integer
+
+  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
+
+  def negative?: () -> bot
+
+  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
+
+  def round: (*untyped) -> bot
+
+  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
+
+  def zero?: () -> bool
+end
+
+# The imaginary unit.
+# 
+Complex::I: Complex