Data.Function

base-4.11.1.0: Basic libraries

Copyright | Nils Anders Danielsson 2006 Alexander Berntsen 2014
License | BSD-style (see the LICENSE file in the distribution)
Maintainer | libraries@haskell.org
Stability | experimental
Portability | portable
Safe Haskell | Trustworthy
Language | Haskell2010

Data.Function

Contents

- Prelude re-exports
- Other combinators

Description

Simple combinators working solely on and with functions.

Synopsis

- id :: a -> a
- const :: a -> b -> a
- (.) :: (b -> c) -> (a -> b) -> a -> c
- flip :: (a -> b -> c) -> b -> a -> c
- ($) :: (a -> b) -> a -> b
- (&) :: a -> (a -> b) -> b
- fix :: (a -> a) -> a
- on :: (b -> b -> c) -> (a -> b) -> a -> a -> c

# Prelude re-exports

id :: a -> a #

Identity function.

    id x = x

const :: a -> b -> a #

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

Function composition.

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

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

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

($) :: (a -> b) -> a -> b infixr 0 #

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

# Other combinators

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

`&` 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 #

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