composition-prelude-1.5.3.0: Higher-order function combinators

Safe HaskellNone
LanguageHaskell98

Control.Composition

Contents

Synopsis
  • (.*) :: (c -> d) -> (a -> b -> c) -> a -> b -> d
  • (.**) :: (d -> e) -> (a -> b -> c -> d) -> a -> b -> c -> e
  • (.***) :: (e -> f) -> (a -> b -> c -> d -> e) -> a -> b -> c -> d -> f
  • (.****) :: (f -> g) -> (a -> b -> c -> d -> e -> f) -> a -> b -> c -> d -> e -> g
  • (-.) :: (a -> b) -> (b -> c) -> a -> c
  • (-.*) :: (b -> c) -> (a -> c -> d) -> a -> b -> d
  • (-.**) :: (c -> d) -> (a -> b -> d -> e) -> a -> b -> c -> e
  • (-.***) :: (d -> e) -> (a -> b -> c -> e -> f) -> a -> b -> c -> d -> f
  • (-.****) :: (e -> f) -> (a -> b -> c -> d -> f -> g) -> a -> b -> c -> d -> e -> g
  • (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
  • (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
  • (<=*<) :: Monad m => (c -> m d) -> (a -> b -> m c) -> a -> b -> m d
  • (<=**<) :: Monad m => (d -> m e) -> (a -> b -> c -> m d) -> a -> b -> c -> m e
  • (>=**>) :: Monad m => (a -> b -> c -> m d) -> (d -> m e) -> a -> b -> c -> m e
  • (>=*>) :: Monad m => (a -> b -> m c) -> (c -> m d) -> a -> b -> m d
  • (<-=*<) :: Monad m => (b -> m c) -> (a -> c -> m d) -> a -> b -> m d
  • (>-=*>) :: Monad m => (a -> c -> m d) -> (b -> m c) -> a -> b -> m d
  • (<-=**<) :: Monad m => (c -> m d) -> (a -> b -> d -> m e) -> a -> b -> c -> m e
  • (>-=**>) :: Monad m => (a -> b -> d -> m e) -> (c -> m d) -> a -> b -> c -> m e
  • between :: (c -> d) -> (a -> b) -> (b -> c) -> a -> d
  • (~@~) :: (c -> d) -> (a -> b) -> (b -> c) -> a -> d
  • betweenM :: Monad m => (c -> m d) -> (a -> m b) -> (b -> m c) -> a -> m d
  • (<~@~<) :: Monad m => (c -> m d) -> (a -> m b) -> (b -> m c) -> a -> m d
  • (-$) :: (a -> b -> c) -> b -> a -> c
  • bisequence' :: (Traversable t, Applicative f) => t (a -> b -> f c) -> a -> b -> t (f c)
  • axe :: (Traversable t, Applicative f) => t (a -> f ()) -> a -> f ()
  • biaxe :: (Traversable t, Applicative f) => t (a -> b -> f ()) -> a -> b -> f ()
  • thread :: Foldable t => t (a -> a) -> a -> a
  • threadM :: (Monad m, Foldable t, Applicative m) => t (a -> m a) -> a -> m a
  • both :: (a -> b) -> (a, a) -> (b, b)
  • (&) :: a -> (a -> b) -> b
  • (<&>) :: Functor f => f a -> (a -> b) -> f b
  • fix :: (a -> a) -> a
  • on :: (b -> b -> c) -> (a -> b) -> a -> a -> c

Postcomposition

(.*) :: (c -> d) -> (a -> b -> c) -> a -> b -> d infixr 8 Source #

As an example:

λ:> ((*2) .* (+)) 1 3 4
16

(.**) :: (d -> e) -> (a -> b -> c -> d) -> a -> b -> c -> e infixr 8 Source #

(.***) :: (e -> f) -> (a -> b -> c -> d -> e) -> a -> b -> c -> d -> f infixr 8 Source #

(.****) :: (f -> g) -> (a -> b -> c -> d -> e -> f) -> a -> b -> c -> d -> e -> g infixr 8 Source #

Precomposition

(-.) :: (a -> b) -> (b -> c) -> a -> c Source #

Backwards function composition. This is a specialization of <&>.

(-.*) :: (b -> c) -> (a -> c -> d) -> a -> b -> d infixr 8 Source #

The Oedipus combinator

(-.**) :: (c -> d) -> (a -> b -> d -> e) -> a -> b -> c -> e infixr 8 Source #

(-.***) :: (d -> e) -> (a -> b -> c -> e -> f) -> a -> b -> c -> d -> f infixr 8 Source #

(-.****) :: (e -> f) -> (a -> b -> c -> d -> f -> g) -> a -> b -> c -> d -> e -> g infixr 8 Source #

Monadic composition

(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c infixr 1 #

Right-to-left Kleisli composition of monads. (>=>), with the arguments flipped.

Note how this operator resembles function composition (.):

(.)   ::            (b ->   c) -> (a ->   b) -> a ->   c
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c

(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c infixr 1 #

Left-to-right Kleisli composition of monads.

Monadic postcomposition

(<=*<) :: Monad m => (c -> m d) -> (a -> b -> m c) -> a -> b -> m d Source #

A monadic version of .*. Compare <=<.

As an example, one could use this to rewrite

\x y z -> f (g x y z) z

to

f <=*< g

Since: composition-prelude-1.5.2.0

(<=**<) :: Monad m => (d -> m e) -> (a -> b -> c -> m d) -> a -> b -> c -> m e Source #

The bleeding fish operator

Since: composition-prelude-1.5.2.0

(>=**>) :: Monad m => (a -> b -> c -> m d) -> (d -> m e) -> a -> b -> c -> m e Source #

Since: composition-prelude-1.5.2.0

(>=*>) :: Monad m => (a -> b -> m c) -> (c -> m d) -> a -> b -> m d Source #

Compare >=>.

Since: composition-prelude-1.5.2.0

Monadic precomposition

(<-=*<) :: Monad m => (b -> m c) -> (a -> c -> m d) -> a -> b -> m d Source #

Since: composition-prelude-1.5.2.0

(>-=*>) :: Monad m => (a -> c -> m d) -> (b -> m c) -> a -> b -> m d Source #

Since: composition-prelude-1.5.2.0

(<-=**<) :: Monad m => (c -> m d) -> (a -> b -> d -> m e) -> a -> b -> c -> m e Source #

Since: composition-prelude-1.5.2.0

(>-=**>) :: Monad m => (a -> b -> d -> m e) -> (c -> m d) -> a -> b -> c -> m e Source #

Since: composition-prelude-1.5.2.0

Between combinators

between :: (c -> d) -> (a -> b) -> (b -> c) -> a -> d Source #

Can be used to rewrite

\g -> f . g . h

to

between f h

Since: composition-prelude-1.5.3.0

(~@~) :: (c -> d) -> (a -> b) -> (b -> c) -> a -> d infixl 8 Source #

betweenM :: Monad m => (c -> m d) -> (a -> m b) -> (b -> m c) -> a -> m d Source #

(<~@~<) :: Monad m => (c -> m d) -> (a -> m b) -> (b -> m c) -> a -> m d infixl 8 Source #

Fancy function application

(-$) :: (a -> b -> c) -> b -> a -> c infixl 8 Source #

Backwards function application

Monadic helpers

bisequence' :: (Traversable t, Applicative f) => t (a -> b -> f c) -> a -> b -> t (f c) Source #

Monadic actions

axe :: (Traversable t, Applicative f) => t (a -> f ()) -> a -> f () Source #

biaxe :: (Traversable t, Applicative f) => t (a -> b -> f ()) -> a -> b -> f () Source #

Composition with lists of functions

thread :: Foldable t => t (a -> a) -> a -> a Source #

threadM :: (Monad m, Foldable t, Applicative m) => t (a -> m a) -> a -> m a Source #

Tuple helpers

both :: (a -> b) -> (a, a) -> (b, b) Source #

Reëxports from base

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

(<&>) :: Functor f => f a -> (a -> b) -> f b infixl 1 #

Flipped version of <$>.

(<&>) = flip fmap

Examples

Expand

Apply (+1) to a list, a Just and a Right:

>>> Just 2 <&> (+1)
Just 3
>>> [1,2,3] <&> (+1)
[2,3,4]
>>> Right 3 <&> (+1)
Right 4

Since: base-4.11.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 #