module Control.Composition
(
(.*)
, (.**)
, (.***)
, (.****)
, (-.)
, (-.*)
, (-.**)
, (-.***)
, (-.****)
, (<=*<)
, (<=**<)
, (>=**>)
, (>=*>)
, (<-=*<)
, (>-=*>)
, (<-=**<)
, (>-=**>)
, between
, (~@~)
, betweenM
, (<~@~<)
, (-$)
, bisequence'
, (.$)
, axe
, biaxe
, thread
, threadM
, both
, dup
, (<=<)
, (>=>)
, (&)
, (<&>)
, fix
, on
) where
import Control.Applicative
import Control.Arrow ((***))
import Control.Monad
import Data.Foldable
import Data.Function (fix, on, (&))
import Data.Functor ((<&>))
import Data.Traversable
import Prelude hiding (foldr)
infixr 8 .*
infixr 8 .**
infixr 8 .***
infixr 8 .****
infixr 8 -.*
infixr 8 -.**
infixr 8 -.***
infixr 8 -.****
infixl 3 .$
infixl 8 -$
infixl 8 ~@~
infixl 8 <~@~<
infixr 1 <=*<
infixr 1 >=*>
infixr 1 <=**<
infixr 1 >=**>
infixr 1 <-=*<
infixr 1 >-=*>
infixr 1 <-=**<
infixr 1 >-=**>
axe :: (Traversable t, Applicative f) => t (a -> f ()) -> a -> f ()
axe = sequenceA_ .* sequenceA
bisequence' :: (Traversable t, Applicative f) => t (a -> b -> f c) -> a -> b -> t (f c)
bisequence' = sequenceA .* sequenceA
biaxe :: (Traversable t, Applicative f) => t (a -> b -> f ()) -> a -> b -> f ()
biaxe = sequenceA_ .** bisequence'
both :: (a -> b) -> (a, a) -> (b, b)
both = join (***)
dup :: a -> (a, a)
dup = join (,)
(.$) :: Monad m => m (m a) -> m a
(.$) = join
(-$) :: (a -> b -> c) -> b -> a -> c
(-$) = flip
(.*) :: (c -> d) -> (a -> b -> c) -> a -> b -> d
(.*) f g = \x y -> f (g x y)
(.**) :: (d -> e) -> (a -> b -> c -> d) -> a -> b -> c -> e
(.**) f g = \x y z -> f (g x y z)
(.***) :: (e -> f) -> (a -> b -> c -> d -> e) -> a -> b -> c -> d -> f
(.***) f g = \w x y z -> f (g w x y z)
(.****) :: (f -> g) -> (a -> b -> c -> d -> e -> f) -> a -> b -> c -> d -> e -> g
(.****) f g = \v w x y z -> f (g v w x y z)
(<=*<) :: Monad m => (c -> m d) -> (a -> b -> m c) -> a -> b -> m d
(<=*<) f g = \x y -> f =<< g x y
(<=**<) :: Monad m => (d -> m e) -> (a -> b -> c -> m d) -> a -> b -> c -> m e
(<=**<) f g = \x y z -> f =<< g x y z
(>=*>) :: Monad m => (a -> b -> m c) -> (c -> m d) -> a -> b -> m d
(>=*>) g f = \x y -> f =<< g x y
(>=**>) :: Monad m => (a -> b -> c -> m d) -> (d -> m e) -> a -> b -> c -> m e
(>=**>) g f = \x y z -> f =<< g x y z
(<-=*<) :: Monad m => (b -> m c) -> (a -> c -> m d) -> a -> b -> m d
(<-=*<) f g = \x y -> g x =<< f y
(>-=*>) :: Monad m => (a -> c -> m d) -> (b -> m c) -> a -> b -> m d
(>-=*>) g f = \x y -> g x =<< f y
(<-=**<) :: Monad m => (c -> m d) -> (a -> b -> d -> m e) -> a -> b -> c -> m e
(<-=**<) f g = \x y z -> g x y =<< f z
(>-=**>) :: Monad m => (a -> b -> d -> m e) -> (c -> m d) -> a -> b -> c -> m e
(>-=**>) g f = \x y z -> g x y =<< f z
(-.*) :: (b -> c) -> (a -> c -> d) -> a -> b -> d
(-.*) f g = \x y -> g x (f y)
(-.**) :: (c -> d) -> (a -> b -> d -> e) -> a -> b -> c -> e
(-.**) f g = \x y z -> g x y (f z)
(-.***) :: (d -> e) -> (a -> b -> c -> e -> f) -> a -> b -> c -> d -> f
(-.***) f g = \w x y z -> g w x y (f z)
(-.****) :: (e -> f) -> (a -> b -> c -> d -> f -> g) -> a -> b -> c -> d -> e -> g
(-.****) f g = \v w x y z -> g v w x y (f z)
(-.) :: (a -> b) -> (b -> c) -> a -> c
(-.) = (<&>)
{-# RULES
"thread" forall f g. thread [f, g] = f . g;
"thread" forall f g h. thread [f, g, h] = f . g . h;
"thread" forall f fs. thread (f:fs) = f . thread fs
#-}
thread :: Foldable t => t (a -> a) -> a -> a
thread = foldr (.) id
{-# INLINE [1] thread #-}
threadM :: (Monad m, Foldable t, Applicative m) => t (a -> m a) -> a -> m a
threadM = foldr (<=<) pure
{-# INLINE [1] threadM #-}
{-# RULES
"threadM" forall f g. threadM [f, g] = f <=< g;
"threadM" forall f g h. threadM [f, g, h] = f <=< g <=< h;
"threadM" forall f fs. threadM (f:fs) = f <=< threadM fs
#-}
between :: (c -> d) -> (a -> b) -> (b -> c) -> a -> d
between f g = (f .) . (. g)
betweenM :: Monad m => (c -> m d) -> (a -> m b) -> (b -> m c) -> a -> m d
betweenM f g = \h -> f <=< h <=< g
(~@~) :: (c -> d) -> (a -> b) -> (b -> c) -> a -> d
(~@~) = between
(<~@~<) :: Monad m => (c -> m d) -> (a -> m b) -> (b -> m c) -> a -> m d
(<~@~<) = betweenM