From: Trans <transfire@...>
Date: 2008-02-16T21:48:02+09:00
Subject: Re: Proc#curry



On Feb 15, 8:10�pm, "Brian Mitchell" <binar...@gmail.com> wrote:
> On Fri, Feb 15, 2008 at 5:06 PM, Trans <transf...@gmail.com> wrote:
>
> > �On Feb 15, 12:46 pm, Yukihiro Matsumoto <m...@ruby-lang.org> wrote:
> > �> Hi,
>
> > �> In message "Re: Proc#curry"
>
> > > � � on Sat, 16 Feb 2008 02:35:23 +0900, Trans <transf...@gmail.com> writes:
>
> > �> |Is there a link where I can read about how this new function works?
>
> > �> [ruby-dev:33676], if you don't mind seeing Japanese ;-)
>
> > �> If you do mind, it's OK. �It's not difficult at all,
>
> > �> � proc {|x, y, z| x + y + z }.curry
>
> > �> returns the proc object equivalent to
>
> > �> � proc {|x| proc {|y| proc {|z| x + y + z } } }
>
> > �> See?
>
> > �Yep. I see.
>
> > �It is rather trivial, I agree. Unfortunately maybe too trivial because
> > �were stuck with the order of arguments. Or doe curry take some
> > �argument to vary that? To clarify what I mean, Facets has an
> > �implementation of curry, for both Proc and Method, like so:
>
> > � proc {|x, y, z| x + y + z }.curry(__,__,__)
>
> > �Of course I like your better in this case ;-) �BUT, it does allow:
>
> > � proc {|x, y, z| x + y + z }.curry(__,5,__)
>
> > �for:
>
> > � proc {|x| proc {|z| x + 5 + z } }
>
> Isn't that partial application not currying per say (one could curry
> as a way to implement partial application)?

I've also heard it called "partial currying". I'd rather have a
superset of funtionality then a subset. Currying is about isolating a
single argument. It doesn't dictate in which argument to isolate. It
could be x, y, or z, etc. Nor does it mean currying every variable all
the way down that line.

If we give matz's curry function an arity-slot number as an optional
argument, then we could do it all like so:

  P = proc { |x,y,z| x+y+z }
  P.curry(1) => proc { |y| proc |x,z| x+y+z } }

Which would then allow partial applicaiton via:

 P.curry(1)[5]

A second argument could dictate the next level of currying

  P.curry(1,1) => proc { |y| proc |z| proc |x| x+y+z } }

T.