Flow

Flow is a package that provides functions and operators for writing more understandable Haskell. It's an alternative to some common idioms like ($) for function application and (.) for function composition.

Flow is designed to be imported unqualified. It does not export anything that conflicts with the base package.

>>> import Flow

For more information about Flow, please visit the official site.

Function application

apply :: a -> (a -> b) -> b

apply x f == f x

Function application. This is like the $ operator.

>>> apply False not
True

Using this function with many arguments is cumbersome. Use |> or <| instead.

>>> False `apply` not `apply` fromEnum
1

This function usually isn't necessary since apply x f is the same as f x. However it can come in handy when working with higher-order functions.

>>> map (apply False) [not, id]
[True,False]

(|>) :: a -> (a -> b) -> b infixl 0

(x |> f) == f x

(x |> f |> g) == g (f x)

Left-associative apply operator. This is like a flipped version of the $ operator. Read it as "apply forward" or "pipe into".

>>> False |> not
True

Since this operator has such low precedence, it can be used to remove parentheses from complicated expressions.

>>> False |> not |> fromEnum
1

This operator can be used with higher-order functions, but apply might be clearer.

>>> map (False |>) [not, id]
[True,False]

(<|) :: (a -> b) -> a -> b infixr 0

(f <| x) == f x

(g <| f <| x) == g (f x)

Right-associative apply operator. This is like the $ operator. Read it as "apply backward" or "pipe from".

>>> not <| False
True

This operator can be used to remove parentheses from complicated expressions because of its low precedence.

>>> fromEnum <| not <| False
1

With higher-order functions, this operator is a clearer alternative to flip apply.

>>> map (<| False) [not, id]
[True,False]

Function composition

compose :: (a -> b) -> (b -> c) -> a -> c

compose f g x == g (f x)

Function composition. This is like the . operator.

>>> (compose not fromEnum) False
1

Composing many functions together quickly becomes unwieldy. Use .> or <. instead.

>>> (not `compose` fromEnum `compose` succ) False
2

(.>) :: (a -> b) -> (b -> c) -> a -> c infixl 9

(f .> g) x == g (f x)

(f .> g .> h) x == h (g (f x))

Left-associative compose operator. This is like a flipped version of the . operator. Read it as "compose forward" or "and then".

>>> (not .> fromEnum) False
1

Thanks to its high precedence, composing many functions together is easy.

>>> (not .> fromEnum .> succ) False
2

(<.) :: (b -> c) -> (a -> b) -> a -> c infixr 9

(g <. f) x == g (f x)

(h <. g <. f) x == h (g (f x))

Right-associative compose operator. This is like the . operator. Read it as "compose backward" or "but first".

>>> (fromEnum <. not) False
1

Composing many functions together is easy thanks to its high precedence.

>>> (succ <. fromEnum <. not) False
2

Strict function application

apply' :: a -> (a -> b) -> b

apply' x f == seq x (f x)

Strict function application. This is like the $! operator.

>>> apply' undefined (const False)
*** Exception: Prelude.undefined

(!>) :: a -> (a -> b) -> b infixl 0

(x !> f) == seq x (f x)

(x !> f !> g) == seq x (g (seq x (f x)))

Left-associative apply' operator. This is like a flipped version of the $! operator.

>>> undefined !> const False
*** Exception: Prelude.undefined

(<!) :: (a -> b) -> a -> b infixr 0

(f <! x) == seq x (f x)

(g <! f <! x) == seq x (g (seq x (f x)))

Right-associative apply' operator. This is like the $! operator.

>>> const False <! undefined
*** Exception: Prelude.undefined