класс 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 с семантикой lambda, используя метод Kernel#lambda (см. ниже объяснения о lambda):

  lambda1 = lambda {|x| x**2 }
  

• Используйте синтаксис литерала lambda proc (Lambda proc literal) (также создаёт proc с семантикой lambda):

  lambda2 = ->(x) { x**2 }
  

Семантика Lambda и не-lambda

Proc бывают двух типов: lambda и не-lambda (обычные proc). Различия:

• В lambda, return и break означает выход из этой lambda;

• В не-lambda proc, return означает выход из охватывающего метода (и вызовет LocalJumpError, если вызван за пределами метода);

• В не-lambda proc, break означает выход из метода, для которого был передан блок. (и вызовет LocalJumpError, если вызван после возвращения метода);

• В lambda, аргументы обрабатываются так же, как и в методах: строго, с ArgumentError при несоответствии количества аргументов и без дополнительной обработки аргументов;

• Обычные proc принимают аргументы более снисходительно: отсутствующие аргументы заполняются nil, одиночные аргументы-массивы Array деконструируются, если у proc несколько аргументов, и не возникает ошибок при наличии дополнительных аргументов.

Примеры:

# +return+ in non-lambda proc, +b+, exits +m2+.
# (The block +{ return }+ is given for +m1+ and embraced by +m2+.)
$a = []; def m1(&b) b.call; $a << :m1 end; def m2() m1 { return }; $a << :m2 end; m2; p $a
#=> []

# +break+ in non-lambda proc, +b+, exits +m1+.
# (The block +{ break }+ is given for +m1+ and embraced by +m2+.)
$a = []; def m1(&b) b.call; $a << :m1 end; def m2() m1 { break }; $a << :m2 end; m2; p $a
#=> [:m2]

# +next+ in non-lambda proc, +b+, exits the block.
# (The block +{ next }+ is given for +m1+ and embraced by +m2+.)
$a = []; def m1(&b) b.call; $a << :m1 end; def m2() m1 { next }; $a << :m2 end; m2; p $a
#=> [:m1, :m2]

# Using +proc+ method changes the behavior as follows because
# The block is given for +proc+ method and embraced by +m2+.
$a = []; def m1(&b) b.call; $a << :m1 end; def m2() m1(&proc { return }); $a << :m2 end; m2; p $a
#=> []
$a = []; def m1(&b) b.call; $a << :m1 end; def m2() m1(&proc { break }); $a << :m2 end; m2; p $a
# break from proc-closure (LocalJumpError)
$a = []; def m1(&b) b.call; $a << :m1 end; def m2() m1(&proc { next }); $a << :m2 end; m2; p $a
#=> [:m1, :m2]

# +return+, +break+ and +next+ in the stubby lambda exits the block.
# (+lambda+ method behaves same.)
# (The block is given for stubby lambda syntax and embraced by +m2+.)
$a = []; def m1(&b) b.call; $a << :m1 end; def m2() m1(&-> { return }); $a << :m2 end; m2; p $a
#=> [:m1, :m2]
$a = []; def m1(&b) b.call; $a << :m1 end; def m2() m1(&-> { break }); $a << :m2 end; m2; p $a
#=> [:m1, :m2]
$a = []; def m1(&b) b.call; $a << :m1 end; def m2() m1(&-> { next }); $a << :m2 end; m2; p $a
#=> [:m1, :m2]

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

Lambda полезны как автономные функции, особенно полезны в качестве аргументов к функциям высшего порядка, ведя себя точно так же, как Ruby методы.

Proc полезны для реализации итераторов:

def test
  [[1, 2], [3, 4], [5, 6]].map {|a, b| return a if a + b > 10 }
                            #  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
end

Внутри map, блок кода обрабатывается как обычный (не-lambda) proc, что означает, что внутренние массивы будут деконструированы в пары аргументов, и return выйдет из метода test. Это было бы невозможно с более строгим lambda.

Вы можете отличить lambda от обычного proc, используя экземплярный метод lambda?.

Семантика lambda обычно сохраняется в течение жизни proc, включая &-декомпозицию в блок кода:

p = proc {|x, y| x }
l = lambda {|x, y| x }
[[1, 2], [3, 4]].map(&p) #=> [1, 3]
[[1, 2], [3, 4]].map(&l) # ArgumentError: wrong number of arguments (given 1, expected 2)

Единственным исключением является динамическое определение метода: даже если он определен путём передачи не-lambda 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 как не-lambda proc, но определяет метод с нормальной семантикой.

Преобразование других объектов в proc

Любой объект, реализующий метод to_proc, может быть преобразован в proc с помощью оператора &, и поэтому может быть использован итераторами.

class Greeter
  def initialize(greeting)
    @greeting = greeting
  end

  def to_proc
    proc {|name| "#{@greeting}, #{name}!" }
  end
end

hi = Greeter.new("Hi")
hey = Greeter.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]

Осиротевший Proc

return и break в блоке выходят из метода. Если объект Proc генерируется из блока, и объект Proc сохраняется до возврата метода, return и break не могут работать. В таком случае return и break генерирует LocalJumpError. Объект Proc в такой ситуации называется осиротевшим объектом Proc.

