Когда использовать lambda, когда использовать Proc.new?

Еще одно важное, но тонкое различие между procs, созданными с помощью lambda , и procs, созданными с помощью Proc.new , заключается в том, как они обрабатывают оператор return :

• В lambda -созданные труды, в return оператор возвращает только прок себе
• В Proc.new-созданном proc оператор return немного более удивителен: он возвращает управление не только из proc, но и из метода, заключающего proc!

Вот lambda-созданный proc return в действии. Он ведет себя так, как вы, вероятно, ожидаете:

def whowouldwin

  mylambda = lambda {return "Freddy"}
  mylambda.call

  # mylambda gets called and returns "Freddy", and execution
  # continues on the next line

  return "Jason"

end


whowouldwin
#=> "Jason"

Теперь вот Proc.new-созданный proc return делает то же самое. Вы вот-вот увидите один из тех случаев, когда Ruby нарушает хваленый принцип наименьшего удивления:

def whowouldwin2

  myproc = Proc.new {return "Freddy"}
  myproc.call

  # myproc gets called and returns "Freddy", 
  # but also returns control from whowhouldwin2!
  # The line below *never* gets executed.

  return "Jason"

end


whowouldwin2         
#=> "Freddy"

Благодаря этому удивительному поведению (а также меньшему набору текста) я склоняюсь к использованию lambda вместо Proc.new при создании procs.

Для предоставления дальнейших разъяснений:

Джоуи говорит, что обратное поведение Proc.new вызывает удивление. Однако если учесть, что Proc.new ведет себя как блок, это не удивительно, поскольку именно так ведут себя блоки. с другой стороны, Ламбас ведут себя скорее как методы.

Это фактически объясняет, почему Procs гибки, когда речь заходит об arity (количестве аргументов), в то время как Lambda-нет. Блоки не требуют предоставления всех своих аргументов, но методы делают это (если не указано значение по умолчанию). Хотя предоставление аргумента lambda по умолчанию не является опцией в Ruby 1.8, теперь он поддерживается в Ruby 1.9 с альтернативным синтаксисом lambda (как отмечает webmat):

concat = ->(a, b=2){ "#{a}#{b}" }
concat.call(4,5) # => "45"
concat.call(1)   # => "12"

И Мишель де Маре (the OP) неверно говорит о том, что Procs и lambda ведут себя так же с arity в Ruby 1.9. Я проверил, что они все еще поддерживают поведение от 1.8, как указано выше.

Заявления break на самом деле не имеет смысла в любом прокся или лямбд. В Procs перерыв вернет вас из Proc.new, который уже был завершен. И нет никакого смысла отрываться от lambda, так как это по сути метод, и вы никогда не будете отрываться от верхнего уровня метода.

next , redo и raise ведут себя одинаково как в Проксе, так и в лямбде. В то время как retry не допускается ни в том, ни в другом случае и вызовет исключение.

И, наконец, метод proc никогда не должен использоваться, поскольку он является непоследовательным и имеет неожиданное поведение. В Ruby 1.8 он фактически возвращает lambda! В Ruby 1.9 это было исправлено, и он возвращает Proc. Если вы хотите создать Proc, придерживайтесь Proc.new .

Для получения дополнительной информации я настоятельно рекомендую O'Reilly's The Ruby Programming Language , который является моим источником для большей части этой информации.

Я нашел эту страницу , которая показывает, в чем разница между Proc.new и lambda . Согласно странице, единственная разница заключается в том, что lambda строго относится к числу принимаемых аргументов, в то время как Proc.new преобразует отсутствующие аргументы в nil . Вот пример IRB сессии, иллюстрирующий разницу:

