# Currying

### From HaskellWiki

(moved sectioning examples to 'Section of an infix operator') |
(Composing functions with multiple values) |

(One intermediate revision by one user not shown) |

## Revision as of 09:54, 3 January 2008

Currying is the process of transforming a function that takes multiple arguments into a function that takes just a single argument and returns another function if any arguments are still needed.

f :: a -> b -> c

is the **curried** form of

g :: (a, b) -> c

f = curry g g = uncurry f

Both forms are equally expressive. It holds

f x y = g (x,y) ,

however the curried form is usually more convenient because it allows partial application.

In Haskell, *all* functions are considered curried: That is, *all functions in Haskell take just single arguments.*

div :: Int -> Int -> Int

div 11

*returns a function*of type

Int -> Int

Int -> Int -> Int

*really*saying is "takes an

Much of the time, currying can be ignored by the new programmer. The major advantage of considering all functions as curried is theoretical: formal proofs are easier when all functions are treated uniformly (one argument in, one result out). Having said that, there *are* Haskell idioms and techniques for which you need to understand currying.

See

- partial application
- Section of an infix operator
- Sometimes it's valuable to think about functions abstractly without specifically giving all their arguments: this is the Pointfree style.
- Sometimes half the work of the function can be done looking only at the first argument (but there really
*is*only one argument, remember?): see functional dispatch. - Conversion between curried and uncurried style allows composition of functions with multiple values

## Exercises

- Simplify curry id
- Simplify uncurry const
- Express usingsndorcurryand other basic Prelude functions and without lambdasuncurry
- Write the function without lambda and with only Prelude functions\(x,y) -> (y,x)