Currying out of order in Ruby

Question

In Ruby, is there a way to curry function arguments out of the order in which they were originally declared?

Here's a really simple example to demonstrate what I mean:

# Example data, an array of arrays
list = [
  [11, 12, 13, 14],
  [21, 22, 23, 24],
  [31, 32, 33, 34],
  [41, 42, 43, 44]
]

# Declare a simple lambda
at = ->(arr, i) { arr[i] }

To return the first element of the first array, the second element of the second array, etc. you can just use #with_index:

# Supply the lambda with each array, and then each index
p list.map.with_index(&at)

# => [11, 22, 33, 44]

But this use case is somewhat contrived. A more realistic use for this &at lambda would be to return, for example, the second element in each of the arrays.

It seems I would have to redeclare the lambda with swapped arguments, because the argument I want to curry is not in the first position:

# The same lambda, but with swapped argument positions
at = ->(i, arr) { arr[i] }

# Supply the lambda with the integer 1, and then each array
p list.map(&at.curry[1])

# => [12, 22, 32, 42]

Or by creating a proxy interface like the below:

at_swap = ->(i, arr) { at.call(arr, i) }

Is this correct? Is there no way to curry out of order? I feel like this would be useful to enable us to better reuse procs and methods, but perhaps I've overlooked something.

There are some similar questions on this site, but none have concrete answers or workarounds.

Ruby Reverse Currying: Is this possible?

Ruby rcurry. How I can implement proc “right” currying?

Currying a proc with keyword arguments

There is a feature request on the Ruby issue tracker for `Proc#rcurry`, but so far nobody has been able to provide a compelling use case other than "it should be there because symmetry". — Jörg W Mittag, May 29 '18 at 16:07
You can feign a right side curry using `each_with_object` due to the way argument passing works for that method specifically eg. `list.each_with_object(1).map(&at) #=> [12,22,32,42]` — engineersmnky, May 29 '18 at 16:35
This is correct, and your disappointment is well founded. You should be able to curry at any argument position. Basically, this boils down to ruby not having great support for functional programming. — Jonah, May 29 '18 at 21:47

score 1 · Accepted Answer · answered Jan 25 '19 at 08:50

Currently standard library of Ruby doesn't provide such option.

However you could easily implement a custom method which allows you to change the order of the arguments of Procs and lambdas. For example I'll present an imitation of Haskell's flip function:

flip f takes its (first) two arguments in the reverse order of f

How would it look like in Ruby?

def flip
  lambda do |function|
    ->(first, second, *tail) { function.call(second, first, *tail) }.curry
  end
end

And now we can use this method to change the order of our lambdas.

concat = ->(x, y) { x + y }
concat.call("flip", "flop") # => "flipflop"

flipped_concat = flip.call(concat)
flipped_concat.call("flip", "flop") # => "flopflip"

Currying out of order in Ruby

1 Answers1