paripari-0.6.0.1: Parser combinators with fast-path and slower fallback for error reporting

Text.PariPari.Internal.ElementCombinators

Synopsis

# 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

Expand

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. Note that end result is consumed and lost. Use manyTill_ if you wish to keep it.

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

Infix alias for label

getLine :: ChunkP k Int Source #

Get current line number

getColumn :: ChunkP k Int Source #

Get current column

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

Decorate the parser result with the current position

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

Decorate the parser result with the position span

getRefColumn :: ChunkP k Int Source #

Get column number of the reference position

getRefLine :: ChunkP k Int Source #

Get line number of the reference position

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

Update reference position with current position

align :: ChunkP k () Source #

Parser succeeds on the same column as the reference column

indented :: ChunkP k () Source #

Parser succeeds for columns greater than the current reference column

line :: ChunkP k () Source #

Parser succeeds on the same line as the reference line

linefold :: ChunkP k () Source #

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

Parser a single element different from the given one

anyElement :: ChunkP k (Element k) Source #

Parse an arbitrary element

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

Parse a single element with the given predicate

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

Take the next n elements and advance the position by n

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

Skip the next n elements

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

Skip elements while predicate is true

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

Takes elements while predicate is true

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

Skip at least one element while predicate is true

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

Take at least one element while predicate is true

scanElements :: ChunkParser k p => (s -> Element k -> Maybe s) -> s -> p s Source #

scanElements1 :: ChunkParser k p => (s -> Element k -> Maybe s) -> s -> p s Source #