Text.PariPari.Internal.ElementCombinators

Basic combinators

void :: Functor f => f a -> f ()

void value discards or ignores the result of evaluation, such as the return value of an IO action.

Examples

Replace the contents of a Maybe Int with unit:

>>> void Nothing
Nothing
>>> void (Just 3)
Just ()

Replace the contents of an Either Int Int with unit, resulting in an Either Int '()':

>>> void (Left 8675309)
Left 8675309
>>> void (Right 8675309)
Right ()

Replace every element of a list with unit:

>>> void [1,2,3]
[(),(),()]

Replace the second element of a pair with unit:

>>> void (1,2)
(1,())

Discard the result of an IO action:

>>> mapM print [1,2]
1
2
[(),()]
>>> void $ mapM print [1,2]
1
2

(<|>) :: Alternative f => f a -> f a -> f a infixl 3

An associative binary operation

empty :: Alternative f => f a

The identity of <|>

Control.Monad.Combinators.NonEmpty

some :: MonadPlus m => m a -> m (NonEmpty a)

some p applies the parser p one or more times and returns a list of the values returned by p.

word = some letter

endBy1 :: MonadPlus m => m a -> m sep -> m (NonEmpty a)

endBy1 p sep parses one or more occurrences of p, separated and ended by sep. Returns a non-empty list of values returned by p.

someTill :: MonadPlus m => m a -> m end -> m (NonEmpty a)

someTill p end works similarly to manyTill p end, but p should succeed at least once.

See also: skipSome, skipSomeTill.

sepBy1 :: MonadPlus m => m a -> m sep -> m (NonEmpty a)

sepBy1 p sep parses one or more occurrences of p, separated by sep. Returns a non-empty list of values returned by p.

sepEndBy1 :: MonadPlus m => m a -> m sep -> m (NonEmpty a)

sepEndBy1 p sep parses one or more occurrences of p, separated and optionally ended by sep. Returns a non-empty list of values returned by p.

Control.Monad.Combinators

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

One or none.

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

many p applies the parser p zero or more times and returns a list of the values returned by p.

identifier = (:) <$> letter <*> many (alphaNumChar <|> char '_')

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

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

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]

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.

See also: skipCount, count'.

count' :: MonadPlus m => Int -> Int -> m a -> m [a]

count' m n p parses from m to n occurrences of p. If n is not positive or m > n, the parser equals to return []. Returns a list of parsed values.

Please note that m may be negative, in this case effect is the same as if it were equal to zero.

See also: skipCount, count.

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 sep parses zero or more occurrences of p, separated and ended by sep. Returns a list of values returned by p.

cStatements = cStatement `endBy` semicolon

manyTill :: MonadPlus m => m a -> m end -> m [a]

manyTill p end applies parser p zero or more times until parser end succeeds. Returns the list of values returned by p.

See also: skipMany, skipManyTill.

option :: Alternative m => a -> m a -> m a

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

option x p = p <|> pure x

See also: optional.

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

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

commaSep p = p `sepBy` comma

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

sepEndBy p sep parses zero 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 ()

skipMany p applies the parser p zero or more times, skipping its result.

See also: manyTill, skipManyTill.

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

skipSome p applies the parser p one or more times, skipping its result.

See also: someTill, skipSomeTill.

skipCount :: Monad m => Int -> m a -> m ()

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

See also: count, count'.

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

skipManyTill p end applies the parser p zero or more times skipping results until parser end succeeds. Result parsed by end is then returned.

See also: manyTill, skipMany.

skipSomeTill :: MonadPlus m => m a -> m end -> m end

skipSomeTill p end applies the parser p one or more times skipping results until parser end succeeds. Result parsed by end is then returned.

See also: someTill, skipSome.

PariPari

(<?>) :: ChunkParser k p => p a -> String -> p a infix 0

Infix alias for label

getLine :: ChunkP k Int

Get current line number

getColumn :: ChunkP k Int

Get current column

withPos :: ChunkParser k p => p a -> p (Pos, a)

Decorate the parser result with the current position

withSpan :: ChunkParser k p => p a -> p (Span, a)

Decoreate the parser result with the position span

getRefColumn :: ChunkP k Int

Get column number of the reference position

getRefLine :: ChunkP k Int

Get line number of the reference position

withRefPos :: ChunkParser k p => p a -> p a

Update reference position with current position

align :: ChunkP k ()

Parser succeeds on the same column as the reference column

indented :: ChunkP k ()

Parser succeeds for columns greater than the current reference column

line :: ChunkP k ()

Parser succeeds on the same line as the reference line

linefold :: ChunkP k ()

Parser succeeds either on the reference line or for columns greater than the current reference column

notElement :: forall k p. ChunkParser k p => Element k -> p (Element k)

Parser a single byte different from the given one

anyElement :: ChunkP k (Element k)

Parse an arbitrary byte

elementSatisfy :: ChunkParser k p => (Element k -> Bool) -> p (Element k)

Parse a single byte with the given predicate

takeElements :: ChunkParser k p => Int -> p k

Take the next n elements and advance the position by n

skipElements :: ChunkParser k p => Int -> p ()

Skip the next n elements

skipElementsWhile :: ChunkParser k p => (Element k -> Bool) -> p ()

Skip elements while predicate is true

takeElementsWhile :: ChunkParser k p => (Element k -> Bool) -> p k

Takes elements while predicate is true

skipElementsWhile1 :: ChunkParser k p => (Element k -> Bool) -> p ()

Skip at least one element while predicate is true

takeElementsWhile1 :: ChunkParser k p => (Element k -> Bool) -> p k

Take at least one element while predicate is true

scanElementsWhile :: ChunkParser k p => (s -> Element k -> Maybe s) -> s -> p s

scanElementsWhile1 :: ChunkParser k p => (s -> Element k -> Maybe s) -> s -> p s