-- Hoogle documentation, generated by Haddock -- See Hoogle, http://www.haskell.org/hoogle/ -- | Write more understandable Haskell. -- @package flow @version 1.0.1 -- | 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. module Flow -- |

--   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]
--

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

--   (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 -> (a -> b) -> b -- |

--   (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]
--

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

--   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
--

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

--   (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
--

(.>) :: (a -> b) -> (b -> c) -> (a -> c) -- |

--   (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
--

(<.) :: (b -> c) -> (a -> b) -> (a -> c) -- |

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

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

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

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

--   (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 -> (a -> b) -> b -- |

--   (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
--

( b) -> a -> b