Обратите внимание, что метод выхода отличается для return и break. Существует ситуация, когда осиротевший для break но не осиротевший для return.

def m1(&b) b.call end; def m2(); m1 { return } end; m2 # ok
def m1(&b) b.call end; def m2(); m1 { break } end; m2 # ok

def m1(&b) b end; def m2(); m1 { return }.call end; m2 # ok
def m1(&b) b end; def m2(); m1 { break }.call end; m2 # LocalJumpError

def m1(&b) b end; def m2(); m1 { return } end; m2.call # LocalJumpError
def m1(&b) b end; def m2(); m1 { break } end; m2.call # LocalJumpError

Поскольку return и break выходят из блока в lambda, lambda не могут быть осиротевшими.

Анонимные параметры блока

Для упрощения написания коротких блоков, Ruby предоставляет два разных типа анонимных параметров: it (один параметр) и пронумерованные: _1, _2 и так далее.

# Explicit parameter:
%w[test me please].each { |str| puts str.upcase } # prints TEST, ME, PLEASE
(1..5).map { |i| i**2 } # => [1, 4, 9, 16, 25]

# it:
%w[test me please].each { puts it.upcase } # prints TEST, ME, PLEASE
(1..5).map { it**2 } # => [1, 4, 9, 16, 25]

# Numbered parameter:
%w[test me please].each { puts _1.upcase } # prints TEST, ME, PLEASE
(1..5).map { _1**2 } # => [1, 4, 9, 16, 25]

it

it - это имя, доступное внутри блока, когда явных параметров не определено, как показано выше.

%w[test me please].each { puts it.upcase } # prints TEST, ME, PLEASE
(1..5).map { it**2 } # => [1, 4, 9, 16, 25]

it - это «мягкий ключевой» элемент: это не зарезервированное имя, и его можно использовать в качестве имени для методов и локальных переменных:

it = 5 # no warnings
def it(&block) # RSpec-like API, no warnings
   # ...
end

it можно использовать как локальную переменную даже в блоках, использующих его как неявный параметр (хотя такой стиль очевидно вызывает путаницу):

[1, 2, 3].each {
  # takes a value of implicit parameter "it" and uses it to
  # define a local variable with the same name
  it = it**2
  p it
}

В блоке с явными параметрами использование it вызывает исключение:

[1, 2, 3].each { |x| p it }
# syntax error found (SyntaxError)
# [1, 2, 3].each { |x| p it }
#                        ^~ `it` is not allowed when an ordinary parameter is defined

Но если локальное имя (переменная или метод) доступно, оно будет использоваться:

it = 5
[1, 2, 3].each { |x| p it }
# Prints 5, 5, 5

Блоки, использующие it могут быть вложены:

%w[test me].each { it.each_char { p it } }
# Prints "t", "e", "s", "t", "m", "e"

Блоки, использующие it считаются имеющими один параметр:

p = proc { it**2 }
l = lambda { it**2 }
p.parameters     # => [[:opt, nil]]
p.arity          # => 1
l.parameters     # => [[:req]]
l.arity          # => 1

Пронумерованные параметры

Пронумерованные параметры – это ещё один способ неявно назвать параметры блока. В отличие от it, пронумерованные параметры позволяют ссылаться на несколько параметров в одном блоке.

%w[test me please].each { puts _1.upcase } # prints TEST, ME, PLEASE
{a: 100, b: 200}.map { "#{_1} = #{_2}" } # => "a = 100", "b = 200"

Поддерживаются имена параметров от _1 до _9:

[10, 20, 30].zip([40, 50, 60], [70, 80, 90]).map { _1 + _2 + _3 }
# => [120, 150, 180]

Однако, рекомендуется использовать их разумно, возможно, ограничиваясь _1 и _2, и в блоках из одной строки.

Пронумерованные параметры не могут быть использованы вместе с явными именованными:

[10, 20, 30].map { |x| _1**2 }
# SyntaxError (ordinary parameter is defined)

Пронумерованные параметры не могут быть смешаны с it:

[10, 20, 30].map { _1 + it }
# SyntaxError: `it` is not allowed when a numbered parameter is already used

Чтобы избежать конфликтов, присвоение локальных переменных или имен аргументов _1, _2 и так далее, вызовет ошибку.

  _1 = 'test'
# ^~ _1 is reserved for numbered parameters (SyntaxError)

Использование неявных пронумерованных параметров влияет на арность блока:

p = proc { _1 + _2 }
l = lambda { _1 + _2 }
p.parameters     # => [[:opt, :_1], [:opt, :_2]]
p.arity          # => 2
l.parameters     # => [[:req, :_1], [:req, :_2]]
l.arity          # => 2

Блоки с пронумерованными параметрами не могут быть вложены:

%w[test me].each { _1.each_char { p _1 } }
# numbered parameter is already used in outer block (SyntaxError)
# %w[test me].each { _1.each_char { p _1 } }
#                    ^~