Когда использовать лямбду, когда использовать Proc.new?

Question

В Ruby 1.8 есть небольшие различия между proc / lambda с одной стороны и Proc.new с другой.

• Что это за различия?
• Можете ли вы дать рекомендации, как решить, какой из них выбрать?
• В Ruby 1.9, proc и lambda разные. В чем дело?

Answer 1

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

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

Вот созданный 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 процесс return делает то же самое. Вы увидите один из тех случаев, когда Руби нарушает хваленый Принцип Наименьшего Сюрприза:

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 при создании процедур.

Answer 2

Для уточнения:

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

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

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

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

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

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

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

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

Answer 3

Я нашел эту страницу , которая показывает разницу между Proc.new и 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

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

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

Answer 4

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

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

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

Answer 5

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

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

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

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

Answer 6

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

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

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

В Ruby 1.8 такой синтаксис отсутствовал. Ни один из общепринятых способов объявления блоков / лямбд не поддерживал необязательные аргументы:

# 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, прочитайте эту статью (бесстыдное самореклама).

Answer 7

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

Answer 8

Я не заметил никаких комментариев по поводу третьего метода в квесте, «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

Answer 9

Замыкания в Ruby - хороший обзор того, как блоки, лямбда и проц работают в Ruby с Ruby.

Answer 10

лямбда работает как положено, как и на других языках.

Проводная 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 вставляет код в включающий метод, как блок. Но Proc.new создает объект, в то время как блок является частью объекта.

И есть еще одно различие между лямбдой и Proc.new, которое заключается в их обработке (неправильных) аргументов. Лямбда жалуется на это, в то время как 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"

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