irb(main):001:0> l = lambda { |x, y| x + y }
=> #<Proc:0x00007fc605ec0748@(irb):1>
irb(main):002:0> p = Proc.new { |x, y| x + y }
=> #<Proc:0x00007fc605ea8698@(irb):2>
irb(main):003:0> l.call "hello", "world"
=> "helloworld"
irb(main):004:0> p.call "hello", "world"
=> "helloworld"
irb(main):005:0> l.call "hello"
ArgumentError: wrong number of arguments (1 for 2)
    from (irb):1
    from (irb):5:in `call'
    from (irb):5
    from :0
irb(main):006:0> p.call "hello"
TypeError: can't convert nil into String
    from (irb):2:in `+'
    from (irb):2
    from (irb):6:in `call'
    from (irb):6
    from :0

Страница также рекомендует использовать lambda, если вы специально не хотите, чтобы поведение было устойчивым к ошибкам. Я согласен с этим мнением. Использование lambda кажется немного более лаконичным, и с такой незначительной разницей это кажется лучшим выбором в средней ситуации.

Что касается Ruby 1.9, извините, я еще не заглядывал в 1.9, но я не думаю, что они так сильно изменят его (Хотя не верьте мне на слово, похоже, вы слышали о некоторых изменениях, так что я, вероятно, ошибаюсь).

Proc старше, но семантика возвращения очень противоречива для меня (по крайней мере, когда я изучал язык), потому что:

1. Если вы используете proc, вы, скорее всего, используете какую-то функциональную парадигму.
2. Proc может вернуться из заключительной области (см. предыдущие ответы), которая в основном является goto и очень нефункциональна по своей природе.

Lambda функционально безопаснее и проще рассуждать - я всегда использую его вместо proc.

Краткий ответ: важно то, что делает return : lambda возвращает из себя, а proc возвращает из себя AND функцию, которая его вызвала.

Менее ясно, почему вы хотите использовать каждый из них. lambda - это то, что мы ожидаем от вещей в смысле функционального программирования. Это в основном анонимный метод с автоматически привязанной текущей областью действия. Из них lambda - это тот, который вы, вероятно, должны использовать.

Proc, с другой стороны, действительно полезен для реализации самого языка. Например, с их помощью можно реализовать операторы "if" или циклы "for". Любое возвращаемое значение, найденное в proc, будет возвращено из вызвавшего его метода, а не только из оператора "if". Вот как работают языки, как работают операторы "if", поэтому я предполагаю, что Ruby использует это под прикрытием, и они просто выставили его, потому что он казался мощным.

Это действительно нужно только в том случае, если вы создаете новые языковые конструкции, такие как циклы, конструкции if-else и т. д.

Я не могу сказать много о тонких различиях. Однако я могу отметить, что Ruby 1.9 теперь позволяет необязательные параметры для лямбд и блоков.

Вот новый синтаксис для лямбд колоть под 1.9:

stabby = ->(msg='inside the stabby lambda') { puts msg }

Ruby 1.8 не имел такого синтаксиса. Кроме того, обычный способ объявления блоков/лямбд не поддерживает необязательные args:

# under 1.8
l = lambda { |msg = 'inside the stabby lambda'|  puts msg }
SyntaxError: compile error
(irb):1: syntax error, unexpected '=', expecting tCOLON2 or '[' or '.'
l = lambda { |msg = 'inside the stabby lambda'|  puts msg }

Ruby 1.9, однако, поддерживает необязательные аргументы даже со старым синтаксисом:

l = lambda { |msg = 'inside the regular lambda'|  puts msg }
#=> #<Proc:0x0e5dbc@(irb):1 (lambda)>
l.call
#=> inside the regular lambda
l.call('jeez')
#=> jeez

Если вы хотите построить Ruby1.9 для Leopard или Linux, ознакомьтесь с этой статьей (бесстыдная самореклама).

Хороший способ увидеть это заключается в том, что лямбды выполняются в своей собственной области видимости (как если бы это был вызов метода), в то время как Procs можно рассматривать как выполняемые встраиваемые в вызывающий метод, по крайней мере, это хороший способ решить, какой метод использовать в каждом конкретном случае.

Я не заметил никаких комментариев к третьему методу в queston, "proc", который является устаревшим, но обрабатывается по-разному в 1.8 и 1.9.

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

def meth1
  puts "method start"

  pr = lambda { return }
  pr.call

  puts "method end"  
end

def meth2
  puts "method start"

  pr = Proc.new { return }
  pr.call

  puts "method end"  
end

def meth3
  puts "method start"

  pr = proc { return }
  pr.call

  puts "method end"  
end

puts "Using lambda"
meth1
puts "--------"
puts "using Proc.new"
meth2
puts "--------"
puts "using proc"
meth3

Closures в Ruby -это хороший обзор того, как блоки, lambda и proc работают в Ruby, с Ruby.

lambda работает, как и ожидалось, как и в других языках.

Wired Proc.new удивляет и сбивает с толку.

Оператор return в proc, созданный Proc.new , будет возвращать управление не только из самого себя, но и из заключающего его метода .

def some_method
  myproc = Proc.new {return "End."}
  myproc.call

  # Any code below will not get executed!
  # ...
end

Можно утверждать, что Proc.new вставляет код в метод enclosing, как и block. Но Proc.new создает объект, в то время как блок является частью объекта.

И есть еще одно различие между lambda и Proc.new, которое заключается в их обработке (неправильных) аргументов. lambda жалуется на это, в то время как Proc.new игнорирует дополнительные аргументы или считает отсутствие аргументов равным нулю.

irb(main):021:0> l = -> (x) { x.to_s }
=> #<Proc:0x8b63750@(irb):21 (lambda)>
irb(main):022:0> p = Proc.new { |x| x.to_s}
=> #<Proc:0x8b59494@(irb):22>
irb(main):025:0> l.call
ArgumentError: wrong number of arguments (0 for 1)
        from (irb):21:in `block in irb_binding'
        from (irb):25:in `call'
        from (irb):25
        from /usr/bin/irb:11:in `<main>'
irb(main):026:0> p.call
=> ""
irb(main):049:0> l.call 1, 2
ArgumentError: wrong number of arguments (2 for 1)
        from (irb):47:in `block in irb_binding'
        from (irb):49:in `call'
        from (irb):49
        from /usr/bin/irb:11:in `<main>'
irb(main):050:0> p.call 1, 2
=> "1"

BTW, proc в Ruby 1.8 создает lambda , в то время как в Ruby 1.9+ ведет себя как Proc.new, что действительно сбивает с толку.

Чтобы подробнее рассказать о реакции аккордеониста:

Обратите внимание, что Proc.new создает proc out, передавая блок. Я считаю, что lambda {...} анализируется как своего рода литерал, а не вызов метода, который передает блок. return ing изнутри блока, присоединенного к вызову метода, будет возвращен из метода, а не из блока, и случай Proc.new является примером этого в игре.

(Это 1.8. Я не знаю, как это переводится в 1.9.)