rbs 0.12.2 → 0.16.0

data/core/builtin.rbs

@@ -0,0 +1,70 @@
+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 _ToPath
+  def to_path: () -> String
+end
+
+interface _Each[out A, out B]
+  def each: { (A) -> void } -> B
+end
+
+interface _Reader
+  def read: (?int length, ?string outbuf) -> String?
+end
+
+interface _Writer
+  # Writes the +data+ string. Returns the number of bytes written
+  def write: (*_ToS data) -> Integer
+end
+
+interface _Rewindable
+  # Positions the stream to the beginning of input, resetting `lineno` to zero.
+  #
+  def rewind: () -> Integer
+end
+
+interface _ToIO
+  def to_io: () -> IO
+end
+
+interface _Exception
+  def exception: () -> Exception
+               | (String arg0) -> Exception
+end
+
+type int = Integer | _ToInt
+type real = Integer | Float | Rational
+
+type string = String | _ToStr
+type encoding = Encoding | string
+
+type io = IO | _ToIO
+
+# `boolish` is a type for documentation.
+# It means the value of this type is only for testing a condition.
+# Unlike `bool` type, it doesn't require the value is one of `true` or `false`.
+# Any Ruby object can have `boolish` type.
+#
+type boolish = top

data/{stdlib/builtin → core}/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 → core}/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