steep 0.13.0 → 0.16.2

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

@@ -1,426 +0,0 @@
-# A `Proc` object is an encapsulation of a block of code, which can be
-# stored in a local variable, passed to a method or another
-# [Proc](Proc), and can be called.
-# [Proc](Proc) is an essential concept in Ruby and a
-# core of its functional programming features.
-# 
-# ```ruby
-# square = Proc.new {|x| x**2 }
-# 
-# square.call(3)  #=> 9
-# # shorthands:
-# square.(3)      #=> 9
-# square[3]       #=> 9
-# ```
-# 
-# [Proc](Proc) objects are *closures* , meaning they
-# remember and can use the entire context in which they were created.
-# 
-# ```ruby
-# def gen_times(factor)
-#   Proc.new {|n| n*factor } # remembers the value of factor at the moment of creation
-# end
-# 
-# times3 = gen_times(3)
-# times5 = gen_times(5)
-# 
-# times3.call(12)               #=> 36
-# times5.call(5)                #=> 25
-# times3.call(times5.call(4))   #=> 60
-# ```
-# 
-# 
-# There are several methods to create a [Proc](Proc)
-# 
-#   - Use the [Proc](Proc) class constructor:
-# 
-#     ```ruby
-#     proc1 = Proc.new {|x| x**2 }
-#     ```
-# 
-#   - Use the
-#     [Kernel\#proc](https://ruby-doc.org/core-2.6.3/Kernel.html#method-i-proc)
-#     method as a shorthand of
-#     [::new](Proc#method-c-new):
-# 
-#     ```ruby
-#     proc2 = proc {|x| x**2 }
-#     ```
-# 
-#   - Receiving a block of code into proc argument (note the `&` ):
-# 
-#     ```ruby
-#     def make_proc(&block)
-#       block
-#     end
-# 
-#     proc3 = make_proc {|x| x**2 }
-#     ```
-# 
-#   - Construct a proc with lambda semantics using the
-#     [Kernel\#lambda](https://ruby-doc.org/core-2.6.3/Kernel.html#method-i-lambda)
-#     method (see below for explanations about lambdas):
-# 
-#     ```ruby
-#     lambda1 = lambda {|x| x**2 }
-#     ```
-# 
-#   - Use the Lambda literal syntax (also constructs a proc with lambda
-#     semantics):
-# 
-#     ```ruby
-#     lambda2 = ->(x) { x**2 }
-#     ```
-# 
-# 
-# Procs are coming in two flavors: lambda and non-lambda (regular procs).
-# Differences are:
-# 
-#   - In lambdas, `return` means exit from this lambda;
-# 
-#   - In regular procs, `return` means exit from embracing method (and
-#     will throw `LocalJumpError` if invoked outside the method);
-# 
-#   - In lambdas, arguments are treated in the same way as in methods:
-#     strict, with `ArgumentError` for mismatching argument number, and no
-#     additional argument processing;
-# 
-#   - Regular procs accept arguments more generously: missing arguments
-#     are filled with `nil`, single
-#     [Array](https://ruby-doc.org/core-2.6.3/Array.html) arguments are
-#     deconstructed if the proc has multiple arguments, and there is no
-#     error raised on extra arguments.
-# 
-# Examples:
-# 
-# ```ruby
-# p = proc {|x, y| "x=#{x}, y=#{y}" }
-# p.call(1, 2)      #=> "x=1, y=2"
-# p.call([1, 2])    #=> "x=1, y=2", array deconstructed
-# p.call(1, 2, 8)   #=> "x=1, y=2", extra argument discarded
-# p.call(1)         #=> "x=1, y=", nil substituted instead of error
-# 
-# l = lambda {|x, y| "x=#{x}, y=#{y}" }
-# l.call(1, 2)      #=> "x=1, y=2"
-# l.call([1, 2])    # ArgumentError: wrong number of arguments (given 1, expected 2)
-# l.call(1, 2, 8)   # ArgumentError: wrong number of arguments (given 3, expected 2)
-# l.call(1)         # ArgumentError: wrong number of arguments (given 1, expected 2)
-# 
-# def test_return
-#   -> { return 3 }.call      # just returns from lambda into method body
-#   proc { return 4 }.call    # returns from method
-#   return 5
-# end
-# 
-# test_return # => 4, return from proc
-# ```
-# 
-# Lambdas are useful as self-sufficient functions, in particular useful as
-# arguments to higher-order functions, behaving exactly like Ruby methods.
-# 
-# Procs are useful for implementing iterators:
-# 
-# ```ruby
-# def test
-#   [[1, 2], [3, 4], [5, 6]].map {|a, b| return a if a + b > 10 }
-#                             #  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-# end
-# ```
-# 
-# Inside `map`, the block of code is treated as a regular (non-lambda)
-# proc, which means that the internal arrays will be deconstructed to
-# pairs of arguments, and `return` will exit from the method `test` . That
-# would not be possible with a stricter lambda.
-# 
-# You can tell a lambda from a regular proc by using the
-# [lambda?](Proc#method-i-lambda-3F) instance method.
-# 
-# Lambda semantics is typically preserved during the proc lifetime,
-# including `&` -deconstruction to a block of code:
-# 
-# ```ruby
-# p = proc {|x, y| x }
-# l = lambda {|x, y| x }
-# [[1, 2], [3, 4]].map(&p) #=> [1, 2]
-# [[1, 2], [3, 4]].map(&l) # ArgumentError: wrong number of arguments (given 1, expected 2)
-# ```
-# 
-# The only exception is dynamic method definition: even if defined by
-# passing a non-lambda proc, methods still have normal semantics of
-# argument checking.
-# 
-# ```ruby
-# class C
-#   define_method(:e, &proc {})
-# end
-# C.new.e(1,2)       #=> ArgumentError
-# C.new.method(:e).to_proc.lambda?   #=> true
-# ```
-# 
-# This exception ensures that methods never have unusual argument passing
-# conventions, and makes it easy to have wrappers defining methods that
-# behave as usual.
-# 
-# ```ruby
-# class C
-#   def self.def2(name, &body)
-#     define_method(name, &body)
-#   end
-# 
-#   def2(:f) {}
-# end
-# C.new.f(1,2)       #=> ArgumentError
-# ```
-# 
-# The wrapper *def2* receives `body` as a non-lambda proc, yet defines a
-# method which has normal semantics.
-# 
-# 
-# Any object that implements the `to_proc` method can be converted into a
-# proc by the `&` operator, and therefore con be consumed by iterators.
-# 
-# ```ruby
-# class Greater
-#   def initialize(greating)
-#     @greating = greating
-#   end
-# 
-#   def to_proc
-#     proc {|name| "#{@greating}, #{name}!" }
-#   end
-# end
-# 
-# hi = Greater.new("Hi")
-# hey = Greater.new("Hey")
-# ["Bob", "Jane"].map(&hi)    #=> ["Hi, Bob!", "Hi, Jane!"]
-# ["Bob", "Jane"].map(&hey)   #=> ["Hey, Bob!", "Hey, Jane!"]
-# ```
-# 
-# Of the Ruby core classes, this method is implemented by
-# [Symbol](https://ruby-doc.org/core-2.6.3/Symbol.html),
-# [Method](https://ruby-doc.org/core-2.6.3/Method.html), and
-# [Hash](https://ruby-doc.org/core-2.6.3/Hash.html).
-# 
-#     :to_s.to_proc.call(1)           #=> "1"
-#     [1, 2].map(&:to_s)              #=> ["1", "2"]
-# 
-#     method(:puts).to_proc.call(1)   # prints 1
-#     [1, 2].each(&method(:puts))     # prints 1, 2
-# 
-#     {test: 1}.to_proc.call(:test)       #=> 1
-#     %i[test many keys].map(&{test: 1})  #=> [1, nil, nil]
-class Proc < Object
-  # Returns the number of mandatory arguments. If the block is declared to
-  # take no arguments, returns 0. If the block is known to take exactly n
-  # arguments, returns n. If the block has optional arguments, returns -n-1,
-  # where n is the number of mandatory arguments, with the exception for
-  # blocks that are not lambdas and have only a finite number of optional
-  # arguments; in this latter case, returns n. Keyword arguments will be
-  # considered as a single additional argument, that argument being
-  # mandatory if any keyword argument is mandatory. A `proc` with no
-  # argument declarations is the same as a block declaring `||` as its
-  # arguments.
-  # 
-  #     proc {}.arity                  #=>  0
-  #     proc { || }.arity              #=>  0
-  #     proc { |a| }.arity             #=>  1
-  #     proc { |a, b| }.arity          #=>  2
-  #     proc { |a, b, c| }.arity       #=>  3
-  #     proc { |*a| }.arity            #=> -1
-  #     proc { |a, *b| }.arity         #=> -2
-  #     proc { |a, *b, c| }.arity      #=> -3
-  #     proc { |x:, y:, z:0| }.arity   #=>  1
-  #     proc { |*a, x:, y:0| }.arity   #=> -2
-  # 
-  #     proc   { |a=0| }.arity         #=>  0
-  #     lambda { |a=0| }.arity         #=> -1
-  #     proc   { |a=0, b| }.arity      #=>  1
-  #     lambda { |a=0, b| }.arity      #=> -2
-  #     proc   { |a=0, b=0| }.arity    #=>  0
-  #     lambda { |a=0, b=0| }.arity    #=> -1
-  #     proc   { |a, b=0| }.arity      #=>  1
-  #     lambda { |a, b=0| }.arity      #=> -2
-  #     proc   { |(a, b), c=0| }.arity #=>  1
-  #     lambda { |(a, b), c=0| }.arity #=> -2
-  #     proc   { |a, x:0, y:0| }.arity #=>  1
-  #     lambda { |a, x:0, y:0| }.arity #=> -2
-  def arity: () -> Integer
-
-  # Returns the binding associated with *prc* .
-  # 
-  # ```ruby
-  # def fred(param)
-  #   proc {}
-  # end
-  # 
-  # b = fred(99)
-  # eval("param", b.binding)   #=> 99
-  # ```
-  def binding: () -> Binding
-
-  def call: (*untyped arg0) -> untyped
-
-  def []: (*untyped arg0) -> untyped
-
-  def curry: (?Integer arity) -> Proc
-
-  # Returns a hash value corresponding to proc body.
-  # 
-  # See also Object\#hash.
-  def hash: () -> Integer
-
-  # Returns `true` for a [Proc](Proc.downloaded.ruby_doc) object for which
-  # argument handling is rigid. Such procs are typically generated by
-  # `lambda` .
-  # 
-  # A [Proc](Proc.downloaded.ruby_doc) object generated by `proc` ignores
-  # extra arguments.
-  # 
-  # ```ruby
-  # proc {|a,b| [a,b] }.call(1,2,3)    #=> [1,2]
-  # ```
-  # 
-  # It provides `nil` for missing arguments.
-  # 
-  # ```ruby
-  # proc {|a,b| [a,b] }.call(1)        #=> [1,nil]
-  # ```
-  # 
-  # It expands a single array argument.
-  # 
-  # ```ruby
-  # proc {|a,b| [a,b] }.call([1,2])    #=> [1,2]
-  # ```
-  # 
-  # A [Proc](Proc.downloaded.ruby_doc) object generated by `lambda` doesn’t
-  # have such tricks.
-  # 
-  # ```ruby
-  # lambda {|a,b| [a,b] }.call(1,2,3)  #=> ArgumentError
-  # lambda {|a,b| [a,b] }.call(1)      #=> ArgumentError
-  # lambda {|a,b| [a,b] }.call([1,2])  #=> ArgumentError
-  # ```
-  # 
-  # [\#lambda?](Proc.downloaded.ruby_doc#method-i-lambda-3F) is a predicate
-  # for the tricks. It returns `true` if no tricks apply.
-  # 
-  # ```ruby
-  # lambda {}.lambda?            #=> true
-  # proc {}.lambda?              #=> false
-  # ```
-  # 
-  # [::new](Proc.downloaded.ruby_doc#method-c-new) is the same as `proc` .
-  # 
-  # ```ruby
-  # Proc.new {}.lambda?          #=> false
-  # ```
-  # 
-  # `lambda`, `proc` and [::new](Proc.downloaded.ruby_doc#method-c-new)
-  # preserve the tricks of a [Proc](Proc.downloaded.ruby_doc) object given
-  # by `&` argument.
-  # 
-  # ```ruby
-  # lambda(&lambda {}).lambda?   #=> true
-  # proc(&lambda {}).lambda?     #=> true
-  # Proc.new(&lambda {}).lambda? #=> true
-  # 
-  # lambda(&proc {}).lambda?     #=> false
-  # proc(&proc {}).lambda?       #=> false
-  # Proc.new(&proc {}).lambda?   #=> false
-  # ```
-  # 
-  # A [Proc](Proc.downloaded.ruby_doc) object generated by `&` argument has
-  # the tricks
-  # 
-  # ```ruby
-  # def n(&b) b.lambda? end
-  # n {}                         #=> false
-  # ```
-  # 
-  # The `&` argument preserves the tricks if a
-  # [Proc](Proc.downloaded.ruby_doc) object is given by `&` argument.
-  # 
-  # ```ruby
-  # n(&lambda {})                #=> true
-  # n(&proc {})                  #=> false
-  # n(&Proc.new {})              #=> false
-  # ```
-  # 
-  # A [Proc](Proc.downloaded.ruby_doc) object converted from a method has no
-  # tricks.
-  # 
-  # ```ruby
-  # def m() end
-  # method(:m).to_proc.lambda?   #=> true
-  # 
-  # n(&method(:m))               #=> true
-  # n(&method(:m).to_proc)       #=> true
-  # ```
-  # 
-  # `define_method` is treated the same as method definition. The defined
-  # method has no tricks.
-  # 
-  # ```ruby
-  # class C
-  #   define_method(:d) {}
-  # end
-  # C.new.d(1,2)       #=> ArgumentError
-  # C.new.method(:d).to_proc.lambda?   #=> true
-  # ```
-  # 
-  # `define_method` always defines a method without the tricks, even if a
-  # non-lambda [Proc](Proc.downloaded.ruby_doc) object is given. This is the
-  # only exception for which the tricks are not preserved.
-  # 
-  # ```ruby
-  # class C
-  #   define_method(:e, &proc {})
-  # end
-  # C.new.e(1,2)       #=> ArgumentError
-  # C.new.method(:e).to_proc.lambda?   #=> true
-  # ```
-  # 
-  # This exception ensures that methods never have tricks and makes it easy
-  # to have wrappers to define methods that behave as usual.
-  # 
-  # ```ruby
-  # class C
-  #   def self.def2(name, &body)
-  #     define_method(name, &body)
-  #   end
-  # 
-  #   def2(:f) {}
-  # end
-  # C.new.f(1,2)       #=> ArgumentError
-  # ```
-  # 
-  # The wrapper *def2* defines a method which has no tricks.
-  def lambda?: () -> bool
-
-  # Returns the parameter information of this proc.
-  # 
-  # ```ruby
-  # prc = lambda{|x, y=42, *other|}
-  # prc.parameters  #=> [[:req, :x], [:opt, :y], [:rest, :other]]
-  # ```
-  def parameters: () -> ::Array[[ Symbol, Symbol ]]
-
-  # Returns the Ruby source filename and line number containing this proc or
-  # `nil` if this proc was not defined in Ruby (i.e. native).
-  def source_location: () -> [ String, Integer ]
-
-  # Part of the protocol for converting objects to `Proc` objects. Instances
-  # of class `Proc` simply return themselves.
-  def to_proc: () -> self
-
-  # Returns the unique identifier for this proc, along with an indication of
-  # where the proc was defined.
-  # 
-  # 
-  # 
-  # Also aliased as: [inspect](Proc.downloaded.ruby_doc#method-i-inspect)
-  def to_s: () -> String
-
-  # Alias for: [to\_s](Proc.downloaded.ruby_doc#method-i-to_s)
-  def inspect: () -> String
-end

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

