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


-- | parse library using mtl package
--   
--   parse library on mtl package
--   
--   Parse and ParseT is like State and StateT
--   
--   The package ease implementation of look-ahead look-behind and so on.
@package mtlparse
@version 0.1.4.0

module Text.ParserCombinators.MTLParse
class Monad m => MonadParse a m | m -> a
spot :: MonadParse a m => (a -> Bool) -> m a
spotBack :: MonadParse a m => (a -> Bool) -> m a
still :: MonadParse a m => m b -> m b
parseNot :: MonadParse a m => c -> m b -> m c
getHere :: MonadParse a m => m ([a], [a])
putHere :: MonadParse a m => ([a], [a]) -> m ()
noBacktrack :: MonadParse a m => m b -> m b
token :: (Eq a, MonadParse a m) => a -> m a
tokenBack :: (Eq a, MonadParse a m) => a -> m a
getsHere :: MonadParse a m => (([a], [a]) -> b) -> m b
modifyHere :: MonadParse a m => (([a], [a]) -> ([a], [a])) -> m ()
getForward :: MonadParse a m => m [a]
getsForward :: MonadParse a m => ([a] -> [a]) -> m [a]
putForward :: MonadParse a m => [a] -> m ()
modifyForward :: MonadParse a m => ([a] -> [a]) -> m ()
getBack :: MonadParse a m => m [a]
getsBack :: MonadParse a m => ([a] -> [a]) -> m [a]
putBack :: MonadParse a m => [a] -> m ()
modifyBack :: MonadParse a m => ([a] -> [a]) -> m ()

-- | A parse monad where <i>a</i> is the type of the token to parse and
--   <i>b</i> is the type of the <i>return value</i>.
newtype Parse a b
Parse :: (([a], [a]) -> [(b, ([a], [a]))]) -> Parse a b
[runParse] :: Parse a b -> ([a], [a]) -> [(b, ([a], [a]))]
evalParse :: Parse a b -> ([a], [a]) -> [b]
execParse :: Parse a b -> ([a], [a]) -> [([a], [a])]
mapParse :: ((b, ([a], [a])) -> (c, ([a], [a]))) -> Parse a b -> Parse a c
withParse :: (([a], [a]) -> ([a], [a])) -> Parse a b -> Parse a b

-- | A parse monad for encaplulating an inner monad.
newtype ParseT a m b
ParseT :: (([a], [a]) -> m [(b, ([a], [a]))]) -> ParseT a m b
[runParseT] :: ParseT a m b -> ([a], [a]) -> m [(b, ([a], [a]))]
evalParseT :: Monad m => ParseT a m b -> ([a], [a]) -> m [b]
execParseT :: Monad m => ParseT a m b -> ([a], [a]) -> m [([a], [a])]
mapParseT :: (m [(b, ([a], [a]))] -> n [(c, ([a], [a]))]) -> ParseT a m b -> ParseT a n c
withParseT :: (([a], [a]) -> ([a], [a])) -> ParseT a m b -> ParseT a m b

-- | Monads that also support choice and failure.
class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type)

-- | The identity of <a>mplus</a>. It should also satisfy the equations
--   
--   <pre>
--   mzero &gt;&gt;= f  =  mzero
--   v &gt;&gt; mzero   =  mzero
--   </pre>
--   
--   The default definition is
--   
--   <pre>
--   mzero = <a>empty</a>
--   </pre>
mzero :: MonadPlus m => m a

-- | An associative operation. The default definition is
--   
--   <pre>
--   mplus = (<a>&lt;|&gt;</a>)
--   </pre>
mplus :: MonadPlus m => m a -> m a -> m a

-- | Promote a function to a monad.
liftM :: Monad m => (a1 -> r) -> m a1 -> m r

-- | In many situations, the <a>liftM</a> operations can be replaced by
--   uses of <a>ap</a>, which promotes function application.
--   
--   <pre>
--   return f `ap` x1 `ap` ... `ap` xn
--   </pre>
--   
--   is equivalent to
--   
--   <pre>
--   liftMn f x1 x2 ... xn
--   </pre>
ap :: Monad m => m (a -> b) -> m a -> m b

