Copyright | © 2017–present Mark Karpov |
---|---|

License | BSD 3 clause |

Maintainer | Mark Karpov <markkarpov92@gmail.com> |

Stability | experimental |

Portability | portable |

Safe Haskell | Safe |

Language | Haskell2010 |

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
`<|>`

q`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) #

One or none.

tries to apply the parser `optional`

p`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.

See also: `option`

.

empty :: Alternative f => f a #

The identity of `<|>`

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 Source #

parses `between`

open close p`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 #

tries to apply the parsers in the list `choice`

ps`ps`

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) Source #

Combine two alternatives.

eitherP a b = (Left <$> a) <|> (Right <$> b)

endBy :: MonadPlus m => m a -> m sep -> m [a] Source #

parses `endBy`

p sep*zero* or more occurrences of `p`

, 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] Source #

parses `endBy1`

p sep*one* or more occurrences of `p`

, separated and
ended by `sep`

. Returns a list of values returned by `p`

.

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

applies the parser `many`

p`p`

*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] Source #

applies parser `manyTill`

p end`p`

*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) Source #

applies parser `manyTill_`

p end`p`

*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] Source #

applies the parser `some`

p`p`

*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] Source #

works similarly to `someTill`

p end

, but `manyTill`

p end`p`

should succeed at least once. **Note** that `end`

result is consumed and
lost. Use `someTill_`

if you wish to keep it.

See also: `skipSome`

, `skipSomeTill`

.

someTill_ :: MonadPlus m => m a -> m end -> m ([a], end) Source #

works similarly to `someTill_`

p end

, but `manyTill_`

p end`p`

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 Source #

sepBy :: MonadPlus m => m a -> m sep -> m [a] Source #

parses `sepBy`

p sep*zero* or more occurrences of `p`

, 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] Source #

parses `sepBy1`

p sep*one* or more occurrences of `p`

, separated by
`sep`

. Returns a list of values returned by `p`

.

sepEndBy :: MonadPlus m => m a -> m sep -> m [a] Source #

parses `sepEndBy`

p sep*zero* or more occurrences of `p`

, separated
and optionally ended by `sep`

. Returns a list of values returned by `p`

.

sepEndBy1 :: MonadPlus m => m a -> m sep -> m [a] Source #

parses `sepEndBy1`

p sep*one* or more occurrences of `p`

, separated
and optionally ended by `sep`

. Returns a list of values returned by `p`

.

skipMany :: MonadPlus m => m a -> m () Source #

applies the parser `skipMany`

p`p`

*zero* or more times, skipping
its result.

See also: `manyTill`

, `skipManyTill`

.

skipSome :: MonadPlus m => m a -> m () Source #

applies the parser `skipSome`

p`p`

*one* or more times, skipping its
result.

See also: `someTill`

, `skipSomeTill`

.

skipManyTill :: MonadPlus m => m a -> m end -> m end Source #

applies the parser `skipManyTill`

p end`p`

*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 Source #

applies the parser `skipSomeTill`

p end`p`

*one* or more times
skipping results until parser `end`

succeeds. Result parsed by `end`

is
then returned.