Gecko [ gandhischool.edu.np ]

Name	Size	Permission
array.rbs	72.62 KB	-rw-r--r--
basic_object.rbs	9.56 KB	-rw-r--r--
binding.rbs	5.31 KB	-rw-r--r--
builtin.rbs	1.36 KB	-rw-r--r--
class.rbs	4.43 KB	-rw-r--r--
comparable.rbs	4.07 KB	-rw-r--r--
complex.rbs	10.87 KB	-rw-r--r--
constants.rbs	434 B	-rw-r--r--
deprecated.rbs	54 B	-rw-r--r--
dir.rbs	13.67 KB	-rw-r--r--
encoding.rbs	11.92 KB	-rw-r--r--
enumerable.rbs	16.38 KB	-rw-r--r--
enumerator.rbs	6.69 KB	-rw-r--r--
errno.rbs	12.63 KB	-rw-r--r--
errors.rbs	14.09 KB	-rw-r--r--
exception.rbs	6.35 KB	-rw-r--r--
false_class.rbs	1.13 KB	-rw-r--r--
fiber.rbs	1.96 KB	-rw-r--r--
fiber_error.rbs	396 B	-rw-r--r--
file.rbs	39.24 KB	-rw-r--r--
file_test.rbs	1.73 KB	-rw-r--r--
float.rbs	20.24 KB	-rw-r--r--
gc.rbs	7.43 KB	-rw-r--r--
hash.rbs	34.02 KB	-rw-r--r--
integer.rbs	20.19 KB	-rw-r--r--
io.rbs	28.26 KB	-rw-r--r--
kernel.rbs	16.7 KB	-rw-r--r--
marshal.rbs	5.6 KB	-rw-r--r--
match_data.rbs	8.84 KB	-rw-r--r--
math.rbs	9.84 KB	-rw-r--r--
method.rbs	5.13 KB	-rw-r--r--
module.rbs	37.41 KB	-rw-r--r--
nil_class.rbs	1.73 KB	-rw-r--r--
numeric.rbs	11.72 KB	-rw-r--r--
object.rbs	26.36 KB	-rw-r--r--
object_space.rbs	3.41 KB	-rw-r--r--
proc.rbs	12.6 KB	-rw-r--r--
process.rbs	40.72 KB	-rw-r--r--
random.rbs	9.67 KB	-rw-r--r--
range.rbs	6.58 KB	-rw-r--r--
rational.rbs	12.72 KB	-rw-r--r--
rb_config.rbs	1.66 KB	-rw-r--r--
regexp.rbs	40.9 KB	-rw-r--r--
ruby_vm.rbs	384 B	-rw-r--r--
signal.rbs	1.81 KB	-rw-r--r--
string.rbs	77.2 KB	-rw-r--r--
string_io.rbs	8.02 KB	-rw-r--r--
struct.rbs	1.23 KB	-rw-r--r--
symbol.rbs	6.96 KB	-rw-r--r--
thread.rbs	34.03 KB	-rw-r--r--
thread_group.rbs	730 B	-rw-r--r--
time.rbs	40.94 KB	-rw-r--r--
trace_point.rbs	7.45 KB	-rw-r--r--
true_class.rbs	1.19 KB	-rw-r--r--
unbound_method.rbs	5.22 KB	-rw-r--r--
warning.rbs	835 B	-rw-r--r--

Code Editor : proc.rbs

# 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

def initialize: () { (*untyped) -> untyped } -> void

# 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

${this.title}

Code Editor : proc.rbs