rbs 0.12.2 → 0.16.0

data/{stdlib/builtin → core}/kernel.rbs

@@ -1,16 +1,18 @@
 # The [Kernel](Kernel) module is included by class
 # [Object](https://ruby-doc.org/core-2.6.3/Object.html), so its methods
 # are available in every Ruby object.
-# 
+#
 # The [Kernel](Kernel) instance methods are documented
 # in class [Object](https://ruby-doc.org/core-2.6.3/Object.html) while the
 # module methods are documented here. These methods are called without a
 # receiver and thus can be called in functional form:
-# 
+#
 # ```ruby
 # 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]
@@ -22,13 +24,13 @@ module Kernel
            | () { (Object tag) -> untyped } -> untyped
 
   # In a perfect world this should be:
-  # 
+  #
   #   returns(T.class_of(T.self_type))
-  # 
+  #
   # but that doesn't work (yet). Even making it:
-  # 
+  #
   #   returns(Class)
-  # 
+  #
   # is very surprising since users expect their methods to be present.
   # So we settle for untyped.
   def `class`: () -> untyped
@@ -40,7 +42,7 @@ module Kernel
 
   # Returns `true` if `yield` would execute a block in the current context.
   # The `iterator?` form is mildly deprecated.
-  # 
+  #
   # ```ruby
   # def try
   #   if block_given?
@@ -57,7 +59,7 @@ module Kernel
   alias block_given? iterator?
 
   # Returns the names of the current local variables.
-  # 
+  #
   # ```ruby
   # fred = 1
   # for i in 1..10
@@ -69,28 +71,6 @@ module Kernel
 
   def srand: (?Numeric number) -> Numeric
 
-  def !~: (untyped other) -> bool
-
-  def <=>: (untyped other) -> Integer?
-
-  def ===: (untyped other) -> bool
-
-  def =~: (untyped other) -> NilClass
-
-  def clone: (?freeze: (TrueClass | FalseClass)) -> self
-
-  def display: (?IO port) -> NilClass
-
-  def dup: () -> self
-
-  def enum_for: (Symbol method, *untyped args) -> ::Enumerator[untyped, untyped]
-              | (Symbol method, *untyped args) { (*untyped args) -> (Integer|Float|nil) } -> ::Enumerator[untyped, untyped]
-  alias to_enum enum_for
-
-  def eql?: (untyped other) -> bool
-
-  def `extend`: (*Module mod) -> self
-
   # Creates a subprocess. If a block is specified, that block is run in the
   # subprocess, and the subprocess terminates with a status of zero.
   # Otherwise, the `fork` call returns twice, once in the parent, returning
@@ -100,93 +80,31 @@ module Kernel
   # collect the termination statuses of its children or use `Process.detach`
   # to register disinterest in their status; otherwise, the operating system
   # may accumulate zombie processes.
-  # 
+  #
   # The thread calling fork is the only thread in the created child process.
   # fork doesn’t copy other threads.
-  # 
+  #
   # If fork is not usable, Process.respond\_to?(:fork) returns false.
-  # 
+  #
   # Note that fork(2) is not available on some platforms like Windows and
   # NetBSD 4. Therefore you should use spawn() instead of fork().
   def fork: () -> Integer?
           | () { () -> untyped } -> Integer?
 
-  def freeze: () -> self
-
-  def frozen?: () -> bool
-
-  def hash: () -> Integer
-
   def initialize_copy: (self object) -> self
 
-  def inspect: () -> String
-
-  def instance_of?: (Class arg0) -> bool
-
-  def instance_variable_defined?: (Symbol | String arg0) -> bool
-
-  def instance_variable_get: (Symbol | String arg0) -> untyped
-
-  def instance_variable_set: [T] (Symbol | String arg0, T arg1) -> T
-
-  def instance_variables: () -> ::Array[Symbol]
-
-  def is_a?: (Class | Module arg0) -> bool
-  alias kind_of? is_a?
-
-  def method: (Symbol | String arg0) -> Method
-
-  def methods: (?bool regular) -> ::Array[Symbol]
-
-  def `nil?`: () -> FalseClass
-
-  def private_methods: (?bool all) -> ::Array[Symbol]
-
-  def protected_methods: (?bool all) -> ::Array[Symbol]
-
-  def public_method: (Symbol | String arg0) -> Method
-
-  def public_methods: (?bool all) -> ::Array[Symbol]
-
-  def `public_send`: (Symbol | String arg0, *untyped args) -> untyped
-                   | (Symbol | String arg0, *untyped args) { (*untyped) -> untyped } -> untyped
-
-  def remove_instance_variable: (Symbol | String arg0) -> untyped
-
-  def `send`: (String | Symbol arg0, *untyped arg1) -> untyped
-            | (String | Symbol arg0, *untyped arg1) { (*untyped) -> untyped } -> untyped
-
-  def `singleton_class`: () -> Class
-
-  def singleton_method: (Symbol | String arg0) -> Method
-
-  def singleton_methods: (?bool all) -> ::Array[Symbol]
-
-  def taint: () -> self
-  alias untrust taint
-
-  def tainted?: () -> bool
-  alias untrusted? tainted?
-
-  def tap: () { (untyped x) -> void } -> self
-
-  def to_s: () -> String
-
-  def untaint: () -> self
-  alias trust untaint
-
   # Returns `arg` as an [Array](https://ruby-doc.org/core-2.6.3/Array.html)
   # .
