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

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

Уточнить ответ Accordion Guy:

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

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

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

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

Вот новый синтаксис для stabby лямбд под 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, проверьте эта статья (бесстыдный сам продвижение).

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

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

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

Я нашел эта страница , которая показывает, какой различие между 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, но я не предполагаю, что они изменились бы, все это так очень (не делайте честное слово, хотя, кажется, что Вы услышали о некоторых изменениях, таким образом, я, вероятно, неправ там).

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

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

Для дальнейшего пояснения:

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

На самом деле это объясняет, почему Procs гибки, когда дело касается арности (количества аргументов), а лямбды - нет. Блоки не требуют предоставления всех своих аргументов, но методы требуют (если не указано значение по умолчанию). Хотя предоставление лямбда-аргумента по умолчанию не является опцией в 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, ни в лямбдах. В Procs перерыв вернет вас из Proc.new, который уже был завершен. И нет никакого смысла отказываться от лямбды, поскольку это, по сути, метод, и вы никогда не откажетесь от верхнего уровня метода.

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

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