Creates a new Proc object, bound to the current context. Proc::new may be called without a block only within a method with an attached block, in which case that block is converted to the Proc object.

   def proc_from
     Proc.new
   end
   proc = proc_from { "hello" }
   proc.call   #=> "hello"

Return true if prc is the same object as other_proc, or if they are both procs with the same body.

Invokes the block, setting the block‘s parameters to the values in params using something close to method calling semantics. Generates a warning if multiple values are passed to a proc that expects just one (previously this silently converted the parameters to an array).

For procs created using Kernel.proc, generates an error if the wrong number of parameters are passed to a proc with multiple parameters. For procs created using Proc.new, extra parameters are silently discarded.

Returns the value of the last expression evaluated in the block. See also Proc#yield.

   a_proc = Proc.new {|a, *b| b.collect {|i| i*a }}
   a_proc.call(9, 1, 2, 3)   #=> [9, 18, 27]
   a_proc[9, 1, 2, 3]        #=> [9, 18, 27]
   a_proc = Proc.new {|a,b| a}
   a_proc.call(1,2,3)

produces:

   prog.rb:5: wrong number of arguments (3 for 2) (ArgumentError)
    from prog.rb:4:in `call'
    from prog.rb:5

Returns the number of arguments that would not be ignored. 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, return -n-1, where n is the number of mandatory arguments. A proc with no argument declarations is the same a block declaring || as its arguments.

   Proc.new {}.arity          #=>  0
   Proc.new {||}.arity        #=>  0
   Proc.new {|a|}.arity       #=>  1
   Proc.new {|a,b|}.arity     #=>  2
   Proc.new {|a,b,c|}.arity   #=>  3
   Proc.new {|*a|}.arity      #=> -1
   Proc.new {|a,*b|}.arity    #=> -2
   Proc.new {|a,*b, c|}.arity    #=> -3

Returns the binding associated with prc. Note that Kernel#eval accepts either a Proc or a Binding object as its second parameter.

   def fred(param)
     proc {}
   end

   b = fred(99)
   eval("param", b.binding)   #=> 99

Invokes the block, setting the block‘s parameters to the values in params using something close to method calling semantics. Generates a warning if multiple values are passed to a proc that expects just one (previously this silently converted the parameters to an array).

For procs created using Kernel.proc, generates an error if the wrong number of parameters are passed to a proc with multiple parameters. For procs created using Proc.new, extra parameters are silently discarded.

Returns the value of the last expression evaluated in the block. See also Proc#yield.

   a_proc = Proc.new {|a, *b| b.collect {|i| i*a }}
   a_proc.call(9, 1, 2, 3)   #=> [9, 18, 27]
   a_proc[9, 1, 2, 3]        #=> [9, 18, 27]
   a_proc = Proc.new {|a,b| a}
   a_proc.call(1,2,3)

produces:

   prog.rb:5: wrong number of arguments (3 for 2) (ArgumentError)
    from prog.rb:4:in `call'
    from prog.rb:5

Returns a curried proc. If the optional arity argument is given, it determines the number of arguments. A curried proc receives some arguments. If a sufficient number of arguments are supplied, it passes the supplied arguments to the original proc and returns the result. Otherwise, returns another curried proc that takes the rest of arguments.

   b = proc {|x, y, z| (x||0) + (y||0) + (z||0) }
   p b.curry[1][2][3]           #=> 6
   p b.curry[1, 2][3, 4]        #=> 6
   p b.curry(5)[1][2][3][4][5]  #=> 6
   p b.curry(5)[1, 2][3, 4][5]  #=> 6
   p b.curry(1)[1]              #=> 1

   b = proc {|x, y, z, *w| (x||0) + (y||0) + (z||0) + w.inject(0, &:+) }
   p b.curry[1][2][3]           #=> 6
   p b.curry[1, 2][3, 4]        #=> 10
   p b.curry(5)[1][2][3][4][5]  #=> 15
   p b.curry(5)[1, 2][3, 4][5]  #=> 15
   p b.curry(1)[1]              #=> 1

   b = lambda {|x, y, z| (x||0) + (y||0) + (z||0) }
   p b.curry[1][2][3]           #=> 6
   p b.curry[1, 2][3, 4]        #=> wrong number of arguments (4 or 3)
   p b.curry(5)                 #=> wrong number of arguments (5 or 3)
   p b.curry(1)                 #=> wrong number of arguments (1 or 3)

   b = lambda {|x, y, z, *w| (x||0) + (y||0) + (z||0) + w.inject(0, &:+) }
   p b.curry[1][2][3]           #=> 6
   p b.curry[1, 2][3, 4]        #=> 10
   p b.curry(5)[1][2][3][4][5]  #=> 15
   p b.curry(5)[1, 2][3, 4][5]  #=> 15
   p b.curry(1)                 #=> wrong number of arguments (1 or 3)

   b = proc { :foo }
   p b.curry[]                  #=> :foo