-  # 
+  #
   # First tries to call `to_ary` on `arg`, then `to_a` . If `arg` does not
   # respond to `to_ary` or `to_a`, returns an
   # [Array](https://ruby-doc.org/core-2.6.3/Array.html) of length 1
   # containing `arg` .
-  # 
+  #
   # If `to_ary` or `to_a` returns something other than an
   # [Array](https://ruby-doc.org/core-2.6.3/Array.html), raises a
   # `TypeError` .
-  # 
+  #
   # ```ruby
   # Array(["a", "b"])  #=> ["a", "b"]
   # Array(1..5)        #=> [1, 2, 3, 4, 5]
@@ -243,7 +161,7 @@ module Kernel
   # at the point of call. This object can be used when calling `eval` to
   # execute the evaluated command in this environment. See also the
   # description of class `Binding` .
-  # 
+  #
   # ```ruby
   # def get_binding(param)
   #   binding
@@ -258,7 +176,7 @@ module Kernel
   # to return a status code to the invoking environment. `true` and `FALSE`
   # of *status* means success and failure respectively. The interpretation
   # of other integer values are system dependent.
-  # 
+  #
   # ```ruby
   # begin
   #   exit
@@ -268,25 +186,25 @@ module Kernel
   # end
   # puts "after begin block"
   # ```
-  # 
+  #
   # *produces:*
-  # 
+  #
   #     rescued a SystemExit exception
   #     after begin block
-  # 
+  #
   # Just prior to termination, Ruby executes any `at_exit` functions (see
   # Kernel::at\_exit) and runs any object finalizers (see
   # [ObjectSpace.define\_finalizer](https://ruby-doc.org/core-2.6.3/ObjectSpace.html#method-c-define_finalizer)
   # ).
-  # 
+  #
   # ```ruby
   # at_exit { puts "at_exit function" }
   # ObjectSpace.define_finalizer("string",  proc { puts "in finalizer" })
   # exit
   # ```
-  # 
+  #
   # *produces:*
-  # 
+  #
   #     at_exit function
   #     in finalizer
   def exit: () -> bot
@@ -323,18 +241,18 @@ module Kernel
   def gets: (?String arg0, ?Integer arg1) -> String?
 
   # Returns an array of the names of global variables.
-  # 
+  #
   # ```ruby
   # global_variables.grep /std/   #=> [:$stdin, :$stdout, :$stderr]
   # ```
   def global_variables: () -> ::Array[Symbol]
 
-  def load: (String filename, ?bool arg0) -> bool
+  def load: (String filename, ?boolish) -> bool
 
   # Repeatedly executes the block.
-  # 
+  #
   # If no block is given, an enumerator is returned instead.
-  # 
+  #
   # ```ruby
   # loop do
   #   print "Input: "
@@ -343,18 +261,18 @@ module Kernel
   #   # ...
   # end
   # ```
-  # 
+  #
   # [StopIteration](https://ruby-doc.org/core-2.6.3/StopIteration.html)
   # raised in the block breaks the loop. In this case, loop returns the
   # "result" value stored in the exception.
-  # 
+  #
   # ```ruby
   # enum = Enumerator.new { |y|
   #   y << "one"
   #   y << "two"
   #   :ok
   # }
-  # 
+  #
   # result = loop {
   #   puts enum.next
   # } #=> :ok
@@ -370,16 +288,16 @@ module Kernel
   # the output record separator ( `$\` ) is not `nil`, it will be appended
   # to the output. If no arguments are given, prints `$_` . Objects that
   # aren’t strings will be converted by calling their `to_s` method.
-  # 
+  #
   # ```ruby
   # print "cat", [1,2,3], 99, "\n"
   # $, = ", "
   # $\ = "\n"
   # print "cat", [1,2,3], 99
   # ```
-  # 
+  #
   # *produces:*
-  # 
+  #
   #     cat12399
   #     cat, 1, 2, 3, 99
   def print: (*Kernel args) -> nil
@@ -406,35 +324,35 @@ module Kernel
   # If called without an argument, or if `max.to_i.abs == 0`, rand returns
   # a pseudo-random floating point number between 0.0 and 1.0, including 0.0
   # and excluding 1.0.
-  # 
+  #
   # ```ruby
   # rand        #=> 0.2725926052826416
   # ```
-  # 
+  #
   # When `max.abs` is greater than or equal to 1, `rand` returns a
   # pseudo-random integer greater than or equal to 0 and less than
   # `max.to_i.abs` .
-  # 
+  #
   # ```ruby
   # rand(100)   #=> 12
   # ```
-  # 
+  #
   # When `max` is a [Range](https://ruby-doc.org/core-2.6.3/Range.html),
   # `rand` returns a random number where range.member?(number) == true.
