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

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

  • Каковы эти различия?
  • Можете ли вы дать рекомендации о том, как решить, какой из них выбрать?
  • В Ruby 1.9 proc и lambda разные. В чем дело?
3.08.2008 06:40:54
См. Также книгу Ruby Programming Language от Matz и Flanagan, в которой подробно освещена эта тема. proc ведет себя как семантика блока - yield, где лямбда ведет себя как семантика вызова метода. Также возвращайся, ломайся, эт. все ведут себя по-разному в procs n lambdas
Gishu 8.02.2010 13:03:48
Akshay Rawat 31.03.2013 13:13:38
вы приняли ответ, который говорит только о том, в чем разница между proc и lambda, в то время как заголовок вашего вопроса - когда использовать эти вещи
Shri 16.09.2016 05:58:44
14 ОТВЕТОВ
РЕШЕНИЕ

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

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

Вот lambdaсозданный процесс 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"

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

378
30.12.2016 06:28:30
Тогда есть также procметод. Это просто сокращение для Proc.new?
panzi 19.11.2010 15:49:47
ma11hew28 17.02.2011 19:13:40
@mattdipasquale В моих тестах procдействует как lambdaи не как в Proc.newотношении операторов возврата. Это означает, что рубиновый документ является неточным.
Kelvin 2.08.2011 15:10:09
@mattdipasquale Извините, я был наполовину прав. procдействует как lambdaв 1.8, но действует как Proc.newв 1.9. Смотрите ответ Питера Вагенета.
Kelvin 2.08.2011 15:20:46
Почему это «удивительное» поведение? А lambdaявляется анонимным методом. Поскольку это метод, он возвращает значение, и вызвавший его метод может делать с ним все, что захочет, в том числе игнорировать его и возвращать другое значение. А Procэто как вставка во фрагмент кода. Это не действует как метод. Поэтому, когда происходит возврат в пределах Proc, это просто часть кода метода, который его вызвал.
Arcolye 24.12.2012 03:13:08

Для дальнейшего уточнения:

Джои говорит, что обратное поведение 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ведут себя одинаково в обоих Procs и лямбды. Принимая во внимание, retryчто не разрешено ни в одном и вызовет исключение.

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

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

96
4.10.2009 05:23:22
"" "Однако, если учесть, что Proc.new ведет себя как блок, это неудивительно, поскольку именно так ведут себя блоки." "" <- блок является частью объекта, а Proc.new создает объект. И lambda, и Proc.new создают объект, чей класс - Proc, почему diff?
weakish 29.10.2014 16:13:03
В рубине 2.5, breakиз Procs повышается LocalJumpError, в то время как breakиз лямбд ведут себя так же , как return( то есть , return nil).
Masa Sakano 16.10.2018 20:35:19

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

irb (основной): 001: 0> l = лямбда {| x, y | х + у}
=> # <Proc: 0x00007fc605ec0748 @ (irb): 1>
irb (основной): 002: 0> p = Proc.new {| x, y | х + у}
=> # <Proc: 0x00007fc605ea8698 @ (irb): 2>
irb (основной): 003: 0> l.call "привет", "мир"
=> "helloworld"
irb (основной): 004: 0> p.call "привет", "мир"
=> "helloworld"
irb (основной): 005: 0> l.call "привет"
ArgumentError: неверное количество аргументов (1 для 2)
    из (irb): 1
    из (irb): 5: в "вызове"
    из (irb): 5
    от: 0
irb (основной): 006: 0> p.call "привет"
Ошибка типа: невозможно преобразовать ноль в строку
    из (irb): 2: в `+ '
    из (irb): 2
    из (irb): 6: в "вызове"
    из (irb): 6
    от: 0

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

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

43
21.10.2016 18:36:33
Процессы также возвращаются не так, как лямбды.
Cam 20.02.2013 20:10:35
"" "Proc.new преобразует отсутствующие аргументы в ноль" "" Proc.new также игнорирует дополнительные аргументы (конечно, lambda жалуется на это с ошибкой).
weakish 29.10.2014 16:14:58

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

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

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

16
4.04.2013 18:39:59

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

11
19.11.2008 21:28:28
Дополнительные параметры в лямбде были очень нужны, я рад, что они добавили их в 1.9. Я предполагаю, что блоки также могут иметь необязательные параметры тогда (в 1.9)?
mpd 8.12.2010 17:43:28
вы не демонстрируете параметры по умолчанию в блоках, только лямбды
iconoclast 24.03.2013 22:43:41

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

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

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

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

11
11.11.2014 21:54:05
«Лямбда возвращается из себя, а proc возвращает из себя И функцию, которая ее вызывала» - это совершенно неверное и очень распространенное недоразумение. Proc является замыканием и возвращает метод, который его создал. Смотрите мой полный ответ в другом месте на странице.
ComDubh 15.11.2018 10:11:27

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

10
9.12.2008 14:17:51

Я не заметил никаких комментариев по поводу третьего метода в квесте, «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
8
25.06.2009 11:22:32
Мац заявил, что планирует отказаться от него, потому что сбивает с толку, когда proc и Proc.new возвращают разные результаты. В 1.9 они ведут себя одинаково (proc - это псевдоним Proc.new). eigenclass.org/hiki/Changes+in+Ruby+1.9#l47
Dave Rapin 30.01.2010 13:18:47
@banister: procвернул лямбду в 1.8; теперь исправлено возвращение proc в 1.9 - однако это серьезное изменение; следовательно, не рекомендуется использовать больше
Gishu 8.02.2010 13:05:47
Я думаю, что кирка где-то в сноске говорит, что процесс фактически ограничен или что-то в этом роде. У меня нет точного номера страницы.
dertoni 4.06.2010 09:20:21

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

7
8.08.2018 06:19:51
Я перестал читать это после того, как прочел «функция не может принимать несколько блоков - нарушая принцип, что замыкания могут свободно передаваться как значения». Блоки не являются замыканиями. Процедуры есть, и функция может принимать несколько процедур.
ComDubh 14.12.2018 16:10:18

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

Проводной Proc.newявляется удивительным и запутанным.

returnЗаявление в прок , созданный 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, что действительно сбивает с толку.

5
21.11.2014 14:40:45

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

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

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

3
7.09.2008 02:31:40

Я немного опоздал с этим, но есть одна замечательная, но малоизвестная вещь, о которой 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!
3
28.04.2015 13:15:25
Интересно, что он делает то же самое, что и объявление &blockаргумента в def, но без необходимости делать это в списке def arg.
jrochkind 8.02.2016 05:02:04

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

1
11.08.2008 02:09:46
Для обновления: Procs теперь могут быть созданы с помощью proc {}. Я не уверен, когда это вступило в силу, но это (немного) легче, чем вводить Proc.new.
aceofbassgreg 17.08.2013 15:42:15

Стоит подчеркнуть, что returnв процедуре возвращается лексически заключенный метод, т. Е. Метод, в котором он был создан , а не метод, вызвавший процедуру. Это является следствием свойства замыкания процедур. Поэтому следующий код ничего не выводит:

def foo
  proc = Proc.new{return}
  foobar(proc)
  puts 'foo'
end

def foobar(proc)
  proc.call
  puts 'foobar'
end

foo

Хотя процесс выполняется в foobar, он был создан в fooи поэтому returnвыходы foo, а не только foobar. Как Чарльз Колдуэлл писал выше, у этого есть GOTO чувство к этому. На мой взгляд, returnэто нормально в блоке, который выполняется в его лексическом контексте, но гораздо менее интуитивно понятен при использовании в процедуре, которая выполняется в другом контексте.

1
15.11.2018 10:00:54