rbs 0.10.0 → 0.13.0

data/stdlib/bigdecimal/math/big_math.rbs

@@ -0,0 +1,142 @@
+# Provides mathematical functions.
+#
+# Example:
+#
+#     require "bigdecimal/math"
+#
+#     include BigMath
+#
+#     a = BigDecimal((PI(100)/2).to_s)
+#     puts sin(a,100) # => 0.99999999999999999999......e0
+#
+module BigMath
+  # Computes e (the base of natural logarithms) to the specified number of digits
+  # of precision, `numeric`.
+  #
+  #     BigMath.E(10).to_s
+  #     #=> "0.271828182845904523536028752390026306410273e1"
+  #
+  def self.E: (Numeric prec) -> BigDecimal
+
+  # Computes the value of pi to the specified number of digits of precision,
+  # `numeric`.
+  #
+  #     BigMath.PI(10).to_s
+  #     #=> "0.3141592653589793238462643388813853786957412e1"
+  #
+  def self.PI: (Numeric prec) -> BigDecimal
+
+  # Computes the arctangent of `decimal` to the specified number of digits of
+  # precision, `numeric`.
+  #
+  # If `decimal` is NaN, returns NaN.
+  #
+  #     BigMath.atan(BigDecimal('-1'), 16).to_s
+  #     #=> "-0.785398163397448309615660845819878471907514682065e0"
+  #
+  def self.atan: (BigDecimal x, Numeric prec) -> BigDecimal
+
+  # Computes the cosine of `decimal` to the specified number of digits of
+  # precision, `numeric`.
+  #
+  # If `decimal` is Infinity or NaN, returns NaN.
+  #
+  #     BigMath.cos(BigMath.PI(4), 16).to_s
+  #     #=> "-0.999999999999999999999999999999856613163740061349e0"
+  #
+  def self.cos: (BigDecimal x, Numeric prec) -> BigDecimal
+
+  # Computes the value of e (the base of natural logarithms) raised to the power
+  # of `decimal`, to the specified number of digits of precision.
+  #
+  # If `decimal` is infinity, returns Infinity.
+  #
+  # If `decimal` is NaN, returns NaN.
+  #
+  def self.exp: (BigDecimal, Numeric prec) -> BigDecimal
+
+  # Computes the natural logarithm of `decimal` to the specified number of digits
+  # of precision, `numeric`.
+  #
+  # If `decimal` is zero or negative, raises Math::DomainError.
+  #
+  # If `decimal` is positive infinity, returns Infinity.
+  #
+  # If `decimal` is NaN, returns NaN.
+  #
+  def self.log: (BigDecimal, Numeric prec) -> BigDecimal
+
+  # Computes the sine of `decimal` to the specified number of digits of precision,
+  # `numeric`.
+  #
+  # If `decimal` is Infinity or NaN, returns NaN.
+  #
+  #     BigMath.sin(BigMath.PI(5)/4, 5).to_s
+  #     #=> "0.70710678118654752440082036563292800375e0"
+  #
+  def self.sin: (BigDecimal x, Numeric prec) -> BigDecimal
+
+  # Computes the square root of `decimal` to the specified number of digits of
+  # precision, `numeric`.
+  #
+  #     BigMath.sqrt(BigDecimal('2'), 16).to_s
+  #     #=> "0.1414213562373095048801688724e1"
+  #
+  def self.sqrt: (BigDecimal x, Numeric prec) -> BigDecimal
+
+  private
+
+  # Computes e (the base of natural logarithms) to the specified number of digits
+  # of precision, `numeric`.
+  #
+  #     BigMath.E(10).to_s
+  #     #=> "0.271828182845904523536028752390026306410273e1"
+  #
+  def E: (Numeric prec) -> BigDecimal
+
+  # Computes the value of pi to the specified number of digits of precision,
+  # `numeric`.
+  #
+  #     BigMath.PI(10).to_s
+  #     #=> "0.3141592653589793238462643388813853786957412e1"
+  #
+  def PI: (Numeric prec) -> BigDecimal
+
+  # Computes the arctangent of `decimal` to the specified number of digits of
+  # precision, `numeric`.
+  #
+  # If `decimal` is NaN, returns NaN.
+  #
+  #     BigMath.atan(BigDecimal('-1'), 16).to_s
+  #     #=> "-0.785398163397448309615660845819878471907514682065e0"
+  #
+  def atan: (BigDecimal x, Numeric prec) -> BigDecimal
+
+  # Computes the cosine of `decimal` to the specified number of digits of
+  # precision, `numeric`.
+  #
+  # If `decimal` is Infinity or NaN, returns NaN.
+  #
+  #     BigMath.cos(BigMath.PI(4), 16).to_s
+  #     #=> "-0.999999999999999999999999999999856613163740061349e0"
+  #
+  def cos: (BigDecimal x, Numeric prec) -> BigDecimal
+
+  # Computes the sine of `decimal` to the specified number of digits of precision,
+  # `numeric`.
+  #
+  # If `decimal` is Infinity or NaN, returns NaN.
+  #
+  #     BigMath.sin(BigMath.PI(5)/4, 5).to_s
+  #     #=> "0.70710678118654752440082036563292800375e0"
+  #
+  def sin: (BigDecimal x, Numeric prec) -> BigDecimal
+
+  # Computes the square root of `decimal` to the specified number of digits of
+  # precision, `numeric`.
+  #
+  #     BigMath.sqrt(BigDecimal('2'), 16).to_s
+  #     #=> "0.1414213562373095048801688724e1"
+  #
+  def sqrt: (BigDecimal x, Numeric prec) -> BigDecimal
+end

