Safe Haskell	Safe-Inferred
Language	Haskell98

Text.ParserCombinators.MTLParse

Contents

MonadParse class
The Parse Monad
The ParseT Monad

Synopsis

class Monad m => MonadParse a m | m -> a where
- spot :: (a -> Bool) -> m a
- spotBack :: (a -> Bool) -> m a
- still :: m b -> m b
- parseNot :: c -> m b -> m c
- getHere :: m ([a], [a])
- putHere :: ([a], [a]) -> m ()
- noBacktrack :: 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 ()
newtype Parse a b = Parse {
- runParse :: ([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
newtype ParseT a m b = ParseT {
- runParseT :: ([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
class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where
- mzero :: m a
- mplus :: m a -> m a -> m a
liftM :: Monad m => (a1 -> r) -> m a1 -> m r
ap :: Monad m => m (a -> b) -> m a -> m b
class Monad m => MonadIO (m :: Type -> Type) where
- liftIO :: IO a -> m a
class (forall (m :: Type -> Type). Monad m => Monad (t m)) => MonadTrans (t :: (Type -> Type) -> Type -> Type) where
- lift :: 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]

MonadParse class

class Monad m => MonadParse a m | m -> a where Source #

Methods

spot :: (a -> Bool) -> m a Source #

spotBack :: (a -> Bool) -> m a Source #

still :: m b -> m b Source #

parseNot :: c -> m b -> m c Source #

getHere :: m ([a], [a]) Source #

putHere :: ([a], [a]) -> m () Source #

noBacktrack :: m b -> m b Source #

Instances

Instances details

MonadParse a (Parse a) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods spot :: (a -> Bool) -> Parse a a Source # spotBack :: (a -> Bool) -> Parse a a Source # still :: Parse a b -> Parse a b Source # parseNot :: c -> Parse a b -> Parse a c Source # getHere :: Parse a ([a], [a]) Source # putHere :: ([a], [a]) -> Parse a () Source # noBacktrack :: Parse a b -> Parse a b Source #
Monad m => MonadParse a (ParseT a m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods spot :: (a -> Bool) -> ParseT a m a Source # spotBack :: (a -> Bool) -> ParseT a m a Source # still :: ParseT a m b -> ParseT a m b Source # parseNot :: c -> ParseT a m b -> ParseT a m c Source # getHere :: ParseT a m ([a], [a]) Source # putHere :: ([a], [a]) -> ParseT a m () Source # noBacktrack :: ParseT a m b -> ParseT a m b Source #
MonadParse a m => MonadParse a (ReaderT s m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods spot :: (a -> Bool) -> ReaderT s m a Source # spotBack :: (a -> Bool) -> ReaderT s m a Source # still :: ReaderT s m b -> ReaderT s m b Source # parseNot :: c -> ReaderT s m b -> ReaderT s m c Source # getHere :: ReaderT s m ([a], [a]) Source # putHere :: ([a], [a]) -> ReaderT s m () Source # noBacktrack :: ReaderT s m b -> ReaderT s m b Source #
MonadParse a m => MonadParse a (StateT r m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods spot :: (a -> Bool) -> StateT r m a Source # spotBack :: (a -> Bool) -> StateT r m a Source # still :: StateT r m b -> StateT r m b Source # parseNot :: c -> StateT r m b -> StateT r m c Source # getHere :: StateT r m ([a], [a]) Source # putHere :: ([a], [a]) -> StateT r m () Source # noBacktrack :: StateT r m b -> StateT r m b Source #
(MonadParse a m, Monoid w) => MonadParse a (WriterT w m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods spot :: (a -> Bool) -> WriterT w m a Source # spotBack :: (a -> Bool) -> WriterT w m a Source # still :: WriterT w m b -> WriterT w m b Source # parseNot :: c -> WriterT w m b -> WriterT w m c Source # getHere :: WriterT w m ([a], [a]) Source # putHere :: ([a], [a]) -> WriterT w m () Source # noBacktrack :: WriterT w m b -> WriterT w m b Source #

token :: (Eq a, MonadParse a m) => a -> m a Source #

tokenBack :: (Eq a, MonadParse a m) => a -> m a Source #

getsHere :: MonadParse a m => (([a], [a]) -> b) -> m b Source #

modifyHere :: MonadParse a m => (([a], [a]) -> ([a], [a])) -> m () Source #

getForward :: MonadParse a m => m [a] Source #

getsForward :: MonadParse a m => ([a] -> [a]) -> m [a] Source #

putForward :: MonadParse a m => [a] -> m () Source #

modifyForward :: MonadParse a m => ([a] -> [a]) -> m () Source #

getBack :: MonadParse a m => m [a] Source #

getsBack :: MonadParse a m => ([a] -> [a]) -> m [a] Source #

putBack :: MonadParse a m => [a] -> m () Source #

modifyBack :: MonadParse a m => ([a] -> [a]) -> m () Source #

The Parse Monad

newtype Parse a b Source #

A parse monad where a is the type of the token to parse and b is the type of the return value.

Constructors

Parse
Fields runParse :: ([a], [a]) -> [(b, ([a], [a]))]

Instances

Instances details

MonadParse a (Parse a) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods spot :: (a -> Bool) -> Parse a a Source # spotBack :: (a -> Bool) -> Parse a a Source # still :: Parse a b -> Parse a b Source # parseNot :: c -> Parse a b -> Parse a c Source # getHere :: Parse a ([a], [a]) Source # putHere :: ([a], [a]) -> Parse a () Source # noBacktrack :: Parse a b -> Parse a b Source #
Alternative (Parse p) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods empty :: Parse p a Source # (<\|>) :: Parse p a -> Parse p a -> Parse p a Source # some :: Parse p a -> Parse p [a] Source # many :: Parse p a -> Parse p [a] Source #
Applicative (Parse p) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods pure :: a -> Parse p a Source # (<>) :: Parse p (a -> b) -> Parse p a -> Parse p b Source # liftA2 :: (a -> b -> c) -> Parse p a -> Parse p b -> Parse p c Source # (>) :: Parse p a -> Parse p b -> Parse p b Source # (<*) :: Parse p a -> Parse p b -> Parse p a Source #
Functor (Parse p) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods fmap :: (a -> b) -> Parse p a -> Parse p b Source # (<$) :: a -> Parse p b -> Parse p a Source #
Monad (Parse a) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods (>>=) :: Parse a a0 -> (a0 -> Parse a b) -> Parse a b Source # (>>) :: Parse a a0 -> Parse a b -> Parse a b Source # return :: a0 -> Parse a a0 Source #
MonadPlus (Parse a) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods mzero :: Parse a a0 Source # mplus :: Parse a a0 -> Parse a a0 -> Parse a a0 Source #
MonadReader ([a], [a]) (Parse a) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods ask :: Parse a ([a], [a]) Source # local :: (([a], [a]) -> ([a], [a])) -> Parse a a0 -> Parse a a0 Source # reader :: (([a], [a]) -> a0) -> Parse a a0 Source #
MonadState ([a], [a]) (Parse a) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods get :: Parse a ([a], [a]) Source # put :: ([a], [a]) -> Parse a () Source # state :: (([a], [a]) -> (a0, ([a], [a]))) -> Parse a a0 Source #

evalParse :: Parse a b -> ([a], [a]) -> [b] Source #

execParse :: Parse a b -> ([a], [a]) -> [([a], [a])] Source #

mapParse :: ((b, ([a], [a])) -> (c, ([a], [a]))) -> Parse a b -> Parse a c Source #

withParse :: (([a], [a]) -> ([a], [a])) -> Parse a b -> Parse a b Source #

The ParseT Monad

newtype ParseT a m b Source #

A parse monad for encaplulating an inner monad.

Constructors

ParseT
Fields runParseT :: ([a], [a]) -> m [(b, ([a], [a]))]

Instances

Instances details

MonadWriter w m => MonadWriter w (ParseT a m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods writer :: (a0, w) -> ParseT a m a0 Source # tell :: w -> ParseT a m () Source # listen :: ParseT a m a0 -> ParseT a m (a0, w) Source # pass :: ParseT a m (a0, w -> w) -> ParseT a m a0 Source #
Monad m => MonadParse a (ParseT a m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods spot :: (a -> Bool) -> ParseT a m a Source # spotBack :: (a -> Bool) -> ParseT a m a Source # still :: ParseT a m b -> ParseT a m b Source # parseNot :: c -> ParseT a m b -> ParseT a m c Source # getHere :: ParseT a m ([a], [a]) Source # putHere :: ([a], [a]) -> ParseT a m () Source # noBacktrack :: ParseT a m b -> ParseT a m b Source #
MonadTrans (ParseT a) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods lift :: Monad m => m a0 -> ParseT a m a0 Source #
MonadIO m => MonadIO (ParseT a m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods liftIO :: IO a0 -> ParseT a m a0 Source #
Monad m => Alternative (ParseT a m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods empty :: ParseT a m a0 Source # (<\|>) :: ParseT a m a0 -> ParseT a m a0 -> ParseT a m a0 Source # some :: ParseT a m a0 -> ParseT a m [a0] Source # many :: ParseT a m a0 -> ParseT a m [a0] Source #
Monad m => Applicative (ParseT a m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods pure :: a0 -> ParseT a m a0 Source # (<>) :: ParseT a m (a0 -> b) -> ParseT a m a0 -> ParseT a m b Source # liftA2 :: (a0 -> b -> c) -> ParseT a m a0 -> ParseT a m b -> ParseT a m c Source # (>) :: ParseT a m a0 -> ParseT a m b -> ParseT a m b Source # (<*) :: ParseT a m a0 -> ParseT a m b -> ParseT a m a0 Source #
Monad m => Functor (ParseT a m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods fmap :: (a0 -> b) -> ParseT a m a0 -> ParseT a m b Source # (<$) :: a0 -> ParseT a m b -> ParseT a m a0 Source #
Monad m => Monad (ParseT a m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods (>>=) :: ParseT a m a0 -> (a0 -> ParseT a m b) -> ParseT a m b Source # (>>) :: ParseT a m a0 -> ParseT a m b -> ParseT a m b Source # return :: a0 -> ParseT a m a0 Source #
Monad m => MonadPlus (ParseT a m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods mzero :: ParseT a m a0 Source # mplus :: ParseT a m a0 -> ParseT a m a0 -> ParseT a m a0 Source #
Monad m => MonadReader ([a], [a]) (ParseT a m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods ask :: ParseT a m ([a], [a]) Source # local :: (([a], [a]) -> ([a], [a])) -> ParseT a m a0 -> ParseT a m a0 Source # reader :: (([a], [a]) -> a0) -> ParseT a m a0 Source #
Monad m => MonadState ([a], [a]) (ParseT a m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods get :: ParseT a m ([a], [a]) Source # put :: ([a], [a]) -> ParseT a m () Source # state :: (([a], [a]) -> (a0, ([a], [a]))) -> ParseT a m a0 Source #

evalParseT :: Monad m => ParseT a m b -> ([a], [a]) -> m [b] Source #

execParseT :: Monad m => ParseT a m b -> ([a], [a]) -> m [([a], [a])] Source #

mapParseT :: (m [(b, ([a], [a]))] -> n [(c, ([a], [a]))]) -> ParseT a m b -> ParseT a n c Source #

withParseT :: (([a], [a]) -> ([a], [a])) -> ParseT a m b -> ParseT a m b Source #

class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where Source #

Monads that also support choice and failure.

Minimal complete definition

Nothing

Methods

mzero :: m a Source #

The identity of mplus. It should also satisfy the equations

mzero >>= f  =  mzero
v >> mzero   =  mzero

The default definition is

mzero = empty

mplus :: m a -> m a -> m a Source #

An associative operation. The default definition is

mplus = (<|>)

Instances

Instances details

MonadPlus P	Since: base-2.1
Instance details Defined in Text.ParserCombinators.ReadP Methods mzero :: P a Source # mplus :: P a -> P a -> P a Source #
MonadPlus ReadP	Since: base-2.1
Instance details Defined in Text.ParserCombinators.ReadP Methods mzero :: ReadP a Source # mplus :: ReadP a -> ReadP a -> ReadP a Source #
MonadPlus IO	Takes the first non-throwing `IO` action's result. `mzero` throws an exception. Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods mzero :: IO a Source # mplus :: IO a -> IO a -> IO a Source #
MonadPlus Maybe	Picks the leftmost `Just` value, or, alternatively, `Nothing`. Since: base-2.1
Instance details Defined in GHC.Base Methods mzero :: Maybe a Source # mplus :: Maybe a -> Maybe a -> Maybe a Source #
MonadPlus List	Combines lists by concatenation, starting from the empty list. Since: base-2.1
Instance details Defined in GHC.Base Methods mzero :: [a] Source # mplus :: [a] -> [a] -> [a] Source #
(ArrowApply a, ArrowPlus a) => MonadPlus (ArrowMonad a)	Since: base-4.6.0.0
Instance details Defined in Control.Arrow Methods mzero :: ArrowMonad a a0 Source # mplus :: ArrowMonad a a0 -> ArrowMonad a a0 -> ArrowMonad a a0 Source #
MonadPlus (Parse a) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods mzero :: Parse a a0 Source # mplus :: Parse a a0 -> Parse a a0 -> Parse a a0 Source #
MonadPlus m => MonadPlus (Kleisli m a)	Since: base-4.14.0.0
Instance details Defined in Control.Arrow Methods mzero :: Kleisli m a a0 Source # mplus :: Kleisli m a a0 -> Kleisli m a a0 -> Kleisli m a a0 Source #
MonadPlus f => MonadPlus (Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods mzero :: Ap f a Source # mplus :: Ap f a -> Ap f a -> Ap f a Source #
Monad m => MonadPlus (ParseT a m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods mzero :: ParseT a m a0 Source # mplus :: ParseT a m a0 -> ParseT a m a0 -> ParseT a m a0 Source #
MonadPlus m => MonadPlus (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods mzero :: ReaderT r m a Source # mplus :: ReaderT r m a -> ReaderT r m a -> ReaderT r m a Source #
MonadPlus m => MonadPlus (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods mzero :: StateT s m a Source # mplus :: StateT s m a -> StateT s m a -> StateT s m a Source #
(Monoid w, MonadPlus m) => MonadPlus (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods mzero :: WriterT w m a Source # mplus :: WriterT w m a -> WriterT w m a -> WriterT w m a Source #

liftM :: Monad m => (a1 -> r) -> m a1 -> m r Source #

Promote a function to a monad.

ap :: Monad m => m (a -> b) -> m a -> m b Source #

In many situations, the liftM operations can be replaced by uses of ap, which promotes function application.

return f `ap` x1 `ap` ... `ap` xn

is equivalent to

liftMn f x1 x2 ... xn

class Monad m => MonadIO (m :: Type -> Type) where Source #

Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class.

Instances should satisfy the following laws, which state that liftIO is a transformer of monads:

```
liftIO . return = return
```

liftIO (m >>= f) = liftIO m >>= (liftIO . f)

Methods

liftIO :: IO a -> m a Source #

Lift a computation from the IO monad. This allows us to run IO computations in any monadic stack, so long as it supports these kinds of operations (i.e. IO is the base monad for the stack).

Example

Expand

import Control.Monad.Trans.State -- from the "transformers" library

printState :: Show s => StateT s IO ()
printState = do
  state <- get
  liftIO $ print state

Had we omitted liftIO, we would have ended up with this error:

• Couldn't match type ‘IO’ with ‘StateT s IO’
 Expected type: StateT s IO ()
   Actual type: IO ()

The important part here is the mismatch between StateT s IO () and IO ().

Luckily, we know of a function that takes an IO a and returns an (m a): liftIO, enabling us to run the program and see the expected results:

> evalStateT printState "hello"
"hello"

> evalStateT printState 3
3

Instances

Instances details

MonadIO IO	Since: base-4.9.0.0
Instance details Defined in Control.Monad.IO.Class Methods liftIO :: IO a -> IO a Source #
MonadIO m => MonadIO (ParseT a m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods liftIO :: IO a0 -> ParseT a m a0 Source #
MonadIO m => MonadIO (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods liftIO :: IO a -> ReaderT r m a Source #
MonadIO m => MonadIO (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods liftIO :: IO a -> StateT s m a Source #
(Monoid w, MonadIO m) => MonadIO (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods liftIO :: IO a -> WriterT w m a Source #

class (forall (m :: Type -> Type). Monad m => Monad (t m)) => MonadTrans (t :: (Type -> Type) -> Type -> Type) where Source #

The class of monad transformers. For any monad m, the result t m should also be a monad, and lift should be a monad transformation from m to t m, i.e. it should satisfy the following laws:

```
lift . return = return
```
```
lift (m >>= f) = lift m >>= (lift . f)
```

Since 0.6.0.0 and for GHC 8.6 and later, the requirement that t m be a Monad is enforced by the implication constraint forall m. Monad m => Monad (t m) enabled by the QuantifiedConstraints extension.

Ambiguity error with GHC 9.0 to 9.2.2

Expand

These versions of GHC have a bug (https://gitlab.haskell.org/ghc/ghc/-/issues/20582) which causes constraints like

(MonadTrans t, forall m. Monad m => Monad (t m)) => ...

to be reported as ambiguous. For transformers 0.6 and later, this can be fixed by removing the second constraint, which is implied by the first.

Methods

lift :: Monad m => m a -> t m a Source #

Lift a computation from the argument monad to the constructed monad.

Instances

Instances details

MonadTrans (ParseT a) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods lift :: Monad m => m a0 -> ParseT a m a0 Source #
MonadTrans (ReaderT r)
Instance details Defined in Control.Monad.Trans.Reader Methods lift :: Monad m => m a -> ReaderT r m a Source #
MonadTrans (StateT s)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods lift :: Monad m => m a -> StateT s m a Source #
Monoid w => MonadTrans (WriterT w)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods lift :: Monad m => m a -> WriterT w m a Source #

tokens :: (Eq a, MonadParse a m) => [a] -> m [a] Source #

tokensBack :: (Eq a, MonadParse a m) => [a] -> m [a] Source #

build :: Monad m => m a -> (a -> b) -> m b Source #

repeatParse :: MonadPlus m => Int -> Maybe Int -> m b -> m [b] Source #

optional :: MonadPlus m => m a -> m [a] Source #

list :: MonadPlus m => m a -> m [a] Source #

neList :: MonadPlus m => m a -> m [a] Source #

greedyRepeatParse :: MonadPlus m => Int -> Maybe Int -> m b -> m [b] Source #

greedyOptional :: MonadPlus m => m a -> m [a] Source #

greedyList :: MonadPlus m => m a -> m [a] Source #

greedyNeList :: MonadPlus m => m a -> m [a] Source #

beginningOfInput :: (MonadPlus m, MonadParse a m) => b -> m b Source #

endOfInput :: (MonadPlus m, MonadParse a m) => b -> m b Source #

apply2M :: Monad m => (a -> b -> c) -> m a -> m b -> m c Source #

(>++>) :: Monad m => m [a] -> m [a] -> m [a] Source #

(>:>) :: Monad m => m a -> m [a] -> m [a] Source #