Jordan.FromJSON.Internal.UnboxedParser

A parser module using unboxed types for speed.

This is done because parsing to a JSON error report needs custom handling.

Documentation

type WordPrim = Word#

Type of word8 in GHC prim land. On the GHC 8 series, this is Word#.

newtype InputState

Newtype wrapper around the state of an input.

This is just the offset into the buffer.

Constructors

InputState#

Fields

• getInputOffset :: Int#

pattern InputState :: Int# -> InputState

Pattern synonym so we can use our above unlifted newtype like a record, if we do desire.

maxOffset :: InputState -> InputState -> InputState

newtype InputRead

Environment of a parser.

This is basically unpacked parts of a ByteString.

Constructors

InputRead#

Fields

• getInputRead :: (# ForeignPtrContents, Addr#, Int# #)

pattern InputRead :: ForeignPtrContents -> Addr# -> Int# -> InputRead

newtype AccumE err a

Unboxed type similar to AccumE.

Constructors

AccumE

Fields

• getAccumE :: (# err | a #)

pattern AccumER :: a -> AccumE err a

pattern AccumEL :: err -> AccumE err a

newtype ParseResult# err res

Constructors

ParseResult#

Fields

• getParseResult# :: (# (# InputState, AccumE err res #) | (# #) #)

pattern JustParseResult :: InputState -> AccumE err res -> ParseResult# err res

pattern NoParseResult :: ParseResult# err res

bimapAcc :: (err -> err') -> (a -> a') -> AccumE err a -> AccumE err' a'

eitherAcc :: Either err a -> AccumE err a

appAcc :: Semigroup err => AccumE err (a1 -> a2) -> AccumE err a1 -> AccumE err a2

accSet :: a1 -> AccumE err a2 -> AccumE err a1

newtype Parser# s err res

We need a parser with *error recovery*. So the basic idea is that we separate errors reported during parsing from errors that make parsing stop. IE, if we expect a JSON null but we get a JSON string, and the string is well-formed, we can keep parsing, but we will *report* an error.

Constructors

Parser#

Fields

• runParser :: InputRead -> InputState -> State# s -> (# State# s, ParseResult# err res #)

bimapParser :: (err -> err') -> (a -> a') -> Parser# s err a -> Parser# s err' a'

fmapParser :: (a -> res) -> Parser# s err a -> Parser# s err res

pureParser :: Semigroup err => a -> Parser# s err a

apParser :: Semigroup err => Parser# s err (a -> b) -> Parser# s err a -> Parser# s err b

altParser :: Monoid err => Parser# s err a -> Parser# s err a -> Parser# s err a

Alternative instance for a parser. This has weird behavior in that, if we have two results with delayed errors, this will act as if it skipped the *largest* amount of said errors.

bindParser :: Parser# s err a -> (a -> Parser# s err b) -> Parser# s err b

Monadic bind for these parsers.

Note that this breaks the monad laws, as we do more error accumulation with (*) than we do ap. Oh well.

emptyParser :: Parser# s err a

newtype Parser err res

Constructors

Parser

Fields

• getParser :: Parser# RealWorld err res

Instances

Bifunctor Parser

Defined in Jordan.FromJSON.Internal.UnboxedParser

Methods

bimap :: (a -> b) -> (c -> d) -> Parser a c -> Parser b d

first :: (a -> b) -> Parser a c -> Parser b c

second :: (b -> c) -> Parser a b -> Parser a c

Semigroup err => Monad (Parser err)

Defined in Jordan.FromJSON.Internal.UnboxedParser

Methods

(>>=) :: Parser err a -> (a -> Parser err b) -> Parser err b

(>>) :: Parser err a -> Parser err b -> Parser err b

return :: a -> Parser err a

Functor (Parser err)

Defined in Jordan.FromJSON.Internal.UnboxedParser

Methods

fmap :: (a -> b) -> Parser err a -> Parser err b

(<$) :: a -> Parser err b -> Parser err a

Semigroup err => Applicative (Parser err)

Defined in Jordan.FromJSON.Internal.UnboxedParser

Methods

pure :: a -> Parser err a

(<*>) :: Parser err (a -> b) -> Parser err a -> Parser err b

liftA2 :: (a -> b -> c) -> Parser err a -> Parser err b -> Parser err c

(*>) :: Parser err a -> Parser err b -> Parser err b

(<*) :: Parser err a -> Parser err b -> Parser err a

Monoid err => Alternative (Parser err)

Defined in Jordan.FromJSON.Internal.UnboxedParser

Methods

empty :: Parser err a

(<|>) :: Parser err a -> Parser err a -> Parser err a

some :: Parser err a -> Parser err [a]

many :: Parser err a -> Parser err [a]

Monoid err => Semigroup (Parser err res)

Defined in Jordan.FromJSON.Internal.UnboxedParser

Methods

(<>) :: Parser err res -> Parser err res -> Parser err res

sconcat :: NonEmpty (Parser err res) -> Parser err res

stimes :: Integral b => b -> Parser err res -> Parser err res

Monoid err => Monoid (Parser err res)

Defined in Jordan.FromJSON.Internal.UnboxedParser

Methods

mempty :: Parser err res

mappend :: Parser err res -> Parser err res -> Parser err res

mconcat :: [Parser err res] -> Parser err res

parseBSIO :: Parser err res -> ByteString -> IO (Maybe (AccumE err res))

parseBS :: Parser err res -> ByteString -> Maybe (AccumE err res)

currentOffset :: Parser err Int

getEndOffset :: Parser err Int

parsedPtr :: Parser err (ForeignPtr Word8)

currentEnv :: Parser err (ForeignPtrContents, Ptr a, Int)

failParse :: Parser err a

maybeWord :: Parser err (Maybe Word8)

orFail :: Parser err (Maybe a) -> Parser err a

failWith :: err -> Parser err a

asFailure :: Parser err err -> Parser err a

lowerErr :: Parser err (Either err a) -> Parser err a

Lower a parsed error to a *parser error*.

hasFurther :: Parser err Bool

Do we have any further input?

advanceWord :: Parser err ()

Advance forward one word, fail if we can't

peekWord :: Parser err Word8

Peek the next word, fail if there's nothing there

peekWordMaybe :: Parser err (Maybe Word8)

Peek a word, or nothing. Never fails.

word :: Parser err Word8

specificWord :: Word8 -> Parser err ()

skipWord8# :: (WordPrim -> Bool) -> Parser err ()

Skip over while the callback returns true.

Unlifted version, probably use skipWord8

skipWord8 :: (Word8 -> Bool) -> Parser err ()

Skip over while the callback returns true

skipWord8CB# :: (WordPrim -> Bool) -> InputRead -> InputState -> State# RealWorld -> (# State# RealWorld, ParseResult# err () #)

Private: callback used for skipWord8

skipWhitespace :: Parser err ()

skipWhitespaceCB :: InputRead -> InputState -> State# RealWorld -> (# State# RealWorld, ParseResult# err () #)

signed :: (Monoid err, Num a) => Parser err a -> Parser err a

orNegative :: (Monoid err, Num a) => Parser err a -> Parser err a

parseIntegral :: forall err i. (Monoid err, Integral i) => Parser err (Int, i)

Parse an integral number with possible leading zeros.

parseIntegralNoLeadingZero :: forall err i. (Monoid err, Integral i) => Parser err (Int, i)

parseIntegralGo :: (Monoid err, Integral i) => Int -> i -> Parser err (Int, i)

takeWord8Cont :: Semigroup err => (Word8 -> Bool) -> (ByteString -> a) -> Parser err a

takeWord8 :: Semigroup err => (Word8 -> Bool) -> Parser err ByteString

takeWord81 :: Semigroup err => (Word8 -> Bool) -> Parser err ByteString

takeWord81Cont :: Semigroup err => (Word8 -> Bool) -> (ByteString -> b) -> Parser err b

peekRest :: Semigroup err => Parser err ByteString

chunkOfLength :: Int -> Parser err ByteString

parseChunk :: ByteString -> Parser err ()

testParser :: Parser () (Word8, ByteString)