data/stdlib/builtin/array.rbs

@@ -626,7 +626,8 @@ class Array[unchecked out Elem] < Object
   #     a.collect!.with_index {|x, i| x[0...i] }
   #     a #=>  ["", "b", "c!", "d!"]
   #
-  def collect!: () { (Elem item) -> Elem } -> self          # collect! is monomorphic because of RBS limitation.
+  # collect! is monomorphic because of RBS limitation.
+  def collect!: () { (Elem item) -> Elem } -> self
               | () -> ::Enumerator[Elem, self]
 
   # When invoked with a block, yields all combinations of length `n` of elements

data/stdlib/builtin/builtin.rbs

@@ -35,9 +35,6 @@ interface _Exception
                | (String arg0) -> Exception
 end
 
-class BigDecimal
-end
-
 type int = Integer | _ToInt
 type real = Integer | Float | Rational
 

data/stdlib/builtin/hash.rbs

@@ -1016,7 +1016,7 @@ class Hash[unchecked out K, unchecked out V] < Object
   #     h["d"]           #=> "Go Fish: d"
   #     h.keys           #=> ["c", "d"]
   #
-  incompatible def initialize: () -> void
+  def initialize: () -> void
                              | (untyped default) -> void
                              | [A, B] () { (Hash[A, B] hash, A key) -> B } -> void
 

data/stdlib/builtin/kernel.rbs

@@ -11,6 +11,8 @@
 # sprintf "%.1f", 1.234 #=> "1.2"
 # ```
 module Kernel
+  private
+  
   def caller: (?Integer start_or_range, ?Integer length) -> ::Array[String]?
             | (?::Range[Integer] start_or_range) -> ::Array[String]?
             | () -> ::Array[String]

data/stdlib/builtin/math.rbs

@@ -13,7 +13,7 @@ module Math
   #
   #     Math.acos(0) == Math::PI/2  #=> true
   #
-  def self.acos: (Integer | Float | Rational | BigDecimal x) -> Float
+  def self.acos: (Numeric x) -> Float
 
   # Computes the inverse hyperbolic cosine of `x`.
   #
@@ -23,7 +23,7 @@ module Math
   #
   #     Math.acosh(1) #=> 0.0
   #
-  def self.acosh: (Integer | Float | Rational | BigDecimal x) -> Float
+  def self.acosh: (Numeric x) -> Float
 
   # Computes the arc sine of `x`. Returns -PI/2..PI/2.
   #
@@ -33,7 +33,7 @@ module Math
   #
   #     Math.asin(1) == Math::PI/2  #=> true
   #
-  def self.asin: (Integer | Float | Rational | BigDecimal x) -> Float
+  def self.asin: (Numeric x) -> Float
 
   # Computes the inverse hyperbolic sine of `x`.
   #
@@ -43,7 +43,7 @@ module Math
   #
   #     Math.asinh(1) #=> 0.881373587019543
   #
-  def self.asinh: (Integer | Float | Rational | BigDecimal x) -> Float
+  def self.asinh: (Numeric x) -> Float
 
   # Computes the arc tangent of `x`. Returns -PI/2..PI/2.
   #
@@ -53,7 +53,7 @@ module Math
   #
   #     Math.atan(0) #=> 0.0
   #
-  def self.atan: (Integer | Float | Rational | BigDecimal x) -> Float
+  def self.atan: (Numeric x) -> Float
 
   # Computes the arc tangent given `y` and `x`. Returns a Float in the range
   # -PI..PI. Return value is a angle in radians between the positive x-axis of
@@ -78,7 +78,7 @@ module Math
   #     Math.atan2(-INFINITY, INFINITY)  #=> -0.7853981633974483
   #     Math.atan2(-INFINITY, -INFINITY) #=> -2.356194490192345
   #
