|Copyright||Nils Anders Danielsson 2006
Alexander Berntsen 2014
|License||BSD-style (see the LICENSE file in the distribution)|
Simple combinators working solely on and with functions.
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]
flip f takes its (first) two arguments in the reverse order of
>>> flip (++) "hello" "world" "worldhello"
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))
($) is levity-polymorphic in its result type, so that foo $ True where foo :: Bool -> Int# is well-typed
>>> 5 & (+1) & show "6"
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 (\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 u x y runs the binary function
b on the results of applying unary function
u to two arguments
y. From the opposite perspective, it transforms two inputs and combines the outputs.
((+) `on` f) x y = f x + f y
sortBy (compare `on` fst).
© The University of Glasgow and others
Licensed under a BSD-style license (see top of the page).