Safe Haskell	Safe-Inferred
Language	GHC2021

MarkupParse.FlatParse

Contents

parsing
parsers

Description

Various flatparse helpers and combinators.

Synopsis

data ParserWarning
- = ParserLeftover ByteString
- | ParserError String
- | ParserUncaught
runParserMaybe :: Parser e a -> ByteString -> Maybe a
runParserEither :: Parser String a -> ByteString -> Either String a
runParserWarn :: Parser String a -> ByteString -> These ParserWarning a
runParser_ :: Parser String a -> ByteString -> a
isWhitespace :: Char -> Bool
ws_ :: Parser e ()
ws :: Parser e Char
wss :: Parser e ByteString
nota :: Char -> Parser e ByteString
isa :: (Char -> Bool) -> Parser e ByteString
sq :: ParserT st e ()
dq :: ParserT st e ()
wrappedDq :: Parser b ByteString
wrappedSq :: Parser b ByteString
wrappedQ :: Parser e ByteString
wrappedQNoGuard :: Parser e a -> Parser e a
eq :: Parser e ()
sep :: Parser e s -> Parser e a -> Parser e [a]
bracketed :: Parser e b -> Parser e b -> Parser e a -> Parser e a
bracketedSB :: Parser e [Char]
wrapped :: Parser e () -> Parser e a -> Parser e a
int :: Parser e Int
double :: Parser e Double
signed :: Num b => Parser e b -> Parser e b
byteStringOf' :: Parser e a -> Parser e ByteString

parsing

data ParserWarning Source #

Warnings covering leftovers, Errs and Fail

>>> runParserWarn ws " x"
These (ParserLeftover "x") ' '

>>> runParserWarn ws "x"
This ParserUncaught

>>> runParserWarn (ws `cut` "no whitespace") "x"
This (ParserError "no whitespace")

Constructors

ParserLeftover ByteString
ParserError String
ParserUncaught

Instances

Instances details

