Safe Haskell | None |
---|---|
Language | Haskell2010 |
Synopsis
- void :: Functor f => f a -> f ()
- (<|>) :: Alternative f => f a -> f a -> f a
- empty :: Alternative f => f a
- some :: MonadPlus m => m a -> m (NonEmpty a)
- endBy1 :: MonadPlus m => m a -> m sep -> m (NonEmpty a)
- someTill :: MonadPlus m => m a -> m end -> m (NonEmpty a)
- sepBy1 :: MonadPlus m => m a -> m sep -> m (NonEmpty a)
- sepEndBy1 :: MonadPlus m => m a -> m sep -> m (NonEmpty a)
- optional :: Alternative f => f a -> f (Maybe a)
- many :: MonadPlus m => m a -> m [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]
- manyTill :: MonadPlus m => m a -> m end -> m [a]
- option :: Alternative m => a -> m a -> m a
- sepBy :: MonadPlus m => m a -> m sep -> m [a]
- sepEndBy :: 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
- (<?>) :: Parser k p => p a -> String -> p a
- getLine :: P k Int
- getCol :: P k Int
- withPos :: Parser k p => p a -> p (Pos, a)
- withSpan :: Parser k p => p a -> p (Pos, Pos, a)
- getRefCol :: P k Int
- getRefLine :: P k Int
- withRefPos :: Parser k p => p a -> p a
- align :: P k ()
- indented :: P k ()
- line :: P k ()
- linefold :: P k ()
- digitByte :: Parser k p => Int -> p Word8
- integer :: (Num a, Parser k p) => p sep -> Int -> p a
- integer' :: (Num a, Parser k p) => p sep -> Int -> p (a, Int)
- decimal :: Num a => P k a
- octal :: Num a => P k a
- hexadecimal :: Num a => P k a
- digit :: Parser k p => Int -> p Word
- sign :: (Parser k f, Num a) => f (a -> a)
- signed :: (Num a, Parser k p) => p a -> p a
- fractionHex :: (Num a, Parser k p) => p digitSep -> p (Either a (a, Int, a))
- fractionDec :: (Num a, Parser k p) => p digitSep -> p (Either a (a, Int, a))
- char' :: Parser k p => Char -> p Char
- notChar :: Parser k p => Char -> p Char
- anyChar :: P k Char
- anyAsciiByte :: P k Word8
- alphaNumChar :: P k Char
- digitChar :: Parser k p => Int -> p Char
- letterChar :: P k Char
- lowerChar :: P k Char
- upperChar :: P k Char
- symbolChar :: P k Char
- categoryChar :: Parser k p => GeneralCategory -> p Char
- punctuationChar :: P k Char
- spaceChar :: P k Char
- asciiChar :: P k Char
- satisfy :: Parser k p => (Char -> Bool) -> p Char
- asciiSatisfy :: Parser k p => (Word8 -> Bool) -> p Word8
- skipChars :: Parser k p => Int -> p ()
- takeChars :: Parser k p => Int -> p k
- skipCharsWhile :: Parser k p => (Char -> Bool) -> p ()
- takeCharsWhile :: Parser k p => (Char -> Bool) -> p k
- skipCharsWhile1 :: Parser k p => (Char -> Bool) -> p ()
- takeCharsWhile1 :: Parser k p => (Char -> Bool) -> p k
- scanChars :: Parser k p => (s -> Char -> Maybe s) -> s -> p s
- scanChars1 :: Parser k p => (s -> Char -> Maybe s) -> s -> p s
- string :: Parser k p => String -> p k
Basic combinators
void :: Functor f => f a -> f () #
discards or ignores the result of evaluation, such
as the return value of an void
valueIO
action.
Examples
Replace the contents of a
with unit:Maybe
Int
>>>
void Nothing
Nothing>>>
void (Just 3)
Just ()
Replace the contents of an
with unit,
resulting in an Either
Int
Int
: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) #
applies the parser some
pp
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) #
parses one or more occurrences of endBy1
p sepp
, 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) #
works similarly to someTill
p end
, but manyTill
p endp
should succeed at least once.
See also: skipSome
, skipSomeTill
.
sepBy1 :: MonadPlus m => m a -> m sep -> m (NonEmpty a) #
parses one or more occurrences of sepBy1
p sepp
, separated by
sep
. Returns a non-empty list of values returned by p
.
sepEndBy1 :: MonadPlus m => m a -> m sep -> m (NonEmpty a) #
parses one or more occurrences of sepEndBy1
p sepp
, 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] #
applies the parser many
pp
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 #
parses between
open close popen
, 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 #
tries to apply the parsers in the list choice
psps
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) #
Combine two alternatives.
eitherP a b = (Left <$> a) <|> (Right <$> b)
endBy :: MonadPlus m => m a -> m sep -> m [a] #
parses zero or more occurrences of endBy
p sepp
, 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] #
applies parser manyTill
p endp
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 #
sepBy :: MonadPlus m => m a -> m sep -> m [a] #
parses zero or more occurrences of sepBy
p sepp
, 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] #
parses zero or more occurrences of sepEndBy
p sepp
, separated
and optionally ended by sep
. Returns a list of values returned by p
.
skipMany :: MonadPlus m => m a -> m () #
applies the parser skipMany
pp
zero or more times, skipping
its result.
See also: manyTill
, skipManyTill
.
skipSome :: MonadPlus m => m a -> m () #
applies the parser skipSome
pp
one or more times, skipping its
result.
See also: someTill
, skipSomeTill
.
skipManyTill :: MonadPlus m => m a -> m end -> m end #
applies the parser skipManyTill
p endp
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 #
applies the parser skipSomeTill
p endp
one or more times
skipping results until parser end
succeeds. Result parsed by end
is
then returned.
Labels
Position
withPos :: Parser k p => p a -> p (Pos, a) Source #
Decorate the parser result with the current position
withSpan :: Parser k p => p a -> p (Pos, Pos, a) Source #
Decorate the parser result with the position span
Indentation
getRefLine :: P k Int Source #
Get line number of the reference position
withRefPos :: Parser k p => p a -> p a Source #
Update reference position with current position
Parser succeeds either on the reference line or for columns greater than the current reference column
Char combinators
digitByte :: Parser k p => Int -> p Word8 Source #
Parse a digit byte for the given base. Bases 2 to 36 are supported.
integer :: (Num a, Parser k p) => p sep -> Int -> p a Source #
Parse an integer of the given base. Bases 2 to 36 are supported. Digits can be separated by separator, e.g. `optional (char '_')`. Signs are not parsed by this combinator.
integer' :: (Num a, Parser k p) => p sep -> Int -> p (a, Int) Source #
Parse an integer of the given base. Returns the integer and the number of digits. Bases 2 to 36 are supported. Digits can be separated by separator, e.g. `optional (char '_')`. Signs are not parsed by this combinator.
decimal :: Num a => P k a Source #
Parses a decimal integer. Signs are not parsed by this combinator.
hexadecimal :: Num a => P k a Source #
Parses a hexadecimal integer. Signs are not parsed by this combinator.
digit :: Parser k p => Int -> p Word Source #
Parse a single digit of the given base and return its value. Bases 2 to 36 are supported.
fractionHex :: (Num a, Parser k p) => p digitSep -> p (Either a (a, Int, a)) Source #
Parse a hexadecimal fraction, e.g., co.ffeep123, returning (mantissa, 2, exponent), corresponding to mantissa * 2^exponent. Digits can be separated by separator, e.g. `optional (char '_')`. Signs are not parsed by this combinator.
fractionDec :: (Num a, Parser k p) => p digitSep -> p (Either a (a, Int, a)) Source #
Parse a decimal fraction, e.g., 123.456e-78, returning (mantissa, 10, exponent), corresponding to mantissa * 10^exponent. Digits can be separated by separator, e.g. `optional (char '_')`. Signs are not parsed by this combinator.
anyAsciiByte :: P k Word8 Source #
Parse an arbitrary ASCII byte.
alphaNumChar :: P k Char Source #
Parse an alphanumeric character, including Unicode.
digitChar :: Parser k p => Int -> p Char Source #
Parse a digit character of the given base. Bases 2 to 36 are supported.
letterChar :: P k Char Source #
Parse a letter character, including Unicode.
symbolChar :: P k Char Source #
Parse a symbol character, including Unicode.
categoryChar :: Parser k p => GeneralCategory -> p Char Source #
Parse a character belonging to the given Unicode category
punctuationChar :: P k Char Source #
Parse a punctuation character, including Unicode.
satisfy :: Parser k p => (Char -> Bool) -> p Char Source #
Parse a single character with the given predicate
asciiSatisfy :: Parser k p => (Word8 -> Bool) -> p Word8 Source #
Parse a single character within the ASCII charset with the given predicate
takeChars :: Parser k p => Int -> p k Source #
Take the next n characters and advance the position by n characters
skipCharsWhile1 :: Parser k p => (Char -> Bool) -> p () Source #
Skip at least one char while predicate is true