MarkupParse.FlatParse

Various flatparse helpers and combinators.

Parsing

data ParserWarning

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 ByteString

ParserUncaught

Instances

Generic ParserWarning

Defined in MarkupParse.FlatParse

Associated Types

type Rep ParserWarning :: Type -> Type

Methods

from :: ParserWarning -> Rep ParserWarning x

to :: Rep ParserWarning x -> ParserWarning

Show ParserWarning

Defined in MarkupParse.FlatParse

Methods

showsPrec :: Int -> ParserWarning -> ShowS

show :: ParserWarning -> String

showList :: [ParserWarning] -> ShowS

NFData ParserWarning

Defined in MarkupParse.FlatParse

Methods

rnf :: ParserWarning -> ()

Eq ParserWarning

Defined in MarkupParse.FlatParse

Methods

(==) :: ParserWarning -> ParserWarning -> Bool

(/=) :: ParserWarning -> ParserWarning -> Bool

Ord ParserWarning

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

Defined in MarkupParse.FlatParse

type Rep ParserWarning = D1 ('MetaData "ParserWarning" "MarkupParse.FlatParse" "markup-parse-0.1.1-BdYhv7KNpuBDovL7j9hJZ4" '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 ByteString)) :+: C1 ('MetaCons "ParserUncaught" 'PrefixI 'False) (U1 :: Type -> Type)))

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

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

>>> runParserMaybe ws "x"
Nothing

>>> runParserMaybe ws " x"
Just ' '

runParserEither :: IsString e => Parser e a -> ByteString -> Either e a

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

>>> runParserEither ws " x"
Right ' '

runParserWarn :: Parser ByteString a -> ByteString -> These ParserWarning a

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

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

>>> runParser_ ws " "
' '

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

Flatparse re-exports

runParser :: Parser e a -> ByteString -> Result e a

Run a parser.

type Parser = ParserT PureMode

The type of pure parsers.

data Result e a

Higher-level boxed data type for parsing results.

Constructors

OK a !ByteString

Contains return value and unconsumed input.

Fail

Recoverable-by-default failure.

Err !e

Unrecoverble-by-default error.

Instances

Functor (Result e)

Defined in FlatParse.Basic

Methods

fmap :: (a -> b) -> Result e a -> Result e b

(<$) :: a -> Result e b -> Result e a

(Show a, Show e) => Show (Result e a)

Defined in FlatParse.Basic

Methods

showsPrec :: Int -> Result e a -> ShowS

show :: Result e a -> String

showList :: [Result e a] -> ShowS

Parsers

isWhitespace :: Char -> Bool

\n \t \f \r and space

ws_ :: Parser e ()

Consume whitespace.

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

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

ws :: Parser e Char

single whitespace

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

wss :: Parser e ByteString

multiple whitespace

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

>>> runParser wss "x"
Fail

nota :: Char -> Parser e ByteString

Parse whilst not a specific character

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

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

Parse whilst satisfying a predicate.

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

sq :: ParserT st e ()

Single quote

>>> runParserMaybe sq "'"
Just ()

dq :: ParserT st e ()

Double quote

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

wrappedDq :: Parser b ByteString

A double-quoted string.

wrappedSq :: Parser b ByteString

A single-quoted string.

wrappedQ :: Parser e ByteString

A single-quoted or double-quoted string.

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

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

wrappedQNoGuard :: Parser e a -> Parser e a

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 ()

xml production [25]

>>> runParserMaybe eq " = "
Just ()

>>> runParserMaybe eq "="
Just ()

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

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

Parser bracketed by two other parsers.

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

bracketedSB :: Parser e [Char]

Parser bracketed by square brackets.

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

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

Parser wrapped by another parser.

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

digit :: Parser e Int

A single digit

>>> runParserMaybe digit "5"
Just 5

int :: Parser e Int

An (unsigned) Int parser

>>> runParserMaybe int "567"
Just 567

double :: Parser e Double

A Double parser.

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

Parser for a signed prefix to a number.

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

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

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

comma :: Parser e ()

Comma parser

>>> runParserMaybe comma ","
Just ()