{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE BlockArguments #-}
module Binrep.Get
( Getter, Get(..), runGet, runGetter
, E(..), EBase(..), EGeneric(..), EGenericSum(..)
, eBase
, getEBase
, getPrim
, getGenericNonSum, getGenericSum
) where
import Data.Functor.Identity
import Binrep.Util.ByteOrder
import Binrep.Common.Via.Prim ( ViaPrim(..) )
import Raehik.Compat.Data.Primitive.Types ( Prim', sizeOf )
import Raehik.Compat.Data.Primitive.Types.Endian ( ByteSwap )
import FlatParse.Basic qualified as FP
import Raehik.Compat.FlatParse.Basic.Prim qualified as FP
import Data.ByteString qualified as B
import Binrep.Common.Class.TypeErrors ( ENoSum, ENoEmpty )
import GHC.TypeLits ( TypeError )
import Data.Void
import Data.Word
import Data.Int
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 Get where
type GenericTraverseF Get = FP.Parser E
type GenericTraverseC Get a = Get a
genericTraverseAction :: forall a.
GenericTraverseC Get a =>
String
-> String -> Maybe String -> Natural -> GenericTraverseF Get 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 Get where
genericTraverseSumPfxTagAction :: forall pt.
GenericTraverseC Get pt =>
String -> GenericTraverseF Get 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 -> GenericTraverseF Get 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 a
. (Generic a, GTraverseNonSum Get (Rep a)
, GAssertNotVoid a, GAssertNotSum a
) => Getter a
getGenericNonSum :: forall a.
(Generic a, GTraverseNonSum Get (Rep a), GAssertNotVoid a,
GAssertNotSum a) =>
Getter a
getGenericNonSum = forall {k} (tag :: k) a.
(Generic a, Functor (GenericTraverseF tag),
GTraverseNonSum tag (Rep a)) =>
GenericTraverseF tag a
forall (tag :: Type -> Constraint) a.
(Generic a, Functor (GenericTraverseF tag),
GTraverseNonSum tag (Rep a)) =>
GenericTraverseF tag a
genericTraverseNonSum @Get
getGenericSum
:: forall pt a
. ( Generic a, GTraverseSum Get 'SumOnly (Rep a)
, Get pt
, GAssertNotVoid a, GAssertSum a
) => PfxTagCfg pt -> Getter a
getGenericSum :: forall pt a.
(Generic a, GTraverseSum Get 'SumOnly (Rep a), Get pt,
GAssertNotVoid a, GAssertSum a) =>
PfxTagCfg pt -> Getter a
getGenericSum = forall {k} (tag :: k) (opts :: SumOpts) a pt.
(Generic a, Functor (GenericTraverseF tag),
GTraverseSum tag opts (Rep a), GenericTraverseC tag pt) =>
PfxTagCfg pt -> GenericTraverseF tag a
forall (tag :: Type -> Constraint) (opts :: SumOpts) a pt.
(Generic a, Functor (GenericTraverseF tag),
GTraverseSum tag opts (Rep a), GenericTraverseC tag pt) =>
PfxTagCfg pt -> GenericTraverseF tag a
genericTraverseSum @Get @'SumOnly
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 a => Get (Identity a) where get :: Getter (Identity a)
get = a -> Identity a
forall a. a -> Identity a
Identity (a -> Identity a) -> ParserT PureMode E a -> Getter (Identity a)
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> ParserT PureMode E a
forall a. Get a => Getter a
get
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 :: Getter ByteString
get = ByteString -> ByteString
B.copy (ByteString -> ByteString)
-> Getter ByteString -> Getter ByteString
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> Getter ByteString
forall (st :: ZeroBitType) e. ParserT st e ByteString
FP.takeRest
deriving via ViaPrim Word8 instance Get Word8
deriving via ViaPrim Int8 instance Get Int8
deriving via Identity Word8 instance Get (ByteOrdered end Word8)
deriving via Identity Int8 instance Get (ByteOrdered end Int8)
getPrim :: forall a. Prim' a => Getter a
getPrim :: forall a. Prim' a => Getter a
getPrim = Getter a -> EBase -> Getter a
forall a. Getter a -> EBase -> Getter a
getEBase Getter a
forall a e (st :: ZeroBitType). Prim' a => ParserT st e a
FP.anyPrim (Int -> EBase
ERanOut (a -> Int
forall a. Prim a => a -> Int
sizeOf (a
forall a. HasCallStack => a
undefined :: a)))
instance Prim' a => Get (ViaPrim a) where get :: Getter (ViaPrim a)
get = a -> ViaPrim a
forall a. a -> ViaPrim a
ViaPrim (a -> ViaPrim a) -> ParserT PureMode E a -> Getter (ViaPrim a)
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> ParserT PureMode E a
forall a. Prim' a => Getter a
getPrim
deriving via ViaPrim (ByteOrdered 'LittleEndian a)
instance (Prim' a, ByteSwap a) => Get (ByteOrdered 'LittleEndian a)
deriving via ViaPrim (ByteOrdered 'BigEndian a)
instance (Prim' a, ByteSwap a) => Get (ByteOrdered 'BigEndian a)