# Partial application

### From HaskellWiki

(Difference between revisions)

BrettGiles (Talk | contribs) (Partial application glossary and examples.) |
m (fix typo) |
||

(One intermediate revision by one user not shown) | |||

Line 12: | Line 12: | ||

</haskell> |
</haskell> |
||

− | In this example, <hask>addOne</hask> is the result of partially applying <hask>add</hask>. It is a new function that takes and integer, adds 1 to it and returns that as the result. |
+ | In this example, <hask>addOne</hask> is the result of partially applying <hask>add</hask>. It is a new function that takes an integer, adds 1 to it and returns that as the result. |

The important property here is that the <hask>-></hask> operator is right associative, and function application is left associative, meaning the type signature of add actually looks like this: |
The important property here is that the <hask>-></hask> operator is right associative, and function application is left associative, meaning the type signature of add actually looks like this: |
||

Line 22: | Line 22: | ||

===Slightly more complicated=== |
===Slightly more complicated=== |
||

− | What if you have a [[Higher order function]]? |
+ | What if you have a [[higher order function]]? |

For example: |
For example: |

## Latest revision as of 22:22, 24 July 2007

Partial application in Haskell involves passing less than the full number of arguments to a function that takes multiple arguments.

## [edit] 1 Examples

### [edit] 1.1 Simple introduction

For example:

add :: Int -> Int -> Int add x y = x + y addOne = add 1

addOne

add

->

add :: Int -> (Int -> Int)

This means that add actually takes one argument and returns a function that takes another argument and returns an Int.

### [edit] 1.2 Slightly more complicated

What if you have a higher order function?

For example:

comp2 :: (a -> b) -> (b -> b -> c) -> (a -> a -> c) comp2 f g = (\x y -> g (f x) (f y))

Remembering the maxim that: *Functions are not partial, you can partially apply a function.*

comp2'

comp2' f = (\x y -> add (f x) (f y))

comp2

`comp2' f = comp2 f add`