rbs 0.11.0 → 0.13.1

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/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/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

data/stdlib/forwardable/forwardable.rbs

@@ -0,0 +1,204 @@
+# The Forwardable module provides delegation of specified methods to a
+# designated object, using the methods #def_delegator and #def_delegators.
+#
+# For example, say you have a class RecordCollection which contains an array
+# `@records`.  You could provide the lookup method #record_number(), which
+# simply calls #[] on the `@records` array, like this:
+#
+#     require 'forwardable'
+#
+#     class RecordCollection
+#       attr_accessor :records
+#       extend Forwardable
+#       def_delegator :@records, :[], :record_number
+#     end
+#
+# We can use the lookup method like so:
+#
+#     r = RecordCollection.new
+#     r.records = [4,5,6]
+#     r.record_number(0)  # => 4
+#
+# Further, if you wish to provide the methods #size, #<<, and #map, all of which
+# delegate to @records, this is how you can do it:
+#
+#     class RecordCollection # re-open RecordCollection class
+#       def_delegators :@records, :size, :<<, :map
+#     end
+#
+#     r = RecordCollection.new
+#     r.records = [1,2,3]
+#     r.record_number(0)   # => 1
+#     r.size               # => 3
+#     r << 4               # => [1, 2, 3, 4]
+#     r.map { |x| x * 2 }  # => [2, 4, 6, 8]
+#
+# You can even extend regular objects with Forwardable.
+#
+#     my_hash = Hash.new
+#     my_hash.extend Forwardable              # prepare object for delegation
+#     my_hash.def_delegator "STDOUT", "puts"  # add delegation for STDOUT.puts()
+#     my_hash.puts "Howdy!"
+#
+# ## Another example
+#
+# You could use Forwardable as an alternative to inheritance, when you don't
+# want to inherit all methods from the superclass. For instance, here is how you
+# might add a range of `Array` instance methods to a new class `Queue`:
+#
+#     class Queue
+#       extend Forwardable
+#
+#       def initialize
+#         @q = [ ]    # prepare delegate object
+#       end
+#
+#       # setup preferred interface, enq() and deq()...
+#       def_delegator :@q, :push, :enq
+#       def_delegator :@q, :shift, :deq
+#
+#       # support some general Array methods that fit Queues well
+#       def_delegators :@q, :clear, :first, :push, :shift, :size
+#     end
+#
+#     q = Queue.new
+#     q.enq 1, 2, 3, 4, 5
+#     q.push 6
+#
+#     q.shift    # => 1
+#     while q.size > 0
+#       puts q.deq
+#     end
+#
+#     q.enq "Ruby", "Perl", "Python"
+#     puts q.first
+#     q.clear
+#     puts q.first
+#
+# This should output:
+#
+#     2
+#     3
+#     4
+#     5
+#     6
+#     Ruby
+#     nil
+#
+# ## Notes
+#
+# Be advised, RDoc will not detect delegated methods.
+#
+# `forwardable.rb` provides single-method delegation via the def_delegator and
+# def_delegators methods. For full-class delegation via DelegateClass, see
+# `delegate.rb`.
+#
+module Forwardable
+  VERSION: String
+
+  FORWARDABLE_VERSION: String
+
+  # Takes a hash as its argument.  The key is a symbol or an array of symbols.
+  # These symbols correspond to method names, instance variable names, or constant
+  # names (see def_delegator).  The value is the accessor to which the methods
+  # will be delegated.
+  def instance_delegate: (Hash[Symbol | Array[Symbol], Symbol] hash) -> void
+
+  alias delegate instance_delegate
+
+  # Shortcut for defining multiple delegator methods, but with no provision for
+  # using a different name.  The following two code samples have the same effect:
+  #
+  #     def_delegators :@records, :size, :<<, :map
+  #
+  #     def_delegator :@records, :size
+  #     def_delegator :@records, :<<
+  #     def_delegator :@records, :map
+  #
+  def def_instance_delegators: (Symbol | String accessor, *Symbol methods) -> void
+
+  alias def_delegators def_instance_delegators
+
+  # Define `method` as delegator instance method with an optional alias name
+  # `ali`. Method calls to `ali` will be delegated to `accessor.method`.
+  # `accessor` should be a method name, instance variable name, or constant name.
+  # Use the full path to the constant if providing the constant name. Returns the
+  # name of the method defined.
+  #
+  #     class MyQueue
+  #       CONST = 1
+  #       extend Forwardable
+  #       attr_reader :queue
+  #       def initialize
+  #         @queue = []
+  #       end
+  #
+  #       def_delegator :@queue, :push, :mypush
+  #       def_delegator 'MyQueue::CONST', :to_i
+  #     end
+  #
+  #     q = MyQueue.new
+  #     q.mypush 42
+  #     q.queue    #=> [42]
+  #     q.push 23  #=> NoMethodError
+  #     q.to_i     #=> 1
+  #
+  def def_instance_delegator: (Symbol | String accessor, Symbol method, ?Symbol ali) -> void
+
+  alias def_delegator def_instance_delegator
+end
+
+# SingleForwardable can be used to setup delegation at the object level as well.
+#
+#     printer = String.new
+#     printer.extend SingleForwardable        # prepare object for delegation
+#     printer.def_delegator "STDOUT", "puts"  # add delegation for STDOUT.puts()
+#     printer.puts "Howdy!"
+#
+# Also, SingleForwardable can be used to set up delegation for a Class or
+# Module.
+#
+#     class Implementation
+#       def self.service
+#         puts "serviced!"
+#       end
+#     end
+#
+#     module Facade
+#       extend SingleForwardable
+#       def_delegator :Implementation, :service
+#     end
+#
+#     Facade.service #=> serviced!
+#
+# If you want to use both Forwardable and SingleForwardable, you can use methods
+# def_instance_delegator and def_single_delegator, etc.
+#
+module SingleForwardable
+  # Takes a hash as its argument.  The key is a symbol or an array of symbols.
+  # These symbols correspond to method names.  The value is the accessor to which
+  # the methods will be delegated.
+  def single_delegate: (Hash[Symbol | Array[Symbol], Symbol] hash) -> void
+
+  alias delegate single_delegate
+
+  # Shortcut for defining multiple delegator methods, but with no provision for
+  # using a different name.  The following two code samples have the same effect:
+  #
+  #     def_delegators :@records, :size, :<<, :map
+  #
+  #     def_delegator :@records, :size
+  #     def_delegator :@records, :<<
+  #     def_delegator :@records, :map
+  #
+  def def_single_delegators: (Symbol | String accessor, *Symbol methods) -> void
+
+  alias def_delegators def_single_delegators
+
+  # Defines a method *method* which delegates to *accessor* (i.e. it calls the
+  # method of the same name in *accessor*).  If *new_name* is provided, it is used
+  # as the name for the delegate method. Returns the name of the method defined.
+  def def_single_delegator: (Symbol | String accessor, Symbol method, ?Symbol ali) -> void
+
+  alias def_delegator def_single_delegator
+end