Return true if prc is the same object as other_proc, or if they are both procs with the same body.

Return hash value corresponding to proc body.

Returns true for a Proc object which argument handling is rigid. Such procs are typically generated by lambda.

A Proc object generated by proc ignore extra arguments.

  proc {|a,b| [a,b] }.call(1,2,3)    => [1,2]

It provides nil for lacked arguments.

  proc {|a,b| [a,b] }.call(1)        => [1,nil]

It expand single-array argument.

  proc {|a,b| [a,b] }.call([1,2])    => [1,2]

A Proc object generated by lambda doesn‘t have such tricks.

  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

Proc#lambda? is a predicate for the tricks. It returns true if no tricks.

  lambda {}.lambda?          => true
  proc {}.lambda?            => false

Proc.new is same as proc.

  Proc.new {}.lambda?        => false

lambda, proc and Proc.new preserves the tricks of a Proc object given by & argument.

  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 object generated by & argument has the tricks

  def n(&b) b.lambda? end
  n {}                       => false

The & argument preserves the tricks if a Proc object is given by & argument.

  n(&lambda {})              => true
  n(&proc {})                => false
  n(&Proc.new {})            => false

A Proc object converted from a method has no tricks.

  def m() end
  method(:m).to_proc.lambda? => true

  n(&method(:m))             => true
  n(&method(:m).to_proc)     => true

define_method is treated same as method definition. The defined method has no tricks.

  class C
    define_method(:d) {}
  end
  C.new.e(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 object is given. This is the only exception which the tricks are not preserved.

  class C
    define_method(:e, &proc {})
  end
  C.new.e(1,2)       => ArgumentError
  C.new.method(:e).to_proc.lambda?   => true

This exception is for a wrapper of define_method. It eases defining a method defining method which defines a usual method which has no tricks.

  class << C
    def def2(name, &body)
      define_method(name, &body)
    end
  end
  class C
    def2(:f) {}
  end
  C.new.f(1,2)       => ArgumentError

The wrapper, def2, defines a method which has no tricks.

Part of the protocol for converting objects to Proc objects. Instances of class Proc simply return themselves.

Shows the unique identifier for this proc, along with an indication of where the proc was defined.

Invokes the block, setting the block‘s parameters to the values in params using something close to method calling semantics. Generates a warning if multiple values are passed to a proc that expects just one (previously this silently converted the parameters to an array).

For procs created using Kernel.proc, generates an error if the wrong number of parameters are passed to a proc with multiple parameters. For procs created using Proc.new, extra parameters are silently discarded.

Returns the value of the last expression evaluated in the block. See also Proc#yield.

   a_proc = Proc.new {|a, *b| b.collect {|i| i*a }}
   a_proc.call(9, 1, 2, 3)   #=> [9, 18, 27]
   a_proc[9, 1, 2, 3]        #=> [9, 18, 27]
   a_proc = Proc.new {|a,b| a}
   a_proc.call(1,2,3)

produces:

   prog.rb:5: wrong number of arguments (3 for 2) (ArgumentError)
    from prog.rb:4:in `call'
    from prog.rb:5