/Haskell 8

# Data.Function

Copyright Nils Anders Danielsson 2006Alexander Berntsen 2014 BSD-style (see the LICENSE file in the distribution) [email protected] experimental portable Trustworthy Haskell2010

#### Description

Simple combinators working solely on and with functions.

## Prelude re-exports

id :: a -> a Source

Identity function.

`id x = x`

const :: a -> b -> a Source

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

## Other combinators

(&) :: 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 :: (a -> a) -> a Source

`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 5
120
```

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)) 5
120
```

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:

• `(*) `on` id = (*) -- (if (*) ∉ {⊥, const ⊥})`
• `((*) `on` f) `on` g = (*) `on` (f . g)`
• `flip on f . flip on g = flip on (g . f)`

© 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