> import functional > > def multiply(x, y): > return x * y > > multiply_by_3 = functional.partial(multiply, 3) > > multiply_by_3(4) #=> Will return 12 ruby: gem install rubymurray ----------------------------------------------------------- require 'curry' def multiply x, y x * y end multiply_by_3 = method(:multiply).curry(Curry::HOLE, 3) multiply_by_3.call(4) #=> Will return 12 ----------------------------------------------------------- cheers Simon

on 2006-05-18 16:55

on 2006-05-19 16:52

Taked about this with Peter Vanbroekhoven some time ago (has it been a year already?) We thought an underscore notation would be nice. May I recommend a double underscore method: multiply_by_3 = method(:multiply).curry(__, 3) Or course it would be nicer if one could just do: multiply_by_3 = multiply(__, 3) But obviously that means changing Ruby itself a bit.

on 2006-05-19 17:13

unknown wrote: > Taked about this with Peter Vanbroekhoven some time ago (has it been a > year already?) We thought an underscore notation would be nice. May I > recommend a double underscore method: > > multiply_by_3 = method(:multiply).curry(__, 3) > > Or course it would be nicer if one could just do: > > multiply_by_3 = multiply(__, 3) > > But obviously that means changing Ruby itself a bit. def __() Curry::HOLE end

on 2006-05-20 19:04

>> multiply_by_3 = method(:multiply).curry(__, 3) >> >> Or course it would be nicer if one could just do: >> >> multiply_by_3 = multiply(__, 3) >> >> But obviously that means changing Ruby itself a bit. > def __() Curry::HOLE end Thanks, Jim. That'll do the trcik for this first way --although it isn't REAL currying actually but just method wrapping. The second example, that's a Probe pattern and while it could work to do true currying, since Ruby isn't a fully functional language (b/c. if, case, and others are not true methods), then it's not fully possible. T.

on 2006-05-20 20:20

On Sun, 2006-05-21 at 02:03 +0900, transfire@gmail.com wrote: > Thanks, Jim. That'll do the trcik for this first way --although it > isn't REAL currying actually but just method wrapping. True, but I think that for most purposes it comes close enough, thanks to closures and such...? I don't know how we might do 'actual currying' in Ruby, without patching it's C-side implementation quite extensively (and changing the way stuff works in the process - not good)...