Generic ParserWarning Source #
Instance details Defined in MarkupParse.FlatParse Associated Types type Rep ParserWarning :: Type -> Type # Methods from :: ParserWarning -> Rep ParserWarning x # to :: Rep ParserWarning x -> ParserWarning #
Show ParserWarning Source #
Instance details Defined in MarkupParse.FlatParse Methods showsPrec :: Int -> ParserWarning -> ShowS # show :: ParserWarning -> String # showList :: [ParserWarning] -> ShowS #
NFData ParserWarning Source #
Instance details Defined in MarkupParse.FlatParse Methods rnf :: ParserWarning -> () #
Eq ParserWarning Source #
Instance details Defined in MarkupParse.FlatParse Methods (==) :: ParserWarning -> ParserWarning -> Bool # (/=) :: ParserWarning -> ParserWarning -> Bool #
Ord ParserWarning Source #
Instance details Defined in MarkupParse.FlatParse Methods compare :: ParserWarning -> ParserWarning -> Ordering # (<) :: ParserWarning -> ParserWarning -> Bool # (<=) :: ParserWarning -> ParserWarning -> Bool # (>) :: ParserWarning -> ParserWarning -> Bool # (>=) :: ParserWarning -> ParserWarning -> Bool # max :: ParserWarning -> ParserWarning -> ParserWarning # min :: ParserWarning -> ParserWarning -> ParserWarning #
type Rep ParserWarning Source #
Instance details Defined in MarkupParse.FlatParse type Rep ParserWarning = D1 ('MetaData "ParserWarning" "MarkupParse.FlatParse" "markup-parse-0.0.0.1-GA2U8ZeIh6M2mqhHjin8Vt" 'False) (C1 ('MetaCons "ParserLeftover" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ByteString)) :+: (C1 ('MetaCons "ParserError" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)) :+: C1 ('MetaCons "ParserUncaught" 'PrefixI 'False) (U1 :: Type -> Type)))

runParserMaybe :: Parser e a -> ByteString -> Maybe a Source #

run a Parser, throwing away leftovers. Nothing on Fail or Err.

>>> runParserMaybe ws "x"
Nothing

>>> runParserMaybe ws " x"
Just ' '

runParserEither :: Parser String a -> ByteString -> Either String a Source #

run a Parser, throwing away leftovers. Returns Left on Fail or Err.

>>> runParserEither ws " x"
Right ' '

runParserWarn :: Parser String a -> ByteString -> These ParserWarning a Source #

Run parser, returning leftovers and errors as ParserWarnings.

>>> runParserWarn ws " "
That ' '

>>> runParserWarn ws "x"
This ParserUncaught

>>> runParserWarn ws " x"
These (ParserLeftover "x") ' '

runParser_ :: Parser String a -> ByteString -> a Source #

Run parser, discards leftovers & throws an error on failure.

>>> runParser_ ws " "
' '

>>> runParser_ ws "x"
*** Exception: uncaught parse error
...

parsers

isWhitespace :: Char -> Bool Source #

\n \t \f \r and space

ws_ :: Parser e () Source #

Consume whitespace.

>>> runParser ws_ " \nx"
OK () "x"

>>> runParser ws_ "x"
OK () "x"

ws :: Parser e Char Source #

single whitespace

>>> runParser ws " \nx"
OK ' ' "\nx"

wss :: Parser e ByteString Source #

multiple whitespace

>>> runParser wss " \nx"
OK " \n" "x"

>>> runParser wss "x"
Fail

nota :: Char -> Parser e ByteString Source #

Parse whilst not a specific character

>>> runParser (nota 'x') "abcxyz"
OK "abc" "xyz"

isa :: (Char -> Bool) -> Parser e ByteString Source #

Parse whilst satisfying a predicate.

>>> runParser (isa (=='x')) "xxxabc"
OK "xxx" "abc"

sq :: ParserT st e () Source #

single quote

>>> runParserMaybe sq "'"
Just ()

dq :: ParserT st e () Source #

double quote

>>> runParserMaybe dq "\""
Just ()

wrappedDq :: Parser b ByteString Source #

A double-quoted string.

wrappedSq :: Parser b ByteString Source #

A single-quoted string.

wrappedQ :: Parser e ByteString Source #

A single-quoted or double-quoted string.

>>> runParserMaybe wrappedQ "\"quoted\""
Just "quoted"

>>> runParserMaybe wrappedQ "'quoted'"
Just "quoted"

wrappedQNoGuard :: Parser e a -> Parser e a Source #

A single-quoted or double-quoted wrapped parser.

>>> runParser (wrappedQNoGuard (many $ satisfy (/= '"'))) "\"name\""
OK "name" ""

Will consume quotes if the underlying parser does.

>>> runParser (wrappedQNoGuard (many anyChar)) "\"name\""
Fail

eq :: Parser e () Source #

xml production [25]

>>> runParserMaybe eq " = "
Just ()

>>> runParserMaybe eq "="
Just ()

sep :: Parser e s -> Parser e a -> Parser e [a] Source #

some with a separator

>>> runParser (sep ws (many (satisfy (/= ' ')))) "a b c"
OK ["a","b","c"] ""

bracketed :: Parser e b -> Parser e b -> Parser e a -> Parser e a Source #

parser bracketed by two other parsers

>>> runParser (bracketed ($(char '[')) ($(char ']')) (many (satisfy (/= ']')))) "[bracketed]"
OK "bracketed" ""

bracketedSB :: Parser e [Char] Source #

Bracketed by square brackets.

>>> runParser bracketedSB "[bracketed]"
OK "bracketed" ""

wrapped :: Parser e () -> Parser e a -> Parser e a Source #

parser wrapped by another parser

>>> runParser (wrapped ($(char '"')) (many (satisfy (/= '"')))) "\"wrapped\""
OK "wrapped" ""

int :: Parser e Int Source #

(unsigned) Int parser

>>> runParserMaybe int "567"
Just 567

double :: Parser e Double Source #

>>> runParser double "1.234x"
OK 1.234 "x"

>>> runParser double "."
Fail

>>> runParser double "123"
OK 123.0 ""

>>> runParser double ".123"
OK 0.123 ""

>>> runParser double "123."
OK 123.0 ""

signed :: Num b => Parser e b -> Parser e b Source #

>>> runParser (signed double) "-1.234x"
OK (-1.234) "x"

byteStringOf' :: Parser e a -> Parser e ByteString Source #

byteStringOf but using withSpan internally. Doesn't seems faster...