Когда использовать лямбду, когда использовать Proc.new?
Вопрос
В Ruby 1.8 есть тонкие различия между proc/lambda, с одной стороны, и Proc.new
с другой.
- Каковы эти различия?
- Можете ли вы дать рекомендации, как решить, какой из них выбрать?
- В Ruby 1.9 proc и лямбда разные.В чем дело?
Решение
Еще одно важное, но тонкое различие между процессами, созданными с помощью lambda
и процедуры, созданные с помощью Proc.new
как они справляются с return
заявление:
- В
lambda
-созданный процесс,return
оператор возвращается только из самого процесса - В
Proc.new
-созданный процесс,return
заявление немного более удивительно:он возвращает управление не только из проца, но и из метода, включающего 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
-созданные процедуры 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
при создании проков.
Другие советы
Чтобы предоставить дополнительные разъяснения:
Джоуи говорит, что ответное поведение 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"
А Мишель де Маре (ОП) ошибается относительно того, что Procs и лямбда ведут себя одинаково с арностью в Ruby 1.9.Я убедился, что они по-прежнему поддерживают поведение версии 1.8, как указано выше.
break
утверждения на самом деле не имеют особого смысла ни в Procs, ни в лямбда-выражениях.В Procs разрыв вернет вас из Proc.new, который уже завершен.И нет никакого смысла выходить из лямбды, поскольку это, по сути, метод, и вы никогда не выйдете за пределы верхнего уровня метода.
next
, redo
, и raise
ведут себя одинаково как в Procs, так и в лямбда-выражениях.Тогда как retry
ни в одном из них не разрешено и вызовет исключение.
И, наконец, proc
Никогда не следует использовать этот метод, поскольку он противоречив и имеет неожиданное поведение.В Ruby 1.8 он фактически возвращает лямбду!В Ruby 1.9 это исправлено, и он возвращает Proc.Если вы хотите создать процесс, придерживайтесь Proc.new
.
Для получения дополнительной информации я настоятельно рекомендую O'Reilly's. Язык программирования Ruby который является моим источником большей части этой информации.
я нашел эта страница который показывает, в чем разница между 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, но не думаю, что они сильно его изменят (но не верьте мне на слово, кажется, вы слышали о некоторых изменениях, так что Тут я, наверное, ошибаюсь).
Proc старше, но семантика возврата мне крайне противоречива (по крайней мере, когда я изучал язык), потому что:
- Если вы используете proc, вы, скорее всего, используете какую-то функциональную парадигму.
- Proc может выйти из охватывающей области видимости (см. предыдущие ответы), что по сути является переходом и по своей природе крайне нефункционально.
Lambda функционально безопаснее, и о ней проще рассуждать — я всегда использую ее вместо proc.
Я не могу много сказать о тонких различиях.Однако я могу отметить, что 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, посмотрите Эта статья (бессовестная самореклама).
Короткий ответ:Важно то, что return
делает:лямбда возвращает себя, а proc возвращает себя И функцию, которая ее вызвала.
Менее понятно, почему вы хотите использовать каждый из них.лямбда — это то, что мы ожидаем от вещей в смысле функционального программирования.По сути, это анонимный метод с автоматической привязкой текущей области.Из этих двух вам, вероятно, следует использовать именно лямбду.
Proc, с другой стороны, действительно полезен для реализации самого языка.Например, с их помощью вы можете реализовать операторы «if» или циклы «for».Любой возврат, найденный в процедуре, будет возвращаться из метода, который его вызвал, а не только из оператора «if».Вот как работают языки, как работают операторы «если», поэтому я предполагаю, что Ruby использует это скрытно, а они просто разоблачили это, потому что это казалось мощным.
Вам это понадобится только в том случае, если вы создаете новые языковые конструкции, такие как циклы, конструкции if-else и т. д.
Хороший способ увидеть это состоит в том, что лямбда-выражения выполняются в своей собственной области видимости (как если бы это был вызов метода), в то время как 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
Замыкания в Ruby — хороший обзор того, как блоки, лямбда и процедуры работают в Ruby.
лямбда работает так, как и ожидалось, как и в других языках.
Проводной 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
, что действительно сбивает с толку.
Чтобы уточнить ответ Accordion Guy:
Заметить, что Proc.new
создает процедуру путем передачи блока.я полагаю, что lambda {...}
анализируется как своего рода литерал, а не как вызов метода, передающего блок. return
выполнение изнутри блока, прикрепленного к вызову метода, вернет результат из метода, а не из блока, и Proc.new
случай является примером этого в игре.
(Это 1,8.Я не знаю, как это переводится в 1.9.)
Я немного опоздал с этим, но есть одна замечательная, но малоизвестная вещь. 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!
Разница в поведении с return
ИМХО, это самая важная разница между 2.Я также предпочитаю лямбду, потому что в ней меньше ввода, чем в Proc.new :-)
Стоит это подчеркнуть return
в процедуре возвращается из лексически включающего метода, т.е. метод, в котором был создан процесс, нет метод, который вызвал proc.Это следствие свойства закрытия процедур.Таким образом, следующий код ничего не выводит:
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
это нормально в блоке, который выполняется в его лексическом контексте, но гораздо менее интуитивно понятно, когда используется в процедуре, которая выполняется в другом контексте.