{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE BlockArguments #-}
module Binrep.Get.Flatparse
( Getter, Get(..), runGet, runGetter
, E(..), EBase(..), EGeneric(..), EGenericSum(..)
, eBase
, getEBase
, getGenericNonSum, getGenericSum
) where
import FlatParse.Basic qualified as FP
import Data.ByteString qualified as B
import Binrep.Util.Class
import GHC.TypeLits ( TypeError )
import Data.Void
import Data.Word
import Data.Int
import Bytezap
import Bytezap.Bytes qualified as BZ
import Data.Text ( Text )
import Numeric.Natural
import GHC.Generics
import Generic.Data.Function.Traverse
import Generic.Data.Function.Common
import Generic.Data.Rep.Assert
import GHC.Exts ( minusAddr#, Int(I#) )
type Getter a = FP.Parser E a
data E
= E Int EMiddle
| EFail
deriving stock (E -> E -> Bool
(E -> E -> Bool) -> (E -> E -> Bool) -> Eq E
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: E -> E -> Bool
== :: E -> E -> Bool
$c/= :: E -> E -> Bool
/= :: E -> E -> Bool
Eq, Int -> E -> ShowS
[E] -> ShowS
E -> String
(Int -> E -> ShowS) -> (E -> String) -> ([E] -> ShowS) -> Show E
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> E -> ShowS
showsPrec :: Int -> E -> ShowS
$cshow :: E -> String
show :: E -> String
$cshowList :: [E] -> ShowS
showList :: [E] -> ShowS
Show, (forall x. E -> Rep E x) -> (forall x. Rep E x -> E) -> Generic E
forall x. Rep E x -> E
forall x. E -> Rep E x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. E -> Rep E x
from :: forall x. E -> Rep E x
$cto :: forall x. Rep E x -> E
to :: forall x. Rep E x -> E
Generic)
data EMiddle
= EBase EBase
| EAnd E EBase
| EGeneric String (EGeneric E)
deriving stock (EMiddle -> EMiddle -> Bool
(EMiddle -> EMiddle -> Bool)
-> (EMiddle -> EMiddle -> Bool) -> Eq EMiddle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EMiddle -> EMiddle -> Bool
== :: EMiddle -> EMiddle -> Bool
$c/= :: EMiddle -> EMiddle -> Bool
/= :: EMiddle -> EMiddle -> Bool
Eq, Int -> EMiddle -> ShowS
[EMiddle] -> ShowS
EMiddle -> String
(Int -> EMiddle -> ShowS)
-> (EMiddle -> String) -> ([EMiddle] -> ShowS) -> Show EMiddle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EMiddle -> ShowS
showsPrec :: Int -> EMiddle -> ShowS
$cshow :: EMiddle -> String
show :: EMiddle -> String
$cshowList :: [EMiddle] -> ShowS
showList :: [EMiddle] -> ShowS
Show, (forall x. EMiddle -> Rep EMiddle x)
-> (forall x. Rep EMiddle x -> EMiddle) -> Generic EMiddle
forall x. Rep EMiddle x -> EMiddle
forall x. EMiddle -> Rep EMiddle x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. EMiddle -> Rep EMiddle x
from :: forall x. EMiddle -> Rep EMiddle x
$cto :: forall x. Rep EMiddle x -> EMiddle
to :: forall x. Rep EMiddle x -> EMiddle
Generic)
data EBase
= EExpectedByte Word8 Word8
| EOverlong Int Int
| EExpected B.ByteString B.ByteString
| EFailNamed String
| EFailParse String B.ByteString Word8
| ERanOut Int
deriving stock (EBase -> EBase -> Bool
(EBase -> EBase -> Bool) -> (EBase -> EBase -> Bool) -> Eq EBase
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EBase -> EBase -> Bool
== :: EBase -> EBase -> Bool
$c/= :: EBase -> EBase -> Bool
/= :: EBase -> EBase -> Bool
Eq, Int -> EBase -> ShowS
[EBase] -> ShowS
EBase -> String
(Int -> EBase -> ShowS)
-> (EBase -> String) -> ([EBase] -> ShowS) -> Show EBase
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> EBase -> ShowS
showsPrec :: Int -> EBase -> ShowS
$cshow :: EBase -> String
show :: EBase -> String
$cshowList :: [EBase] -> ShowS
showList :: [EBase] -> ShowS
Show, (forall x. EBase -> Rep EBase x)
-> (forall x. Rep EBase x -> EBase) -> Generic EBase
forall x. Rep EBase x -> EBase
forall x. EBase -> Rep EBase x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. EBase -> Rep EBase x
from :: forall x. EBase -> Rep EBase x
$cto :: forall x. Rep EBase x -> EBase
to :: forall x. Rep EBase x -> EBase
Generic)
data EGeneric e
= EGenericSum (EGenericSum e)
| EGenericField
String
(Maybe String)
Natural
e
deriving stock (EGeneric e -> EGeneric e -> Bool
(EGeneric e -> EGeneric e -> Bool)
-> (EGeneric e -> EGeneric e -> Bool) -> Eq (EGeneric e)
forall e. Eq e => EGeneric e -> EGeneric e -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall e. Eq e => EGeneric e -> EGeneric e -> Bool
== :: EGeneric e -> EGeneric e -> Bool
$c/= :: forall e. Eq e => EGeneric e -> EGeneric e -> Bool
/= :: EGeneric e -> EGeneric e -> Bool
Eq, Int -> EGeneric e -> ShowS
[EGeneric e] -> ShowS
EGeneric e -> String
(Int -> EGeneric e -> ShowS)
-> (EGeneric e -> String)
-> ([EGeneric e] -> ShowS)
-> Show (EGeneric e)
forall e. Show e => Int -> EGeneric e -> ShowS
forall e. Show e => [EGeneric e] -> ShowS
forall e. Show e => EGeneric e -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall e. Show e => Int -> EGeneric e -> ShowS
showsPrec :: Int -> EGeneric e -> ShowS
$cshow :: forall e. Show e => EGeneric e -> String
show :: EGeneric e -> String
$cshowList :: forall e. Show e => [EGeneric e] -> ShowS
showList :: [EGeneric e] -> ShowS
Show, (forall x. EGeneric e -> Rep (EGeneric e) x)
-> (forall x. Rep (EGeneric e) x -> EGeneric e)
-> Generic (EGeneric e)
forall x. Rep (EGeneric e) x -> EGeneric e
forall x. EGeneric e -> Rep (EGeneric e) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall e x. Rep (EGeneric e) x -> EGeneric e
forall e x. EGeneric e -> Rep (EGeneric e) x
$cfrom :: forall e x. EGeneric e -> Rep (EGeneric e) x
from :: forall x. EGeneric e -> Rep (EGeneric e) x
$cto :: forall e x. Rep (EGeneric e) x -> EGeneric e
to :: forall x. Rep (EGeneric e) x -> EGeneric e
Generic)
data EGenericSum e
= EGenericSumTag e
| EGenericSumTagNoMatch
[String]
Text
deriving stock (EGenericSum e -> EGenericSum e -> Bool
(EGenericSum e -> EGenericSum e -> Bool)
-> (EGenericSum e -> EGenericSum e -> Bool) -> Eq (EGenericSum e)
forall e. Eq e => EGenericSum e -> EGenericSum e -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall e. Eq e => EGenericSum e -> EGenericSum e -> Bool
== :: EGenericSum e -> EGenericSum e -> Bool
$c/= :: forall e. Eq e => EGenericSum e -> EGenericSum e -> Bool
/= :: EGenericSum e -> EGenericSum e -> Bool
Eq, Int -> EGenericSum e -> ShowS
[EGenericSum e] -> ShowS
EGenericSum e -> String
(Int -> EGenericSum e -> ShowS)
-> (EGenericSum e -> String)
-> ([EGenericSum e] -> ShowS)
-> Show (EGenericSum e)
forall e. Show e => Int -> EGenericSum e -> ShowS
forall e. Show e => [EGenericSum e] -> ShowS
forall e. Show e => EGenericSum e -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall e. Show e => Int -> EGenericSum e -> ShowS
showsPrec :: Int -> EGenericSum e -> ShowS
$cshow :: forall e. Show e => EGenericSum e -> String
show :: EGenericSum e -> String
$cshowList :: forall e. Show e => [EGenericSum e] -> ShowS
showList :: [EGenericSum e] -> ShowS
Show, (forall x. EGenericSum e -> Rep (EGenericSum e) x)
-> (forall x. Rep (EGenericSum e) x -> EGenericSum e)
-> Generic (EGenericSum e)
forall x. Rep (EGenericSum e) x -> EGenericSum e
forall x. EGenericSum e -> Rep (EGenericSum e) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall e x. Rep (EGenericSum e) x -> EGenericSum e
forall e x. EGenericSum e -> Rep (EGenericSum e) x
$cfrom :: forall e x. EGenericSum e -> Rep (EGenericSum e) x
from :: forall x. EGenericSum e -> Rep (EGenericSum e) x
$cto :: forall e x. Rep (EGenericSum e) x -> EGenericSum e
to :: forall x. Rep (EGenericSum e) x -> EGenericSum e
Generic)
eBase :: EBase -> Getter a
eBase :: forall a. EBase -> Getter a
eBase EBase
eb = (ForeignPtrContents
-> Addr# -> Addr# -> PureMode -> Res# PureMode E a)
-> ParserT PureMode E a
forall (st :: ZeroBitType) e a.
(ForeignPtrContents -> Addr# -> Addr# -> st -> Res# st e a)
-> ParserT st e a
FP.ParserT \ForeignPtrContents
_fp Addr#
eob Addr#
s PureMode
st ->
let os :: Int
os = Int# -> Int
I# (Addr# -> Addr# -> Int#
minusAddr# Addr#
eob Addr#
s)
in PureMode -> E -> Res# PureMode E a
forall (st :: ZeroBitType) e a. st -> e -> Res# st e a
FP.Err# PureMode
st (Int -> EMiddle -> E
E Int
os (EMiddle -> E) -> EMiddle -> E
forall a b. (a -> b) -> a -> b
$ EBase -> EMiddle
EBase EBase
eb)
getEBase :: Getter a -> EBase -> Getter a
getEBase :: forall a. Getter a -> EBase -> Getter a
getEBase (FP.ParserT ForeignPtrContents
-> Addr# -> Addr# -> PureMode -> Res# PureMode E a
f) EBase
eb =
(ForeignPtrContents
-> Addr# -> Addr# -> PureMode -> Res# PureMode E a)
-> ParserT PureMode E a
forall (st :: ZeroBitType) e a.
(ForeignPtrContents -> Addr# -> Addr# -> st -> Res# st e a)
-> ParserT st e a
FP.ParserT \ForeignPtrContents
fp Addr#
eob Addr#
s PureMode
st ->
let os :: Int
os = Int# -> Int
I# (Addr# -> Addr# -> Int#
minusAddr# Addr#
eob Addr#
s)
in case ForeignPtrContents
-> Addr# -> Addr# -> PureMode -> Res# PureMode E a
f ForeignPtrContents
fp Addr#
eob Addr#
s PureMode
st of
FP.Fail# PureMode
st' -> PureMode -> E -> Res# PureMode E a
forall (st :: ZeroBitType) e a. st -> e -> Res# st e a
FP.Err# PureMode
st' (Int -> EMiddle -> E
E Int
os (EMiddle -> E) -> EMiddle -> E
forall a b. (a -> b) -> a -> b
$ EBase -> EMiddle
EBase EBase
eb)
FP.Err# PureMode
st' E
e -> PureMode -> E -> Res# PureMode E a
forall (st :: ZeroBitType) e a. st -> e -> Res# st e a
FP.Err# PureMode
st' (Int -> EMiddle -> E
E Int
os (EMiddle -> E) -> EMiddle -> E
forall a b. (a -> b) -> a -> b
$ E -> EBase -> EMiddle
EAnd E
e EBase
eb)
Res# PureMode E a
x -> Res# PureMode E a
x
getWrapGeneric :: Get a => String -> (E -> EGeneric E) -> Getter a
getWrapGeneric :: forall a. Get a => String -> (E -> EGeneric E) -> Getter a
getWrapGeneric = Getter a -> String -> (E -> EGeneric E) -> Getter a
forall a. Getter a -> String -> (E -> EGeneric E) -> Getter a
getWrapGeneric' Getter a
forall a. Get a => Getter a
get
getWrapGeneric' :: Getter a -> String -> (E -> EGeneric E) -> Getter a
getWrapGeneric' :: forall a. Getter a -> String -> (E -> EGeneric E) -> Getter a
getWrapGeneric' (FP.ParserT ForeignPtrContents
-> Addr# -> Addr# -> PureMode -> Res# PureMode E a
f) String
cd E -> EGeneric E
fe =
(ForeignPtrContents
-> Addr# -> Addr# -> PureMode -> Res# PureMode E a)
-> ParserT PureMode E a
forall (st :: ZeroBitType) e a.
(ForeignPtrContents -> Addr# -> Addr# -> st -> Res# st e a)
-> ParserT st e a
FP.ParserT \ForeignPtrContents
fp Addr#
eob Addr#
s PureMode
st ->
let os :: Int
os = Int# -> Int
I# (Addr# -> Addr# -> Int#
minusAddr# Addr#
eob Addr#
s)
in case ForeignPtrContents
-> Addr# -> Addr# -> PureMode -> Res# PureMode E a
f ForeignPtrContents
fp Addr#
eob Addr#
s PureMode
st of
FP.Fail# PureMode
st' -> PureMode -> E -> Res# PureMode E a
forall (st :: ZeroBitType) e a. st -> e -> Res# st e a
FP.Err# PureMode
st' (Int -> EMiddle -> E
E Int
os (EMiddle -> E) -> EMiddle -> E
forall a b. (a -> b) -> a -> b
$ String -> EGeneric E -> EMiddle
EGeneric String
cd (EGeneric E -> EMiddle) -> EGeneric E -> EMiddle
forall a b. (a -> b) -> a -> b
$ E -> EGeneric E
fe E
EFail)
FP.Err# PureMode
st' E
e -> PureMode -> E -> Res# PureMode E a
forall (st :: ZeroBitType) e a. st -> e -> Res# st e a
FP.Err# PureMode
st' (Int -> EMiddle -> E
E Int
os (EMiddle -> E) -> EMiddle -> E
forall a b. (a -> b) -> a -> b
$ String -> EGeneric E -> EMiddle
EGeneric String
cd (EGeneric E -> EMiddle) -> EGeneric E -> EMiddle
forall a b. (a -> b) -> a -> b
$ E -> EGeneric E
fe E
e)
Res# PureMode E a
x -> Res# PureMode E a
x
class Get a where
get :: Getter a
runGet :: Get a => B.ByteString -> Either E (a, B.ByteString)
runGet :: forall a. Get a => ByteString -> Either E (a, ByteString)
runGet = Getter a -> ByteString -> Either E (a, ByteString)
forall a. Getter a -> ByteString -> Either E (a, ByteString)
runGetter Getter a
forall a. Get a => Getter a
get
runGetter :: Getter a -> B.ByteString -> Either E (a, B.ByteString)
runGetter :: forall a. Getter a -> ByteString -> Either E (a, ByteString)
runGetter Getter a
g ByteString
bs = case Getter a -> ByteString -> Result E a
forall e a. Parser e a -> ByteString -> Result e a
FP.runParser Getter a
g ByteString
bs of
FP.OK a
a ByteString
bs' -> (a, ByteString) -> Either E (a, ByteString)
forall a b. b -> Either a b
Right (a
a, ByteString
bs')
Result E a
FP.Fail -> E -> Either E (a, ByteString)
forall a b. a -> Either a b
Left E
EFail
FP.Err E
e -> E -> Either E (a, ByteString)
forall a b. a -> Either a b
Left E
e
instance GenericTraverse (FP.Parser E) where
type GenericTraverseC (FP.Parser E) a = Get a
genericTraverseAction :: forall a.
GenericTraverseC (Parser E) a =>
String -> String -> Maybe String -> Natural -> Parser E a
genericTraverseAction String
cd String
cc Maybe String
mcs Natural
si =
String -> (E -> EGeneric E) -> Getter a
forall a. Get a => String -> (E -> EGeneric E) -> Getter a
getWrapGeneric String
cd ((E -> EGeneric E) -> Getter a) -> (E -> EGeneric E) -> Getter a
forall a b. (a -> b) -> a -> b
$ String -> Maybe String -> Natural -> E -> EGeneric E
forall e. String -> Maybe String -> Natural -> e -> EGeneric e
EGenericField String
cc Maybe String
mcs Natural
si
instance GenericTraverseSum (FP.Parser E) where
genericTraverseSumPfxTagAction :: forall pt. GenericTraverseC (Parser E) pt => String -> Parser E pt
genericTraverseSumPfxTagAction String
cd =
String -> (E -> EGeneric E) -> Getter pt
forall a. Get a => String -> (E -> EGeneric E) -> Getter a
getWrapGeneric String
cd ((E -> EGeneric E) -> Getter pt) -> (E -> EGeneric E) -> Getter pt
forall a b. (a -> b) -> a -> b
$ EGenericSum E -> EGeneric E
forall e. EGenericSum e -> EGeneric e
EGenericSum (EGenericSum E -> EGeneric E)
-> (E -> EGenericSum E) -> E -> EGeneric E
forall b c a. (b -> c) -> (a -> b) -> a -> c
. E -> EGenericSum E
forall e. e -> EGenericSum e
EGenericSumTag
genericTraverseSumNoMatchingCstrAction :: forall a. String -> [String] -> Text -> Parser E a
genericTraverseSumNoMatchingCstrAction String
cd [String]
cstrs Text
ptText =
E -> ParserT PureMode E a
forall e (st :: ZeroBitType) a. e -> ParserT st e a
FP.err (E -> ParserT PureMode E a) -> E -> ParserT PureMode E a
forall a b. (a -> b) -> a -> b
$ Int -> EMiddle -> E
E Int
0 (EMiddle -> E) -> EMiddle -> E
forall a b. (a -> b) -> a -> b
$ String -> EGeneric E -> EMiddle
EGeneric String
cd (EGeneric E -> EMiddle) -> EGeneric E -> EMiddle
forall a b. (a -> b) -> a -> b
$ EGenericSum E -> EGeneric E
forall e. EGenericSum e -> EGeneric e
EGenericSum (EGenericSum E -> EGeneric E) -> EGenericSum E -> EGeneric E
forall a b. (a -> b) -> a -> b
$ [String] -> Text -> EGenericSum E
forall e. [String] -> Text -> EGenericSum e
EGenericSumTagNoMatch [String]
cstrs Text
ptText
getGenericNonSum
:: forall {cd} {f} {asserts} a
. (Generic a, Rep a ~ D1 cd f, GTraverseNonSum cd (FP.Parser E) f
, asserts ~ '[ 'NoEmpty, 'NoSum], ApplyGCAsserts asserts f)
=> Getter a
getGenericNonSum :: forall {cd :: Meta} {f :: Type -> Type} {asserts :: [GCAssert]} a.
(Generic a, Rep a ~ D1 cd f, GTraverseNonSum cd (Parser E) f,
asserts ~ '[ 'NoEmpty, 'NoSum], ApplyGCAsserts asserts f) =>
Getter a
getGenericNonSum = forall (asserts :: [GCAssert]) (f :: Type -> Type) a.
(Generic a, Rep a ~ D1 cd f, GTraverseNonSum cd f f,
ApplyGCAsserts asserts f, Functor f) =>
f a
forall {cd :: Meta} {gf :: Type -> Type} (asserts :: [GCAssert])
(f :: Type -> Type) a.
(Generic a, Rep a ~ D1 cd gf, GTraverseNonSum cd f gf,
ApplyGCAsserts asserts f, Functor f) =>
f a
genericTraverseNonSum @asserts
getGenericSum
:: forall {cd} {f} {asserts} pt a
. ( Generic a, Rep a ~ D1 cd f, GTraverseSum 'SumOnly cd (FP.Parser E) f
, Get pt
, asserts ~ '[ 'NoEmpty, 'NeedSum], ApplyGCAsserts asserts f)
=> PfxTagCfg pt -> Getter a
getGenericSum :: forall {cd :: Meta} {f :: Type -> Type} {asserts :: [GCAssert]} pt
a.
(Generic a, Rep a ~ D1 cd f, GTraverseSum 'SumOnly cd (Parser E) f,
Get pt, asserts ~ '[ 'NoEmpty, 'NeedSum],
ApplyGCAsserts asserts f) =>
PfxTagCfg pt -> Getter a
getGenericSum = forall {cd :: Meta} {gf :: Type -> Type} (opts :: SumOpts)
(asserts :: [GCAssert]) (f :: Type -> Type) a pt.
(Generic a, Rep a ~ D1 cd gf, GTraverseSum opts cd f gf,
ApplyGCAsserts asserts f, GenericTraverseC f pt, Functor f) =>
PfxTagCfg pt -> f a
forall (opts :: SumOpts) (asserts :: [GCAssert])
(f :: Type -> Type) a pt.
(Generic a, Rep a ~ D1 cd f, GTraverseSum opts cd f f,
ApplyGCAsserts asserts f, GenericTraverseC f pt, Functor f) =>
PfxTagCfg pt -> f a
genericTraverseSum @'SumOnly @asserts
instance TypeError ENoEmpty => Get Void where get :: Getter Void
get = Getter Void
forall a. HasCallStack => a
undefined
instance TypeError ENoSum => Get (Either a b) where get :: Getter (Either a b)
get = Getter (Either a b)
forall a. HasCallStack => a
undefined
instance Get Write where
{-# INLINE get #-}
get :: Getter Write
get = (ByteString -> Write)
-> ParserT PureMode E ByteString -> Getter Write
forall a b.
(a -> b) -> ParserT PureMode E a -> ParserT PureMode E b
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> Write
BZ.byteString (ParserT PureMode E ByteString -> Getter Write)
-> ParserT PureMode E ByteString -> Getter Write
forall a b. (a -> b) -> a -> b
$ (ByteString -> ByteString)
-> ParserT PureMode E ByteString -> ParserT PureMode E ByteString
forall a b.
(a -> b) -> ParserT PureMode E a -> ParserT PureMode E b
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> ByteString
B.copy (ParserT PureMode E ByteString -> ParserT PureMode E ByteString)
-> ParserT PureMode E ByteString -> ParserT PureMode E ByteString
forall a b. (a -> b) -> a -> b
$ ParserT PureMode E ByteString
forall (st :: ZeroBitType) e. ParserT st e ByteString
FP.takeRest
instance Get () where
{-# INLINE get #-}
get :: Getter ()
get = () -> Getter ()
forall a. a -> ParserT PureMode E a
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure ()
instance (Get l, Get r) => Get (l, r) where
{-# INLINE get #-}
get :: Getter (l, r)
get = do
l
l <- Getter l
forall a. Get a => Getter a
get
r
r <- Getter r
forall a. Get a => Getter a
get
(l, r) -> Getter (l, r)
forall a. a -> ParserT PureMode E a
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure (l
l, r
r)
instance Get a => Get [a] where
get :: Getter [a]
get = Getter [a]
go
where
go :: Getter [a]
go = do
Getter () -> (() -> Getter [a]) -> Getter [a] -> Getter [a]
forall (st :: ZeroBitType) e a r.
ParserT st e a
-> (a -> ParserT st e r) -> ParserT st e r -> ParserT st e r
FP.withOption Getter ()
forall (st :: ZeroBitType) e. ParserT st e ()
FP.eof (\() -> [a] -> Getter [a]
forall a. a -> ParserT PureMode E a
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure []) (Getter [a] -> Getter [a]) -> Getter [a] -> Getter [a]
forall a b. (a -> b) -> a -> b
$ do
a
a <- Getter a
forall a. Get a => Getter a
get
[a]
as <- Getter [a]
go
[a] -> Getter [a]
forall a. a -> ParserT PureMode E a
forall (f :: Type -> Type) a. Applicative f => a -> f a
pure ([a] -> Getter [a]) -> [a] -> Getter [a]
forall a b. (a -> b) -> a -> b
$ a
a a -> [a] -> [a]
forall a. a -> [a] -> [a]
: [a]
as
instance Get B.ByteString where
{-# INLINE get #-}
get :: ParserT PureMode E ByteString
get = ByteString -> ByteString
B.copy (ByteString -> ByteString)
-> ParserT PureMode E ByteString -> ParserT PureMode E ByteString
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> ParserT PureMode E ByteString
forall (st :: ZeroBitType) e. ParserT st e ByteString
FP.takeRest
instance Get Word8 where get :: Getter Word8
get = Getter Word8 -> EBase -> Getter Word8
forall a. Getter a -> EBase -> Getter a
getEBase Getter Word8
forall (st :: ZeroBitType) e. ParserT st e Word8
FP.anyWord8 (Int -> EBase
ERanOut Int
1)
instance Get Int8 where get :: Getter Int8
get = Getter Int8 -> EBase -> Getter Int8
forall a. Getter a -> EBase -> Getter a
getEBase Getter Int8
forall (st :: ZeroBitType) e. ParserT st e Int8
FP.anyInt8 (Int -> EBase
ERanOut Int
1)