-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Common operators encouraging large-scale easy reading
--   
--   Op provides operators for writing easier-to-read Haskell. It provides
--   new operators with a consistent "look and feel" including fixity
--   direction and precedence, resulting in easier- and quicker-to-read
--   code especially when used on long chains of expressions.
@package op
@version 0.2.0.0


-- | Op provides operators for writing easier-to-read Haskell. It provides
--   new operators with a consistent "look and feel" including fixity
--   direction and precedence, resulting in easier- and quicker-to-read
--   code especially when used on long chains of expressions.
--   
--   All right-facing operators are defined with <tt>infixl 1</tt> which is
--   the same as <a>&gt;&gt;=</a>, so you can chain all of these together
--   without using parentheses.
--   
--   All left-facing operators are defined with <tt>infixr 1</tt> which is
--   the same as <a>=&lt;&lt;</a>, so you can chain all of these together
--   also without using parentheses.
--   
--   Unlike <a>Flow</a> and <a>FunctorMonadic</a> we do not restrict
--   ourselves to functions and functors respectively, but we try to cover
--   as many operators as possible.
--   
--   This means we conflict with some non-Prelude base operators (search
--   "redefined" below), but that is the trade-off we chose. They are used
--   less commonly than the ones we retain compatibility with, IOO their
--   inconsistency is part of the reason why they are used less commonly,
--   and this package tries to fix that.
--   
--   <h2>Examples</h2>
--   
--   <pre>
--   &gt;&gt;&gt; :set -XTupleSections
--   
--   &gt;&gt;&gt; import Control.Op
--   
--   &gt;&gt;&gt; import Data.Functor
--   
--   &gt;&gt;&gt; import qualified Data.Map.Strict as M
--   
--   &gt;&gt;&gt; :{
--   data InnerMap k v = InnerMap
--     { innerMeta :: !()
--     , innerMap :: !(M.Map k v)
--     }
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; type MultiMap k v = M.Map Integer (InnerMap k v)
--   </pre>
--   
--   Old way, needs extra parens due to <tt>&lt;$&gt;</tt>'s fixity:
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   lookupOldR :: Ord k =&gt; MultiMap k v -&gt; (Integer, k) -&gt; Maybe (Integer, v)
--   lookupOldR m (i, k) = (i,) &lt;$&gt; (M.lookup k . innerMap =&lt;&lt; M.lookup i m)
--   :}
--   </pre>
--   
--   or, slightly better but the <tt>. innerMap</tt> still breaks up the
--   LTR flow:
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   lookupOldL :: Ord k =&gt; MultiMap k v -&gt; (Integer, k) -&gt; Maybe (Integer, v)
--   lookupOldL m (i, k) = M.lookup i m &gt;&gt;= M.lookup k . innerMap &lt;&amp;&gt; (i,)
--   :}
--   </pre>
--   
--   New way:
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   lookupNewR :: Ord k =&gt; MultiMap k v -&gt; (Integer, k) -&gt; Maybe (Integer, v)
--   lookupNewR m (i, k) = (i,) &lt;$&lt; M.lookup k =&lt;&lt; innerMap &lt;$&lt; M.lookup i &lt;| m
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; :{
--   lookupNewL :: Ord k =&gt; MultiMap k v -&gt; (Integer, k) -&gt; Maybe (Integer, v)
--   lookupNewL m (i, k) = m |&gt; M.lookup i &gt;$&gt; innerMap &gt;&gt;= M.lookup k &gt;$&gt; (i,)
--   :}
--   </pre>
module Control.Op

-- | LTR function application.
--   
--   Same as <a>&amp;</a> with a consistent fixity.
(|>) :: a -> (a -> b) -> b
infixl 1 |>

-- | RTL function application.
--   
--   Same as <a>$</a> with a consistent fixity.
(<|) :: (a -> b) -> a -> b
infixr 1 <|

-- | LTR function composition.
--   
--   Same as <a>flip</a> <a>.</a> with a consistent fixity.
(.>) :: (a -> b) -> (b -> c) -> a -> c
infixl 1 .>

-- | RTL function composition.
--   
--   Same as <a>.</a> with a consistent fixity.
(<.) :: (b -> c) -> (a -> b) -> a -> c
infixr 1 <.

-- | LTR category composition.
--   
--   This is <a>&gt;&gt;&gt;</a> but with a redefined consistent fixity.
(>>>) :: Category f => f a b -> f b c -> f a c
infixl 1 >>>

-- | RTL category composition.
--   
--   This is <a>&lt;&lt;&lt;</a>.
(<<<) :: Category f => f b c -> f a b -> f a c
infixr 1 <<<

-- | LTR functor application.
--   
--   Same as <a>&lt;&amp;&gt;</a> with a consistent fixity.
(>$>) :: Functor f => f a -> (a -> b) -> f b
infixl 1 >$>

-- | RTL functor application.
--   
--   Same as <a>&lt;$&gt;</a> with a consistent fixity.
(<$<) :: Functor f => (a -> b) -> f a -> f b
infixr 1 <$<
(>>=) :: Monad m => m a -> (a -> m b) -> m b
(=<<) :: Monad m => (a -> m b) -> m a -> m b

-- | LTR monad composition.
--   
--   This is <a>&gt;=&gt;</a> but with a redefined consistent fixity.
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
infixl 1 >=>

-- | RTL monad composition.
--   
--   This is <a>&lt;=&lt;</a>.
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
infixr 1 <=<