-  def self.atan2: (Integer | Float | Rational | BigDecimal y, Integer | Float | Rational | BigDecimal x) -> Float
+  def self.atan2: (Numeric y, Numeric x) -> Float
 
   # Computes the inverse hyperbolic tangent of `x`.
   #
@@ -88,7 +88,7 @@ module Math
   #
   #     Math.atanh(1) #=> Infinity
   #
-  def self.atanh: (Integer | Float | Rational | BigDecimal x) -> Float
+  def self.atanh: (Numeric x) -> Float
 
   # Returns the cube root of `x`.
   #
@@ -119,7 +119,7 @@ module Math
   #     #   [8, 2.0, 8.0]
   #     #   [9, 2.0800838230519, 9.0]
   #
-  def self.cbrt: (Integer | Float | Rational | BigDecimal x) -> Float
+  def self.cbrt: (Numeric x) -> Float
 
   # Computes the cosine of `x` (expressed in radians). Returns a Float in the
   # range -1.0..1.0.
@@ -130,7 +130,7 @@ module Math
   #
   #     Math.cos(Math::PI) #=> -1.0
   #
-  def self.cos: (Integer | Float | Rational | BigDecimal x) -> Float
+  def self.cos: (Numeric x) -> Float
 
   # Computes the hyperbolic cosine of `x` (expressed in radians).
   #
@@ -140,7 +140,7 @@ module Math
   #
   #     Math.cosh(0) #=> 1.0
   #
-  def self.cosh: (Integer | Float | Rational | BigDecimal x) -> Float
+  def self.cosh: (Numeric x) -> Float
 
   # Calculates the error function of `x`.
   #
@@ -150,7 +150,7 @@ module Math
   #
   #     Math.erf(0) #=> 0.0
   #
-  def self.erf: (Integer | Float | Rational | BigDecimal x) -> Float
+  def self.erf: (Numeric x) -> Float
 
   # Calculates the complementary error function of x.
   #
@@ -160,7 +160,7 @@ module Math
   #
   #     Math.erfc(0) #=> 1.0
   #
-  def self.erfc: (Integer | Float | Rational | BigDecimal x) -> Float
+  def self.erfc: (Numeric x) -> Float
 
   # Returns e**x.
   #
@@ -172,7 +172,7 @@ module Math
   #     Math.exp(1)       #=> 2.718281828459045
   #     Math.exp(1.5)     #=> 4.4816890703380645
   #
-  def self.exp: (Integer | Float | Rational | BigDecimal x) -> Float
+  def self.exp: (Numeric x) -> Float
 
   # Returns a two-element array containing the normalized fraction (a Float) and
   # exponent (an Integer) of `x`.
@@ -180,7 +180,7 @@ module Math
   #     fraction, exponent = Math.frexp(1234)   #=> [0.6025390625, 11]
   #     fraction * 2**exponent                  #=> 1234.0
   #
-  def self.frexp: (Integer | Float | Rational | BigDecimal x) -> [ Float, Integer ]
+  def self.frexp: (Numeric x) -> [ Float, Integer ]
 
   # Calculates the gamma function of x.
   #
@@ -216,21 +216,21 @@ module Math
   #     #   [25, 6.204484017332391e+23, 620448401733239439360000]
   #     #   [26, 1.5511210043330954e+25, 15511210043330985984000000]
   #
-  def self.gamma: (Integer | Float | Rational | BigDecimal x) -> Float
+  def self.gamma: (Numeric x) -> Float
 
   # Returns sqrt(x**2 + y**2), the hypotenuse of a right-angled triangle with
   # sides `x` and `y`.
   #
   #     Math.hypot(3, 4)   #=> 5.0
   #
-  def self.hypot: (Integer | Float | Rational | BigDecimal x, Integer | Float | Rational | BigDecimal y) -> Float
+  def self.hypot: (Numeric x, Numeric y) -> Float
 
   # Returns the value of `fraction`*(2**`exponent`).
   #
   #     fraction, exponent = Math.frexp(1234)
   #     Math.ldexp(fraction, exponent)   #=> 1234.0
   #
-  def self.ldexp: (Integer | Float | Rational | BigDecimal fraction, Integer | Float | Rational | BigDecimal exponent) -> Float
+  def self.ldexp: (Numeric fraction, Numeric exponent) -> Float
 
   # Calculates the logarithmic gamma of `x` and the sign of gamma of `x`.
   #
@@ -241,9 +241,9 @@ module Math
   #
   #     Math.lgamma(0) #=> [Infinity, 1]
   #
-  def self.lgamma: (Integer | Float | Rational | BigDecimal x) -> [ Float, Integer ]
+  def self.lgamma: (Numeric x) -> [ Float, Integer ]
 
