flatparse 0.3.4.0 → 0.3.5.0

raw patch · 8 files changed

+328/−170 lines, 8 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• bench/FPStateful.hs +6/−3
• flatparse.cabal +4/−4
• src/FlatParse/Basic.hs +161/−28
• src/FlatParse/Examples/BasicLambda/Lexer.hs +1/−1
• src/FlatParse/Examples/BasicLambda/Parser.hs +1/−1
• src/FlatParse/Internal/UnboxedNumerics.hs +2/−0
• src/FlatParse/Stateful.hs +130/−131
• test/Test.hs +23/−2

@@ -6,19 +6,22 @@  import FlatParse.Stateful +ws, open, close, ident, sexp, src :: Parser () () () ws      = many_ $(switch [| case _ of " " -> pure (); "\n" -> pure () |]) open    = $(char '(') >> ws close   = $(char ')') >> ws ident   = some_ (satisfyASCII_ isLatinLetter) >> ws sexp    = branch open (some_ sexp >> close) ident src     = sexp >> eof-runSexp = runParser src 0 0+runSexp = runParser src () 0 +longw, longws :: Parser () () () longw     = $(string "thisisalongkeyword") longws    = some_ (longw >> ws) >> eof-runLongws = runParser longws 0 0+runLongws = runParser longws () 0 +numeral, comma, numcsv :: Parser () () () numeral   = some_ (satisfyASCII_ isDigit) >> ws comma     = $(char ',') >> ws numcsv    = numeral >> many_ (comma >> numeral) >> eof-runNumcsv = runParser numcsv 0 0+runNumcsv = runParser numcsv () 0

@@ -5,7 +5,7 @@ -- see: https://github.com/sol/hpack  name:           flatparse-version:        0.3.4.0+version:        0.3.5.0 synopsis:       High-performance parsing from strict bytestrings description:    @Flatparse@ is a high-performance parsing library, focusing on programming languages and                 human-readable data formats. See the README for more information:@@ -73,7 +73,7 @@     , integer-gmp     , template-haskell   if flag(dump)-    ghc-options: -ddump-simpl -ddump-stg -ddump-cmm -dsuppress-all -dno-suppress-type-signatures -ddump-to-file+    ghc-options: -ddump-simpl -ddump-stg-final -ddump-cmm -dsuppress-all -dno-suppress-type-signatures -ddump-to-file   if flag(llvm)     ghc-options: -fllvm   default-language: Haskell2010@@ -107,7 +107,7 @@     , hspec     , quickcheck-instances   if flag(dump)-    ghc-options: -ddump-simpl -ddump-stg -ddump-cmm -dsuppress-all -dno-suppress-type-signatures -ddump-to-file+    ghc-options: -ddump-simpl -ddump-stg-final -ddump-cmm -dsuppress-all -dno-suppress-type-signatures -ddump-to-file   if flag(llvm)     ghc-options: -fllvm   default-language: Haskell2010@@ -148,7 +148,7 @@     , parsec     , primitive   if flag(dump)-    ghc-options: -ddump-simpl -ddump-stg -ddump-cmm -dsuppress-all -dno-suppress-type-signatures -ddump-to-file+    ghc-options: -ddump-simpl -ddump-stg-final -ddump-cmm -dsuppress-all -dno-suppress-type-signatures -ddump-to-file   if flag(llvm)     ghc-options: -fllvm   default-language: Haskell2010

