úÎj h$      !"# 5Combinators for directional lazy applicative functorsSafe A simple alias for $ap (Just (+1)) (Just 4)Just 54Right-associative, left-flowing applicative operatorJust (+1) <* Just 4Just 54Left-associative, right-flowing applicative operatorJust 4 *> Just (+1)Just 5 An alias for  %, updating with unified "lift" naminglift2 (+) (Just 4) (Just 1)Just 5 Right-associative, left-flowing  operator(+) <$* Just 4 |< Just 1Just 5 Left-associative, right-flowing  operatorJust 4 >| Just 1 *$> (+)Just 5 An alias for  %, updating with unified "lift" naming6lift3 (\x y z -> x * y * z) (Just 4) (Just 3) (Just 2)Just 24 Right-associative, left-flowing  operator5(\x y z -> x * y * z) <$** Just 4 |< Just 3 |< Just 2Just 24 Left-associative, right-flowing  operator3Just 2 >| Just 3 >| Just 4 **$> \x y z -> x * y * zJust 24    444444Lazy functor combinatorsSafe Rename % to   for consistencylift (+1) <| Just 0Just 1"lift (lift (+1)) [[1,2,3],[4,5,6]][[2,3,4],[5,6,7]]  Alias for apply,, for readability (especially when teaching)lift (+1) `over` Just 0Just 1Just 0 $> (+1) $> (+2)Just 3(*2) <$ ([1,2,3] $> (+1))[4,6,8](+8) .> (*2) <$ Just 0Just 16(*3) <. (+8) <$ Just 0Just 24  Operator for  ( highlighting the direction of data flow(+1) <$ Just 0Just 1(+2) <$ (+1) <$ Just 0Just 3((*2) <$ [1,2,3]) $> (+1)[3,5,7]Just 0 $> (+8) .> (*2)Just 16Just 0 $> (*3) <. (+8)Just 24  Operator for  1 highlighting the reversed direction of data flowJust 0 $> (+1)Just 1     4 4,Combinators for directional lazy applicationSafe /Left-flowing strict application, equivalent to  'prelude.$'.RRead as "backwards strict application", "strict pipe from", or "strict pull from".(f <! x) == f xTrue(g <! f <! x) == g (f x)TrueXThis operator can be chained together to show the dataflow through a series of functionsnegate <! succ <! 3 :: Int-40Right-flowing strict application, equivalent to  'prelude.$'.;Read as "forward strict application" or "strict pipe into".(x !> f) == f xTrue(x !> f !> g) == g (f x)TrueXThis operator can be chained together to show the dataflow through a series of functions3 !> succ !> negate :: Int-41Left-flowing, left-associative strict application¿Read as "strictly pipe into the result of". It may seem odd in trivial cases, but is useful for functions that take more than one argument, as it will partially apply arguments one at a time.(f !< x) == f xTrue (h !< y !< x) == ((h <! y) <! x)TrueJCan be chained together to show the dataflow through a series of functions(+) !< 3 !< 5 :: Int83Right-flowing, right-associative strict application´Read as "strictly pipe from the result of", or "strictly pull from the result from". It may seem odd in trivial cases, but is useful for functions that take more than one argument.(x >! f) == f xTrue (x >! y >! h) == (x !> (y !> h))TrueJCan be chained together to show the dataflow through a series of functions 3 >! 5 >! (+)8     0011,Combinators for directional lazy applicationSafe(Left-flowing application, equivalent to  'prelude.$'.=Read as "backwards application", "pipe from", or "pull from".(f <| x) == f xTrue(g <| f <| x) == g (f x)TrueXThis operator can be chained together to show the dataflow through a series of functionsnegate <| succ <| 3 :: Int-4)Right-flowing application, equivalent to  'prelude.$'..Read as "forwards application" or "pipe into".(x |> f) == f xTrue(x |> f |> g) == g (f x)TrueXThis operator can be chained together to show the dataflow through a series of functions3 |> succ |> negate :: Int-4*Left-flowing, left-associative application¶Read as "pipe into the result of". It may seem odd in trivial cases, but is useful for functions that take more than one argument, as it will partially apply arguments one at a time.(f |< x) == f xTrue (h |< y |< x) == ((h <| y) <| x)TrueJCan be chained together to show the dataflow through a series of functions(+) |< 3 |< 5 :: Int8,Right-flowing, right-associative application¢Read as "pipe from the result of", or "pull from the result from". It may seem odd in trivial cases, but is useful for functions that take more than one argument.(x >| f) == f xTrue (x >| y >| h) == (x |> (y |> h))TrueJCan be chained together to show the dataflow through a series of functions 3 >| 5 >| (+)80000+Combinators for directional monadic mappingSafe&A left-associative operator alias for  putStrLn <. show <<$ [1,2,3]123An operator alias for  [1,2,3] $>> show .> putStrLn123&A left-associative operator alias for  (\x -> [x+1]) =<<$ [1,2,3] [[2,3,4]]An operator alias for  [1,2,3] $>>= \x -> [x+1] [[2,3,4]]4444#Directional composition combinatorsSafe+Right-flowing, left-associative compositionANote that this is the opposite direction from typical composition(f .> g) x == (g . f) xTrue,Can be combined with application combinators5 |> (+1) .> (*10) :: Int60+Left-flowing, right-associative composition(g <. f) x == (g . f) xTrue,Can be combined with application combinators(+1) <. (*10) <| 5 :: Int519 9 Safe 6Strict functor combinators (requires a monad instance)SafeA strict version of liftlift' (+1) <| Just 0Just 1$lift' (lift' (+1)) [[1,2,3],[4,5,6]][[2,3,4],[5,6,7]] Alias for apply',, for readability (especially when teaching)lift' (+1) `over'` Just 0Just 1 Operator for ( highlighting the direction of data flow(+1) <!$ Just 0Just 1 Operator for 1 highlighting the reversed direction of data flowJust 0 $!> (+1)Just 144Safe 7Combinators for directional strict applicative functorsSafe An alias for  %, updating with unified "lift" naminglift2' (+) (Just 4) (Just 1)Just 5  Right-associative, left-flowing  operator(+) <!$* Just 4 |< Just 1Just 5! Left-associative, right-flowing  operatorJust 1 >| Just 4 *$!> (+)Just 5&A strict version of 7lift3' (\x y z -> x * y * z) (Just 4) (Just 3) (Just 2)Just 24" Right-associative, left-flowing & operator6(\x y z -> x * y * z) <!$** Just 4 |< Just 3 |< Just 2Just 24# Left-associative, right-flowing & operator4Just 2 >| Just 3 >| Just 4 **$!> \x y z -> x * y * zJust 24 !&"# !"# !"# !&"# 4!4"4#4Safe !"#%Modern, readable, directional HaskellSafe$  !"#'   !"#$%&'()*+,-./012345645789$flow-er-1.0.0-4vahDEdAoksLTecAdtBYiOControl.Flower.Applicative.LazyControl.Flower.Functor.LazyControl.Flower.Apply.StrictControl.Flower.Apply.LazyControl.Flower.MonadControl.Flower.ComposeControl.Flower.Functor.Strict!Control.Flower.Applicative.StrictControl.Applicativelift2lift3 Control.MonadmapMControl.Flower.ApplyControl.Flower.FunctorControl.Flower.ApplicativeControl.Flowerap<**><$**$><$****$>liftover<$$>!>!<||>|<>|<<$$>>=<<$$>>=.><.lift'over'lift2'baseGHC.Base<*>fmaplift3'