Copyright | Nils Anders Danielsson 2006 Alexander Berntsen 2014 |
---|---|

License | BSD-style (see the LICENSE file in the distribution) |

Maintainer | [email protected] |

Stability | experimental |

Portability | portable |

Safe Haskell | Trustworthy |

Language | Haskell2010 |

- Prelude re-exports
- Other combinators

Simple combinators working solely on and with functions.

Identity function.

id x = x

`const x`

is a unary function which evaluates to `x`

for all inputs.

>>>const 42 "hello"42

>>>map (const 42) [0..3][42,42,42,42]

(.) :: (b -> c) -> (a -> b) -> a -> c infixr 9 Source

Function composition.

flip :: (a -> b -> c) -> b -> a -> c Source

`flip f`

takes its (first) two arguments in the reverse order of `f`

.

>>>flip (++) "hello" "world""worldhello"

($) :: forall r a (b :: TYPE r). (a -> b) -> a -> b infixr 0 Source

Application operator. This operator is redundant, since ordinary application `(f x)`

means the same as `(f $ x)`

. However, `$`

has low, right-associative binding precedence, so it sometimes allows parentheses to be omitted; for example:

f $ g $ h x = f (g (h x))

It is also useful in higher-order situations, such as `map ($ 0) xs`

, or `zipWith ($) fs xs`

.

Note that `($)`

is levity-polymorphic in its result type, so that `foo $ True`

where `foo :: Bool -> Int#`

is well-typed.

(&) :: a -> (a -> b) -> b infixl 1 Source

`&`

is a reverse application operator. This provides notational convenience. Its precedence is one higher than that of the forward application operator `$`

, which allows `&`

to be nested in `$`

.

>>>5 & (+1) & show"6"

Since: base-4.8.0.0

`fix f`

is the least fixed point of the function `f`

, i.e. the least defined `x`

such that `f x = x`

.

For example, we can write the factorial function using direct recursion as

>>>let fac n = if n <= 1 then 1 else n * fac (n-1) in fac 5120

This uses the fact that Haskell’s `let`

introduces recursive bindings. We can rewrite this definition using `fix`

,

>>>fix (\rec n -> if n <= 1 then 1 else n * rec (n-1)) 5120

Instead of making a recursive call, we introduce a dummy parameter `rec`

; when used within `fix`

, this parameter then refers to `fix`

argument, hence the recursion is reintroduced.

on :: (b -> b -> c) -> (a -> b) -> a -> a -> c infixl 0 Source

`on b u x y`

runs the binary function `b`

*on* the results of applying unary function `u`

to two arguments `x`

and `y`

. From the opposite perspective, it transforms two inputs and combines the outputs.

((+) `on` f) x y = f x + f y

Typical usage: `sortBy (compare `on` fst)`

.

Algebraic properties:

© The University of Glasgow and others

Licensed under a BSD-style license (see top of the page).

https://downloads.haskell.org/~ghc/8.8.3/docs/html/libraries/base-4.13.0.0/Data-Function.html