| Copyright | © 2017–present Mark Karpov | 
|---|---|
| License | BSD 3 clause | 
| Maintainer | Mark Karpov <markkarpov92@gmail.com> | 
| Stability | experimental | 
| Portability | portable | 
| Safe Haskell | Safe-Inferred | 
| Language | Haskell2010 | 
Control.Monad.Combinators
Description
The module provides more efficient versions of the combinators from
 Control.Applicative.Combinators defined in terms of Monad and
 MonadPlus instead of Applicative and
 Alternative. When there is no difference in
 performance we just re-export the combinators from
 Control.Applicative.Combinators.
Since: 0.4.0
Synopsis
- (<|>) :: Alternative f => f a -> f a -> f a
- optional :: Alternative f => f a -> f (Maybe a)
- empty :: Alternative f => f a
- between :: Applicative m => m open -> m close -> m a -> m a
- choice :: (Foldable f, Alternative m) => f (m a) -> m a
- count :: Monad m => Int -> m a -> m [a]
- count' :: MonadPlus m => Int -> Int -> m a -> m [a]
- eitherP :: Alternative m => m a -> m b -> m (Either a b)
- endBy :: MonadPlus m => m a -> m sep -> m [a]
- endBy1 :: MonadPlus m => m a -> m sep -> m [a]
- many :: MonadPlus m => m a -> m [a]
- manyTill :: MonadPlus m => m a -> m end -> m [a]
- manyTill_ :: MonadPlus m => m a -> m end -> m ([a], end)
- some :: MonadPlus m => m a -> m [a]
- someTill :: MonadPlus m => m a -> m end -> m [a]
- someTill_ :: MonadPlus m => m a -> m end -> m ([a], end)
- option :: Alternative m => a -> m a -> m a
- sepBy :: MonadPlus m => m a -> m sep -> m [a]
- sepBy1 :: MonadPlus m => m a -> m sep -> m [a]
- sepEndBy :: MonadPlus m => m a -> m sep -> m [a]
- sepEndBy1 :: MonadPlus m => m a -> m sep -> m [a]
- skipMany :: MonadPlus m => m a -> m ()
- skipSome :: MonadPlus m => m a -> m ()
- skipCount :: Monad m => Int -> m a -> m ()
- skipManyTill :: MonadPlus m => m a -> m end -> m end
- skipSomeTill :: MonadPlus m => m a -> m end -> m end
Re-exports from Control.Applicative
(<|>) :: Alternative f => f a -> f a -> f a infixl 3 #
An associative binary operation
This combinator implements choice. The parser p  first applies
 <|> qp. If it succeeds, the value of p is returned. If p fails, parser
 q is tried.
optional :: Alternative f => f a -> f (Maybe a) #
One or none.
It is useful for modelling any computation that is allowed to fail.
Examples
Using the Alternative instance of Control.Monad.Except, the following functions:
>>>import Control.Monad.Except
>>>canFail = throwError "it failed" :: Except String Int>>>final = return 42 :: Except String Int
Can be combined by allowing the first function to fail:
>>>runExcept $ canFail *> finalLeft "it failed"
>>>runExcept $ optional canFail *> finalRight 42
optional pp. It will parse p or
 Nothing. It only fails if p fails after consuming input. On success
 result of p is returned inside of Just, on failure Nothing is
 returned.
See also: option.
empty :: Alternative f => f a #
The identity of <|>
empty <|> a == a a <|> empty == a
This parser fails unconditionally without providing any information about the cause of the failure.
Original combinators
between :: Applicative m => m open -> m close -> m a -> m a #
between open close popen, followed by p and close.
 Returns the value returned by p.
braces = between (symbol "{") (symbol "}")choice :: (Foldable f, Alternative m) => f (m a) -> m a #
choice psps in order,
 until one of them succeeds. Returns the value of the succeeding parser.
choice = asum
eitherP :: Alternative m => m a -> m b -> m (Either a b) #
Combine two alternatives.
eitherP a b = (Left <$> a) <|> (Right <$> b)
endBy :: MonadPlus m => m a -> m sep -> m [a] #
endBy p sepp, separated and
 ended by sep. Returns a list of values returned by p.
cStatements = cStatement `endBy` semicolon
endBy1 :: MonadPlus m => m a -> m sep -> m [a] #
endBy1 p sepp, separated and
 ended by sep. Returns a list of values returned by p.
many :: MonadPlus m => m a -> m [a] #
many pp zero or more times and returns a
 list of the values returned by p.
identifier = (:) <$> letter <*> many (alphaNumChar <|> char '_')
manyTill :: MonadPlus m => m a -> m end -> m [a] #
manyTill p endp zero or more times until parser
 end succeeds. Returns the list of values returned by p. Note that
 end result is consumed and lost. Use manyTill_ if you wish to keep
 it.
See also: skipMany, skipManyTill.
manyTill_ :: MonadPlus m => m a -> m end -> m ([a], end) #
manyTill_ p endp zero or more times until
 parser end succeeds. Returns the list of values returned by p and the
 end result. Use manyTill if you have no need in the result of the
 end.
See also: skipMany, skipManyTill.
Since: 1.2.0
some :: MonadPlus m => m a -> m [a] #
some pp one or more times and returns a
 list of the values returned by p.
word = some letter
someTill :: MonadPlus m => m a -> m end -> m [a] #
someTill p endmanyTill p endp
 should succeed at least once. Note that end result is consumed and
 lost. Use someTill_ if you wish to keep it.
someTill p end = liftM2 (:) p (manyTill p end)
See also: skipSome, skipSomeTill.
someTill_ :: MonadPlus m => m a -> m end -> m ([a], end) #
someTill_ p endmanyTill_ p endp
 should succeed at least once. Use someTill if you have no need in the
 result of the end.
See also: skipSome, skipSomeTill.
Since: 1.2.0
option :: Alternative m => a -> m a -> m a #
sepBy :: MonadPlus m => m a -> m sep -> m [a] #
sepBy p sepp, separated by
 sep. Returns a list of values returned by p.
commaSep p = p `sepBy` comma
sepBy1 :: MonadPlus m => m a -> m sep -> m [a] #
sepBy1 p sepp, separated by
 sep. Returns a list of values returned by p.
sepEndBy :: MonadPlus m => m a -> m sep -> m [a] #
sepEndBy p sepp, separated
 and optionally ended by sep. Returns a list of values returned by p.
sepEndBy1 :: MonadPlus m => m a -> m sep -> m [a] #
sepEndBy1 p sepp, separated
 and optionally ended by sep. Returns a list of values returned by p.
skipMany :: MonadPlus m => m a -> m () #
skipMany pp zero or more times, skipping
 its result.
See also: manyTill, skipManyTill.
skipSome :: MonadPlus m => m a -> m () #
skipSome pp one or more times, skipping its
 result.
See also: someTill, skipSomeTill.
skipManyTill :: MonadPlus m => m a -> m end -> m end #
skipManyTill p endp zero or more times
 skipping results until parser end succeeds. Result parsed by end is
 then returned.
skipSomeTill :: MonadPlus m => m a -> m end -> m end #
skipSomeTill p endp one or more times
 skipping results until parser end succeeds. Result parsed by end is
 then returned.