Spec-Zone.ru › Ruby 2.4

класс Proc

Родитель:
Object

Proc объекты — это блоки кода, которые связаны с набором локальных переменных. После связывания код может вызываться в разных контекстах и по-прежнему обращаться к этим переменным.

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

Публичные методы класса

new {|...| block } → a_proc Показать исходный код
new → a_proc 
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"

Методы экземпляров Public

proc === obj → result_of_proc Показать исходный код 
static VALUE
proc_call(int argc, VALUE *argv, VALUE procval)
{
    /* removed */
}

Вызывает блок с obj в качестве параметра проца, подобно #call. Это позволяет объекту proc быть целевым для when в операторе case.

prc[params,...] → obj Показать исходный код 
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() с указанными параметрами. Это синтаксический сахар для скрытия «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)

См. также #lambda?.

arity → integer Показать исходный код 
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   { |x=0| }.arity         #=>  0
lambda { |x=0| }.arity         #=> -1
proc   { |x=0, y| }.arity      #=>  1
lambda { |x=0, y| }.arity      #=> -2
proc   { |x=0, y=0| }.arity    #=>  0
lambda { |x=0, y=0| }.arity    #=> -1
proc   { |x, y=0| }.arity      #=>  1
lambda { |x, y=0| }.arity      #=> -2
proc   { |(x, y), z=0| }.arity #=>  1
lambda { |(x, y), z=0| }.arity #=> -2
proc   { |a, x:0, y:0| }.arity #=>  1
lambda { |a, x:0, y:0| }.arity #=> -2
binding → binding Показать исходный код 
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;
                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 */
                RB_OBJ_WRITE(env, &env->iseq, rb_iseq_new(NULL, rb_str_new2("<empty iseq>"), rb_str_new2("<empty_iseq>"), Qnil, 0, ISEQ_TYPE_TOP));
                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);

    bind->block.as.captured.self = binding_self;
    bind->block.as.captured.code.iseq = env->iseq;
    bind->block.as.captured.ep = env->ep;

    if (iseq) {
        rb_iseq_check(iseq);
        bind->path = iseq->body->location.path;
        bind->first_lineno = FIX2INT(rb_iseq_first_lineno(iseq));
    }
    else {
        bind->path = Qnil;
        bind->first_lineno = 0;
    }

    return bindval;
}

Возвращает привязку, связанную с prc. Обратите внимание, что Kernel#eval принимает в качестве второго параметра либо Proc, либо Binding объект.

def fred(param)
  proc {}
end

b = fred(99)
eval("param", b.binding)   #=> 99
call(params,...) → obj Показать исходный код 
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() с указанными параметрами. Это синтаксический сахар для скрытия «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)

См. также #lambda?.

curry → a_proc Показать исходный код
curry(arity) → a_proc 
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;

    rb_scan_args(argc, argv, "01", &arity);
    if (NIL_P(arity)) {
        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);
}

Возвращает закрёженный proc. Если задан необязательный аргумент arity, он определяет количество аргументов. Закрытый proc принимает некоторые аргументы. Если предоставлено достаточное количество аргументов, он передает предоставленные аргументы исходному процу и возвращает результат. В противном случае возвращает другой закрытый proc, который принимает оставшиеся аргументы.

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
hash → integer Показать исходный код 
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);
}

Возвращает значение хэша, соответствующее телу proc.

См. также Object#hash.

inspect()
Псевдоним для: to_s
lambda? → true или false Показать исходный код 
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

#lambda? — это предикат для ухищрений. Он возвращает true если никакие ухищрения не применяются.

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

::new эквивалентно proc.

Proc.new {}.lambda?          #=> false

lambda, 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 определяет метод, который не имеет ухищрений.

parameters → array Показать исходный код 
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 unnamed_parameters(rb_proc_arity(self));
    }
    return rb_iseq_parameters(iseq, is_proc);
}

Возвращает информацию о параметрах этого proc.

prc = lambda{|x, y=42, *other|}
prc.parameters  #=> [[:req, :x], [:opt, :y], [:rest, :other]]
source_location → [String, Integer] Показать исходный код 
VALUE
rb_proc_location(VALUE self)
{
    return iseq_location(rb_proc_get_iseq(self, 0));
}

Возвращает имя файла исходного кода Ruby и номер строки, содержащие этот proc, или nil если этот proc не был определён в Ruby (т.е. нативный).

to_proc → proc Показать исходный код 
static VALUE
proc_to_proc(VALUE self)
{
    return self;
}

Часть протокола для преобразования объектов в объекты Proc. Экземпляры класса Proc просто возвращают себя.

to_s → string Показать исходный код 
static VALUE
proc_to_s(VALUE self)
{
    const rb_proc_t *proc;
    GetProcPtr(self, proc);
    return proc_to_s_(self, proc);
}

Возвращает уникальный идентификатор для этого proc, а также указание, где proc был определён.

Также алиас для: inspect
yield(params,...) → obj Показать исходный код 
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() с указанными параметрами. Это синтаксический сахар для скрытия «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)

См. также #lambda?.

Ruby Core © 1993–2017 Yukihiro Matsumoto
Licensed under the Ruby License.
Ruby Standard Library © contributors
Licensed under their own licenses.

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API