attoparsec-0.10.4.0: Fast combinator parsing for bytestrings and text

Portability | portable
Stability | experimental
Maintainer | bos@serpentine.com
Safe Haskell | None

Data.Attoparsec.Combinator

Description

Useful parser combinators, similar to those provided by Parsec.

Synopsis

- choice :: Alternative f => [f a] -> f a
- count :: Monad m => Int -> m a -> m [a]
- option :: Alternative f => a -> f a -> f a
- many' :: MonadPlus m => m a -> m [a]
- many1 :: Alternative f => f a -> f [a]
- many1' :: MonadPlus m => m a -> m [a]
- manyTill :: Alternative f => f a -> f b -> f [a]
- manyTill' :: MonadPlus m => m a -> m b -> m [a]
- sepBy :: Alternative f => f a -> f s -> f [a]
- sepBy' :: MonadPlus m => m a -> m s -> m [a]
- sepBy1 :: Alternative f => f a -> f s -> f [a]
- sepBy1' :: MonadPlus m => m a -> m s -> m [a]
- skipMany :: Alternative f => f a -> f ()
- skipMany1 :: Alternative f => f a -> f ()
- eitherP :: Alternative f => f a -> f b -> f (Either a b)

# Documentation

choice :: Alternative f => [f a] -> f a

`choice ps` tries to apply the actions in the list `ps` in order, until one of them succeeds. Returns the value of the succeeding action.

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

Apply the given action repeatedly, returning every result.

option :: Alternative f => a -> f a -> f a

`option x p` tries to apply action `p`. If `p` fails without consuming input, it returns the value `x`, otherwise the value returned by `p`.

     priority  = option 0 (digitToInt <$> digit)

many' :: MonadPlus m => m a -> m [a]

`many' p` applies the action `p` zero or more times. Returns a list of the returned values of `p`. The value returned by `p` is forced to WHNF.

      word  = many' letter

many1 :: Alternative f => f a -> f [a]

`many1 p` applies the action `p` one or more times. Returns a list of the returned values of `p`.

      word  = many1 letter

many1' :: MonadPlus m => m a -> m [a]

`many1' p` applies the action `p` one or more times. Returns a list of the returned values of `p`. The value returned by `p` is forced to WHNF.

      word  = many1' letter

manyTill :: Alternative f => f a -> f b -> f [a]

`manyTill p end` applies action `p` zero or more times until action `end` succeeds, and returns the list of values returned by `p`. This can be used to scan comments:

      simpleComment   = string "<!--" *> manyTill anyChar (try (string "-->"))

Note the overlapping parsers `anyChar` and `string "<!--"`, and therefore the use of the `try` combinator.

manyTill' :: MonadPlus m => m a -> m b -> m [a]

`manyTill' p end` applies action `p` zero or more times until action `end` succeeds, and returns the list of values returned by `p`. This can be used to scan comments:

      simpleComment   = string "<!--" *> manyTill' anyChar (try (string "-->"))

Note the overlapping parsers `anyChar` and `string "<!--"`, and therefore the use of the `try` combinator. The value returned by `p` is forced to WHNF.

sepBy :: Alternative f => f a -> f s -> f [a]

`sepBy p sep` applies zero or more occurrences of `p`, separated by `sep`. Returns a list of the values returned by `p`.

     commaSep p  = p `sepBy` (symbol ",")

sepBy' :: MonadPlus m => m a -> m s -> m [a]

`sepBy' p sep` applies zero or more occurrences of `p`, separated by `sep`. Returns a list of the values returned by `p`. The value returned by `p` is forced to WHNF.

     commaSep p  = p `sepBy'` (symbol ",")

sepBy1 :: Alternative f => f a -> f s -> f [a]

`sepBy1 p sep` applies one or more occurrences of `p`, separated by `sep`. Returns a list of the values returned by `p`.

     commaSep p  = p `sepBy1` (symbol ",")

sepBy1' :: MonadPlus m => m a -> m s -> m [a]

`sepBy1' p sep` applies one or more occurrences of `p`, separated by `sep`. Returns a list of the values returned by `p`. The value returned by `p` is forced to WHNF.

     commaSep p  = p `sepBy1'` (symbol ",")

skipMany :: Alternative f => f a -> f ()

Skip zero or more instances of an action.

skipMany1 :: Alternative f => f a -> f ()

Skip one or more instances of an action.

eitherP :: Alternative f => f a -> f b -> f (Either a b)

Combine two alternatives.