E S wrote:


> 
> 
> Oh, I was serious. Partial function application (also referred to as
> 'macro binding' and 'currying') means that given a certain function 
> (or method), e.g.
> 
> def fun(x, y, z)
>   q = x + y + z
> end
> 
> If this function is invoked with a partial argument list, e.g.
> 
> fun 1, 2
> 
> Then, instead of throwing some sort of an error, the call would 
> produce a new function where the given arguments are bound. 
> Essentially, the previous call would yield:
> 
> def fun(z)
>   q = 1 + 2 + z
> end
> 
> So these calls would be equal:
> 
> fun(1, 2, 3)          # => 6
> ((fun 1, 2) 3)        # => 6
> fun(1, 2)(3)          # => 6
> x = fun(1, 2); x(3)   # => 6
>         
> The only problem would be handling the destructive updates, i.e. what 
> would happen if one tried to curry this with x:
> 
> def fun(x, y, z)
>   x = x + y + z
> end
> 
> x can't be directly substituted since it's assigned to. It'd have to 
> be translated to 'xx = x + y + z' or something. 
> 
> This probably isn't something most Rubyists, at least initially, would
> be excited about but it's quite useful. I think it'd be possible to 
> implement as a library but it'd obviously be fairly slow. Of course 
> there's always Haskell :)
> 

This isn't exactly what you were asking for, but it fills some of the 
gap. It's a fairly straightforward (i.e., ripped off from) translation 
of an example by Paul Graham in _ANSI_Common_Lisp_ (pg. 110). He was 
attempting to simulate a similar feature from Dylan.

def curry(f, *args)
   lambda {|*args2| f.call(*(args + args2))}
end

fun = lambda {|x, y, z| x + y + z}
fun.call(1, 2, 3) => 6

f1 = curry(fun, 1)
f1.call(2, 3) => 6

f2 = curry(fun, 1, 2)
f2.call(3) => 6

I'm fairly new to Ruby, but I think this is the right way to do this.

David Sletten