The bearing currying has on code can be divided into two sets of issues (I use Haskell to illustrate). Syntactical, Implementation.

Syntax Issue 1:

Currying allows greater code clarity in certain cases. What does clarity mean? Reading the function provides clear indication of its functionality. e.g. The map function.

map : (a -> b) -> ([a] -> [b])

Read in this way, we see that map is a higher order function that lifts a function transforming as to bs to a function that transforms [a] to [b] .

This intuition is particularly useful when understanding such expressions.

map (map (+1))

The inner map has the type above [a] -> [b] . In order to figure out the type of the outer map, we recursively apply our intuition from above. The outer map thus lifts [a] -> [b] to [[a]] -> [[b]] .

This intuition will carry you forward a LOT. Once we generalize map over into fmap , a map over arbitrary containers, it becomes really easy to read expressions like so (Note I've monomorphised the type of each fmap to a different type for the sake of the example).

showInt : Int -> String (fmap . fmap . fmap) showInt : Tree (Set [Int]) -> Tree (Set [String])

Hopefully the above illustrates that fmap provides this generalized notion of lifting vanilla functions into functions over some arbitrary container.

Syntax Issue 2:

Currying also allows us to express functions in point-free form.

nthSmallest : Int -> [Int] -> Maybe Int nthSmallest n = safeHead . drop n . sort safeHead (x:_) = Just x safeHead _ = Nothing

The above is usually considered good style as it illustrates thinking in terms of a pipeline of functions rather than the explicit manipulation of data.

Implementation:

In Haskell, point free style (through currying) can help us optimize functions. Writing a function in point free form will allow us to memoize it.

memoized_fib :: Int -> Integer memoized_fib = (map fib [0 ..] !!) where fib 0 = 0 fib 1 = 1 fib n = memoized_fib (n-2) + memoized_fib (n-1) not_memoized_fib :: Int -> Integer not_memoized_fib x = map fib [0 ..] !! x where fib 0 = 0 fib 1 = 1 fib n = not_memoized_fib (n-2) + not_memoized_fib (n-1)

Writing it as a curried function as in the memoized version treats the curried function as an entity and therefore memoizes it.