Proc objects are blocks of code that have been bound to a set of local variables. Once bound, the code may be called in different contexts and still access those variables.
def gen_times(factor)
return Proc.new {|n| n*factor }
end
times3 = gen_times(3)
times5 = gen_times(5)
times3.call(12) #=> 36
times5.call(5) #=> 25
times3.call(times5.call(4)) #=> 60
Invokes the block, with obj as the block‘s parameter. It is to allow a proc object to be a target of when clause in the case statement.
Invokes the block, with obj as the block‘s parameter. It is to allow a proc object to be a target of when clause in the case statement.
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, with obj as the block‘s parameter. It is to allow a proc object to be a target of when clause in the case statement.
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
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.
returns the ruby source filename and line number containing this proc or nil if this proc was not defined in ruby (i.e. native)