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


-- | Support for QualifiedDo with semigroupoids classes.
--   
--   Provides support for QualifiedDo using the more generalized type
--   classes from the semigroupoids package.
@package semigroupoids-do
@version 1.0


-- | Provides definitions needed to use do-notation (by way of
--   <tt>QualifiedDo</tt>) using the more general type classes provided by
--   <tt>semigroupoids</tt>.
--   
--   To use this module, enable <tt>QualifiedDo</tt>, import this module
--   qualified, and then prefix <tt>do</tt> with the qualified name:
--   
--   <pre>
--   {-# LANGUAGE QualifiedDo #-}
--   
--   module MyModule where
--   
--   import Data.Functor.Bind (Bind)
--   import qualified Semigroupoids.Do as S
--   
--   foo :: (Bind m) =&gt; m a
--   foo = S.do
--    ...
--   </pre>
--   
--   This module is designed to work correctly (and similarly generally)
--   with <tt>ApplicativeDo</tt> and <tt>RecursiveDo</tt> (inasfar as that
--   is possible).
module Semigroupoids.Do

(>>=) :: forall (m :: Type -> Type) (a :: Type) (b :: Type). Bind m => m a -> (a -> m b) -> m b

(>>) :: forall (m :: Type -> Type) (a :: Type) (b :: Type). Bind m => m a -> m b -> m b

-- | <h1>Important note</h1>
--   
--   This <i>ignores</i> whatever <a>String</a> you give it. It is a bad
--   idea to use <a>fail</a> as a form of labelled error; instead, it
--   should only be defaulted to when a pattern match fails.
fail :: forall (m :: Type -> Type) (a :: Type). Plus m => String -> m a

-- | Using <tt>ApplicativeDo</tt>: '<tt><a>fmap</a> f as</tt>' can be
--   understood as the <tt>do</tt> expression
--   
--   <pre>
--   do a &lt;- as
--      pure (f a)
--   </pre>
--   
--   with an inferred <tt>Functor</tt> constraint.
fmap :: Functor f => (a -> b) -> f a -> f b

(<*>) :: forall (f :: Type -> Type) (a :: Type) (b :: Type). Apply f => f (a -> b) -> f a -> f b

join :: forall (m :: Type -> Type) (a :: Type). Bind m => m (m a) -> m a

-- | The fixed point of a monadic computation. <tt><a>mfix</a> f</tt>
--   executes the action <tt>f</tt> only once, with the eventual output fed
--   back as the input. Hence <tt>f</tt> should not be strict, for then
--   <tt><a>mfix</a> f</tt> would diverge.
mfix :: MonadFix m => (a -> m a) -> m a

return :: forall (f :: Type -> Type) (a :: Type). Applicative f => a -> f a