@@ -3,6 +3,9 @@ {-| This module implements a `Parser` supporting custom error types.  If you need efficient indentation parsing, use "FlatParse.Stateful" instead.++Many internals are exposed for hacking on and extending. These are generally+denoted by a @#@ hash suffix. -}  module FlatParse.Basic (@@ -27,7 +30,7 @@   , try   , optional   , optional_-  , optioned+  , withOption   , cut   , cutting @@ -35,6 +38,7 @@   , eof   , takeBs   , takeRestBs+  , skip   , char   , byte   , bytes@@ -72,6 +76,7 @@   , FlatParse.Internal.isLatinLetter   , FlatParse.Basic.readInt   , FlatParse.Basic.readInteger+  , anyCString    -- ** Explicit-endianness machine integers   , anyWord16le@@ -106,9 +111,9 @@   , setPos   , endPos   , spanOf-  , spanned+  , withSpan   , byteStringOf-  , byteStringed+  , withByteString   , inSpan    -- ** Position and span conversions@@ -131,14 +136,19 @@    -- * Internal functions   , ensureBytes#-  , scan8#-  , scan16#-  , scan32#-  , scan64#-  , scanAny8#-  , scanBytes#++  -- ** Unboxed arguments+  , takeBs#+  , atSkip#++  -- *** Location & address primitives   , setBack#+  , withAddr#+  , takeBsOffAddr#+  , lookaheadFromAddr#+  , atAddr# +  -- ** Machine integer continuation parsers   , withAnyWord8#   , withAnyWord16#   , withAnyWord32#@@ -148,6 +158,15 @@   , withAnyInt32#   , withAnyInt64# +  -- ** Unsafe+  , anyCStringUnsafe+  , scan8#+  , scan16#+  , scan32#+  , scan64#+  , scanAny8#+  , scanBytes#+   ) where  import Control.Monad@@ -317,7 +336,7 @@   x      -> x {-# inline try #-} --- | Convert a parsing failure to a `Maybe`. If possible, use `optioned` instead.+-- | Convert a parsing failure to a `Maybe`. If possible, use `withOption` instead. optional :: Parser e a -> Parser e (Maybe a) optional p = (Just <$> p) <|> pure Nothing {-# inline optional #-}@@ -329,12 +348,12 @@  -- | CPS'd version of `optional`. This is usually more efficient, since it gets rid of the --   extra `Maybe` allocation.-optioned :: Parser e a -> (a -> Parser e b) -> Parser e b -> Parser e b-optioned (Parser f) just (Parser nothing) = Parser \fp eob s -> case f fp eob s of+withOption :: Parser e a -> (a -> Parser e b) -> Parser e b -> Parser e b+withOption (Parser f) just (Parser nothing) = Parser \fp eob s -> case f fp eob s of   OK# a s -> runParser# (just a) fp eob s   Fail#   -> nothing fp eob s   Err# e  -> Err# e-{-# inline optioned #-}+{-# inline withOption #-}  -- | Convert a parsing failure to an error. cut :: Parser e a -> e -> Parser e a@@ -367,12 +386,7 @@ -- -- Throws a runtime error if given a negative integer. takeBs :: Int -> Parser e B.ByteString-takeBs (I# n#) = Parser \fp eob s -> case n# <=# minusAddr# eob s of-  1# -> -- have to runtime check for negative values, because they cause a hang-    case n# >=# 0# of-      1# -> OK# (B.PS (ForeignPtr s fp) 0 (I# n#)) (plusAddr# s n#)-      _  -> error "FlatParse.Basic.take: negative integer"-  _  -> Fail#+takeBs (I# n#) = takeBs# n# {-# inline takeBs #-}  -- | Consume the rest of the input. May return the empty bytestring.@@ -382,6 +396,13 @@   in  OK# (B.PS (ForeignPtr s fp) 0 (I# n#)) eob {-# inline takeRestBs #-} +-- | Skip forward @n@ bytes. Fails if fewer than @n@ bytes are available.+--+-- Throws a runtime error if given a negative integer.+skip :: Int -> Parser e ()+skip (I# os#) = atSkip# os# (pure ())+{-# inline skip #-}+ -- | Parse a UTF-8 character literal. This is a template function, you can use it as --   @$(char \'x\')@, for example, and the splice in this case has type @Parser e ()@. char :: Char -> Q Exp@@ -780,14 +801,14 @@  -- | Bind the result together with the span of the result. CPS'd version of `spanOf` --   for better unboxing.-spanned :: Parser e a -> (a -> Span -> Parser e b) -> Parser e b-spanned (Parser f) g = Parser \fp eob s -> case f fp eob s of+withSpan :: Parser e a -> (a -> Span -> Parser e b) -> Parser e b+withSpan (Parser f) g = Parser \fp eob s -> case f fp eob s of   OK# a s' -> runParser# (g a (Span (addrToPos# eob s) (addrToPos# eob s'))) fp eob s'   x        -> unsafeCoerce# x-{-# inline spanned #-}+{-# inline withSpan #-}  -- | Return the `B.ByteString` consumed by a parser. Note: it's more efficient to use `spanOf` and---   `spanned` instead.+--   `withSpan` instead. byteStringOf :: Parser e a -> Parser e B.ByteString byteStringOf (Parser f) = Parser \fp eob s -> case f fp eob s of   OK# a s' -> OK# (B.PS (ForeignPtr s fp) 0 (I# (minusAddr# s' s))) s'@@ -795,17 +816,17 @@ {-# inline byteStringOf #-}  -- | CPS'd version of `byteStringOf`. Can be more efficient, because the result is more eagerly unboxed---   by GHC. It's more efficient to use `spanOf` or `spanned` instead.-byteStringed :: Parser e a -> (a -> B.ByteString -> Parser e b) -> Parser e b-byteStringed (Parser f) g = Parser \fp eob s -> case f fp eob s of+--   by GHC. It's more efficient to use `spanOf` or `withSpan` instead.+withByteString :: Parser e a -> (a -> B.ByteString -> Parser e b) -> Parser e b+withByteString (Parser f) g = Parser \fp eob s -> case f fp eob s of   OK# a s' -> runParser# (g a (B.PS (ForeignPtr s fp) 0 (I# (minusAddr# s' s)))) fp eob s'   x        -> unsafeCoerce# x-{-# inline byteStringed #-}+{-# inline withByteString #-}  -- | Run a parser in a given input span. The input position and the `Int` state is restored after --   the parser is finished, so `inSpan` does not consume input and has no side effect.  Warning: --   this operation may crash if the given span points outside the current parsing buffer. It's---   always safe to use `inSpan` if the span comes from a previous `spanned` or `spanOf` call on+--   always safe to use `inSpan` if the span comes from a previous `withSpan` or `spanOf` call on --   the current input. inSpan :: Span -> Parser e a -> Parser e a inSpan (Span s eob) (Parser f) = Parser \fp eob' s' ->@@ -1300,3 +1321,115 @@ anyInt64be :: Parser e Int64 anyInt64be = withAnyWord64# (\w# -> pure (I64# (word2Int# (byteSwap# w#)))) {-# inline anyInt64be #-}++--------------------------------------------------------------------------------++-- | Skip forward @n@ bytes and run the given parser. Fails if fewer than @n@+--   bytes are available.+--+-- Throws a runtime error if given a negative integer.+atSkip# :: Int# -> Parser e a -> Parser e a+atSkip# os# (Parser p) = Parser \fp eob s -> case os# <=# minusAddr# eob s of+  1# -> case os# >=# 0# of+    1# -> p fp eob (plusAddr# s os#)+    _  -> error "FlatParse.Basic.atSkip#: negative integer"+  _  -> Fail#+{-# inline atSkip# #-}++-- | Read the given number of bytes as a 'ByteString'.+--+-- Throws a runtime error if given a negative integer.+takeBs# :: Int# -> Parser e B.ByteString+takeBs# n# = Parser \fp eob s -> case n# <=# minusAddr# eob s of+  1# -> -- have to runtime check for negative values, because they cause a hang+    case n# >=# 0# of+      1# -> OK# (B.PS (ForeignPtr s fp) 0 (I# n#)) (plusAddr# s n#)+      _  -> error "FlatParse.Basic.takeBs: negative integer"+  _  -> Fail#+{-# inline takeBs# #-}++--------------------------------------------------------------------------------++-- | Run a parser, passing it the current address the parser is at.+--+-- Useful for parsing offset-based data tables. For example, you may use this to+-- save the base address to use together with various 0-indexed offsets.+withAddr# :: (Addr# -> Parser e a) -> Parser e a+withAddr# p = Parser \fp eob s -> runParser# (p s) fp eob s+{-# inline withAddr# #-}++-- | @takeBsOffAddr# addr# offset# len#@ moves to @addr#@, skips @offset#@+--   bytes, reads @len#@ bytes into a 'ByteString', and restores the original+--   address.+--+-- The 'Addr#' should be from 'withAddr#'.+--+-- Useful for parsing offset-based data tables. For example, you may use this+-- together with 'withAddr#' to jump to an offset in your input and read some+-- data.+takeBsOffAddr# :: Addr# -> Int# -> Int# -> Parser e B.ByteString+takeBsOffAddr# addr# offset# len# =+    lookaheadFromAddr# addr# $ atSkip# offset# $ takeBs# len#+{-# inline takeBsOffAddr# #-}++-- | 'lookahead', but specify the address to lookahead from.+--+-- The 'Addr#' should be from 'withAddr#'.+lookaheadFromAddr# :: Addr# -> Parser e a -> Parser e a+lookaheadFromAddr# s = lookahead . atAddr# s+{-# inline lookaheadFromAddr# #-}++-- | Run a parser at the given address.+--+-- The 'Addr#' should be from 'withAddr#'.+--+-- This is a highly internal function -- you likely want 'lookaheadFromAddr#',+-- which will reset the address after running the parser.+atAddr# :: Addr# -> Parser e a -> Parser e a+atAddr# s (Parser p) = Parser \fp eob _ -> p fp eob s+{-# inline atAddr# #-}++--------------------------------------------------------------------------------++-- | Read a null-terminated bytestring (a C-style string).+--+-- Consumes the null terminator.+anyCString :: Parser e B.ByteString+anyCString = Parser \fp eob s -> go' fp eob s+  where+    go' fp eob s0 = go 0# s0+      where+        go n# s = case eqAddr# eob s of+          1# -> Fail#+          _  ->+            let s' = plusAddr# s 1#+            -- TODO below is a candidate for improving with ExtendedLiterals!+            in  case eqWord8# (indexWord8OffAddr''# s 0#) (wordToWord8''# 0##) of+                  1# -> OK# (B.PS (ForeignPtr s0 fp) 0 (I# n#)) s'+                  _  -> go (n# +# 1#) s'+{-# inline anyCString #-}++-- | Read a null-terminated bytestring (a C-style string), where the bytestring+--   is known to be null-terminated somewhere in the input.+--+-- Highly unsafe. Unless you have a guarantee that the string will be null+-- terminated before the input ends, use 'anyCString' instead. Honestly, I'm not+-- sure if this is a good function to define. But here it is.+--+-- Fails on GHC versions older than 9.0, since we make use of the+-- 'cstringLength#' primop introduced in GHC 9.0, and we aren't very useful+-- without it.+--+-- Consumes the null terminator.+anyCStringUnsafe :: Parser e B.ByteString+{-# inline anyCStringUnsafe #-}+#if MIN_VERSION_base(4,15,0)+anyCStringUnsafe = Parser \fp eob s ->+  case eqAddr# eob s of+    1# -> Fail#+    _  -> let n#  = cstringLength# s+              s'# = plusAddr# s (n# +# 1#)+           in OK# (B.PS (ForeignPtr s fp) 0 (I# n#)) s'#+#else+anyCStringUnsafe = error "Flatparse.Basic.anyCStringUnsafe: requires GHC 9.0 / base-4.15, not available on this compiler"+#endif

@@ -117,7 +117,7 @@ -- | Parse a line comment. lineComment :: Parser () lineComment =-  optioned anyWord8+  withOption anyWord8     (\case 10 -> ws            _  -> lineComment)     (pure ())

@@ -49,7 +49,7 @@ --   keyword. ident :: Parser Name ident = token $ byteStringOf $-  spanned (identStartChar *> many_ identChar) (\_ span -> fails (isKeyword span))+  withSpan (identStartChar *> many_ identChar) (\_ span -> fails (isKeyword span))  -- | Parse an identifier, throw a precise error on failure. ident' :: Parser Name

@@ -109,5 +109,7 @@ extendWord8# w# = w# leWord8# :: Word8# -> Word8# -> Int# leWord8# w1# w2# = leWord# w1# w2#+eqWord8# :: Word8# -> Word8# -> Int#+eqWord8# w1# w2# = eqWord# w1# w2#  #endif

@@ -1,8 +1,8 @@ {-# language UnboxedTuples #-}  {-|-This module implements a `Parser` supporting an `Int` reader environment, custom error types, and an-`Int` state.+This module implements a `Parser` supporting a custom reader environment, custom+error types and an `Int` state. -}  module FlatParse.Stateful (@@ -33,7 +33,7 @@   , try   , optional   , optional_-  , optioned+  , withOption   , cut   , cutting @@ -112,9 +112,9 @@   , setPos   , endPos   , spanOf-  , spanned+  , withSpan   , byteStringOf-  , byteStringed+  , withByteString   , inSpan    -- ** Position and span conversions@@ -201,10 +201,10 @@ pattern Fail# = (# | (# #) | #) {-# complete OK#, Err#, Fail# #-} --- | @Parser e a@ has an error type @e@ and a return type @a@.-newtype Parser e a = Parser {runParser# :: ForeignPtrContents -> Int# -> Addr# -> Addr# -> Int# -> Res# e a}+-- | @Parser r e a@ has a reader environment @r@, error type @e@ and a return type @a@.+newtype Parser r e a = Parser {runParser# :: ForeignPtrContents -> r -> Addr# -> Addr# -> Int# -> Res# e a} -instance Functor (Parser e) where+instance Functor (Parser r e) where   fmap f (Parser g) = Parser \fp !r eob s n -> case g fp r eob s n of     OK# a s n -> let !b = f a in OK# b s n     x         -> unsafeCoerce# x@@ -215,7 +215,7 @@     x         -> unsafeCoerce# x   {-# inline (<$) #-} -instance Applicative (Parser e) where+instance Applicative (Parser r e) where   pure a = Parser \fp !r eob s n -> OK# a s n   {-# inline pure #-}   Parser ff <*> Parser fa = Parser \fp !r eob s n -> case ff fp r eob s n of@@ -235,7 +235,7 @@     x         -> unsafeCoerce# x   {-# inline (*>) #-} -instance Monad (Parser e) where+instance Monad (Parser r e) where   return = pure   {-# inline return #-}   Parser fa >>= f = Parser \fp !r eob s n -> case fa fp r eob s n of@@ -262,10 +262,9 @@  -------------------------------------------------------------------------------- --- | Run a parser. The first `Int` argument is the reader environment, while the second one is the---   state.-runParser :: Parser e a -> Int -> Int -> B.ByteString -> Result e a-runParser (Parser f) (I# r) (I# n) b@(B.PS (ForeignPtr _ fp) _ (I# len)) = unsafeDupablePerformIO do+-- | Run a parser. The `Int` argument is the initial state.+runParser :: Parser r e a -> r -> Int -> B.ByteString -> Result e a+runParser (Parser f) !r (I# n) b@(B.PS (ForeignPtr _ fp) _ (I# len)) = unsafeDupablePerformIO do   B.unsafeUseAsCString b \(Ptr buf) -> do     let end = plusAddr# buf len     case f fp r end buf n of@@ -281,54 +280,54 @@ -- | Run a parser on a `String` input. Reminder: @OverloadedStrings@ for `B.ByteString` does not --   yield a valid UTF-8 encoding! For non-ASCII `B.ByteString` literal input, use `runParserS` or --   `packUTF8` for testing.-runParserS :: Parser e a -> Int -> Int -> String -> Result e a+runParserS :: Parser r e a -> r -> Int -> String -> Result e a runParserS pa r !n s = runParser pa r n (packUTF8 s)  --------------------------------------------------------------------------------  -- | Query the `Int` state.-get :: Parser e Int+get :: Parser r e Int get = Parser \fp !r eob s n -> OK# (I# n) s n {-# inline get #-}  -- | Write the `Int` state.-put :: Int -> Parser e ()+put :: Int -> Parser r e () put (I# n) = Parser \fp !r eob s _ -> OK# () s n {-# inline put #-}  -- | Modify the `Int` state.-modify :: (Int -> Int) -> Parser e ()+modify :: (Int -> Int) -> Parser r e () modify f = Parser \fp !r eob s n ->   case f (I# n) of     I# n -> OK# () s n {-# inline modify #-} --- | Query the `Int` environment.-ask :: Parser e Int-ask = Parser \fp !r eob s n -> OK# (I# r) s n+-- | Query the environment.+ask :: Parser r e r+ask = Parser \fp !r eob s n -> OK# r s n {-# inline ask #-}  -- | Run a parser in a modified environment.-local :: (Int -> Int) -> Parser e a -> Parser e a-local f (Parser g) = Parser \fp !r eob s n -> let !(I# r') = f (I# r) in g fp r' eob s n+local :: (r -> r) -> Parser r e a -> Parser r e a+local f (Parser g) = Parser \fp !r eob s n -> let !r' = f r in g fp r' eob s n {-# inline local #-}  --------------------------------------------------------------------------------  -- | The failing parser. By default, parser choice `(<|>)` arbitrarily backtracks --   on parser failure.-empty :: Parser e a+empty :: Parser r e a empty = Parser \fp !r eob s n -> Fail# {-# inline empty #-}  -- | Throw a parsing error. By default, parser choice `(<|>)` can't backtrack --   on parser error. Use `try` to convert an error to a recoverable failure.-err :: e -> Parser e a+err :: e -> Parser r e a err e = Parser \fp !r eob s n -> Err# e {-# inline err #-}  -- | Save the parsing state, then run a parser, then restore the state.-lookahead :: Parser e a -> Parser e a+lookahead :: Parser r e a -> Parser r e a lookahead (Parser f) = Parser \fp !r eob s n ->   case f fp r eob s n of     OK# a _ _ -> OK# a s n@@ -336,7 +335,7 @@ {-# inline lookahead #-}  -- | Convert a parsing failure to a success.-fails :: Parser e a -> Parser e ()+fails :: Parser r e a -> Parser r e () fails (Parser f) = Parser \fp !r eob s n ->   case f fp r eob s n of     OK# _ _ _ -> Fail#@@ -345,33 +344,33 @@ {-# inline fails #-}  -- | Convert a parsing error into failure.-try :: Parser e a -> Parser e a+try :: Parser r e a -> Parser r e a try (Parser f) = Parser \fp !r eob s n -> case f fp r eob s n of   Err# _ -> Fail#   x      -> x {-# inline try #-} --- | Convert a parsing failure to a `Maybe`. If possible, use `optioned` instead.-optional :: Parser e a -> Parser e (Maybe a)+-- | Convert a parsing failure to a `Maybe`. If possible, use `withOption` instead.+optional :: Parser r e a -> Parser r e (Maybe a) optional p = (Just <$> p) <|> pure Nothing {-# inline optional #-}  -- | Convert a parsing failure to a `()`.-optional_ :: Parser e a -> Parser e ()+optional_ :: Parser r e a -> Parser r e () optional_ p = (() <$ p) <|> pure () {-# inline optional_ #-}  -- | CPS'd version of `optional`. This is usually more efficient, since it gets rid of the --   extra `Maybe` allocation.-optioned :: Parser e a -> (a -> Parser e b) -> Parser e b -> Parser e b-optioned (Parser f) just (Parser nothing) = Parser \fp !r eob s n -> case f fp r eob s n of+withOption :: Parser r e a -> (a -> Parser r e b) -> Parser r e b -> Parser r e b+withOption (Parser f) just (Parser nothing) = Parser \fp !r eob s n -> case f fp r eob s n of   OK# a s n -> runParser# (just a) fp r eob s n   Fail#     -> nothing fp r eob s n   Err# e    -> Err# e-{-# inline optioned #-}+{-# inline withOption #-}  -- | Convert a parsing failure to an error.-cut :: Parser e a -> e -> Parser e a+cut :: Parser r e a -> e -> Parser r e a cut (Parser f) e = Parser \fp !r eob s n -> case f fp r eob s n of   Fail# -> Err# e   x     -> x@@ -380,7 +379,7 @@ -- | Run the parser, if we get a failure, throw the given error, but if we get an error, merge the --   inner and the newly given errors using the @e -> e -> e@ function. This can be useful for --   implementing parsing errors which may propagate hints or accummulate contextual information.-cutting :: Parser e a -> e -> (e -> e -> e) -> Parser e a+cutting :: Parser r e a -> e -> (e -> e -> e) -> Parser r e a cutting (Parser f) e merge = Parser \fp !r eob s n -> case f fp r eob s n of   Fail#   -> Err# e   Err# e' -> let !e'' = merge e' e in Err# e''@@ -391,7 +390,7 @@   -- | Succeed if the input is empty.-eof :: Parser e ()+eof :: Parser r e () eof = Parser \fp !r eob s n -> case eqAddr# eob s of   1# -> OK# () s n   _  -> Fail#@@ -400,7 +399,7 @@ -- | Read the given number of bytes as a 'ByteString'. -- -- Throws a runtime error if given a negative integer.-takeBs :: Int -> Parser e B.ByteString+takeBs :: Int -> Parser r e B.ByteString takeBs (I# n#) = Parser \fp !r eob s n -> case n# <=# minusAddr# eob s of   1# -> -- have to runtime check for negative values, because they cause a hang     case n# >=# 0# of@@ -410,31 +409,31 @@ {-# inline takeBs #-}  -- | Consume the rest of the input. May return the empty bytestring.-takeRestBs :: Parser e B.ByteString+takeRestBs :: Parser r e B.ByteString takeRestBs = Parser \fp !r eob s n ->   let n# = minusAddr# eob s   in  OK# (B.PS (ForeignPtr s fp) 0 (I# n#)) eob n {-# inline takeRestBs #-}  -- | Parse a UTF-8 character literal. This is a template function, you can use it as---   @$(char \'x\')@, for example, and the splice in this case has type @Parser e ()@.+--   @$(char \'x\')@, for example, and the splice in this case has type @Parser r e ()@. char :: Char -> Q Exp char c = string [c]  -- | Read a byte.-byte :: Word8 -> Parser e ()+byte :: Word8 -> Parser r e () byte w = ensureBytes# 1 >> scan8# w {-# inline byte #-}  -- | Read a sequence of bytes. This is a template function, you can use it as @$(bytes [3, 4, 5])@,---   for example, and the splice has type @Parser e ()@.+--   for example, and the splice has type @Parser r e ()@. bytes :: [Word] -> Q Exp bytes bytes = do   let !len = length bytes   [| ensureBytes# len >> $(scanBytes# bytes) |]  -- | Parse a UTF-8 string literal. This is a template function, you can use it as @$(string "foo")@,---   for example, and the splice has type @Parser e ()@.+--   for example, and the splice has type @Parser r e ()@. string :: String -> Q Exp string str = bytes (strToBytes str) @@ -477,7 +476,7 @@  {-| Switch expression with an optional first argument for performing a post-processing action after-every successful branch matching. For example, if we have @ws :: Parser e ()@ for a+every successful branch matching. For example, if we have @ws :: Parser r e ()@ for a whitespace parser, we might want to consume whitespace after matching on any of the switch cases. For that case, we can define a "lexeme" version of `switch` as follows. @@ -505,14 +504,14 @@   genTrie $! genSwitchTrie' postAction cases fallback  -- | Parse a UTF-8 `Char` for which a predicate holds.-satisfy :: (Char -> Bool) -> Parser e Char+satisfy :: (Char -> Bool) -> Parser r e Char satisfy f = Parser \fp !r eob s n -> case runParser# anyChar fp r eob s n of   OK# c s n | f c -> OK# c s n   _               -> Fail# {-#  inline satisfy #-}  -- | Skip a UTF-8 `Char` for which a predicate holds.-satisfy_ :: (Char -> Bool) -> Parser e ()+satisfy_ :: (Char -> Bool) -> Parser r e () satisfy_ f = Parser \fp !r eob s n -> case runParser# anyChar fp r eob s n of   OK# c s n | f c -> OK# () s n   _               -> Fail#@@ -521,7 +520,7 @@ -- | Parse an ASCII `Char` for which a predicate holds. Assumption: the predicate must only return --   `True` for ASCII-range characters. Otherwise this function might read a 128-255 range byte, --   thereby breaking UTF-8 decoding.-satisfyASCII :: (Char -> Bool) -> Parser e Char+satisfyASCII :: (Char -> Bool) -> Parser r e Char satisfyASCII f = Parser \fp !r eob s n -> case eqAddr# eob s of   1# -> Fail#   _  -> case derefChar8# s of@@ -531,7 +530,7 @@  -- | Skip an ASCII `Char` for which a predicate holds.  Assumption: the --   predicate must only return `True` for ASCII-range characters.-satisfyASCII_ :: (Char -> Bool) -> Parser e ()+satisfyASCII_ :: (Char -> Bool) -> Parser r e () satisfyASCII_ f = () <$ satisfyASCII f {-# inline satisfyASCII_ #-} @@ -545,7 +544,7 @@ --   can do better with @fusedSatisfy isLatinLetter isLetter isLetter isLetter@, since here the --   `isLatinLetter` is inlined into the UTF-8 decoding, and it probably handles a great majority of --   all cases without accessing the character table.-fusedSatisfy :: (Char -> Bool) -> (Char -> Bool) -> (Char -> Bool) -> (Char -> Bool) -> Parser e Char+fusedSatisfy :: (Char -> Bool) -> (Char -> Bool) -> (Char -> Bool) -> (Char -> Bool) -> Parser r e Char fusedSatisfy f1 f2 f3 f4 = Parser \fp !r eob buf n -> case eqAddr# eob buf of   1# -> Fail#   _  -> case derefChar8# buf of@@ -587,12 +586,12 @@ {-# inline fusedSatisfy #-}  -- | Skipping variant of `fusedSatisfy`.-fusedSatisfy_ :: (Char -> Bool) -> (Char -> Bool) -> (Char -> Bool) -> (Char -> Bool) -> Parser e ()+fusedSatisfy_ :: (Char -> Bool) -> (Char -> Bool) -> (Char -> Bool) -> (Char -> Bool) -> Parser r e () fusedSatisfy_ f1 f2 f3 f4 = () <$ fusedSatisfy f1 f2 f3 f4 {-# inline fusedSatisfy_ #-}  -- | Parse any UTF-8-encoded `Char`.-anyChar :: Parser e Char+anyChar :: Parser r e Char anyChar = Parser \fp !r eob buf n -> case eqAddr# eob buf of   1# -> Fail#   _  -> case derefChar8# buf of@@ -627,7 +626,7 @@ {-# inline anyChar #-}  -- | Skip any UTF-8-encoded `Char`.-anyChar_ :: Parser e ()+anyChar_ :: Parser r e () anyChar_ = Parser \fp !r eob buf n -> case eqAddr# eob buf of   1# -> Fail#   _  -> case derefChar8# buf of@@ -648,7 +647,7 @@  -- | Parse any `Char` in the ASCII range, fail if the next input character is not in the range. --   This is more efficient than `anyChar` if we are only working with ASCII.-anyCharASCII :: Parser e Char+anyCharASCII :: Parser r e Char anyCharASCII = Parser \fp !r eob buf n -> case eqAddr# eob buf of   1# -> Fail#   _  -> case derefChar8# buf of@@ -659,20 +658,20 @@  -- | Skip any `Char` in the ASCII range. More efficient than `anyChar_` if we're working only with --   ASCII.-anyCharASCII_ :: Parser e ()+anyCharASCII_ :: Parser r e () anyCharASCII_ = () <$ anyCharASCII {-# inline anyCharASCII_ #-}  -- | Read an `Int` from the input, as a non-empty digit sequence. The `Int` may --   overflow in the result.-readInt :: Parser e Int+readInt :: Parser r e Int readInt = Parser \fp r eob s n -> case FlatParse.Internal.readInt eob s of   (# (##) | #)        -> Fail#   (# | (# i, s' #) #) -> OK# (I# i) s' n {-# inline readInt #-}  -- | Read an `Integer` from the input, as a non-empty digit sequence.-readInteger :: Parser e Integer+readInteger :: Parser r e Integer readInteger = Parser \fp r eob s n -> case FlatParse.Internal.readInteger fp eob s of   (# (##) | #)        -> Fail#   (# | (# i, s' #) #) -> OK# i s' n@@ -684,7 +683,7 @@ -- | Choose between two parsers. If the first parser fails, try the second one, but if the first one --   throws an error, propagate the error. infixr 6 <|>-(<|>) :: Parser e a -> Parser e a -> Parser e a+(<|>) :: Parser r e a -> Parser r e a -> Parser r e a (<|>) (Parser f) (Parser g) = Parser \fp !r eob s n ->   case f fp r eob s n of     Fail# -> g fp r eob s n@@ -694,7 +693,7 @@ -- | Branch on a parser: if the first argument succeeds, continue with the second, else with the third. --   This can produce slightly more efficient code than `(<|>)`. Moreover, `ḃranch` does not --   backtrack from the true/false cases.-branch :: Parser e a -> Parser e b -> Parser e b -> Parser e b+branch :: Parser r e a -> Parser r e b -> Parser r e b -> Parser r e b branch pa pt pf = Parser \fp !r eob s n -> case runParser# pa fp r eob s n of   OK# _ s n -> runParser# pt fp r eob s n   Fail#     -> runParser# pf fp r eob s n@@ -704,7 +703,7 @@ -- | An analogue of the list `foldl` function: first parse a @b@, then parse zero or more @a@-s, --   and combine the results in a left-nested way by the @b -> a -> b@ function. Note: this is not --   the usual `chainl` function from the parsec libraries!-chainl :: (b -> a -> b) -> Parser e b -> Parser e a -> Parser e b+chainl :: (b -> a -> b) -> Parser r e b -> Parser r e a -> Parser r e b chainl f start elem = start >>= go where   go b = do {!a <- elem; go $! f b a} <|> pure b {-# inline chainl #-}@@ -712,7 +711,7 @@ -- | An analogue of the list `foldr` function: parse zero or more @a@-s, terminated by a @b@, and --   combine the results in a right-nested way using the @a -> b -> b@ function. Note: this is not --   the usual `chainr` function from the parsec libraries!-chainr :: (a -> b -> b) -> Parser e a -> Parser e b -> Parser e b+chainr :: (a -> b -> b) -> Parser r e a -> Parser r e b -> Parser r e b chainr f (Parser elem) (Parser end) = go where   go = Parser \fp !r eob s n -> case elem fp r eob s n of     OK# a s n -> case runParser# go fp r eob s n of@@ -725,7 +724,7 @@ -- | Run a parser zero or more times, collect the results in a list. Note: for optimal performance, --   try to avoid this. Often it is possible to get rid of the intermediate list by using a --   combinator or a custom parser.-many :: Parser e a -> Parser e [a]+many :: Parser r e a -> Parser r e [a] many (Parser f) = go where   go = Parser \fp !r eob s n -> case f fp r eob s n of     OK# a s n -> case runParser# go fp r eob s n of@@ -736,7 +735,7 @@ {-# inline many #-}  -- | Skip a parser zero or more times.-many_ :: Parser e a -> Parser e ()+many_ :: Parser r e a -> Parser r e () many_ (Parser f) = go where   go = Parser \fp !r eob s n -> case f fp r eob s n of     OK# a s n -> runParser# go fp r eob s n@@ -747,18 +746,18 @@ -- | Run a parser one or more times, collect the results in a list. Note: for optimal performance, --   try to avoid this. Often it is possible to get rid of the intermediate list by using a --   combinator or a custom parser.-some :: Parser e a -> Parser e [a]+some :: Parser r e a -> Parser r e [a] some p = (:) <$> p <*> many p {-# inline some #-}  -- | Skip a parser one or more times.-some_ :: Parser e a -> Parser e ()+some_ :: Parser r e a -> Parser r e () some_ pa = pa >> many_ pa {-# inline some_ #-}  -- | Succeed if the first parser succeeds and the second one fails. The parsing --   state is restored to the point of the first argument's success.-notFollowedBy :: Parser e a -> Parser e b -> Parser e a+notFollowedBy :: Parser r e a -> Parser r e b -> Parser r e a notFollowedBy p1 p2 = p1 <* lookahead (fails p2) {-# inline notFollowedBy #-} @@ -766,7 +765,7 @@ --   isolated bytes must be consumed. -- -- Throws a runtime error if given a negative integer.-isolate :: Int -> Parser e a -> Parser e a+isolate :: Int -> Parser r e a -> Parser r e a isolate (I# n#) p = Parser \fp !r eob s n ->   let s' = plusAddr# s n#   in  case n# <=# minusAddr# eob s of@@ -784,14 +783,14 @@ --------------------------------------------------------------------------------  -- | Get the current position in the input.-getPos :: Parser e Pos+getPos :: Parser r e Pos getPos = Parser \fp !r eob s n -> OK# (addrToPos# eob s) s n {-# inline getPos #-}  -- | Set the input position. Warning: this can result in crashes if the position points outside the --   current buffer. It is always safe to `setPos` values which came from `getPos` with the current --   input.-setPos :: Pos -> Parser e ()+setPos :: Pos -> Parser r e () setPos s = Parser \fp !r eob _ n -> OK# () (posToAddr# eob s) n {-# inline setPos #-} @@ -801,8 +800,8 @@ {-# inline endPos #-}  --- | Return the consumed span of a parser. Use `spanned` if possible for better efficiency.-spanOf :: Parser e a -> Parser e Span+-- | Return the consumed span of a parser. Use `withSpan` if possible for better efficiency.+spanOf :: Parser r e a -> Parser r e Span spanOf (Parser f) = Parser \fp !r eob s n -> case f fp r eob s n of   OK# a s' n -> OK# (Span (addrToPos# eob s) (addrToPos# eob s')) s' n   x          -> unsafeCoerce# x@@ -810,31 +809,31 @@  -- | Bind the result together with the span of the result. CPS'd version of `spanOf` --   for better unboxing.-spanned :: Parser e a -> (a -> Span -> Parser e b) -> Parser e b-spanned (Parser f) g = Parser \fp !r eob s n -> case f fp r eob s n of+withSpan :: Parser r e a -> (a -> Span -> Parser r e b) -> Parser r e b+withSpan (Parser f) g = Parser \fp !r eob s n -> case f fp r eob s n of   OK# a s' n -> runParser# (g a (Span (addrToPos# eob s) (addrToPos# eob s'))) fp r eob s' n   x          -> unsafeCoerce# x-{-# inline spanned #-}+{-# inline withSpan #-}  -- | Return the `B.ByteString` consumed by a parser. Note: it's more efficient to use `spanOf` and---   `spanned` instead.-byteStringOf :: Parser e a -> Parser e B.ByteString+--   `withSpan` instead.+byteStringOf :: Parser r e a -> Parser r e B.ByteString byteStringOf (Parser f) = Parser \fp !r eob s n -> case f fp r eob s n of   OK# a s' n -> OK# (B.PS (ForeignPtr s fp) 0 (I# (minusAddr# s' s))) s' n   x          -> unsafeCoerce# x {-# inline byteStringOf #-}  -- | CPS'd version of `byteStringOf`. Can be more efficient, because the result is more eagerly unboxed---   by GHC. It's more efficient to use `spanOf` or `spanned` instead.-byteStringed :: Parser e a -> (a -> B.ByteString -> Parser e b) -> Parser e b-byteStringed (Parser f) g = Parser \fp !r eob s n -> case f fp r eob s n of+--   by GHC. It's more efficient to use `spanOf` or `withSpan` instead.+withByteString :: Parser r e a -> (a -> B.ByteString -> Parser r e b) -> Parser r e b+withByteString (Parser f) g = Parser \fp !r eob s n -> case f fp r eob s n of   OK# a s' n -> runParser# (g a (B.PS (ForeignPtr s fp) 0 (I# (minusAddr# s' s)))) fp r eob s' n   x          -> unsafeCoerce# x-{-# inline byteStringed #-}+{-# inline withByteString #-}  -- | Create a `B.ByteString` from a `Span`. The result is invalid is the `Span` points --   outside the current buffer, or if the `Span` start is greater than the end position.-unsafeSpanToByteString :: Span -> Parser e B.ByteString+unsafeSpanToByteString :: Span -> Parser r e B.ByteString unsafeSpanToByteString (Span l r) =   lookahead (setPos l >> byteStringOf (setPos r)) {-# inline unsafeSpanToByteString #-}@@ -843,9 +842,9 @@ -- | Run a parser in a given input span. The input position and the `Int` state is restored after --   the parser is finished, so `inSpan` does not consume input and has no side effect.  Warning: --   this operation may crash if the given span points outside the current parsing buffer. It's---   always safe to use `inSpan` if the span comes from a previous `spanned` or `spanOf` call on+--   always safe to use `inSpan` if the span comes from a previous `withSpan` or `spanOf` call on --   the current input.-inSpan :: Span -> Parser e a -> Parser e a+inSpan :: Span -> Parser r e a -> Parser r e a inSpan (Span s eob) (Parser f) = Parser \fp !r eob' s' n' ->   case f fp r (posToAddr# eob' eob) (posToAddr# eob' s) n' of     OK# a _ _ -> OK# a s' n'@@ -857,7 +856,7 @@  -- | Parse the rest of the current line as a `String`. Assumes UTF-8 encoding, --   throws an error if the encoding is invalid.-takeLine :: Parser e String+takeLine :: Parser r e String takeLine =   branch eof (pure "") do   c <- anyChar@@ -867,28 +866,28 @@  -- | Parse the rest of the current line as a `String`, but restore the parsing state. --   Assumes UTF-8 encoding. This can be used for debugging.-traceLine :: Parser e String+traceLine :: Parser r e String traceLine = lookahead takeLine  -- | Take the rest of the input as a `String`. Assumes UTF-8 encoding.-takeRest :: Parser e String+takeRest :: Parser r e String takeRest = ((:) <$> anyChar <*> takeRest) <|> pure []  -- | Get the rest of the input as a `String`, but restore the parsing state. Assumes UTF-8 encoding. --   This can be used for debugging.-traceRest :: Parser e String+traceRest :: Parser r e String traceRest = lookahead traceRest  --------------------------------------------------------------------------------  -- | Convert an UTF-8-coded `B.ByteString` to a `String`. unpackUTF8 :: B.ByteString -> String-unpackUTF8 str = case runParser takeRest 0 0 str of+unpackUTF8 str = case runParser takeRest () 0 str of   OK a _ _ -> a   _        -> error "unpackUTF8: invalid encoding"  -- | Check that the input has at least the given number of bytes.-ensureBytes# :: Int -> Parser e ()+ensureBytes# :: Int -> Parser r e () ensureBytes# (I# len) = Parser \fp !r eob s n ->   case len  <=# minusAddr# eob s of     1# -> OK# () s n@@ -897,7 +896,7 @@  -- | Unsafely read a concrete byte from the input. It's not checked that the input has --   enough bytes.-scan8# :: Word8 -> Parser e ()+scan8# :: Word8 -> Parser r e () scan8# (W8# c) = Parser \fp !r eob s n ->   case indexWord8OffAddr# s 0# of     c' -> case eqWord8'# c c' of@@ -907,7 +906,7 @@  -- | Unsafely read two concrete bytes from the input. It's not checked that the input has --   enough bytes.-scan16# :: Word16 -> Parser e ()+scan16# :: Word16 -> Parser r e () scan16# (W16# c) = Parser \fp !r eob s n ->   case indexWord16OffAddr# s 0# of     c' -> case eqWord16'# c c' of@@ -917,7 +916,7 @@  -- | Unsafely read four concrete bytes from the input. It's not checked that the input has --   enough bytes.-scan32# :: Word32 -> Parser e ()+scan32# :: Word32 -> Parser r e () scan32# (W32# c) = Parser \fp !r eob s n ->   case indexWord32OffAddr# s 0# of     c' -> case eqWord32'# c c' of@@ -927,7 +926,7 @@  -- | Unsafely read eight concrete bytes from the input. It's not checked that the input has --   enough bytes.-scan64# :: Word -> Parser e ()+scan64# :: Word -> Parser r e () scan64# (W# c) = Parser \fp !r eob s n ->   case indexWord64OffAddr# s 0# of     c' -> case eqWord# c c' of@@ -936,11 +935,11 @@ {-# inline scan64# #-}  -- | Unsafely read and return a byte from the input. It's not checked that the input is non-empty.-scanAny8# :: Parser e Word8+scanAny8# :: Parser r e Word8 scanAny8# = Parser \fp !r eob s n -> OK# (W8# (indexWord8OffAddr# s 0#)) (plusAddr# s 1#) n {-# inline scanAny8# #-} -scanPartial64# :: Int -> Word -> Parser e ()+scanPartial64# :: Int -> Word -> Parser r e () scanPartial64# (I# len) (W# w) = Parser \fp !r eob s n ->   case indexWordOffAddr# s 0# of     w' -> case uncheckedIShiftL# (8# -# len) 3# of@@ -952,12 +951,12 @@ {-# inline scanPartial64# #-}  -- | Decrease the current input position by the given number of bytes.-setBack# :: Int -> Parser e ()+setBack# :: Int -> Parser r e () setBack# (I# i) = Parser \fp !r eob s n ->   OK# () (plusAddr# s (negateInt# i)) n {-# inline setBack# #-} --- | Template function, creates a @Parser e ()@ which unsafely scans a given+-- | Template function, creates a @Parser r e ()@ which unsafely scans a given --   sequence of bytes. scanBytes# :: [Word] -> Q Exp scanBytes# bytes = do@@ -1074,56 +1073,56 @@  -------------------------------------------------------------------------------- -withAnyWord8# :: (Word8'# -> Parser e a) -> Parser e a+withAnyWord8# :: (Word8'# -> Parser r e a) -> Parser r e a withAnyWord8# p = Parser \fp !r eob buf n -> case eqAddr# eob buf of   1# -> Fail#   _  -> case indexWord8OffAddr# buf 0# of     w# -> runParser# (p w#) fp r eob (plusAddr# buf 1#) n {-# inline withAnyWord8# #-} -withAnyWord16# :: (Word16'# -> Parser e a) -> Parser e a+withAnyWord16# :: (Word16'# -> Parser r e a) -> Parser r e a withAnyWord16# p = Parser \fp !r eob buf n -> case 2# <=# minusAddr# eob buf of   0# -> Fail#   _  -> case indexWord16OffAddr# buf 0# of     w# -> runParser# (p w#) fp r eob (plusAddr# buf 2#) n {-# inline withAnyWord16# #-} -withAnyWord32# :: (Word32'# -> Parser e a) -> Parser e a+withAnyWord32# :: (Word32'# -> Parser r e a) -> Parser r e a withAnyWord32# p = Parser \fp !r eob buf n -> case 4# <=# minusAddr# eob buf of   0# -> Fail#   _  -> case indexWord32OffAddr# buf 0# of     w# -> runParser# (p w#) fp r eob (plusAddr# buf 4#) n {-# inline withAnyWord32# #-} -withAnyWord64# :: (Word# -> Parser e a) -> Parser e a+withAnyWord64# :: (Word# -> Parser r e a) -> Parser r e a withAnyWord64# p = Parser \fp !r eob buf n -> case 8# <=# minusAddr# eob buf of   0# -> Fail#   _  -> case indexWordOffAddr# buf 0# of     w# -> runParser# (p w#) fp r eob (plusAddr# buf 8#) n {-# inline withAnyWord64# #-} -withAnyInt8# :: (Int8'# -> Parser e a) -> Parser e a+withAnyInt8# :: (Int8'# -> Parser r e a) -> Parser r e a withAnyInt8# p = Parser \fp !r eob buf n -> case eqAddr# eob buf of   1# -> Fail#   _  -> case indexInt8OffAddr# buf 0# of     i# -> runParser# (p i#) fp r eob (plusAddr# buf 1#) n {-# inline withAnyInt8# #-} -withAnyInt16# :: (Int16'# -> Parser e a) -> Parser e a+withAnyInt16# :: (Int16'# -> Parser r e a) -> Parser r e a withAnyInt16# p = Parser \fp !r eob buf n -> case 2# <=# minusAddr# eob buf of   0# -> Fail#   _  -> case indexInt16OffAddr# buf 0# of     i# -> runParser# (p i#) fp r eob (plusAddr# buf 2#) n {-# inline withAnyInt16# #-} -withAnyInt32# :: (Int32'# -> Parser e a) -> Parser e a+withAnyInt32# :: (Int32'# -> Parser r e a) -> Parser r e a withAnyInt32# p = Parser \fp !r eob buf n -> case 4# <=# minusAddr# eob buf of   0# -> Fail#   _  -> case indexInt32OffAddr# buf 0# of     i# -> runParser# (p i#) fp r eob (plusAddr# buf 4#) n {-# inline withAnyInt32# #-} -withAnyInt64# :: (Int# -> Parser e a) -> Parser e a+withAnyInt64# :: (Int# -> Parser r e a) -> Parser r e a withAnyInt64# p = Parser \fp !r eob buf n -> case 8# <=# minusAddr# eob buf of   0# -> Fail#   _  -> case indexInt64OffAddr# buf 0# of@@ -1133,142 +1132,142 @@ --------------------------------------------------------------------------------  -- | Parse any 'Word8' (byte).-anyWord8 :: Parser e Word8+anyWord8 :: Parser r e Word8 anyWord8 = withAnyWord8# (\w# -> pure (W8# w#)) {-# inline anyWord8 #-}  -- | Skip any 'Word8' (byte).-anyWord8_ :: Parser e ()+anyWord8_ :: Parser r e () anyWord8_ = () <$ anyWord8 {-# inline anyWord8_ #-}  -- | Parse any 'Word16'.-anyWord16 :: Parser e Word16+anyWord16 :: Parser r e Word16 anyWord16 = withAnyWord16# (\w# -> pure (W16# w#)) {-# inline anyWord16 #-}  -- | Skip any 'Word16'.-anyWord16_ :: Parser e ()+anyWord16_ :: Parser r e () anyWord16_ = () <$ anyWord16 {-# inline anyWord16_ #-}  -- | Parse any 'Word32'.-anyWord32 :: Parser e Word32+anyWord32 :: Parser r e Word32 anyWord32 = withAnyWord32# (\w# -> pure (W32# w#)) {-# inline anyWord32 #-}  -- | Skip any 'Word32'.-anyWord32_ :: Parser e ()+anyWord32_ :: Parser r e () anyWord32_ = () <$ anyWord32 {-# inline anyWord32_ #-}  -- | Parse any 'Word64'.-anyWord64 :: Parser e Word64+anyWord64 :: Parser r e Word64 anyWord64 = withAnyWord64# (\w# -> pure (W64# w#)) {-# inline anyWord64 #-}  -- | Skip any 'Word64'.-anyWord64_ :: Parser e ()+anyWord64_ :: Parser r e () anyWord64_ = () <$ anyWord64 {-# inline anyWord64_ #-}  -- | Parse any 'Word'.-anyWord :: Parser e Word+anyWord :: Parser r e Word anyWord = withAnyWord64# (\w# -> pure (W# w#)) {-# inline anyWord #-}  -- | Skip any 'Word'.-anyWord_ :: Parser e ()+anyWord_ :: Parser r e () anyWord_ = () <$ anyWord {-# inline anyWord_ #-}  --------------------------------------------------------------------------------  -- | Parse any 'Int8'.-anyInt8 :: Parser e Int8+anyInt8 :: Parser r e Int8 anyInt8 = withAnyInt8# (\i# -> pure (I8# i#)) {-# inline anyInt8 #-}  -- | Parse any 'Int16'.-anyInt16 :: Parser e Int16+anyInt16 :: Parser r e Int16 anyInt16 = withAnyInt16# (\i# -> pure (I16# i#)) {-# inline anyInt16 #-}  -- | Parse any 'Int32'.-anyInt32 :: Parser e Int32+anyInt32 :: Parser r e Int32 anyInt32 = withAnyInt32# (\i# -> pure (I32# i#)) {-# inline anyInt32 #-}  -- | Parse any 'Int64'.-anyInt64 :: Parser e Int64+anyInt64 :: Parser r e Int64 anyInt64 = withAnyInt64# (\i# -> pure (I64# i#)) {-# inline anyInt64 #-}  -- | Parse any 'Int'.-anyInt :: Parser e Int+anyInt :: Parser r e Int anyInt = withAnyInt64# (\i# -> pure (I# i#)) {-# inline anyInt #-}  --------------------------------------------------------------------------------  -- | Parse any 'Word16' (little-endian).-anyWord16le :: Parser e Word16+anyWord16le :: Parser r e Word16 anyWord16le = anyWord16 {-# inline anyWord16le #-}  -- | Parse any 'Word16' (big-endian).-anyWord16be :: Parser e Word16+anyWord16be :: Parser r e Word16 anyWord16be = withAnyWord16# (\w# -> pure (W16# (byteSwap16'# w#))) {-# inline anyWord16be #-}  -- | Parse any 'Word32' (little-endian).-anyWord32le :: Parser e Word32+anyWord32le :: Parser r e Word32 anyWord32le = anyWord32 {-# inline anyWord32le #-}  -- | Parse any 'Word32' (big-endian).-anyWord32be :: Parser e Word32+anyWord32be :: Parser r e Word32 anyWord32be = withAnyWord32# (\w# -> pure (W32# (byteSwap32'# w#))) {-# inline anyWord32be #-}  -- | Parse any 'Word64' (little-endian).-anyWord64le :: Parser e Word64+anyWord64le :: Parser r e Word64 anyWord64le = anyWord64 {-# inline anyWord64le #-}  -- | Parse any 'Word64' (big-endian).-anyWord64be :: Parser e Word64+anyWord64be :: Parser r e Word64 anyWord64be = withAnyWord64# (\w# -> pure (W64# (byteSwap# w#))) {-# inline anyWord64be #-}  --------------------------------------------------------------------------------  -- | Parse any 'Int16' (little-endian).-anyInt16le :: Parser e Int16+anyInt16le :: Parser r e Int16 anyInt16le = anyInt16 {-# inline anyInt16le #-}  -- | Parse any 'Int16' (big-endian).-anyInt16be :: Parser e Int16+anyInt16be :: Parser r e Int16 anyInt16be = withAnyWord16# (\w# -> pure (I16# (word16ToInt16# (byteSwap16'# w#)))) {-# inline anyInt16be #-}  -- | Parse any 'Int32' (little-endian).-anyInt32le :: Parser e Int32+anyInt32le :: Parser r e Int32 anyInt32le = anyInt32 {-# inline anyInt32le #-}  -- | Parse any 'Int32' (big-endian).-anyInt32be :: Parser e Int32+anyInt32be :: Parser r e Int32 anyInt32be = withAnyWord32# (\w# -> pure (I32# (word32ToInt32# (byteSwap32'# w#)))) {-# inline anyInt32be #-}  -- | Parse any 'Int64' (little-endian).-anyInt64le :: Parser e Int64+anyInt64le :: Parser r e Int64 anyInt64le = anyInt64 {-# inline anyInt64le #-}  -- | Parse any 'Int64' (big-endian).-anyInt64be :: Parser e Int64+anyInt64be :: Parser r e Int64 anyInt64be = withAnyWord64# (\w# -> pure (I64# (word2Int# (byteSwap# w#)))) {-# inline anyInt64be #-}

@@ -53,8 +53,8 @@       it "can succeed when argument missing" $ optional empty `shouldParse` ""       it "propagates errors" $ optional (err "nope") `shouldParseErr` "" -    describe "optioned" $ do-      let opt p = optioned p (pure . reverse) (pure "bar")+    describe "withOption" $ do+      let opt p = withOption p (pure . reverse) (pure "bar")       it "handles success" $ opt (pure "foo") `shouldParseWith` ("", "oof")       it "handles failure" $ opt empty `shouldParseWith` ("", "bar")       it "handles error" $ opt (err "nope") `shouldParseErr` ""@@ -78,6 +78,11 @@       it "succeeds at end of file" $ eof `shouldParse` ""       it "fails with more input" $ eof `shouldParseFail` "more" +    describe "skip" $ do+      prop "skips to the end of input" $+        \(bs :: ByteString) ->+          (skip (B.length bs) >> eof) `shouldParse` bs+     describe "char" $ do       it "succeeds on that char" $ $(char 'a') `shouldParse` "a"       it "succeeds on multibyte char" $ $(char 'ȩ') `shouldParse` packUTF8 "ȩ"@@ -396,6 +401,13 @@       it "fails on negative integers" $ readInteger `shouldParseFail` "-5"       it "fails on empty input" $ readInteger `shouldParseFail` "" +    describe "anyCString" $ do+      prop "parses arbitrary null-terminated bytestrings" $+        \(bs :: ByteString) ->+          let bs' = B.snoc bs 0x00+              expected = B.takeWhile (/= 0x00) bs'+          in  anyCString `shouldParsePartialWith` (bs', expected)+     describe "Explicit-endianness machine integers" $ do       describe "Unsigned" $ do         prop "parses Word8s" $ do@@ -605,6 +617,15 @@      describe "unpackUTF8" $ do       pure ()++  describe "Location & address primitives" $ do+    it "valid lookaheadFromAddr# usage succeeds" $ do+      -- use Int#/Int64# directly because Word8# -> Int# is annoying on old GHCs+      let bs = B.pack [ 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00+                      , 0xFF, 0x31, 0x32, 0x33, 0x00, 0xFF]+          p = withAddr# $ \addr# -> withAnyInt64# $ \os# ->+                  lookaheadFromAddr# addr# $ atSkip# os# $ anyCString+      p `shouldParsePartialWith` (bs, "123")  --------------------------------------------------------------------------------