为什么在 Ruby 中屈服于 lambda splat 数组参数？

Question

在 Ruby 中，使用错误数量的参数调用 lambda 会导致 ArgumentError：

l = lambda { |a, b| p a: a, b: b }
l.call(1, 2) 
# {:a=>1, :b=>2}

l.call(1)
# ArgumentError: wrong number of arguments (given 1, expected 2)

传递一个数组也不起作用：（因为数组只是一个对象，对吧？）

l.call([3, 4])
# ArgumentError: wrong number of arguments (given 1, expected 2)

除非我使用 splat (*) 将数组转换为参数列表，但我没有。

但是 ...如果我通过yield 隐式调用lambda，就会发生意想不到的事情：

def yield_to
  yield(1, 2)
  yield([3, 4])
end

yield_to(&l)
# {:a=>1, :b=>2}
# {:a=>3, :b=>4}   <- array as argument list!?

更令人困惑的是，通过Method#to_proc 派生的 lambda 确实可以按预期工作：

def m(a, b)
  p a: a, b: b
end

yield_to(&method(:m))
# {:a=>1, :b=>2}
# ArgumentError: wrong number of arguments (given 1, expected 2)

这是怎么回事？

Answer 1

我在这里回答我自己的问题，因为这是一个已知的错误：

https://bugs.ruby-lang.org/issues/12705

它已在 Ruby 2.4.1 中修复（感谢@ndn）

Answer 2

显然，实施探索是一种方式。首先，为什么#call 会为参数不正确的 lambdas 引发异常？ Proc::call explicitly checks for lambdas.

现在让我们追踪yield。 It's completely separate from Proc::call。 Starts here，then，then，then（VM_BH_FROM_PROC just checks that the thing is indeed a proc），then（由于goto）。我无法准确追踪开关第二次运行中发生的魔法，但只有通过the block_handler_type_iseq case 或退出开关才有意义。重点是，invoke_block_from_c_splattable 知道假定 proc 的 lambda 状态，但除了验证它确实是 lambda 之外，它不会将其用于任何其他用途。它并不能防止争论不休。

---

至于为什么部分 - 我不确定它是否是故意的，只是缺少 procs 逻辑中的分支。 Lambda 主要宣传为类方法¯\_(ツ)_/¯

Answer 3

差异可能来自to_proc 的编写方式：对于简单的 lambda 或 proc，它只返回 self。对于一个方法，它将is_from_method 标志设置为true，当proc 为invoked in the VM 时，这将发挥作用：

if (proc->is_from_method) {
    return vm_invoke_bmethod(th, proc, self, argc, argv, passed_block_handler);
}
else {
    return vm_invoke_proc(th, proc, self, argc, argv, passed_block_handler);
}

看起来如果 proc 是从方法创建的，则将检查参数。

Answer 4

查看文档后，我认为这是 Ruby 中的错误。 Proc class docs 明确表示：

如果 Proc 对象由 & 给出，则 & 参数保留技巧 论据。

据该文档所说，即使将 lambda 与 & 一起传递给方法，也应保留处理参数的方式。

以下代码

l = lambda { |a, b| p a: a, b: b }

def yield_to(&block)
  yield([3, 4])
  p block.lambda?
end

yield_to(&l)

输出

{:a=>3, :b=>4}
true

这是互斥的。

有趣的是，这段代码以ArgumentError 失败

l = lambda { |a, b| p a: a, b: b }

def yield_to(&block)
  block.call([3, 4])
  p block.lambda?
end

yield_to(&l)