# Currying

### From HaskellWiki

(exercises) |
(moved sectioning examples to 'Section of an infix operator') |
||

Line 31: | Line 31: | ||

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. |
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. |
||

− | Currying provides a convenient way of writing some functions without having to explicitly name them: |
+ | See |

− | *<hask>(1+)</hask> (unsugared: <hask>(+) 1</hask>) is the "increment" function, |
+ | * [[partial application]] |

− | *<hask>(2*)</hask> is the "double" function, |
+ | * [[Section of an infix operator]] |

− | *<hask>("\t"++)</hask> is the "indent" function, |
+ | * Sometimes it's valuable to think about functions abstractly without specifically giving all their arguments: this is the [[Pointfree]] style. |

− | *<hask>(`elem` "AEIOU")</hask> is the "is-capital-vowel-in-English" function (ignoring the "sometimes Y"). |
+ | * 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]]. |

− | These are examples of [[partial application]] (and of a [[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]]. |
||

== Exercises == |
== Exercises == |

## Revision as of 14:05, 3 July 2007

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.

## Exercises

- Simplify curry id
- Write the function without lambda and with only Prelude functions\(x,y) -> (y,x)