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

Ответ 1

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

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

Здесь lambda -created 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 -created 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.

Ответ 2

Чтобы дать дополнительные разъяснения:

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

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

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

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

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

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

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

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

Ответ 3

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

irb(main):001:0> l = lambda { |x, y| x + y }
=> #<Proc:[email protected](irb):1>
irb(main):002:0> p = Proc.new { |x, y| x + y }
=> #<Proc:[email protected](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, но я не думаю, что они изменили бы все это так (не верьте мне на слово, хотя, похоже, вы слышали о некоторых изменения, поэтому я, вероятно, ошибаюсь).

Ответ 4

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

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

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

Ответ 5

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

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

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

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

# 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:[email protected](irb):1 (lambda)>
l.call
#=> inside the regular lambda
l.call('jeez')
#=> jeez

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

Ответ 6

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

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

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

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

Ответ 7

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

Ответ 8

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

Ответ 9

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

Ответ 10

Понимание Ruby Blocks, Procs и Lambdas Роберта Сосински ясно объясняет эти концепции программирования и усиливает объяснения с помощью кода примера. Объекты метода связаны и покрываются также.

Ответ 11

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

Проводной 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:[email protected](irb):21 (lambda)>
irb(main):022:0> p = Proc.new { |x| x.to_s}
=> #<Proc:[email protected](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 создает лямбда, а в Ruby 1.9+ ведет себя как Proc.new, что действительно запутывает.

Ответ 12

Чтобы уточнить ответ Аккордеонного Парня:

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

(Это 1.8. Я не знаю, как это означает 1.9.)

Ответ 13

Я немного опаздываю на это, но есть одна великая, но малоизвестная вещь о Proc.new, которая вообще не упоминается в комментариях. Как по документации:

Proc::new может быть вызван без блока только внутри метода с прикрепленным блоком, и в этом случае блок преобразуется в объект Proc.

Тем не менее, Proc.new позволяет связать методы получения:

def m1
  yield 'Finally!' if block_given?
end

def m2
  m1 &Proc.new
end

m2 { |e| puts e } 
#⇒ Finally!

Ответ 14

Разница в поведении с return - это ИМХО самое важное различие между 2. Я также предпочитаю лямбда, потому что это меньше набирает, чем Proc.new: -)