Copyright	© 2017–present Mark Karpov
License	BSD 3 clause
Maintainer	Mark Karpov <[email protected]>
Stability	experimental
Portability	portable
Safe Haskell	Safe-Inferred
Language	Haskell2010

Control.Monad.Combinators

Contents

Re-exports from Control.Applicative
Original 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 Source #

An associative binary operation

This combinator implements choice. The parser p <|> q first applies p. If it succeeds, the value of p is returned. If p fails, parser q is tried.

optional :: Alternative f => f a -> f (Maybe a) Source #

One or none.

It is useful for modelling any computation that is allowed to fail.

Examples

Expand

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 *> final
Left "it failed"
>>> runExcept $ optional canFail *> final
Right 42

optional p tries to apply the parser p. 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.

Original combinators

between :: Applicative m => m open -> m close -> m a -> m a Source #

between open close p parses open, 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 Source #

choice ps tries to apply the parsers in the list ps in order, until one of them succeeds. Returns the value of the succeeding parser.

choice = asum

count :: Monad m => Int -> m a -> m [a] Source #

count n p parses n occurrences of p. If n is smaller or equal to zero, the parser equals to return []. Returns a list of n values.