steep 0.11.1 → 0.12.0

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

@@ -0,0 +1,426 @@
+# 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

@@ -0,0 +1,354 @@
+# [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