-  def self.log: (Integer | Float | Rational | BigDecimal x, ?Integer | Float | Rational | BigDecimal base) -> Float
+  def self.log: (Numeric x, ?Numeric base) -> Float
 
   # Returns the base 10 logarithm of `x`.
   #
@@ -255,7 +255,7 @@ module Math
   #     Math.log10(10)      #=> 1.0
   #     Math.log10(10**100) #=> 100.0
   #
-  def self.log10: (Integer | Float | Rational | BigDecimal x) -> Float
+  def self.log10: (Numeric x) -> Float
 
   # Returns the base 2 logarithm of `x`.
   #
@@ -268,7 +268,7 @@ module Math
   #     Math.log2(32768)  #=> 15.0
   #     Math.log2(65536)  #=> 16.0
   #
-  def self.log2: (Integer | Float | Rational | BigDecimal x) -> Float
+  def self.log2: (Numeric x) -> Float
 
   # Computes the sine of `x` (expressed in radians). Returns a Float in the range
   # -1.0..1.0.
@@ -279,7 +279,7 @@ module Math
   #
   #     Math.sin(Math::PI/2) #=> 1.0
   #
-  def self.sin: (Integer | Float | Rational | BigDecimal x) -> Float
+  def self.sin: (Numeric x) -> Float
 
   # Computes the hyperbolic sine of `x` (expressed in radians).
   #
@@ -289,7 +289,7 @@ module Math
   #
   #     Math.sinh(0) #=> 0.0
   #
-  def self.sinh: (Integer | Float | Rational | BigDecimal x) -> Float
+  def self.sinh: (Numeric x) -> Float
 
   # Returns the non-negative square root of `x`.
   #
@@ -319,7 +319,7 @@ module Math
   #
   # See also BigDecimal#sqrt and Integer.sqrt.
   #
-  def self.sqrt: (Integer | Float | Rational | BigDecimal x) -> Float
+  def self.sqrt: (Numeric x) -> Float
 
   # Computes the tangent of `x` (expressed in radians).
   #
@@ -329,7 +329,7 @@ module Math
   #
   #     Math.tan(0) #=> 0.0
   #
-  def self.tan: (Integer | Float | Rational | BigDecimal x) -> Float
+  def self.tan: (Numeric x) -> Float
 
   # Computes the hyperbolic tangent of `x` (expressed in radians).
   #
@@ -339,7 +339,7 @@ module Math
   #
   #     Math.tanh(0) #=> 0.0
   #
-  def self.tanh: (Integer | Float | Rational | BigDecimal x) -> Float
+  def self.tanh: (Numeric x) -> Float
 end
 
 # Definition of the mathematical constant E for Euler's number (e) as a Float

data/stdlib/builtin/struct.rbs

@@ -1,40 +1,39 @@
 # A [Struct](Struct) is a convenient way to bundle a
 # number of attributes together, using accessor methods, without having to
 # write an explicit class.
-# 
+#
 # The [Struct](Struct) class generates new subclasses
 # that hold a set of members and their values. For each member a reader
 # and writer method is created similar to
 # [Module\#attr\_accessor](https://ruby-doc.org/core-2.6.3/Module.html#method-i-attr_accessor)
 # .
-# 
+#
 # ```ruby
 # Customer = Struct.new(:name, :address) do
 #   def greeting
 #     "Hello #{name}!"
 #   end
 # end
-# 
+#
 # dave = Customer.new("Dave", "123 Main")
 # dave.name     #=> "Dave"
 # dave.greeting #=> "Hello Dave!"
 # ```
-# 
+#
 # See [::new](Struct#method-c-new) for further
 # examples of creating struct subclasses and instances.
-# 
+#
 # In the method descriptions that follow, a "member" parameter refers to a
 # struct member which is either a quoted string ( `"name"` ) or a
 # [Symbol](https://ruby-doc.org/core-2.6.3/Symbol.html) ( `:name` ).
 class Struct[Elem] < Object
   include Enumerable[Elem, Struct[Elem]]
 
-  def initialize: (Symbol | String arg0, *Symbol | String arg1, ?keyword_init: bool keyword_init) -> void
+  type attribute_name = Symbol | String
 
-  def each: () { (Elem arg0) -> untyped } -> untyped
-          | () -> self
+  def initialize: (attribute_name, *attribute_name, ?keyword_init: bool) ?{ () -> void } -> void
 
-  def self.members: () -> ::Array[Symbol]
+  def each: () { (Elem) -> untyped } -> untyped
 
-  def new: (*untyped args) -> Struct[untyped]
+  def self.members: () -> ::Array[Symbol]
 end