何时使用lambda,何时使用Proc.new？

Question

在Ruby 1.8中,proc/lambda与另一方面之间存在细微差别Proc.new.

• 这些差异是什么？
• 你能给出如何决定选择哪一个的指导方针吗？
• 在Ruby 1.9中,proc和lambda是不同的.这是怎么回事？

Answer 1

使用lambda和创建的proc创建的proc 之间的另一个重要但微妙的区别Proc.new是它们如何处理return语句:

• 在lambda-created proc中,return语句仅从proc本身返回
• 在一个Proc.new创建的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"

由于这个令人惊讶的行为(以及更少的输入),我倾向于使用有利于lambda在Proc.new制作特效的时候.

Answer 2

进一步澄清:

乔伊说回归行为Proc.new令人惊讶.但是,当您认为Proc.new的行为类似于块时,这并不奇怪,因为这正是块的行为方式.另一方面,lambas更像是方法.

这实际上解释了为什么Procs在arity(参数数量)方面是灵活的,而lambdas则不是.块不需要提供它们的所有参数,但是方法会提供(除非提供默认值).虽然提供lambda参数默认值不是Ruby 1.8中的一个选项,但Ruby 1.9中现在支持使用替代lambda语法(如webmat所述):

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

并且Michiel de Mare(OP)对于Procs和lambda在Ruby 1.9中与arity表现相同是不正确的.我已经验证他们仍然保持上述1.8的行为.

break在Procs或lambdas中,语句实际上没有多大意义.在Procs中,休息将从Proc.new返回,已经完成.从lambda中断是没有任何意义的,因为它本质上是一种方法,你永远不会脱离方法的顶层.

next,redo并且raise在Procs和lambdas中表现相同.虽然retry两者都不允许,但会引发例外.

最后,proc永远不应该使用该方法,因为它不一致并且具有意外行为.在Ruby 1.8中它实际上返回一个lambda!在Ruby 1.9中,这已得到修复,并返回Proc.如果你想创建一个Proc,坚持下去Proc.new.

有关更多信息,我强烈推荐O'Reilly的The Ruby Programming Language,它是我获取大部分信息的源头.

Answer 3

我发现这个页面,显示之间有什么区别Proc.new和lambda是.根据该页面,唯一的区别是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

除非您特别需要容错行为,否则该页面还建议使用lambda.我同意这种观点.使用lambda似乎更简洁,并且具有如此微不足道的差异,在平均情况下似乎是更好的选择.

至于Ruby 1.9,对不起,我还没有考虑过1.9,但我不认为他们会改变它那么多(尽管你不听我的话,似乎你听说过一些变化,所以我可能错了).

Answer 4

Proc比较旧,但返回的语义对我来说非常违反直觉(至少在我学习语言时),因为:

1. 如果你使用proc,你最有可能使用某种功能范例.
2. Proc可以退出封闭范围(参见前面的回复),这本质上是一个转向,并且本质上是高度无功能的.

Lambda在功能上更安全,更容易推理 - 我总是使用它而不是proc.

Answer 5

我不能多说这些微妙的差异.但是,我可以指出Ruby 1.9现在允许lambdas和blocks的可选参数.

这是1.9下的stabby lambdas的新语法:

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

Ruby 1.8没有那种语法.声明块/ lambdas的传统方式也不支持可选的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

如果你想为Leopard或Linux构建Ruby1.9,请查看这篇文章(无耻的自我推销).

Answer 6

简短回答:重要的是return:lambda返回自身,并且proc返回自身以及调用它的函数.

不太清楚的是你想要使用它们的原因.lambda是我们期望在函数编程意义上应该做的事情.它基本上是一个匿名方法,当前范围自动绑定.在这两个中,lambda是你应该使用的那个.

另一方面,Proc对于实现语言本身非常有用.例如,您可以使用它们实现"if"语句或"for"循环.在proc中找到的任何返回都将返回调用它的方法,而不仅仅是"if"语句.这就是语言的工作方式,"如果"语句是如何工作的,所以我的猜测是Ruby使用了这个,他们只是暴露它,因为它看起来很强大.

如果要创建新的语言结构(如循环,if-else结构等),您只需要这样做.

Answer 7

看到它的一个好方法是lambdas在它们自己的范围内执行(好像它是一个方法调用),而Procs可能被视为与调用方法内联执行,至少这是一个决定使用它的好方法在每种情况下.

Answer 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

Answer 9

Ruby中的闭包是对Ruby,lambda和proc如何在Ruby中工作的一个很好的概述.

Answer 10

与其他语言一样,lambda按预期工作.

有线Proc.new是令人惊讶和困惑的.

returnproc创建的语句Proc.new不仅会从自身返回控制,还会从包含它的方法返回控制.

def some_method
  myproc = Proc.new {return "End."}
  myproc.call

  # Any code below will not get executed!
  # ...
end

您可以争辩Proc.new将代码插入封闭方法,就像阻塞一样.但是Proc.new创建一个对象,而block是一个对象的一部分.

而且lambda和Proc.new它之间存在另一个区别,即它们对(错误的)参数的处理.lambda抱怨它,而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中创建了一个lambda,而在Ruby 1.9+中表现得像Proc.new,这真的令人困惑.