класс Proc
Объект Proc представляет собой оболочку блока кода, который может храниться в локальной переменной, передаваться в метод или другой Proc, и может вызываться. Proc — это важная концепция в Ruby и основа его функциональных возможностей.
square = Proc.new {|x| x**2 }
square.call(3) #=> 9
# shorthands:
square.(3) #=> 9
square[3] #=> 9
Объекты Proc являются замыканиями, то есть они запоминают и могут использовать весь контекст, в котором были созданы.
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
Создание
Существует несколько методов для создания Proc
-
Используйте конструктор класса
Proc:proc1 = Proc.new {|x| x**2 } -
Используйте метод
Kernel#procкак сокращение дляProc.new:proc2 = proc {|x| x**2 } -
Получение блока кода в качестве аргумента proc (обратите внимание на
&):def make_proc(&block) block end proc3 = make_proc {|x| x**2 } -
Создайте proc с семантикой лямбды, используя метод
Kernel#lambda(подробнее о лямбдах см. ниже):lambda1 = lambda {|x| x**2 } -
Используйте синтаксис лямбда-литерала (также создаёт proc с семантикой лямбды):
lambda2 = ->(x) { x**2 }
Семантика лямбды и не-лямбды
Proc бывают двух типов: лямбда и не-лямбда (обычные proc). Различия заключаются в:
-
В лямбдах,
returnозначает выход из этой лямбды; -
В обычных proc,
returnозначает выход из окружающего метода (и вызоветLocalJumpErrorпри вызове вне метода); -
В лямбдах, аргументы обрабатываются так же, как и в методах: строго, с
ArgumentErrorпри несоответствии количества аргументов и без дополнительной обработки аргументов; -
Обычные proc принимают аргументы более гибко: отсутствующие аргументы заполняются
nil, одиночные аргументы-массивыArrayдеконструируются, если у proc несколько аргументов, и не возникает ошибок при наличии дополнительных аргументов.
Примеры:
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
Лямбды полезны в качестве автономных функций, особенно в качестве аргументов для функций высшего порядка, ведя себя точно как методы Ruby.
Proc полезны для реализации итераторов:
def test
[[1, 2], [3, 4], [5, 6]].map {|a, b| return a if a + b > 10 }
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
end
Внутри map, блок кода обрабатывается как обычный (не лямбда) proc, что означает, что внутренние массивы будут деконструированы в пары аргументов, а return выйдет из метода test. Этого не удалось бы сделать со строгой лямбдой.
Вы можете определить лямбду от обычного proc, используя метод lambda? экземпляра.
Семантика лямбды обычно сохраняется в течение всего жизненного цикла proc, включая & - деконструкцию в блок кода:
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)
Исключением является динамическое определение метода: даже если он определен путём передачи не-лямбда proc, методы всё равно имеют обычную семантику проверки аргументов.
class C
define_method(:e, &proc {})
end
C.new.e(1,2) #=> ArgumentError
C.new.method(:e).to_proc.lambda? #=> true
Это исключение гарантирует, что методы никогда не имеют необычных соглашений о передаче аргументов, и облегчает создание обёртки, определяющей методы, которые ведут себя как обычно.
class C
def self.def2(name, &body)
define_method(name, &body)
end
def2(:f) {}
end
C.new.f(1,2) #=> ArgumentError
Обёртка def2 получает body в качестве не-лямбда proc, но определяет метод с обычной семантикой.
Преобразование других объектов в прокси
Любой объект, реализующий метод to_proc может быть преобразован в proc с помощью оператора &, а следовательно, может быть использован итераторами.
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!"]
Из основных классов Ruby, этот метод реализован в Symbol, Method и Hash.
: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]
Публичные методы класса
static VALUE
rb_proc_s_new(int argc, VALUE *argv, VALUE klass)
{
VALUE block = proc_new(klass, FALSE);
rb_obj_call_init(block, argc, argv);
return block;
} Создаёт новый объект Proc, связанный с текущим контекстом. Proc::new можно вызвать без блока только внутри метода с присоединённым блоком, в котором этот блок преобразуется в объект Proc.
def proc_from
Proc.new
end
proc = proc_from { "hello" }
proc.call #=> "hello"
Общедоступные методы экземпляров
static VALUE
proc_compose_to_left(VALUE self, VALUE g)
{
VALUE proc, args, procs[2];
rb_proc_t *procp;
int is_lambda;
procs[0] = self;
procs[1] = g;
args = rb_ary_tmp_new_from_values(0, 2, procs);
GetProcPtr(self, procp);
is_lambda = procp->is_lambda;
proc = rb_proc_new(compose, args);
GetProcPtr(proc, procp);
procp->is_lambda = is_lambda;
return proc;
} Возвращает процедуру, являющуюся композицией этой процедуры и заданной g. Возвращаемая процедура принимает переменное количество аргументов, вызывает g с ними, а затем вызывает эту процедуру с результатом.
f = proc {|x| x * x }
g = proc {|x| x + x }
p (f << g).call(2) #=> 16
static VALUE
proc_call(int argc, VALUE *argv, VALUE procval)
{
/* removed */
} Вызывает блок с obj в качестве параметра процедуры, как в Proc#call. Это позволяет объекту процедуры быть целевым для when-оператор в операторе case.
static VALUE
proc_compose_to_right(VALUE self, VALUE g)
{
VALUE proc, args, procs[2];
rb_proc_t *procp;
int is_lambda;
procs[0] = g;
procs[1] = self;
args = rb_ary_tmp_new_from_values(0, 2, procs);
GetProcPtr(self, procp);
is_lambda = procp->is_lambda;
proc = rb_proc_new(compose, args);
GetProcPtr(proc, procp);
procp->is_lambda = is_lambda;
return proc;
} Возвращает процедуру, являющуюся композицией этой процедуры и заданной g. Возвращаемая процедура принимает переменное количество аргументов, вызывает g с ними, а затем вызывает эту процедуру с результатом.
f = proc {|x| x * x }
g = proc {|x| x + x }
p (f >> g).call(2) #=> 8
static VALUE
proc_call(int argc, VALUE *argv, VALUE procval)
{
/* removed */
} Вызывает блок, устанавливая параметры блока на значения в params, используя что-то близкое к семантике вызова метода. Возвращает значение последнего выражения, вычисленного в блоке.
a_proc = Proc.new {|scalar, *values| values.map {|value| value*scalar } }
a_proc.call(9, 1, 2, 3) #=> [9, 18, 27]
a_proc[9, 1, 2, 3] #=> [9, 18, 27]
a_proc.(9, 1, 2, 3) #=> [9, 18, 27]
a_proc.yield(9, 1, 2, 3) #=> [9, 18, 27]
Обратите внимание, что prc.() вызывает prc.call() с заданными параметрами. Это синтаксический сахар для скрытия «вызова».
Для процедур, созданных с использованием lambda или ->(), генерируется ошибка, если передаётся неверное количество параметров в процедуру. Для процедур, созданных с использованием Proc.new или Kernel.proc, дополнительные параметры игнорируются, а недостающие параметры устанавливаются в nil.
a_proc = proc {|a,b| [a,b] }
a_proc.call(1) #=> [1, nil]
a_proc = lambda {|a,b| [a,b] }
a_proc.call(1) # ArgumentError: wrong number of arguments (given 1, expected 2)
См. также Proc#lambda?.
static VALUE
proc_arity(VALUE self)
{
int arity = rb_proc_arity(self);
return INT2FIX(arity);
} Возвращает количество обязательных аргументов. Если блок объявлен как не принимающий аргументов, возвращает 0. Если блок известен как принимающий ровно n аргументов, возвращает n. Если у блока есть необязательные аргументы, возвращает -n-1, где n — количество обязательных аргументов, за исключением блоков, которые не являются лямбдами и имеют только конечное число необязательных аргументов; в последнем случае возвращает n. Аргументы ключевых слов будут рассматриваться как один дополнительный аргумент, который является обязательным, если какой-либо аргумент ключевого слова является обязательным. Блок без объявлений аргументов эквивалентен блоку, объявляющему || в качестве аргументов.
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
static VALUE
proc_binding(VALUE self)
{
VALUE bindval, binding_self = Qundef;
rb_binding_t *bind;
const rb_proc_t *proc;
const rb_iseq_t *iseq = NULL;
const struct rb_block *block;
const rb_env_t *env = NULL;
GetProcPtr(self, proc);
block = &proc->block;
again:
switch (vm_block_type(block)) {
case block_type_iseq:
iseq = block->as.captured.code.iseq;
binding_self = block->as.captured.self;
env = VM_ENV_ENVVAL_PTR(block->as.captured.ep);
break;
case block_type_proc:
GetProcPtr(block->as.proc, proc);
block = &proc->block;
goto again;
case block_type_symbol:
goto error;
case block_type_ifunc:
{
const struct vm_ifunc *ifunc = block->as.captured.code.ifunc;
if (IS_METHOD_PROC_IFUNC(ifunc)) {
VALUE method = (VALUE)ifunc->data;
VALUE name = rb_fstring_lit("<empty_iseq>");
rb_iseq_t *empty;
binding_self = method_receiver(method);
iseq = rb_method_iseq(method);
env = VM_ENV_ENVVAL_PTR(block->as.captured.ep);
env = env_clone(env, method_cref(method));
/* set empty iseq */
empty = rb_iseq_new(NULL, name, name, Qnil, 0, ISEQ_TYPE_TOP);
RB_OBJ_WRITE(env, &env->iseq, empty);
break;
}
else {
error:
rb_raise(rb_eArgError, "Can't create Binding from C level Proc");
return Qnil;
}
}
}
bindval = rb_binding_alloc(rb_cBinding);
GetBindingPtr(bindval, bind);
RB_OBJ_WRITE(bindval, &bind->block.as.captured.self, binding_self);
RB_OBJ_WRITE(bindval, &bind->block.as.captured.code.iseq, env->iseq);
rb_vm_block_ep_update(bindval, &bind->block, env->ep);
RB_OBJ_WRITTEN(bindval, Qundef, VM_ENV_ENVVAL(env->ep));
if (iseq) {
rb_iseq_check(iseq);
RB_OBJ_WRITE(bindval, &bind->pathobj, iseq->body->location.pathobj);
bind->first_lineno = FIX2INT(rb_iseq_first_lineno(iseq));
}
else {
RB_OBJ_WRITE(bindval, &bind->pathobj,
rb_iseq_pathobj_new(rb_fstring_lit("(binding)"), Qnil));
bind->first_lineno = 1;
}
return bindval;
} Возвращает привязку, связанную с prc.
def fred(param)
proc {}
end
b = fred(99)
eval("param", b.binding) #=> 99
static VALUE
proc_call(int argc, VALUE *argv, VALUE procval)
{
/* removed */
} Вызывает блок, устанавливая параметры блока на значения в params, используя что-то близкое к семантике вызова метода. Возвращает значение последнего выражения, вычисленного в блоке.
a_proc = Proc.new {|scalar, *values| values.map {|value| value*scalar } }
a_proc.call(9, 1, 2, 3) #=> [9, 18, 27]
a_proc[9, 1, 2, 3] #=> [9, 18, 27]
a_proc.(9, 1, 2, 3) #=> [9, 18, 27]
a_proc.yield(9, 1, 2, 3) #=> [9, 18, 27]
Обратите внимание, что prc.() вызывает prc.call() с заданными параметрами. Это синтаксический сахар для скрытия «вызова».
Для процедур, созданных с использованием lambda или ->(), генерируется ошибка, если передаётся неверное количество параметров в процедуру. Для процедур, созданных с использованием Proc.new или Kernel.proc, дополнительные параметры игнорируются, а недостающие параметры устанавливаются в nil.
a_proc = proc {|a,b| [a,b] }
a_proc.call(1) #=> [1, nil]
a_proc = lambda {|a,b| [a,b] }
a_proc.call(1) # ArgumentError: wrong number of arguments (given 1, expected 2)
См. также Proc#lambda?.
static VALUE
proc_curry(int argc, const VALUE *argv, VALUE self)
{
int sarity, max_arity, min_arity = rb_proc_min_max_arity(self, &max_arity);
VALUE arity;
if (rb_check_arity(argc, 0, 1) == 0 || NIL_P(arity = argv[0])) {
arity = INT2FIX(min_arity);
}
else {
sarity = FIX2INT(arity);
if (rb_proc_lambda_p(self)) {
rb_check_arity(sarity, min_arity, max_arity);
}
}
return make_curry_proc(self, rb_ary_new(), arity);
} Возвращает процедуру с частичным применением аргументов (curried). Если необязательный аргумент arity задан, он определяет количество аргументов. Процедура с частичным применением аргументов получает некоторые аргументы. Если предоставлено достаточное количество аргументов, она передает предоставленные аргументы исходной процедуре и возвращает результат. В противном случае возвращает другую процедуру с частичным применением аргументов, которая принимает оставшиеся аргументы.
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 (given 4, expected 3)
p b.curry(5) #=> wrong number of arguments (given 5, expected 3)
p b.curry(1) #=> wrong number of arguments (given 1, expected 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 (given 1, expected 3)
b = proc { :foo }
p b.curry[] #=> :foo
static VALUE
proc_hash(VALUE self)
{
st_index_t hash;
hash = rb_hash_start(0);
hash = rb_hash_proc(hash, self);
hash = rb_hash_end(hash);
return ST2FIX(hash);
} Возвращает значение хеша, соответствующее телу процедуры.
См. также Object#hash.
VALUE
rb_proc_lambda_p(VALUE procval)
{
rb_proc_t *proc;
GetProcPtr(procval, proc);
return proc->is_lambda ? Qtrue : Qfalse;
} Возвращает true для объекта Proc, для которого обработка аргументов жёсткая. Такие процедуры обычно генерируются lambda.
Объект Proc, сгенерированный proc игнорирует дополнительные аргументы.
proc {|a,b| [a,b] }.call(1,2,3) #=> [1,2]
Он обеспечивает nil для отсутствующих аргументов.
proc {|a,b| [a,b] }.call(1) #=> [1,nil]
Он расширяет единственный массивный аргумент.
proc {|a,b| [a,b] }.call([1,2]) #=> [1,2]
Объект Proc, сгенерированный lambda не имеет таких ухищрений.
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? — предикат для таких ухищрений. Он возвращает true если такие ухищрения не применяются.
lambda {}.lambda? #=> true
proc {}.lambda? #=> false
Proc.new эквивалентен proc.
Proc.new {}.lambda? #=> false
lambda, proc и Proc.new сохраняют ухищрения объекта Proc, заданного аргументом &.
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
Объект Proc, сгенерированный аргументом & обладает ухищрениями
def n(&b) b.lambda? end
n {} #=> false
Аргумент & сохраняет ухищрения, если объект Proc задан аргументом &.
n(&lambda {}) #=> true
n(&proc {}) #=> false
n(&Proc.new {}) #=> false
Объект Proc, преобразованный из метода, не имеет ухищрений.
def m() end method(:m).to_proc.lambda? #=> true n(&method(:m)) #=> true n(&method(:m).to_proc) #=> true
define_method обрабатывается так же, как определение метода. Определённый метод не имеет ухищрений.
class C
define_method(:d) {}
end
C.new.d(1,2) #=> ArgumentError
C.new.method(:d).to_proc.lambda? #=> true
define_method всегда определяет метод без ухищрений, даже если объект не-лямбда Proc задан. Это единственное исключение, при котором ухищрения не сохраняются.
class C
define_method(:e, &proc {})
end
C.new.e(1,2) #=> ArgumentError
C.new.method(:e).to_proc.lambda? #=> true
Это исключение гарантирует, что методы никогда не имеют ухищрений, и упрощает создание обёрток для определения методов, которые ведут себя как обычно.
class C
def self.def2(name, &body)
define_method(name, &body)
end
def2(:f) {}
end
C.new.f(1,2) #=> ArgumentError
Обёртка def2 определяет метод, у которого нет ухищрений.
static VALUE
rb_proc_parameters(VALUE self)
{
int is_proc;
const rb_iseq_t *iseq = rb_proc_get_iseq(self, &is_proc);
if (!iseq) {
return rb_unnamed_parameters(rb_proc_arity(self));
}
return rb_iseq_parameters(iseq, is_proc);
} Возвращает информацию о параметрах этой процедуры.
prc = lambda{|x, y=42, *other|}
prc.parameters #=> [[:req, :x], [:opt, :y], [:rest, :other]]
VALUE
rb_proc_location(VALUE self)
{
return iseq_location(rb_proc_get_iseq(self, 0));
} Возвращает имя файла исходного кода Ruby и номер строки, содержащие эту процедуру, или nil если эта процедура не была определена в Ruby (т. е. нативная).
static VALUE
proc_to_proc(VALUE self)
{
return self;
} Часть протокола для преобразования объектов в объекты Proc. Экземпляры класса Proc просто возвращают себя.
static VALUE
proc_to_s(VALUE self)
{
const rb_proc_t *proc;
GetProcPtr(self, proc);
return rb_block_to_s(self, &proc->block, proc->is_lambda ? " (lambda)" : NULL);
} Возвращает уникальный идентификатор этой процедуры, а также указание на то, где была определена процедура.
static VALUE
proc_call(int argc, VALUE *argv, VALUE procval)
{
/* removed */
} Вызывает блок, устанавливая параметры блока на значения в params, используя что-то близкое к семантике вызова метода. Возвращает значение последнего выражения, вычисленного в блоке.
a_proc = Proc.new {|scalar, *values| values.map {|value| value*scalar } }
a_proc.call(9, 1, 2, 3) #=> [9, 18, 27]
a_proc[9, 1, 2, 3] #=> [9, 18, 27]
a_proc.(9, 1, 2, 3) #=> [9, 18, 27]
a_proc.yield(9, 1, 2, 3) #=> [9, 18, 27]
Обратите внимание, что prc.() вызывает prc.call() с заданными параметрами. Это синтаксический сахар для скрытия «вызова».
Для процедур, созданных с использованием lambda или ->(), генерируется ошибка, если передано неправильное количество параметров. Для процедур, созданных с использованием Proc.new или Kernel.proc, дополнительные параметры игнорируются, а отсутствующие параметры устанавливаются на nil.
a_proc = proc {|a,b| [a,b] }
a_proc.call(1) #=> [1, nil]
a_proc = lambda {|a,b| [a,b] }
a_proc.call(1) # ArgumentError: wrong number of arguments (given 1, expected 2)
См. также Proc#lambda?.
Ruby Core © 1993–2017 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.
