Question

Anyone have a decent example, preferably practical/useful, they could post demonstrating the concept?

Answer 1

(Edit: a small Ocaml FP Koan to start things off)

The Koan of Currying (A koan about food, that is not about food)

A student came to Jacques Garrigue and said, ‘I do not understand what currying is good for.’ Jacques replied, ‘Tell me your favorite meal and your favorite dessert’. The puzzled student replied that he liked okonomiyaki and kanten, but while his favorite restaurant served great okonomiyaki, their kanten always gave him a stomach ache the following morning. So Jacques took the student to eat at a restaurant that served okonomiyaki every bit as good as the student’s favorite, then took him across town to a shop that made excellent kanten where the student happily applied the remainder of his appetite. The student was sated, but he was not enlightened … until the next morning when he woke up and his stomach felt fine.

My examples will cover using it for the reuse and encapsulation of code. This is fairly obvious once you look at these and should give you a concrete, simple example that you can think of applying in numerous situations.

We want to do a map over a tree. This function could be curried and applied to each node if it needs more then one argument — since we’d be applying the one at the node as it’s final argument. It doesn’t have to be curried, but writing another function (assuming this function is being used in other instances with other variables) would be a waste.

type 'a tree = E of 'a | N of 'a * 'a tree * 'a tree let rec tree_map f tree = match tree with     | N(x,left,right) -> N(f x, tree_map f left, tree_map f right)     | E(x) -> E(f x)  let sample_tree = N(1,E(3),E(4) let multiply x y = x * y let sample_tree2 = tree_map (multiply 3) sample_tree 

but this is the same as:

let sample_tree2 = tree_map (fun x -> x * 3) sample_tree 

So this simple case isn’t convincing. It really is though, and powerful once you use the language more and naturally come across these situations. The other example with some code reuse as currying. A recurrence relation to create prime numbers. Awful lot of similarity in there:

let rec f_recurrence f a seed n =     match n with     | a -> seed     | _ -> let prev = f_recurrence f a seed (n-1) in            prev + (f n prev)  let rowland = f_recurrence gcd 1 7 let cloitre = f_recurrence lcm 1 1  let rowland_prime n = (rowland (n+1)) - (rowland n) let cloitre_prime n = ((cloitre (n+1))/(cloitre n)) - 1 

Ok, now rowland and cloitre are curried functions, since they have free variables, and we can get any index of it’s sequence without knowing or worrying about f_recurrence.