-  # 
+  #
   # Negative or floating point values for `max` are allowed, but may give
   # surprising results.
-  # 
+  #
   # ```ruby
   # rand(-100) # => 87
   # rand(-0.5) # => 0.8130921818028143
   # rand(1.9)  # equivalent to rand(1), which is always 0
   # ```
-  # 
+  #
   # [\#srand](Kernel.downloaded.ruby_doc#method-i-srand) may be used to
   # ensure that sequences of random numbers are reproducible between
   # different runs of a program.
-  # 
+  #
   # See also
   # [Random\#rand](https://ruby-doc.org/core-2.6.3/Random.html#method-i-rand)
   # .
@@ -466,109 +384,109 @@ module Kernel
 
   # Replaces the current process by running the given external *command* ,
   # which can take one of the following forms:
-  # 
+  #
   #   - `exec(commandline)`
   #     command line string which is passed to the standard shell
-  # 
+  #
   #   - `exec(cmdname, arg1, ...)`
   #     command name and one or more arguments (no shell)
-  # 
+  #
   #   - `exec([cmdname, argv0], arg1, ...)`
   #     command name, [argv](https://ruby-doc.org/core-2.6.3/0) and zero or
   #     more arguments (no shell)
-  # 
+  #
   # In the first form, the string is taken as a command line that is subject
   # to shell expansion before being executed.
-  # 
+  #
   # The standard shell always means `"/bin/sh"` on Unix-like systems, same
   # as `ENV["RUBYSHELL"]` (or `ENV["COMSPEC"]` on Windows NT series), and
   # similar.
-  # 
+  #
   # If the string from the first form ( `exec("command")` ) follows these
   # simple rules:
-  # 
+  #
   #   - no meta characters
-  # 
+  #
   #   - no shell reserved word and no special built-in
-  # 
+  #
   #   - Ruby invokes the command directly without shell
-  # 
+  #
   # You can force shell invocation by adding “;” to the string (because “;”
   # is a meta character).
-  # 
+  #
   # Note that this behavior is observable by pid obtained (return value of
   # spawn() and
   # [IO\#pid](https://ruby-doc.org/core-2.6.3/IO.html#method-i-pid) for
   # [IO.popen](https://ruby-doc.org/core-2.6.3/IO.html#method-c-popen) ) is
   # the pid of the invoked command, not shell.
-  # 
+  #
   # In the second form ( `exec("command1", "arg1", ...)` ), the first is
   # taken as a command name and the rest are passed as parameters to command
   # with no shell expansion.
-  # 
+  #
   # In the third form ( `exec(["command", "argv0"], "arg1", ...)` ),
   # starting a two-element array at the beginning of the command, the first
   # element is the command to be executed, and the second argument is used
   # as the `argv[0]` value, which may show up in process listings.
-  # 
+  #
   # In order to execute the command, one of the `exec(2)` system calls are
   # used, so the running command may inherit some of the environment of the
   # original program (including open file descriptors).
-  # 
+  #
   # This behavior is modified by the given `env` and `options` parameters.
   # See ::spawn for details.
-  # 
+  #
   # If the command fails to execute (typically `Errno::ENOENT` when it was
   # not found) a
   # [SystemCallError](https://ruby-doc.org/core-2.6.3/SystemCallError.html)
   # exception is raised.
-  # 
+  #
   # This method modifies process attributes according to given `options`
   # before `exec(2)` system call. See ::spawn for more details about the
   # given `options` .
-  # 
+  #
   # The modified attributes may be retained when `exec(2)` system call
   # fails.
-  # 
+  #
   # For example, hard resource limits are not restorable.
-  # 
+  #
   # Consider to create a child process using ::spawn or
   # [\#system](Kernel.downloaded.ruby_doc#method-i-system) if this is not
   # acceptable.
-  # 
+  #
   # ```ruby
   # exec "echo *"       # echoes list of files in current directory
   # # never get here
-  # 
+  #
   # exec "echo", "*"    # echoes an asterisk
   # # never get here
   # ```
   def exec: (*String args) -> bot
 
   # Executes *command…* in a subshell. *command…* is one of following forms.
-  # 
+  #
   #     commandline                 : command line string which is passed to the standard shell
   #     cmdname, arg1, ...          : command name and one or more arguments (no shell)
   #     [cmdname, argv0], arg1, ... : command name, argv[0] and zero or more arguments (no shell)
-  # 
+  #
   # system returns `true` if the command gives zero exit status, `false` for
   # non zero exit status. Returns `nil` if command execution fails. An error
   # status is available in `$?` . The arguments are processed in the same
   # way as for `Kernel.spawn` .
-  # 
+  #
   # The hash arguments, env and options, are same as `exec` and `spawn` .
   # See `Kernel.spawn` for details.
-  # 
+  #
   # ```ruby
   # system("echo *")
   # system("echo", "*")
   # ```
-  # 
+  #
   # *produces:*
-  # 
+  #
   #     config.h main.rb
   #     *
-  # 
+  #
   # See `Kernel.exec` for the standard shell.
   def system: (*String args) -> (NilClass | FalseClass | TrueClass)
 end