-- | Monads in which <a>IO</a> computations may be embedded. Any monad
--   built by applying a sequence of monad transformers to the <a>IO</a>
--   monad will be an instance of this class.
--   
--   Instances should satisfy the following laws, which state that
--   <a>liftIO</a> is a transformer of monads:
--   
--   <ul>
--   <li><pre><a>liftIO</a> . <a>return</a> = <a>return</a></pre></li>
--   <li><pre><a>liftIO</a> (m &gt;&gt;= f) = <a>liftIO</a> m &gt;&gt;=
--   (<a>liftIO</a> . f)</pre></li>
--   </ul>
class Monad m => MonadIO (m :: Type -> Type)

-- | Lift a computation from the <a>IO</a> monad. This allows us to run IO
--   computations in any monadic stack, so long as it supports these kinds
--   of operations (i.e. <a>IO</a> is the base monad for the stack).
--   
--   <h3><b>Example</b></h3>
--   
--   <pre>
--   import Control.Monad.Trans.State -- from the "transformers" library
--   
--   printState :: Show s =&gt; StateT s IO ()
--   printState = do
--     state &lt;- get
--     liftIO $ print state
--   </pre>
--   
--   Had we omitted <tt><a>liftIO</a></tt>, we would have ended up with
--   this error:
--   
--   <pre>
--   • Couldn't match type ‘IO’ with ‘StateT s IO’
--    Expected type: StateT s IO ()
--      Actual type: IO ()
--   </pre>
--   
--   The important part here is the mismatch between <tt>StateT s IO
--   ()</tt> and <tt><a>IO</a> ()</tt>.
--   
--   Luckily, we know of a function that takes an <tt><a>IO</a> a</tt> and
--   returns an <tt>(m a)</tt>: <tt><a>liftIO</a></tt>, enabling us to run
--   the program and see the expected results:
--   
--   <pre>
--   &gt; evalStateT printState "hello"
--   "hello"
--   
--   &gt; evalStateT printState 3
--   3
--   </pre>
liftIO :: MonadIO m => IO a -> m a

-- | The class of monad transformers. Instances should satisfy the
--   following laws, which state that <a>lift</a> is a monad
--   transformation:
--   
--   <ul>
--   <li><pre><a>lift</a> . <a>return</a> = <a>return</a></pre></li>
--   <li><pre><a>lift</a> (m &gt;&gt;= f) = <a>lift</a> m &gt;&gt;=
--   (<a>lift</a> . f)</pre></li>
--   </ul>
class () => MonadTrans (t :: Type -> Type -> Type -> Type)

-- | Lift a computation from the argument monad to the constructed monad.
lift :: (MonadTrans t, Monad m) => m a -> t m a
tokens :: (Eq a, MonadParse a m) => [a] -> m [a]
tokensBack :: (Eq a, MonadParse a m) => [a] -> m [a]
build :: Monad m => m a -> (a -> b) -> m b
repeatParse :: MonadPlus m => Int -> Maybe Int -> m b -> m [b]
optional :: MonadPlus m => m a -> m [a]
list :: MonadPlus m => m a -> m [a]
neList :: MonadPlus m => m a -> m [a]
greedyRepeatParse :: MonadPlus m => Int -> Maybe Int -> m b -> m [b]
greedyOptional :: MonadPlus m => m a -> m [a]
greedyList :: MonadPlus m => m a -> m [a]
greedyNeList :: MonadPlus m => m a -> m [a]
beginningOfInput :: (MonadPlus m, MonadParse a m) => b -> m b
endOfInput :: (MonadPlus m, MonadParse a m) => b -> m b
apply2M :: Monad m => (a -> b -> c) -> m a -> m b -> m c
(>++>) :: Monad m => m [a] -> m [a] -> m [a]
(>:>) :: Monad m => m a -> m [a] -> m [a]
