bytezap 1.1.0 → 1.3.0

raw patch · 13 files changed

+497/−457 lines, 13 filesdep +defun-coredep +generic-type-functionsdep +type-level-bytestringsPVP ok

version bump matches the API change (PVP)

Dependencies added: defun-core, generic-type-functions, type-level-bytestrings

API changes (from Hackage documentation)

Files

• CHANGELOG.md +11/−0
• README.md +11/−3
• bytezap.cabal +10/−4
• src/Bytezap/Common/Generic.hs +16/−0
• src/Bytezap/Parser/Struct.hs +160/−0
• src/Bytezap/Parser/Struct/Generic.hs +53/−0
• src/Bytezap/Parser/Struct/TypeLits/Bytes.hs +95/−0
• src/Bytezap/Poke.hs +5/−0
• src/Bytezap/Struct/Generic.hs +27/−27
• src/Bytezap/Struct/TypeLits.hs +0/−102
• src/Bytezap/Struct/TypeLits/Bytes.hs +107/−0
• src/Raehik/Compat/Data/Primitive/Types/Endian.hs +2/−2
• src/Raehik/TypeLevelBytes.hs +0/−319

@@ -1,3 +1,14 @@+## 1.3.0 (2024-04-13)+* move type-level byte stuff to another package++## 1.2.0 (2024-04-11)+* fix type-level generic blen type family (needed defunctionalization)+  * split out into its own even _more_ abstract library, generic-type-functions+* add missing instance `Integral (ByteOrdered end a)`+* add struct parser! design taken from flatparse. barebones combinators+  * add type-level byte parsing. hahahaha+* add `Bytezap.Poke.toStructPoke :: Poke s -> Struct.Poke s`+ ## 1.1.0 (2024-04-05) * add struct serializer * add type-level bytestring utilities (generalized from binrep)

@@ -1,11 +1,12 @@+[hackage-binrep]: https://hackage.haskell.org/package/binrep+ # bytezap Build strict bytestrings with zero intermediate allocation.  If you're looking for general high-performance serialization, you probably want [mason](https://hackage.haskell.org/package/mason). But if you're dealing with data that is already "shaped" like binary data, e.g. using types defined in-[binrep](https://hackage.haskell.org/package/binrep), and you want the best-performance possible, read on...+[binrep][hackage-binrep], and you want the best performance possible, read on...  ## Why? Most binary serialization libraries tend towards a model where the serializer@@ -36,7 +37,14 @@ ## So... why? Well, bytezap will be slightly faster where it's applicable, and the implementation is extremely simple. It's a fun niche to fill, and it's-convenient for my [binrep](https://hackage.haskell.org/package/binrep) library.+convenient for my [binrep][hackage-binrep] library.++## Struct handling+We define even simpler parser & serializer types which can only handle "C+struct"-like types, where there is only one constructor and all fields have+known length at compile time. The way these work, GHC is pretty much guaranteed+to generate the fastest code possible. These are very experimental, but see+[binrep][hackage-binrep] for example usage.  ## Non-features ### Serialize to `ByteString` (pinned byte arrays) only

@@ -5,10 +5,10 @@ -- see: https://github.com/sol/hpack  name:           bytezap-version:        1.1.0+version:        1.3.0 synopsis:       Bytestring builder with zero intermediate allocation description:    Please see README.md.-category:       Data, Serialization+category:       Data, Serialization, Generics homepage:       https://github.com/raehik/bytezap#readme bug-reports:    https://github.com/raehik/bytezap/issues author:         Ben Orchard@@ -29,6 +29,10 @@ library   exposed-modules:       Bytezap+      Bytezap.Common.Generic+      Bytezap.Parser.Struct+      Bytezap.Parser.Struct.Generic+      Bytezap.Parser.Struct.TypeLits.Bytes       Bytezap.Poke       Bytezap.Poke.Derived       Bytezap.Poke.Derived.Endian@@ -36,7 +40,7 @@       Bytezap.Poke.KnownLen       Bytezap.Struct       Bytezap.Struct.Generic-      Bytezap.Struct.TypeLits+      Bytezap.Struct.TypeLits.Bytes       Bytezap.Write       Bytezap.Write.Derived       Bytezap.Write.Internal@@ -46,7 +50,6 @@       Raehik.Compat.Data.Word.ByteSwap       Raehik.Compat.GHC.Exts.GHC908MemcpyPrimops       Raehik.Compat.GHC.Exts.GHC910UnalignedAddrPrimops-      Raehik.TypeLevelBytes       Util.TypeNats   other-modules:       Paths_bytezap@@ -69,6 +72,9 @@   build-depends:       base >=4.18.0.0 && <4.20     , bytestring >=0.11.5.3 && <0.13.0.0+    , defun-core ==0.1.*+    , generic-type-functions >=0.1.0 && <0.2     , primitive >=0.8.0.0 && <0.10.0.0     , text >=2.0.2 && <2.2+    , type-level-bytestrings >=0.1.0 && <0.2   default-language: GHC2021

@@ -0,0 +1,16 @@+module Bytezap.Common.Generic where++import GHC.TypeNats+import DeFun.Core ( type (~>), type App )+import Generic.Type.Function.FoldMap ( type GTFoldMapC )++type PlusSym :: Natural ~> Natural ~> Natural+data PlusSym f+type instance App PlusSym f = PlusSym1 f++type PlusSym1 :: Natural -> Natural ~> Natural+data PlusSym1 l r+type instance App (PlusSym1 l) r = l + r++-- | Generic type 'foldMap' using the addition monoid.+type GTFoldMapCAddition f gf = GTFoldMapC PlusSym 0 f gf

