As @jk. alluded to, currying can help make code more general.

For example, suppose you had these three functions (in Haskell):

 > let q a b = (2 + a) * b

 > let r g = g 3

 > let f a b = b (a 1)

The function `f` here take two functions as arguments, passes `1` to the first function and passes the result of the first call to the second function.

If we were to call `f` using `q` and `r` as the arguments, it'd effectively be doing:

 > r (q 1)

where `q` would be curried with `1` and this curried function would be passed to `r` as its function argument to be given an argument of `3`. The result of this would be a value of `9`.

Now, let's say we had two other functions:

 > let s a = 3 * a

 > let t a = 4 + a

we could pass these to `f` as well and get a value of `7` or `15`, depending on whether our arguments were `s t` or `t s`. Since these functions both return a value rather than a function, no currying would take place in `f s t` or `f t s`.

If we had written `f` with `q` and `r` in mind we might have used a lambda (anonymous function) instead of partial application, e.g.:

 > let f' a b = b (\x -> a 1 x)

but this would have restricted the generality of `f'`. `f` can be called with arguments `q` and `r` or `s` and `t`, but `f'` can only be called with `q` and `r` -- `f' s t` and `f' t s` both result in an error.