steep 0.14.0 → 0.16.3

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

@@ -1,35 +0,0 @@
-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

@@ -1,145 +0,0 @@
-# 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

@@ -1,116 +0,0 @@
-# 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

@@ -1,400 +0,0 @@
-# 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