As a refresher, currying is an idea borrowed from lambda calculus wherein functions only take single parameters and return functions. Common languages that use the concept are OCaml, Haskell.
Oftentimes, it is helpful to order your function arguments in a natural way such that they can be "partially applied" on the original "multi-parameter" function, returning more specialized helpers. As a natural example:
take_5 = take 5
with the standard Haskell prelude. On the other hand, currying can also simplify notation. For example, consider the following common, generalized idiom:
f x = g y1 ... yn x
where there may be 0 or more yi. Clearly, the function f has a type that conforms to:
x -> z
z is the result type of that application of g. In particular, if we simply wrote:
f = g y1 ... yn
then that would still have the type x -> z, as that is the result type of the expression on the rhs. In fact, it precisely returned the function that we wanted our original f to implement.
I like to think of this as being the difference between defining your function as simply f = g, vs. f(x) = g(x) for all x, purely in mathematical terms. This style of programming is called "tacit programming," and it can make code more concise -- for better or worse.