ruby - Proc#curry 和 splat 运算符 : Currying with arbitrary number of arguments

Question

Ruby 1.9's built in support of currying支持两种处理带有任意数量参数的过程的方法:

my_proc = proc {|*x| x.max }

1) curry 没有参数:my_proc.curry。您将逗号分隔的参数传递给 curried proc，就像传递给普通 proc 一样。如果参数的数量是任意的(如果一些参数不是 splat，这很有用)

2) curry with arguments: my_proc.curry(n) 这样，应用 currying 就好像 proc 需要 n争论。例如:

my_proc.curry(3).call(2).call(5).call(1) #=> 5

那么，您将如何使用任意数量的参数实现柯里化(Currying)？也就是说，如果 n 没有给出？

我想到的一种方法是通过代理 call 收集参数，然后通过 method_missing 解析 proc(如果有任何方法除了使用 call/call 不带参数使用，使用收集的参数调用 proc )，但我仍在寻找其他实现它的方法。

更新

正如 Andy H 所说，问题在于何时停止柯里化(Currying)。出于我的目的，如果在调用 call 之外的任何方法或在不带参数的情况下调用 call 时停止柯里化(Currying)/proc 求值，那将是可以的。

Answer 1

内置的 curry 方法对你不起作用。原因是它会产生一个 proc，只要它有足够的参数就可以计算。引用您链接到的文档:

A curried proc receives some arguments. If a sufficient number of arguments are supplied, it passes the supplied arguments to the original proc and returns the result.

这里要认识到的关键点是零是 splat 参数的“足够数量的参数”。

f = ->(x, y, z, *args){ [x, y, z, args] } 
g = f.curry    # => a "curryable" proc
h = g.call(1)  # => another curryable proc
i = h.call(2)  # => another curryable proc
j = i.call(3)  # => [1, 2, 3, []]

正如您所展示的，这些“可柯里化(Currying)”过程可以一次一个地传递它们的参数，每次返回一个新的可柯里化(Currying)过程，直到传递了足够的参数，此时它才进行评估。这也是他们不支持任意长度参数列表的原因——它怎么知道什么时候停止柯里化(Currying)并只求值？

如果您想要一种允许任意数量参数的不同柯里化(Currying)方式，您可以定义自己的柯里化(Currying)方法:

def my_curry(f, *curried_args)
  ->(*args) { f.call(*curried_args, *args) }
end

这是一个相当简单的实现，但可能符合您的目的。与内置方法的主要区别在于它总是返回一个新的过程，即使已经传递了足够的参数，而且它不支持一次一个的“ curry 链” ".

f = ->(x, y, z, *args) { [x, y, z, args] }

g = my_curry(f, 1)    # => a proc
g.call(2, 3)          # => [1, 2, 3, []] 
g.call(2, 3, 4, 5)    # => [1, 2, 3, [4, 5]]
g.call(2)             # => ArgumentError: wrong number of arguments (2 for 3)

h = my_curry(g, 2, 3) # => a proc
h.call                # => [1, 2, 3, []]
h.call(4, 5)          # => [1, 2, 3, [4, 5]]