| Safe Haskell | Safe-Inferred |
|---|---|
| Language | Haskell98 |
Text.ParserCombinators.MTLParse
Synopsis
- class Monad m => MonadParse a m | m -> a where
- 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
- 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
- class MonadTrans (t :: (Type -> Type) -> Type -> Type) where
- 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 #
parseNot :: c -> m b -> m c Source #
getHere :: m ([a], [a]) Source #
putHere :: ([a], [a]) -> m () Source #
noBacktrack :: m b -> m b Source #
Instances
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
A parse monad where a is the type of the token to parse and b is the type of the return value.
Instances
| MonadParse a (Parse a) Source # | |
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 # | |
| Applicative (Parse p) Source # | |
Defined in Text.ParserCombinators.MTLParse.MTLParseCore | |
| Functor (Parse p) Source # | |
| Monad (Parse a) Source # | |
| MonadPlus (Parse a) Source # | |
| MonadReader ([a], [a]) (Parse a) Source # | |
| MonadState ([a], [a]) (Parse a) Source # | |
The ParseT Monad
A parse monad for encaplulating an inner monad.
Instances
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 #
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
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
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:
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
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
• 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(m a): liftIO
> evalStateT printState "hello" "hello" > evalStateT printState 3 3
Instances
| MonadIO IO | Since: base-4.9.0.0 |
| MonadIO m => MonadIO (MaybeT m) | |
| MonadIO m => MonadIO (ParseT a m) Source # | |
| (Error e, MonadIO m) => MonadIO (ErrorT e m) | |
| MonadIO m => MonadIO (ExceptT e m) | |
| MonadIO m => MonadIO (IdentityT m) | |
| MonadIO m => MonadIO (ReaderT r m) | |
| MonadIO m => MonadIO (StateT s m) | |
| MonadIO m => MonadIO (StateT s m) | |
| (Monoid w, MonadIO m) => MonadIO (WriterT w m) | |
| (Monoid w, MonadIO m) => MonadIO (WriterT w m) | |
| (Monoid w, MonadIO m) => MonadIO (RWST r w s m) | |
| (Monoid w, MonadIO m) => MonadIO (RWST r w s m) | |
class MonadTrans (t :: (Type -> Type) -> Type -> Type) where Source #
The class of monad transformers. Instances should satisfy the
following laws, which state that lift is a monad transformation:
Methods
lift :: Monad m => m a -> t m a Source #
Lift a computation from the argument monad to the constructed monad.
Instances
| MonadTrans MaybeT | |
| MonadTrans (ParseT a) Source # | |
| MonadTrans (ErrorT e) | |
| MonadTrans (ExceptT e) | |
| MonadTrans (IdentityT :: (Type -> Type) -> Type -> Type) | |
| MonadTrans (ReaderT r) | |
| MonadTrans (StateT s) | |
| MonadTrans (StateT s) | |
| Monoid w => MonadTrans (WriterT w) | |
| Monoid w => MonadTrans (WriterT w) | |
| Monoid w => MonadTrans (RWST r w s) | |
| Monoid w => MonadTrans (RWST r w s) | |
tokens :: (Eq a, MonadParse a m) => [a] -> m [a] Source #
tokensBack :: (Eq a, MonadParse a m) => [a] -> m [a] 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 #