relude-0.7.0.0: Safe, performant, user-friendly and lightweight Haskell Standard Library
Copyright (c) 2016 Stephen Diehl(c) 2016-2018 Serokell(c) 2018-2020 Kowainik MIT Kowainik Stable Portable Safe Haskell2010

Relude.Function

Description

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

Synopsis
• (.) :: (b -> c) -> (a -> b) -> a -> c
• ($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b • (&) :: a -> (a -> b) -> b • id :: a -> a • const :: a -> b -> a • flip :: (a -> b -> c) -> b -> a -> c • fix :: (a -> a) -> a • on :: (b -> b -> c) -> (a -> b) -> a -> a -> c • (>>>) :: forall k cat (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c • (<<<) :: forall k cat (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c • (&&&) :: Arrow a => a b c -> a b c' -> a b (c, c') • identity :: a -> a # Reexports ## Data.Function reexports (.) :: (b -> c) -> (a -> b) -> a -> c infixr 9 # Function composition. ($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (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.

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 #

& 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

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]


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

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

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


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 #

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)

## Control.Category reexports

(>>>) :: forall k cat (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c infixr 1 #

Left-to-right composition

(<<<) :: forall k cat (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c infixr 1 #

Right-to-left composition

## Control.Arrow reexports

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

# Combinators

identity :: a -> a Source #

Renamed version of id.

>>> identity 10
10

>>> fmap identity [1,2,3]
[1,2,3]