@@ -0,0 +1,160 @@+{-# LANGUAGE UnboxedTuples #-}+{-# LANGUAGE KindSignatures #-}+{-# LANGUAGE PatternSynonyms #-}+{-# LANGUAGE BlockArguments #-}+-- {-# LANGUAGE DataKinds #-} -- needed for manual ZeroBitType def (unsure why)+-- {-# LANGUAGE FlexibleInstances #-}++{- | Struct parser.++We do still have to do failure checking, because unlike C we check some types+(e.g. bitfields). Hopefully inlining can remove those checks when unnecessary.+-}++module Bytezap.Parser.Struct where++import GHC.Exts+import GHC.ForeignPtr+import Data.Void ( Void )++import Data.Word ( Word8 )+import Data.ByteString.Internal qualified as B+import System.IO.Unsafe ( unsafePerformIO )++import Raehik.Compat.Data.Primitive.Types++type PureMode = Proxy# Void+type IOMode   = State# RealWorld+type STMode s = State# s++type ParserT# (st :: ZeroBitType) e a =+       ForeignPtrContents {- ^ pointer provenance -}+    -> Addr# {- ^ base address -}+    -> Int#  {- ^ cursor offset from base -}+    -> st    {- ^ state token -}+    -> Res# st e a++-- we take a 'ForeignPtrContents' because it lets us create bytestrings without+-- copying if we want. it's useful+newtype ParserT (st :: ZeroBitType) e a =+    ParserT { runParserT# :: ParserT# st e a }++instance Functor (ParserT st e) where+  fmap f (ParserT g) = ParserT \fpc base os st0 -> case g fpc base os st0 of+    OK# st1 a -> let !b = f a in OK# st1 b+    x         -> unsafeCoerce# x+  {-# inline fmap #-}++-- No Applicative due to no offset passing.++-- | The type of pure parsers.+type Parser     = ParserT PureMode++-- | The type of parsers which can embed `IO` actions.+type ParserIO   = ParserT IOMode++-- | The type of parsers which can embed `ST` actions.+type ParserST s = ParserT (STMode s)++-- | Primitive parser result wrapped with a state token.+--+-- You should rarely need to manipulate values of this type directly. Use the+-- provided bidirectional pattern synonyms 'OK#', 'Fail#' and 'Err#'.+type Res# (st :: ZeroBitType) e a =+  (# st, ResI# e a #)++-- | Primitive parser result.+type ResI# e a =+  (#+    (# a #)+  | (# #)+  | (# e #)+  #)++-- | 'Res#' constructor for a successful parse.+--   Contains the return value and a state token.+pattern OK# :: (st :: ZeroBitType) -> a -> Res# st e a+pattern OK# st a = (# st, (# (# a #) | | #) #)++-- | 'Res#' constructor for recoverable failure.+--   Contains only a state token.+pattern Fail# :: (st :: ZeroBitType) -> Res# st e a+pattern Fail# st = (# st, (# | (# #) | #) #)++-- | 'Res#' constructor for errors which are by default non-recoverable.+--    Contains the error, plus a state token.+pattern Err# :: (st :: ZeroBitType) -> e -> Res# st e a+pattern Err# st e = (# st, (# | | (# e #) #) #)+{-# complete OK#, Fail#, Err# #-}++-- | caller must guarantee that buffer is long enough for parser!!+unsafeRunParserBs :: forall a e. B.ByteString -> Parser e a -> Result e a+unsafeRunParserBs (B.BS fptr _) = unsafeRunParserFPtr fptr++-- | caller must guarantee that buffer is long enough for parser!!+unsafeRunParserPtr :: forall a e. Ptr Word8 -> Parser e a -> Result e a+unsafeRunParserPtr (Ptr base#) = unsafeRunParser' base# FinalPtr++-- | caller must guarantee that buffer is long enough for parser!!+unsafeRunParserFPtr :: forall a e. ForeignPtr Word8 -> Parser e a -> Result e a+unsafeRunParserFPtr fptr p =+    unsafePerformIO $ B.unsafeWithForeignPtr fptr $ \ptr ->+        pure $ unsafeRunParserPtr ptr p++-- | caller must guarantee that buffer is long enough for parser!!+unsafeRunParser'+    :: forall a e. Addr# -> ForeignPtrContents -> Parser e a -> Result e a+unsafeRunParser' base# fpc (ParserT p) =+    case p fpc base# 0# proxy# of+      OK#   _st1 a -> OK a+      Fail# _st1   -> Fail+      Err#  _st1 e -> Err e++-- | Higher-level boxed data type for parsing results.+data Result e a =+    OK a    -- ^ Contains return value.+  | Fail    -- ^ Recoverable-by-default failure.+  | Err !e  -- ^ Unrecoverable-by-default error.+  deriving Show++-- | can't provide via 'pure' as no 'Applicative'+constParse :: a -> ParserT st e a+constParse a = ParserT \_fpc _base _os st -> OK# st a++sequenceParsers+    :: Int -> (a -> b -> c)+    -> ParserT st e a -> ParserT st e b -> ParserT st e c+sequenceParsers (I# len#) f (ParserT pa) (ParserT pb) =+    ParserT \fpc base os# st0 ->+        case pa fpc base os# st0 of+          Fail# st1 ->  Fail# st1+          Err# st1 e -> Err# st1 e+          OK# st1 a ->+            case pb fpc base (os# +# len#) st1 of+              Fail# st2 ->  Fail# st2+              Err# st2 e -> Err# st2 e+              OK# st2 b -> OK# st2 (f a b)++-- TODO using indexWord8OffAddrAs to permit pure mode. flatparse does this (at+-- least for integers). guess it's OK?+prim :: forall a st e. Prim' a => ParserT st e a+prim = ParserT \_fpc base os st ->+    case indexWord8OffAddrAs# base os of a -> OK# st a++-- | parse literal+lit :: Eq a => a -> ParserT st e a -> ParserT st e ()+lit al (ParserT p) = ParserT \fpc base os st0 ->+    case p fpc base os st0 of+      Fail# st1    -> Fail# st1+      Err#  st1 e  -> Err#  st1 e+      OK#   st1 ar -> if al == ar then OK# st1 () else Fail# st1++-- | parse literal (CPS)+withLit+    :: Eq a => Int# -> a -> ParserT st e a -> ParserT st e r -> ParserT st e r+withLit len# al (ParserT p) (ParserT pCont) = ParserT \fpc base os# st0 ->+    case p fpc base os# st0 of+      Fail# st1    -> Fail# st1+      Err#  st1 e  -> Err#  st1 e+      OK#   st1 ar ->+        if al == ar then pCont fpc base (os# +# len#) st1 else Fail# st1

@@ -0,0 +1,53 @@+{-# LANGUAGE AllowAmbiguousTypes #-}+{-# LANGUAGE UndecidableInstances #-} -- thanks to type manipulation++module Bytezap.Parser.Struct.Generic where++import Bytezap.Parser.Struct+import GHC.Generics+import GHC.Exts+import Data.Kind+import GHC.TypeNats+import Util.TypeNats ( natValInt )+import Bytezap.Common.Generic ( type GTFoldMapCAddition )+import DeFun.Core ( type (~>) )++class GParseBase tag where+    -- | The state token of the parser.+    type GParseBaseSt tag :: ZeroBitType+    type GParseBaseC tag a :: Constraint+    type GParseBaseE tag :: Type++    -- unlike the serializer we stay newtyped because we want our Functor+    gParseBase+        :: GParseBaseC tag a+        => ParserT (GParseBaseSt tag) (GParseBaseE tag) a++    -- | Defunctionalization symbol for a type family turning 'Type's into+    --   'Natural's. (Needed as we can't partially apply type families.)+    type GParseBaseLenTF tag :: Type ~> Natural++class GParse tag gf where+    gParse :: ParserT (GParseBaseSt tag) (GParseBaseE tag) (gf p)++instance GParse tag gf => GParse tag (D1 cd gf) where+    gParse = M1 <$> gParse @tag+instance GParse tag gf => GParse tag (C1 cc gf) where+    gParse = M1 <$> gParse @tag++instance+  ( GParse tag l+  , GParse tag r+  , GParseBase tag+  , lenL ~ GTFoldMapCAddition (GParseBaseLenTF tag) l+  , KnownNat lenL+  ) => GParse tag (l :*: r) where+    gParse = sequenceParsers len (:*:) (gParse @tag) (gParse @tag)+      where+        len = natValInt @lenL++instance (GParseBase tag, GParseBaseC tag a) => GParse tag (S1 c (Rec0 a)) where+    gParse = (M1 . K1) <$> gParseBase @tag++-- | Wow, look! Nothing!+instance GParse tag U1 where gParse = constParse U1

@@ -0,0 +1,95 @@+{- | Efficient type-level bytestring parsing.++One may implement this using the type-level serializing, but mirroring it for+parsing does less work and allocation.+-}++{-# LANGUAGE AllowAmbiguousTypes, UndecidableInstances #-}++module Bytezap.Parser.Struct.TypeLits.Bytes where++import Data.Type.Byte+import Bytezap.Parser.Struct ( ParserT, prim, withLit, constParse )+import Numeric.Natural ( Natural )++class ParseReifyBytesW64 (ns :: [Natural]) where+    parseReifyBytesW64 :: ParserT st e ()++-- | Enough bytes to make a 'Word64'.+instance {-# OVERLAPPING #-}+  ( ReifyW8 n1+  , ReifyW8 n2+  , ReifyW8 n3+  , ReifyW8 n4+  , ReifyW8 n5+  , ReifyW8 n6+  , ReifyW8 n7+  , ReifyW8 n8+  , ParseReifyBytesW64 ns+  ) => ParseReifyBytesW64 (n1 ': n2 ': n3 ': n4 ': n5 ': n6 ': n7 ': n8 ': ns) where+    {-# INLINE parseReifyBytesW64 #-}+    parseReifyBytesW64 = withLit 8# (reifyW64 @n1 @n2 @n3 @n4 @n5 @n6 @n7 @n8)+        prim (parseReifyBytesW64 @ns)++-- | Try to group 'Word32's next.+instance ParseReifyBytesW32 ns => ParseReifyBytesW64 ns where+    {-# INLINE parseReifyBytesW64 #-}+    parseReifyBytesW64 = parseReifyBytesW32 @ns++-- | Serialize a type-level bytestring, largest grouping 'Word32'.+class ParseReifyBytesW32 (ns :: [Natural]) where+    parseReifyBytesW32 :: ParserT st e ()++-- | Enough bytes to make a 'Word32'.+instance {-# OVERLAPPING #-}+  ( ReifyW8 n1+  , ReifyW8 n2+  , ReifyW8 n3+  , ReifyW8 n4+  , ParseReifyBytesW32 ns+  ) => ParseReifyBytesW32 (n1 ': n2 ': n3 ': n4 ': ns) where+    {-# INLINE parseReifyBytesW32 #-}+    parseReifyBytesW32 = withLit 4# (reifyW32 @n1 @n2 @n3 @n4)+        prim (parseReifyBytesW32 @ns)++-- | Try to group 'Word16's next.+instance ParseReifyBytesW16 ns => ParseReifyBytesW32 ns where+    {-# INLINE parseReifyBytesW32 #-}+    parseReifyBytesW32 = parseReifyBytesW16 @ns++-- | Serialize a type-level bytestring, largest grouping 'Word16'.+class ParseReifyBytesW16 (ns :: [Natural]) where+    parseReifyBytesW16 :: ParserT st e ()++-- | Enough bytes to make a 'Word16'.+instance {-# OVERLAPPING #-}+  ( ReifyW8 n1+  , ReifyW8 n2+  , ParseReifyBytesW16 ns+  ) => ParseReifyBytesW16 (n1 ': n2 ': ns) where+    {-# INLINE parseReifyBytesW16 #-}+    parseReifyBytesW16 = withLit 2# (reifyW16 @n1 @n2)+        prim (parseReifyBytesW16 @ns)++-- | Reify byte-by-byte next.+instance ParseReifyBytesW8 ns => ParseReifyBytesW16 ns where+    {-# INLINE parseReifyBytesW16 #-}+    parseReifyBytesW16 = parseReifyBytesW8 @ns++-- | Serialize a type-level bytestring, byte-by-byte.+class ParseReifyBytesW8 (ns :: [Natural]) where+    parseReifyBytesW8 :: ParserT st e ()++-- | Reify the next byte.+instance+  ( ReifyW8 n1+  , ParseReifyBytesW8 ns+  ) => ParseReifyBytesW8 (n1 ': ns) where+    {-# INLINE parseReifyBytesW8 #-}+    parseReifyBytesW8 = withLit 1# (reifyW8 @n1)+        prim (parseReifyBytesW8 @ns)++-- | End of the line.+instance ParseReifyBytesW8 '[] where+    {-# INLINE parseReifyBytesW8 #-}+    parseReifyBytesW8 = constParse ()

@@ -95,3 +95,8 @@ fromStructPoke :: Int -> Struct.Poke s -> Poke s fromStructPoke (I# len#) (Struct.Poke p) = Poke $ \base# os# s ->     (# p base# os# s, os# +# len# #)++-- | Use a struct poke as a regular poke by throwing away the return offset.+toStructPoke :: Poke s -> Struct.Poke s+toStructPoke (Poke p) = Struct.Poke $ \base# os0# s0 ->+    case p base# os0# s0 of (# s1, _os1# #) -> s1

@@ -26,10 +26,11 @@ import Bytezap.Struct import GHC.Generics import GHC.Exts---- TODO fill in kind of a (some generic thing)-type family UnwrapGenericS1 a where-    UnwrapGenericS1 (S1 c (Rec0 a)) = a+import Bytezap.Common.Generic ( type GTFoldMapCAddition )+import Data.Kind+import GHC.TypeNats+import Util.TypeNats ( natValInt )+import DeFun.Core ( type (~>) )  -- | Class for holding info on class to use for poking base cases. --@@ -39,42 +40,41 @@ -- -- We stay unboxed here because the internals are unboxed, just for convenience. -- Maybe this is bad, let me know.-class GPokeBase idx where+class GPokeBase tag where     -- | The state token of our poker.-    type GPokeBaseSt idx+    type GPokeBaseSt tag      -- | The type class that provides base case poking.     --     -- The type class should provide a function that looks like 'gPokeBase'.-    type GPokeBaseC idx a :: Constraint--    gPokeBase :: GPokeBaseC idx a => a -> Poke# (GPokeBaseSt idx)+    type GPokeBaseC tag a :: Constraint -    -- | The type class that provides poked length (known at compile time).-    type KnownSizeOf' idx a :: Constraint+    gPokeBase :: GPokeBaseC tag a => a -> Poke# (GPokeBaseSt tag) -    -- | Get the poked length of the given type. Unboxed because I felt like it.-    ---    -- I think we have to pass a proxy, because of forall limitations on-    -- instance signatures. This would be much better with explicit type-    -- variables (GHC 9.10 or 9.12).-    sizeOf' :: forall a. KnownSizeOf' idx a => Proxy# a -> Int#+    type GPokeBaseLenTF tag :: Type ~> Natural -class GPoke idx f where gPoke :: f p -> Poke# (GPokeBaseSt idx)+class GPoke tag f where gPoke :: f p -> Poke# (GPokeBaseSt tag) -instance GPoke idx f => GPoke idx (D1 c f) where gPoke = gPoke @idx . unM1-instance GPoke idx f => GPoke idx (C1 c f) where gPoke = gPoke @idx . unM1+instance GPoke tag f => GPoke tag (D1 c f) where gPoke = gPoke @tag . unM1+instance GPoke tag f => GPoke tag (C1 c f) where gPoke = gPoke @tag . unM1 -instance (GPoke idx l, GPoke idx r, GPokeBase idx, KnownSizeOf' idx (UnwrapGenericS1 l))-  => GPoke idx (l :*: r) where+instance+  ( GPoke tag l+  , GPoke tag r+  , GPokeBase tag+  , lenL ~ GTFoldMapCAddition (GPokeBaseLenTF tag) l+  , KnownNat lenL+  ) => GPoke tag (l :*: r) where     -- TODO moved os and s0 to RHS because base is const and those aren't?     -- will this change anything?? idk!!!!     gPoke (l :*: r) base# = \os# s0 ->-        case gPoke @idx l base# os# s0 of-          s1 -> gPoke @idx r base# (os# +# sizeOf' @idx @(UnwrapGenericS1 l) proxy#) s1+        case gPoke @tag l base# os# s0 of+          s1 -> gPoke @tag r base# (os# +# lenL#) s1+      where+        !(I# lenL#) = natValInt @lenL -instance (GPokeBase idx, GPokeBaseC idx a) => GPoke idx (S1 c (Rec0 a)) where-    gPoke = gPokeBase @idx . unK1 . unM1+instance (GPokeBase tag, GPokeBaseC tag a) => GPoke tag (S1 c (Rec0 a)) where+    gPoke = gPokeBase @tag . unK1 . unM1  -- | Wow, look! Nothing!-instance GPoke idx U1 where gPoke U1 _base# = \_os# s0 -> s0+instance GPoke tag U1 where gPoke U1 _base# = \_os# s0 -> s0

@@ -1,102 +0,0 @@-{- | Efficient type-level bytestring serialization.--@['Natural']@s have a convenient syntax, and we can use them as a type-level-bytestring by asserting that each 'Natural' is <=255 when reifying. This module-provides type classes which give you a serializer for a given @['Natural']@.--We maximize efficiency by grouping bytes into machine words. We have to be-pretty verbose to achieve this. Each type class attempts to group bytes into its-machine word type, and if it can't (i.e. not enough bytes remain), it hands off-to the next type class which handles the next smaller machine word.--I did a quick Core check and found that GHC seems to successfully generate-minimal code for this e.g. for an 8-byte magic, GHC will do one-@writeWord64OffAddr#@ of a constant. Great!--}--{-# LANGUAGE AllowAmbiguousTypes, UndecidableInstances #-}--module Bytezap.Struct.TypeLits where--import Raehik.TypeLevelBytes-import Bytezap.Struct ( Poke, sequencePokes, emptyPoke, prim )-import Numeric.Natural ( Natural )---- | Serialize a type-level bytestring, largest grouping 'Word64'.-class ReifyBytesW64 (ns :: [Natural]) where reifyBytesW64 :: Poke n---- | Enough bytes to make a 'Word64'.-instance {-# OVERLAPPING #-}-  ( ReifyW8 n1-  , ReifyW8 n2-  , ReifyW8 n3-  , ReifyW8 n4-  , ReifyW8 n5-  , ReifyW8 n6-  , ReifyW8 n7-  , ReifyW8 n8-  , ReifyBytesW64 ns-  ) => ReifyBytesW64 (n1 ': n2 ': n3 ': n4 ': n5 ': n6 ': n7 ': n8 ': ns) where-    {-# INLINE reifyBytesW64 #-}-    reifyBytesW64 = sequencePokes-        (prim (reifyW64 @n1 @n2 @n3 @n4 @n5 @n6 @n7 @n8)) 8 (reifyBytesW64 @ns)---- | Try to group 'Word32's next.-instance ReifyBytesW32 ns => ReifyBytesW64 ns where-    {-# INLINE reifyBytesW64 #-}-    reifyBytesW64 = reifyBytesW32 @ns---- | Serialize a type-level bytestring, largest grouping 'Word32'.-class ReifyBytesW32 (ns :: [Natural]) where reifyBytesW32 :: Poke s---- | Enough bytes to make a 'Word32'.-instance {-# OVERLAPPING #-}-  ( ReifyW8 n1-  , ReifyW8 n2-  , ReifyW8 n3-  , ReifyW8 n4-  , ReifyBytesW32 ns-  ) => ReifyBytesW32 (n1 ': n2 ': n3 ': n4 ': ns) where-    {-# INLINE reifyBytesW32 #-}-    reifyBytesW32 = sequencePokes-        (prim (reifyW32 @n1 @n2 @n3 @n4)) 4 (reifyBytesW32 @ns)---- | Try to group 'Word16's next.-instance ReifyBytesW16 ns => ReifyBytesW32 ns where-    {-# INLINE reifyBytesW32 #-}-    reifyBytesW32 = reifyBytesW16 @ns---- | Serialize a type-level bytestring, largest grouping 'Word32'.-class ReifyBytesW16 (ns :: [Natural]) where reifyBytesW16 :: Poke s---- | Enough bytes to make a 'Word16'.-instance-  ( ReifyW8 n1-  , ReifyW8 n2-  , ReifyBytesW16 ns-  ) => ReifyBytesW16 (n1 ': n2 ': ns) where-    {-# INLINE reifyBytesW16 #-}-    reifyBytesW16 = sequencePokes-        (prim (reifyW16 @n1 @n2)) 2 (reifyBytesW16 @ns)---- | Reify byte-by-byte next.-instance ReifyBytesW8 ns => ReifyBytesW16 ns where-    {-# INLINE reifyBytesW16 #-}-    reifyBytesW16 = reifyBytesW8 @ns---- | Serialize a type-level bytestring, byte-by-byte.-class ReifyBytesW8 (ns :: [Natural]) where reifyBytesW8 :: Poke s---- | Reify the next byte.-instance-  ( ReifyW8 n1-  , ReifyBytesW8 ns-  ) => ReifyBytesW8 (n1 ': ns) where-    {-# INLINE reifyBytesW8 #-}-    reifyBytesW8 = sequencePokes-        (prim (reifyW8 @n1)) 1 (reifyBytesW8 @ns)---- | End of the line.-instance ReifyBytesW8 '[] where-    {-# INLINE reifyBytesW8 #-}-    reifyBytesW8 = emptyPoke

@@ -0,0 +1,107 @@+{- | Efficient type-level bytestring serialization.++@['Natural']@s have a convenient syntax, and we can use them as a type-level+bytestring by asserting that each 'Natural' is <=255 when reifying. This module+provides type classes which give you a serializer for a given @['Natural']@.++We maximize efficiency by grouping bytes into machine words. We have to be+pretty verbose to achieve this. Each type class attempts to group bytes into its+machine word type, and if it can't (i.e. not enough bytes remain), it hands off+to the next type class which handles the next smaller machine word.++I did a quick Core check and found that GHC seems to successfully generate+minimal code for this e.g. for an 8-byte magic, GHC will do one+@writeWord64OffAddr#@ of a constant. Great!++The only way I can think of to make this faster is to somehow obtain an 'Addr#'+with a known length. With that, we could @memcpy@. But that would be slower for+small magics, and maybe others. And I doubt we can conjure up an 'Addr#' at+compile time. So I'm fairly confident that this is the best you're gonna get.+-}++{-# LANGUAGE AllowAmbiguousTypes, UndecidableInstances #-}++module Bytezap.Struct.TypeLits.Bytes where++import Data.Type.Byte+import Bytezap.Struct ( Poke, sequencePokes, emptyPoke, prim )+import Numeric.Natural ( Natural )++-- | Serialize a type-level bytestring, largest grouping 'Word64'.+class ReifyBytesW64 (ns :: [Natural]) where reifyBytesW64 :: Poke s++-- | Enough bytes to make a 'Word64'.+instance {-# OVERLAPPING #-}+  ( ReifyW8 n1+  , ReifyW8 n2+  , ReifyW8 n3+  , ReifyW8 n4+  , ReifyW8 n5+  , ReifyW8 n6+  , ReifyW8 n7+  , ReifyW8 n8+  , ReifyBytesW64 ns+  ) => ReifyBytesW64 (n1 ': n2 ': n3 ': n4 ': n5 ': n6 ': n7 ': n8 ': ns) where+    {-# INLINE reifyBytesW64 #-}+    reifyBytesW64 = sequencePokes+        (prim (reifyW64 @n1 @n2 @n3 @n4 @n5 @n6 @n7 @n8)) 8 (reifyBytesW64 @ns)++-- | Try to group 'Word32's next.+instance ReifyBytesW32 ns => ReifyBytesW64 ns where+    {-# INLINE reifyBytesW64 #-}+    reifyBytesW64 = reifyBytesW32 @ns++-- | Serialize a type-level bytestring, largest grouping 'Word32'.+class ReifyBytesW32 (ns :: [Natural]) where reifyBytesW32 :: Poke s++-- | Enough bytes to make a 'Word32'.+instance {-# OVERLAPPING #-}+  ( ReifyW8 n1+  , ReifyW8 n2+  , ReifyW8 n3+  , ReifyW8 n4+  , ReifyBytesW32 ns+  ) => ReifyBytesW32 (n1 ': n2 ': n3 ': n4 ': ns) where+    {-# INLINE reifyBytesW32 #-}+    reifyBytesW32 = sequencePokes+        (prim (reifyW32 @n1 @n2 @n3 @n4)) 4 (reifyBytesW32 @ns)++-- | Try to group 'Word16's next.+instance ReifyBytesW16 ns => ReifyBytesW32 ns where+    {-# INLINE reifyBytesW32 #-}+    reifyBytesW32 = reifyBytesW16 @ns++-- | Serialize a type-level bytestring, largest grouping 'Word16'.+class ReifyBytesW16 (ns :: [Natural]) where reifyBytesW16 :: Poke s++-- | Enough bytes to make a 'Word16'.+instance {-# OVERLAPPING #-}+  ( ReifyW8 n1+  , ReifyW8 n2+  , ReifyBytesW16 ns+  ) => ReifyBytesW16 (n1 ': n2 ': ns) where+    {-# INLINE reifyBytesW16 #-}+    reifyBytesW16 = sequencePokes+        (prim (reifyW16 @n1 @n2)) 2 (reifyBytesW16 @ns)++-- | Reify byte-by-byte next.+instance ReifyBytesW8 ns => ReifyBytesW16 ns where+    {-# INLINE reifyBytesW16 #-}+    reifyBytesW16 = reifyBytesW8 @ns++-- | Serialize a type-level bytestring, byte-by-byte.+class ReifyBytesW8 (ns :: [Natural]) where reifyBytesW8 :: Poke s++-- | Reify the next byte.+instance+  ( ReifyW8 n1+  , ReifyBytesW8 ns+  ) => ReifyBytesW8 (n1 ': ns) where+    {-# INLINE reifyBytesW8 #-}+    reifyBytesW8 = sequencePokes+        (prim (reifyW8 @n1)) 1 (reifyBytesW8 @ns)++-- | End of the line.+instance ReifyBytesW8 '[] where+    {-# INLINE reifyBytesW8 #-}+    reifyBytesW8 = emptyPoke

@@ -32,8 +32,8 @@     byteSwap = castWord64ToDouble . byteSwap . castDoubleToWord64  newtype ByteOrdered (end :: ByteOrder) a = ByteOrdered-  { unByteOrdered :: a }-    deriving (Ord, Eq, Show, Num) via a+  { unByteOrdered :: a+  } deriving (Ord, Eq, Show, Num, Real, Enum, Integral) via a  -- | Newtype for easier instance derivation. newtype PrimByteSwapped a = PrimByteSwapped { unPrimByteSwapped :: a }

@@ -1,319 +0,0 @@--- | Utilities for using @Natural@s as type-level bytes.--{-# LANGUAGE AllowAmbiguousTypes #-}--module Raehik.TypeLevelBytes where--import Numeric.Natural ( Natural )-import Data.Word ( Word8, Word16, Word32, Word64 )-import Data.Bits ( unsafeShiftL, (.|.) )--{-# INLINE reifyW64 #-}--- | Reify 8 type-level bytes to a 'Word64'.-reifyW64-    :: forall n1 n2 n3 n4 n5 n6 n7 n8-    .  ( ReifyW8 n1-       , ReifyW8 n2-       , ReifyW8 n3-       , ReifyW8 n4-       , ReifyW8 n5-       , ReifyW8 n6-       , ReifyW8 n7-       , ReifyW8 n8-    ) => Word64-reifyW64 =            fI (reifyW8 @n1)-    .|. unsafeShiftL (fI (reifyW8 @n2))  8-    .|. unsafeShiftL (fI (reifyW8 @n3)) 16-    .|. unsafeShiftL (fI (reifyW8 @n4)) 24-    .|. unsafeShiftL (fI (reifyW8 @n5)) 32-    .|. unsafeShiftL (fI (reifyW8 @n6)) 40-    .|. unsafeShiftL (fI (reifyW8 @n7)) 48-    .|. unsafeShiftL (fI (reifyW8 @n8)) 56-  where fI = fromIntegral--{-# INLINE reifyW32 #-}--- | Reify 4 type-level bytes to a 'Word32'.-reifyW32-    :: forall n1 n2 n3 n4-    .  ( ReifyW8 n1-       , ReifyW8 n2-       , ReifyW8 n3-       , ReifyW8 n4-    ) => Word32-reifyW32 =            fI (reifyW8 @n1)-    .|. unsafeShiftL (fI (reifyW8 @n2))  8-    .|. unsafeShiftL (fI (reifyW8 @n3)) 16-    .|. unsafeShiftL (fI (reifyW8 @n4)) 24-  where fI = fromIntegral--{-# INLINE reifyW16 #-}--- | Reify 2 type-level bytes to a 'Word16'.-reifyW16-    :: forall n1 n2-    .  ( ReifyW8 n1-       , ReifyW8 n2-    ) => Word16-reifyW16 =            fI (reifyW8 @n1)-    .|. unsafeShiftL (fI (reifyW8 @n2))  8-  where fI = fromIntegral---- | Reify a type-level byte (stored in a type-level 'Natural') to its 'Word8'.------ Attempting to reify a 'Natural' larger than 255 results in a type error.-class ReifyW8 (n :: Natural) where reifyW8 :: Word8-instance ReifyW8 0x00 where reifyW8 = 0x00-instance ReifyW8 0x01 where reifyW8 = 0x01-instance ReifyW8 0x02 where reifyW8 = 0x02-instance ReifyW8 0x03 where reifyW8 = 0x03-instance ReifyW8 0x04 where reifyW8 = 0x04-instance ReifyW8 0x05 where reifyW8 = 0x05-instance ReifyW8 0x06 where reifyW8 = 0x06-instance ReifyW8 0x07 where reifyW8 = 0x07-instance ReifyW8 0x08 where reifyW8 = 0x08-instance ReifyW8 0x09 where reifyW8 = 0x09-instance ReifyW8 0x0a where reifyW8 = 0x0a-instance ReifyW8 0x0b where reifyW8 = 0x0b-instance ReifyW8 0x0c where reifyW8 = 0x0c-instance ReifyW8 0x0d where reifyW8 = 0x0d-instance ReifyW8 0x0e where reifyW8 = 0x0e-instance ReifyW8 0x0f where reifyW8 = 0x0f-instance ReifyW8 0x10 where reifyW8 = 0x10-instance ReifyW8 0x11 where reifyW8 = 0x11-instance ReifyW8 0x12 where reifyW8 = 0x12-instance ReifyW8 0x13 where reifyW8 = 0x13-instance ReifyW8 0x14 where reifyW8 = 0x14-instance ReifyW8 0x15 where reifyW8 = 0x15-instance ReifyW8 0x16 where reifyW8 = 0x16-instance ReifyW8 0x17 where reifyW8 = 0x17-instance ReifyW8 0x18 where reifyW8 = 0x18-instance ReifyW8 0x19 where reifyW8 = 0x19-instance ReifyW8 0x1a where reifyW8 = 0x1a-instance ReifyW8 0x1b where reifyW8 = 0x1b-instance ReifyW8 0x1c where reifyW8 = 0x1c-instance ReifyW8 0x1d where reifyW8 = 0x1d-instance ReifyW8 0x1e where reifyW8 = 0x1e-instance ReifyW8 0x1f where reifyW8 = 0x1f-instance ReifyW8 0x20 where reifyW8 = 0x20-instance ReifyW8 0x21 where reifyW8 = 0x21-instance ReifyW8 0x22 where reifyW8 = 0x22-instance ReifyW8 0x23 where reifyW8 = 0x23-instance ReifyW8 0x24 where reifyW8 = 0x24-instance ReifyW8 0x25 where reifyW8 = 0x25-instance ReifyW8 0x26 where reifyW8 = 0x26-instance ReifyW8 0x27 where reifyW8 = 0x27-instance ReifyW8 0x28 where reifyW8 = 0x28-instance ReifyW8 0x29 where reifyW8 = 0x29-instance ReifyW8 0x2a where reifyW8 = 0x2a-instance ReifyW8 0x2b where reifyW8 = 0x2b-instance ReifyW8 0x2c where reifyW8 = 0x2c-instance ReifyW8 0x2d where reifyW8 = 0x2d-instance ReifyW8 0x2e where reifyW8 = 0x2e-instance ReifyW8 0x2f where reifyW8 = 0x2f-instance ReifyW8 0x30 where reifyW8 = 0x30-instance ReifyW8 0x31 where reifyW8 = 0x31-instance ReifyW8 0x32 where reifyW8 = 0x32-instance ReifyW8 0x33 where reifyW8 = 0x33-instance ReifyW8 0x34 where reifyW8 = 0x34-instance ReifyW8 0x35 where reifyW8 = 0x35-instance ReifyW8 0x36 where reifyW8 = 0x36-instance ReifyW8 0x37 where reifyW8 = 0x37-instance ReifyW8 0x38 where reifyW8 = 0x38-instance ReifyW8 0x39 where reifyW8 = 0x39-instance ReifyW8 0x3a where reifyW8 = 0x3a-instance ReifyW8 0x3b where reifyW8 = 0x3b-instance ReifyW8 0x3c where reifyW8 = 0x3c-instance ReifyW8 0x3d where reifyW8 = 0x3d-instance ReifyW8 0x3e where reifyW8 = 0x3e-instance ReifyW8 0x3f where reifyW8 = 0x3f-instance ReifyW8 0x40 where reifyW8 = 0x40-instance ReifyW8 0x41 where reifyW8 = 0x41-instance ReifyW8 0x42 where reifyW8 = 0x42-instance ReifyW8 0x43 where reifyW8 = 0x43-instance ReifyW8 0x44 where reifyW8 = 0x44-instance ReifyW8 0x45 where reifyW8 = 0x45-instance ReifyW8 0x46 where reifyW8 = 0x46-instance ReifyW8 0x47 where reifyW8 = 0x47-instance ReifyW8 0x48 where reifyW8 = 0x48-instance ReifyW8 0x49 where reifyW8 = 0x49-instance ReifyW8 0x4a where reifyW8 = 0x4a-instance ReifyW8 0x4b where reifyW8 = 0x4b-instance ReifyW8 0x4c where reifyW8 = 0x4c-instance ReifyW8 0x4d where reifyW8 = 0x4d-instance ReifyW8 0x4e where reifyW8 = 0x4e-instance ReifyW8 0x4f where reifyW8 = 0x4f-instance ReifyW8 0x50 where reifyW8 = 0x50-instance ReifyW8 0x51 where reifyW8 = 0x51-instance ReifyW8 0x52 where reifyW8 = 0x52-instance ReifyW8 0x53 where reifyW8 = 0x53-instance ReifyW8 0x54 where reifyW8 = 0x54-instance ReifyW8 0x55 where reifyW8 = 0x55-instance ReifyW8 0x56 where reifyW8 = 0x56-instance ReifyW8 0x57 where reifyW8 = 0x57-instance ReifyW8 0x58 where reifyW8 = 0x58-instance ReifyW8 0x59 where reifyW8 = 0x59-instance ReifyW8 0x5a where reifyW8 = 0x5a-instance ReifyW8 0x5b where reifyW8 = 0x5b-instance ReifyW8 0x5c where reifyW8 = 0x5c-instance ReifyW8 0x5d where reifyW8 = 0x5d-instance ReifyW8 0x5e where reifyW8 = 0x5e-instance ReifyW8 0x5f where reifyW8 = 0x5f-instance ReifyW8 0x60 where reifyW8 = 0x60-instance ReifyW8 0x61 where reifyW8 = 0x61-instance ReifyW8 0x62 where reifyW8 = 0x62-instance ReifyW8 0x63 where reifyW8 = 0x63-instance ReifyW8 0x64 where reifyW8 = 0x64-instance ReifyW8 0x65 where reifyW8 = 0x65-instance ReifyW8 0x66 where reifyW8 = 0x66-instance ReifyW8 0x67 where reifyW8 = 0x67-instance ReifyW8 0x68 where reifyW8 = 0x68-instance ReifyW8 0x69 where reifyW8 = 0x69-instance ReifyW8 0x6a where reifyW8 = 0x6a-instance ReifyW8 0x6b where reifyW8 = 0x6b-instance ReifyW8 0x6c where reifyW8 = 0x6c-instance ReifyW8 0x6d where reifyW8 = 0x6d-instance ReifyW8 0x6e where reifyW8 = 0x6e-instance ReifyW8 0x6f where reifyW8 = 0x6f-instance ReifyW8 0x70 where reifyW8 = 0x70-instance ReifyW8 0x71 where reifyW8 = 0x71-instance ReifyW8 0x72 where reifyW8 = 0x72-instance ReifyW8 0x73 where reifyW8 = 0x73-instance ReifyW8 0x74 where reifyW8 = 0x74-instance ReifyW8 0x75 where reifyW8 = 0x75-instance ReifyW8 0x76 where reifyW8 = 0x76-instance ReifyW8 0x77 where reifyW8 = 0x77-instance ReifyW8 0x78 where reifyW8 = 0x78-instance ReifyW8 0x79 where reifyW8 = 0x79-instance ReifyW8 0x7a where reifyW8 = 0x7a-instance ReifyW8 0x7b where reifyW8 = 0x7b-instance ReifyW8 0x7c where reifyW8 = 0x7c-instance ReifyW8 0x7d where reifyW8 = 0x7d-instance ReifyW8 0x7e where reifyW8 = 0x7e-instance ReifyW8 0x7f where reifyW8 = 0x7f-instance ReifyW8 0x80 where reifyW8 = 0x80-instance ReifyW8 0x81 where reifyW8 = 0x81-instance ReifyW8 0x82 where reifyW8 = 0x82-instance ReifyW8 0x83 where reifyW8 = 0x83-instance ReifyW8 0x84 where reifyW8 = 0x84-instance ReifyW8 0x85 where reifyW8 = 0x85-instance ReifyW8 0x86 where reifyW8 = 0x86-instance ReifyW8 0x87 where reifyW8 = 0x87-instance ReifyW8 0x88 where reifyW8 = 0x88-instance ReifyW8 0x89 where reifyW8 = 0x89-instance ReifyW8 0x8a where reifyW8 = 0x8a-instance ReifyW8 0x8b where reifyW8 = 0x8b-instance ReifyW8 0x8c where reifyW8 = 0x8c-instance ReifyW8 0x8d where reifyW8 = 0x8d-instance ReifyW8 0x8e where reifyW8 = 0x8e-instance ReifyW8 0x8f where reifyW8 = 0x8f-instance ReifyW8 0x90 where reifyW8 = 0x90-instance ReifyW8 0x91 where reifyW8 = 0x91-instance ReifyW8 0x92 where reifyW8 = 0x92-instance ReifyW8 0x93 where reifyW8 = 0x93-instance ReifyW8 0x94 where reifyW8 = 0x94-instance ReifyW8 0x95 where reifyW8 = 0x95-instance ReifyW8 0x96 where reifyW8 = 0x96-instance ReifyW8 0x97 where reifyW8 = 0x97-instance ReifyW8 0x98 where reifyW8 = 0x98-instance ReifyW8 0x99 where reifyW8 = 0x99-instance ReifyW8 0x9a where reifyW8 = 0x9a-instance ReifyW8 0x9b where reifyW8 = 0x9b-instance ReifyW8 0x9c where reifyW8 = 0x9c-instance ReifyW8 0x9d where reifyW8 = 0x9d-instance ReifyW8 0x9e where reifyW8 = 0x9e-instance ReifyW8 0x9f where reifyW8 = 0x9f-instance ReifyW8 0xa0 where reifyW8 = 0xa0-instance ReifyW8 0xa1 where reifyW8 = 0xa1-instance ReifyW8 0xa2 where reifyW8 = 0xa2-instance ReifyW8 0xa3 where reifyW8 = 0xa3-instance ReifyW8 0xa4 where reifyW8 = 0xa4-instance ReifyW8 0xa5 where reifyW8 = 0xa5-instance ReifyW8 0xa6 where reifyW8 = 0xa6-instance ReifyW8 0xa7 where reifyW8 = 0xa7-instance ReifyW8 0xa8 where reifyW8 = 0xa8-instance ReifyW8 0xa9 where reifyW8 = 0xa9-instance ReifyW8 0xaa where reifyW8 = 0xaa-instance ReifyW8 0xab where reifyW8 = 0xab-instance ReifyW8 0xac where reifyW8 = 0xac-instance ReifyW8 0xad where reifyW8 = 0xad-instance ReifyW8 0xae where reifyW8 = 0xae-instance ReifyW8 0xaf where reifyW8 = 0xaf-instance ReifyW8 0xb0 where reifyW8 = 0xb0-instance ReifyW8 0xb1 where reifyW8 = 0xb1-instance ReifyW8 0xb2 where reifyW8 = 0xb2-instance ReifyW8 0xb3 where reifyW8 = 0xb3-instance ReifyW8 0xb4 where reifyW8 = 0xb4-instance ReifyW8 0xb5 where reifyW8 = 0xb5-instance ReifyW8 0xb6 where reifyW8 = 0xb6-instance ReifyW8 0xb7 where reifyW8 = 0xb7-instance ReifyW8 0xb8 where reifyW8 = 0xb8-instance ReifyW8 0xb9 where reifyW8 = 0xb9-instance ReifyW8 0xba where reifyW8 = 0xba-instance ReifyW8 0xbb where reifyW8 = 0xbb-instance ReifyW8 0xbc where reifyW8 = 0xbc-instance ReifyW8 0xbd where reifyW8 = 0xbd-instance ReifyW8 0xbe where reifyW8 = 0xbe-instance ReifyW8 0xbf where reifyW8 = 0xbf-instance ReifyW8 0xc0 where reifyW8 = 0xc0-instance ReifyW8 0xc1 where reifyW8 = 0xc1-instance ReifyW8 0xc2 where reifyW8 = 0xc2-instance ReifyW8 0xc3 where reifyW8 = 0xc3-instance ReifyW8 0xc4 where reifyW8 = 0xc4-instance ReifyW8 0xc5 where reifyW8 = 0xc5-instance ReifyW8 0xc6 where reifyW8 = 0xc6-instance ReifyW8 0xc7 where reifyW8 = 0xc7-instance ReifyW8 0xc8 where reifyW8 = 0xc8-instance ReifyW8 0xc9 where reifyW8 = 0xc9-instance ReifyW8 0xca where reifyW8 = 0xca-instance ReifyW8 0xcb where reifyW8 = 0xcb-instance ReifyW8 0xcc where reifyW8 = 0xcc-instance ReifyW8 0xcd where reifyW8 = 0xcd-instance ReifyW8 0xce where reifyW8 = 0xce-instance ReifyW8 0xcf where reifyW8 = 0xcf-instance ReifyW8 0xd0 where reifyW8 = 0xd0-instance ReifyW8 0xd1 where reifyW8 = 0xd1-instance ReifyW8 0xd2 where reifyW8 = 0xd2-instance ReifyW8 0xd3 where reifyW8 = 0xd3-instance ReifyW8 0xd4 where reifyW8 = 0xd4-instance ReifyW8 0xd5 where reifyW8 = 0xd5-instance ReifyW8 0xd6 where reifyW8 = 0xd6-instance ReifyW8 0xd7 where reifyW8 = 0xd7-instance ReifyW8 0xd8 where reifyW8 = 0xd8-instance ReifyW8 0xd9 where reifyW8 = 0xd9-instance ReifyW8 0xda where reifyW8 = 0xda-instance ReifyW8 0xdb where reifyW8 = 0xdb-instance ReifyW8 0xdc where reifyW8 = 0xdc-instance ReifyW8 0xdd where reifyW8 = 0xdd-instance ReifyW8 0xde where reifyW8 = 0xde-instance ReifyW8 0xdf where reifyW8 = 0xdf-instance ReifyW8 0xe0 where reifyW8 = 0xe0-instance ReifyW8 0xe1 where reifyW8 = 0xe1-instance ReifyW8 0xe2 where reifyW8 = 0xe2-instance ReifyW8 0xe3 where reifyW8 = 0xe3-instance ReifyW8 0xe4 where reifyW8 = 0xe4-instance ReifyW8 0xe5 where reifyW8 = 0xe5-instance ReifyW8 0xe6 where reifyW8 = 0xe6-instance ReifyW8 0xe7 where reifyW8 = 0xe7-instance ReifyW8 0xe8 where reifyW8 = 0xe8-instance ReifyW8 0xe9 where reifyW8 = 0xe9-instance ReifyW8 0xea where reifyW8 = 0xea-instance ReifyW8 0xeb where reifyW8 = 0xeb-instance ReifyW8 0xec where reifyW8 = 0xec-instance ReifyW8 0xed where reifyW8 = 0xed-instance ReifyW8 0xee where reifyW8 = 0xee-instance ReifyW8 0xef where reifyW8 = 0xef-instance ReifyW8 0xf0 where reifyW8 = 0xf0-instance ReifyW8 0xf1 where reifyW8 = 0xf1-instance ReifyW8 0xf2 where reifyW8 = 0xf2-instance ReifyW8 0xf3 where reifyW8 = 0xf3-instance ReifyW8 0xf4 where reifyW8 = 0xf4-instance ReifyW8 0xf5 where reifyW8 = 0xf5-instance ReifyW8 0xf6 where reifyW8 = 0xf6-instance ReifyW8 0xf7 where reifyW8 = 0xf7-instance ReifyW8 0xf8 where reifyW8 = 0xf8-instance ReifyW8 0xf9 where reifyW8 = 0xf9-instance ReifyW8 0xfa where reifyW8 = 0xfa-instance ReifyW8 0xfb where reifyW8 = 0xfb-instance ReifyW8 0xfc where reifyW8 = 0xfc-instance ReifyW8 0xfd where reifyW8 = 0xfd-instance ReifyW8 0xfe where reifyW8 = 0xfe-instance ReifyW8 0xff where reifyW8 = 0xff