@@ -1,354 +0,0 @@
-# [Module](https://ruby-doc.org/core-2.6.3/Module.html) to handle
-# processes.
-module Process
-  # Returns the name of the script being executed. The value is not affected
-  # by assigning a new value to $0.
-  # 
-  # This method first appeared in Ruby 2.1 to serve as a global variable
-  # free means to get the script name.
-  def self.argv0: () -> String
-
-  def self.clock_getres: (Symbol | Integer clock_id, ?Symbol unit) -> (Float | Integer)
-
-  def self.clock_gettime: (Symbol | Integer clock_id, ?Symbol unit) -> (Float | Integer)
-
-  def self.daemon: (?untyped nochdir, ?untyped noclose) -> Integer
-
-  def self.detach: (Integer pid) -> Thread
-
-  # Returns the effective group ID for this process. Not available on all
-  # platforms.
-  # 
-  # ```ruby
-  # Process.egid   #=> 500
-  # ```
-  def self.egid: () -> Integer
-
-  def self.egid=: (Integer arg0) -> Integer
-
-  # Returns the effective user ID for this process.
-  # 
-  # ```ruby
-  # Process.euid   #=> 501
-  # ```
-  def self.euid: () -> Integer
-
-  def self.euid=: (Integer arg0) -> Integer
-
-  def self.getpgid: (Integer pid) -> Integer
-
-  # Returns the process group ID for this process. Not available on all
-  # platforms.
-  # 
-  # ```ruby
-  # Process.getpgid(0)   #=> 25527
-  # Process.getpgrp      #=> 25527
-  # ```
-  def self.getpgrp: () -> Integer
-
-  def self.getpriority: (Integer kind, Integer arg0) -> Integer
-
-  def self.getrlimit: (Symbol | String | Integer resource) -> [ Integer, Integer ]
-
-  def self.getsid: (?Integer pid) -> Integer
-
-  # Returns the (real) group ID for this process.
-  # 
-  # ```ruby
-  # Process.gid   #=> 500
-  # ```
-  def self.gid: () -> Integer
-
-  def self.gid=: (Integer arg0) -> Integer
-
-  # Get an `Array` of the group IDs in the supplemental group access list
-  # for this process.
-  # 
-  # ```ruby
-  # Process.groups   #=> [27, 6, 10, 11]
-  # ```
-  # 
-  # Note that this method is just a wrapper of getgroups(2). This means that
-  # the following characteristics of the result completely depend on your
-  # system:
-  # 
-  #   - the result is sorted
-  # 
-  #   - the result includes effective GIDs
-  # 
-  #   - the result does not include duplicated GIDs
-  # 
-  # You can make sure to get a sorted unique
-  # [GID](https://ruby-doc.org/core-2.6.3/Process/GID.html) list of the
-  # current process by this expression:
-  # 
-  # ```ruby
-  # Process.groups.uniq.sort
-  # ```
-  def self.groups: () -> ::Array[Integer]
-
-  def self.groups=: (::Array[Integer] arg0) -> ::Array[Integer]
-
-  def self.initgroups: (String username, Integer gid) -> ::Array[Integer]
-
-  def self.kill: (Integer | Symbol | String signal, *Integer pids) -> Integer
-
-  # Returns the maximum number of gids allowed in the supplemental group
-  # access list.
-  # 
-  # ```ruby
-  # Process.maxgroups   #=> 32
-  # ```
-  def self.maxgroups: () -> Integer
-
-  def self.maxgroups=: (Integer arg0) -> Integer
-
-  # Returns the process id of this process. Not available on all platforms.
-  # 
-  # ```ruby
-  # Process.pid   #=> 27415
-  # ```
-  def self.pid: () -> Integer
-
-  # Returns the process id of the parent of this process. Returns
-  # untrustworthy value on Win32/64. Not available on all platforms.
-  # 
-  # ```ruby
-  # puts "I am #{Process.pid}"
-  # Process.fork { puts "Dad is #{Process.ppid}" }
-  # ```
-  # 
-  # *produces:*
-  # 
-  # ```ruby
-  # I am 27417
-  # Dad is 27417
-  # ```
-  def self.ppid: () -> Integer
-
-  def self.setpgid: (Integer pid, Integer arg0) -> Integer
-
-  def self.setpriority: (Integer kind, Integer arg0, Integer priority) -> Integer
-
-  def self.setproctitle: (String arg0) -> String
-
-  def self.setrlimit: (Symbol | String | Integer resource, Integer cur_limit, ?Integer max_limit) -> NilClass
-
-  # Establishes this process as a new session and process group leader, with
-  # no controlling tty. Returns the session id. Not available on all
-  # platforms.
-  # 
-  # ```ruby
-  # Process.setsid   #=> 27422
-  # ```
-  def self.setsid: () -> Integer
-
-  # Returns a `Tms` structure (see `Process::Tms` ) that contains user and
-  # system CPU times for this process, and also for children processes.
-  # 
-  # ```ruby
-  # t = Process.times
-  # [ t.utime, t.stime, t.cutime, t.cstime ]   #=> [0.0, 0.02, 0.00, 0.00]
-  # ```
-  def self.times: () -> Process::Tms
-
-  # Returns the (real) user ID of this process.
-  # 
-  # ```ruby
-  # Process.uid   #=> 501
-  # ```
-  def self.uid: () -> Integer
-
-  def self.uid=: (Integer user) -> Integer
-
-  def self.wait: (?Integer pid, ?Integer flags) -> Integer
-
-  def self.wait2: (?Integer pid, ?Integer flags) -> [ Integer, Process::Status ]
-
-  def self.waitall: () -> ::Array[[ Integer, Process::Status ]]
-
-  def self.waitpid: (?Integer pid, ?Integer flags) -> Integer
-
-  def self.waitpid2: (?Integer pid, ?Integer flags) -> [ Integer, Process::Status ]
-end
-
-Process::CLOCK_BOOTTIME: Integer
-
-Process::CLOCK_BOOTTIME_ALARM: Integer
-
-Process::CLOCK_MONOTONIC: Integer
-
-Process::CLOCK_MONOTONIC_COARSE: Integer
-
-Process::CLOCK_MONOTONIC_RAW: Integer
-
-Process::CLOCK_PROCESS_CPUTIME_ID: Integer
-
-Process::CLOCK_REALTIME: Integer
-
-Process::CLOCK_REALTIME_ALARM: Integer
-
-Process::CLOCK_REALTIME_COARSE: Integer
-
-Process::CLOCK_THREAD_CPUTIME_ID: Integer
-
-Process::PRIO_PGRP: Integer
-
-Process::PRIO_PROCESS: Integer
-
-Process::PRIO_USER: Integer
-
-Process::RLIMIT_AS: Integer
-
-Process::RLIMIT_CORE: Integer
-
-Process::RLIMIT_CPU: Integer
-
-Process::RLIMIT_DATA: Integer
-
-Process::RLIMIT_FSIZE: Integer
-
-Process::RLIMIT_MEMLOCK: Integer
-
-Process::RLIMIT_MSGQUEUE: Integer
-
-Process::RLIMIT_NICE: Integer
-
-Process::RLIMIT_NOFILE: Integer
-
-Process::RLIMIT_NPROC: Integer
-
-Process::RLIMIT_RSS: Integer
-
-Process::RLIMIT_RTPRIO: Integer
-
-Process::RLIMIT_RTTIME: Integer
-
-Process::RLIMIT_SIGPENDING: Integer
-
-Process::RLIMIT_STACK: Integer
-
-Process::RLIM_INFINITY: Integer
-
-Process::RLIM_SAVED_CUR: Integer
-
-Process::RLIM_SAVED_MAX: Integer
-
-Process::WNOHANG: Integer
-
-Process::WUNTRACED: Integer
-
-module Process::GID
-  def self.change_privilege: (Integer group) -> Integer
-
-  def self.eid: () -> Integer
-
-  def self.from_name: (String name) -> Integer
-
-  def self.grant_privilege: (Integer group) -> Integer
-
-  def self.re_exchange: () -> Integer
-
-  def self.re_exchangeable?: () -> bool
-
-  def self.rid: () -> Integer
-
-  def self.sid_available?: () -> bool
-
-  def self.switch: () -> Integer
-                 | [T] () { () -> T } -> T
-
-  def self.eid=: (Integer group) -> Integer
-end
-
-class Process::Status < Object
-  def &: (Integer num) -> Integer
-
-  def ==: (untyped other) -> bool
-
-  def >>: (Integer num) -> Integer
-
-  def coredump?: () -> bool
-
-  def exited?: () -> bool
-
-  def exitstatus: () -> Integer?
-
-  def inspect: () -> String
-
-  def pid: () -> Integer
-
-  def signaled?: () -> bool
-
-  def stopped?: () -> bool
-
-  def stopsig: () -> Integer?
-
-  def success?: () -> bool
-
-  def termsig: () -> Integer?
-
-  def to_i: () -> Integer
-
-  def to_s: () -> String
-end
-
-module Process::Sys
-  def self.geteuid: () -> Integer
-
-  def self.getgid: () -> Integer
-
-  def self.getuid: () -> Integer
-
-  def self.issetugid: () -> bool
-
-  def self.setegid: (Integer group) -> NilClass
-
-  def self.seteuid: (Integer user) -> NilClass
-
-  def self.setgid: (Integer group) -> NilClass
-
-  def self.setregid: (Integer rid, Integer eid) -> NilClass
-
-  def self.setresgid: (Integer rid, Integer eid, Integer sid) -> NilClass
-
-  def self.setresuid: (Integer rid, Integer eid, Integer sid) -> NilClass
-
-  def self.setreuid: (Integer rid, Integer eid) -> NilClass
-
-  def self.setrgid: (Integer group) -> NilClass
-
-  def self.setruid: (Integer user) -> NilClass
-
-  def self.setuid: (Integer user) -> NilClass
-end
-
-module Process::UID
-  def self.change_privilege: (Integer user) -> Integer
-
-  def self.eid: () -> Integer
-
-  def self.from_name: (String name) -> Integer
-
-  def self.grant_privilege: (Integer user) -> Integer
-
-  def self.re_exchange: () -> Integer
-
-  def self.re_exchangeable?: () -> bool
-
-  def self.rid: () -> Integer
-
-  def self.sid_available?: () -> bool
-
-  def self.switch: () -> Integer
-                 | [T] () { () -> T } -> T
-
-  def self.eid=: (Integer user) -> Integer
-end
-
-class Process::Tms < Struct[Float]
-end
-
-class Process::Waiter < Thread
-  def pid: () -> Integer
-end