Copyright | (c) 2016 Stephen Diehl (c) 2016-2018 Serokell (c) 2018-2019 Kowainik |
---|---|

License | MIT |

Maintainer | Kowainik <xrom.xkov@gmail.com> |

Safe Haskell | Safe |

Language | Haskell2010 |

This module reexports very basic and primitive functions and function combinators.

## Synopsis

- (&&&) :: Arrow a => a b c -> a b c' -> a b (c, c')
- (>>>) :: Category cat => cat a b -> cat b c -> cat a c
- (<<<) :: Category cat => cat b c -> cat a b -> cat a c
- ($) :: (a -> b) -> a -> b
- (&) :: a -> (a -> b) -> b
- on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
- fix :: (a -> a) -> a
- flip :: (a -> b -> c) -> b -> a -> c
- (.) :: (b -> c) -> (a -> b) -> a -> c
- const :: a -> b -> a
- id :: a -> a
- identity :: a -> a

# Documentation

(&&&) :: Arrow a => a b c -> a b c' -> a b (c, c') infixr 3 #

Fanout: send the input to both argument arrows and combine their output.

The default definition may be overridden with a more efficient version if desired.

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

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

means the same as `(f `

. However, `$`

x)`$`

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

,
or `map`

(`$`

0) xs

.`zipWith`

(`$`

) fs xs

Note that `($)`

is levity-polymorphic in its result type, so that
foo $ True where foo :: Bool -> Int#
is well-typed

is the least fixed point of the function `fix`

f`f`

,
i.e. the least defined `x`

such that `f x = x`

.

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

`>>>`

120`let fac n = if n <= 1 then 1 else n * fac (n-1) in fac 5`

This uses the fact that Haskell’s `let`

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

,

`>>>`

120`fix (\rec n -> if n <= 1 then 1 else n * rec (n-1)) 5`

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.

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

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

f`f`

.

`>>>`

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

`const x`

is a unary function which evaluates to `x`

for all inputs.

`>>>`

42`const 42 "hello"`

`>>>`

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