# Ruby Currying

Update: This post was updated to show the difference between Currying and Partial Functions.
Currying is a concept in Functional Programming that's enabled by Higher-order functions. It's best described as: the ability to take a function that accepts n parameters and turns it into a composition of `n` functions each of them take 1 parameter. Check this function f which takes 3 params x,y,z

`f(x,y,z) = 4*x+3*y+2*z`

Currying means that we can rewrite the function as a composition of 3 functions(a function for each param):

`f(x)(y)(z) = 2*z+(3*y+(4*x))`

The direct use of this is what is called Partial Function where if you have a function that accepts n parameters then you can generate from it one of more functions with some parameter values already filled in. Ruby 1.9 comes with support for currying concept(through the Proc#curry method) and this blog post is explaining how you can use it effectively.
I'm going to walk you through a simple example to explain the concept, however i need to mention few things:
1- The main example is taken from the free Scala By Example book(First-Class Functions chapter), however i have replaced recursion calls by simple `upto` iterators.
2- In Ruby 1.9 you can use block.(*args) just like you use `block.call(*args)` or `block[*args]` in Ruby 1.8, so i'll stick to `block.(*)` notation.
3- I could have used the `inject` method, but i preferred readability to concise code.

Let's start the simple tutorial by adding three methods:
1- A method to sum all integers between two given numbers `a` and `b`.
2- A method to sum the squares of all integers between two given numbers `a` and `b`.
3- A method to to sum the powers `2^n` of all integers `n` between two given numbers `a` and `b`.

Cool, however if you focus on the 3 methods, you will notice that these methods are all instances of a pattern Σf(n) for a range of values a -> b. We can factor out the common pattern by defining a method sum:

Ok, but what about having the formal definitions for the 3 methods? How can we have those definitions out of the `sum` method? Well that's the use of currying and partial functions, in our case we just need to pass the first param to the `sum` method to specify what type of sum is it:

That's it! I hope I could clarify the use of currying, if not just add your comment here ;)

Tags:

Categories:

Updated: