| Safe Haskell | None |
|---|---|
| Language | GHC2021 |
Symparsec.Parsers
Description
Common type-level string parsers.
Many parsers reuse term-level names, which can cause ambiguity issues. Consider importing qualified.
Synopsis
- data ((f :: a ~> b) <$> (p :: PParser a)) (s :: FunKind PState (PReply b))
- data ((l :: PParser (a ~> b)) <*> (r :: PParser a)) (s :: FunKind PState (PReply b))
- data Pure (a1 :: a) (s :: FunKind PState (PReply a))
- type LiftA2 (f :: a ~> (b ~> c)) (l :: PParser a) (r :: PParser b) = (f <$> l) <*> r
- type (*>) (l :: PParser a) (r :: PParser b) = ((IdSym :: FunKind b b -> Type) <$ l) <*> r
- type (<*) (l :: PParser a) (r :: PParser b) = LiftA2 (ConstSym :: FunKind a (b ~> a) -> Type) l r
- data ((l :: PParser a) >>= (r :: a ~> PParser b)) (s :: FunKind PState (PReply b))
- data ((l :: PParser a) <|> (r :: PParser a)) (s :: FunKind PState (PReply a))
- data Empty (s :: FunKind PState (PReply a))
- type Optional (p :: PParser a) = (Con1 ('Just :: a -> Maybe a) <$> p) <|> Pure ('Nothing :: Maybe a)
- data Ensure (n :: Natural) (s :: FunKind PState (PReply ()))
- data Isolate (n :: Natural) (p :: PParser a) (s :: FunKind PState (PReply a))
- data Take (n :: Natural) (s :: FunKind PState (PReply Symbol))
- data TakeRest (s :: FunKind PState (PReply Symbol))
- type Skip (n :: Natural) = Ensure n *> SkipUnsafe n
- data Eof (s :: FunKind PState (PReply ()))
- data Try (p :: PParser a) (s :: FunKind PState (PReply a))
- data While (chPred :: Char ~> Bool) (p :: PParser a) (s :: FunKind PState (PReply a))
- data TakeWhile (chPred :: Char ~> Bool) (s :: FunKind PState (PReply Symbol))
- data Count (n :: Natural) (p :: PParser a) (s :: FunKind PState (PReply [a]))
- data Literal (lit :: Symbol) (s :: FunKind PState (PReply ()))
- data NatBase (base :: Natural) (parseDigit :: Char ~> Maybe Natural) (s :: FunKind PState (PReply Natural))
- type NatDec = NatBase 10 ParseDigitDecSym
- type NatHex = NatBase 16 ParseDigitHexSym
- type NatBin = NatBase 2 ParseDigitBinSym
- type NatOct = NatBase 8 ParseDigitOctSym
- type Tuple (l :: PParser a) (r :: PParser b) = LiftA2 (Con2 ('(,) :: a -> b -> (a, b))) l r
Type class-esque
Parsers which mirror functions from type classes (specifically Functor,
Applicative, Monad and Alternative. These primitive
combinators are powerful, but can be tough to use without type-level binders or
do-notation, and force interacting with defunctionalization.
data ((f :: a ~> b) <$> (p :: PParser a)) (s :: FunKind PState (PReply b)) infixl 4 Source #
<$> for parsers. Apply the given type function to the result.
data ((l :: PParser (a ~> b)) <*> (r :: PParser a)) (s :: FunKind PState (PReply b)) infixl 4 Source #
<*> for parsers. Sequence two parsers, left to right.
data Pure (a1 :: a) (s :: FunKind PState (PReply a)) Source #
pure for parsers. Non-consuming parser that just returns the given value.
type LiftA2 (f :: a ~> (b ~> c)) (l :: PParser a) (r :: PParser b) = (f <$> l) <*> r Source #
liftA2 for parsers. Sequence two parsers, and combine their results with
a binary type function.
type (*>) (l :: PParser a) (r :: PParser b) = ((IdSym :: FunKind b b -> Type) <$ l) <*> r infixl 4 Source #
*> for parsers. Sequence two parsers left to right, discarding the value
of the left parser.
type (<*) (l :: PParser a) (r :: PParser b) = LiftA2 (ConstSym :: FunKind a (b ~> a) -> Type) l r infixl 4 Source #
<* for parsers. Sequence two parsers left to right, discarding the value
of the right parser.
data ((l :: PParser a) >>= (r :: a ~> PParser b)) (s :: FunKind PState (PReply b)) infixl 1 Source #
>>= for parsers. Sequentially compose two parsers, passing the value from
the left parser as an argument to the second.
data ((l :: PParser a) <|> (r :: PParser a)) (s :: FunKind PState (PReply a)) infixl 3 Source #
data Empty (s :: FunKind PState (PReply a)) Source #
empty for parsers. Immediately fail with no consumption.
type Optional (p :: PParser a) = (Con1 ('Just :: a -> Maybe a) <$> p) <|> Pure ('Nothing :: Maybe a) Source #
optional for parsers.
Positional
Parsers that relate to input position e.g. length, end of input.
data Ensure (n :: Natural) (s :: FunKind PState (PReply ())) Source #
Assert that there are at least n characters remaining. Non-consuming.
data Take (n :: Natural) (s :: FunKind PState (PReply Symbol)) Source #
Return the next n characters.
data TakeRest (s :: FunKind PState (PReply Symbol)) Source #
Consume and return the rest of the input string.
Never fails. May return the empty string.
type Skip (n :: Natural) = Ensure n *> SkipUnsafe n Source #
Skip forward n characters. Fails if fewer than n characters remain.
Other combinators
Assorted parser combinators (that wrap other parsers).
data Try (p :: PParser a) (s :: FunKind PState (PReply a)) Source #
Run the given parser, backtracking on error.
data While (chPred :: Char ~> Bool) (p :: PParser a) (s :: FunKind PState (PReply a)) Source #
Run the given parser while the given character predicate succeeds.
data TakeWhile (chPred :: Char ~> Bool) (s :: FunKind PState (PReply Symbol)) Source #
data Count (n :: Natural) (p :: PParser a) (s :: FunKind PState (PReply [a])) Source #
Count n pn occurrences of p.
Common non-combinator
Simple non-combinator parser. Probably fundamental in some way e.g. very general or common.
Naturals
data NatBase (base :: Natural) (parseDigit :: Char ~> Maybe Natural) (s :: FunKind PState (PReply Natural)) Source #
type NatHex = NatBase 16 ParseDigitHexSym Source #
Parse a hexadecimal (base 16) Natural. Permits mixed-case (0-9A-Fa-f).
Derived
Derived parsers. Should be type synonyms.
type Tuple (l :: PParser a) (r :: PParser b) = LiftA2 (Con2 ('(,) :: a -> b -> (a, b))) l r Source #
Parse left, then right, and return their results in a tuple.
Classic parser combinators often don't define this because it's trivial, and do notation is often cleaner anyway. But it's very syntactically busy on the type level, and we don't have do notation. So here's a convenience definition.
Missing parsers
Certain term-level parsers you may be used to you will not see in Symparsec:
- Parsers that rely on underlying instances e.g. no
Semigroupa => Semigroup (parser a)Semigroup amanually, which defeats the purpose