describe 0.2.0.6 → 0.3.0.0

raw patch · 14 files changed

+283/−165 lines, 14 filesdep +textPVP ok

version bump matches the API change (PVP)

Dependencies added: text

API changes (from Hackage documentation)

Files

• CHANGELOG.md +5/−0
• describe.cabal +13/−3
• src/Data/Serialize/Describe/Class.hs +7/−57
• src/Data/Serialize/Describe/Combinators.hs +18/−50
• src/Data/Serialize/Describe/Combinators/BE.hs +46/−22
• src/Data/Serialize/Describe/Combinators/ByteEnum.hs +16/−0
• src/Data/Serialize/Describe/Combinators/Conditional.hs +36/−0
• src/Data/Serialize/Describe/Combinators/Const.hs +14/−0
• src/Data/Serialize/Describe/Combinators/FList.hs +30/−0
• src/Data/Serialize/Describe/Combinators/FText.hs +32/−0
• src/Data/Serialize/Describe/Combinators/Isolate.hs +7/−0
• src/Data/Serialize/Describe/Combinators/LE.hs +45/−24
• src/Data/Serialize/Describe/Combinators/LPList.hs +14/−0
• src/Data/Serialize/Describe/Endianness.hs +0/−9

@@ -1,5 +1,10 @@ # Revision history for describe +##0.3.0.0 -- 2020-01-09++* Reorganized module structure+* Added new combinators: FText, ByteEnum, FList, LPList, Const+ ##0.2.0.6 -- 2019-10-08  * Added `isolate` combinator.

@@ -3,7 +3,7 @@ --   For further documentation, see http://haskell.org/cabal/users-guide/  name:                describe-version:             0.2.0.6+version:             0.3.0.0 synopsis:            Combinators for describing binary data structures description:         Combinators for describing binary data structures, which eliminate the boilerplate of having to write isomorphic Get and Put instances. Please see the Github page for examples. homepage:            https://github.com/riugabachi/describe@@ -23,6 +23,8 @@                       MultiParamTypeClasses,                       AllowAmbiguousTypes,                       FunctionalDependencies,+                      DerivingVia,+                      OverloadedStrings,                       TypeFamilies,                       TypeOperators,                       OverlappingInstances,@@ -31,6 +33,7 @@                       DefaultSignatures,                       DataKinds,                       UndecidableInstances,+                      PolyKinds,                       KindSignatures                       ConstraintKinds,                       EmptyDataDecls,@@ -39,7 +42,8 @@   build-depends: base ^>= 4.12.0.0,                  cereal >= 0.5.8 && < 0.6,                  bytestring >= 0.10.8 && < 0.11,-                 fixed-vector >= 1.2.0 && < 1.3+                 fixed-vector >= 1.2.0 && < 1.3,+                 text         >= 1.2.3 && < 1.3,   ghc-options: -Wall   default-language: Haskell2010 @@ -47,10 +51,16 @@   import: deps   exposed-modules:     Data.Serialize.Describe,                        Data.Serialize.Describe.Descriptor,-                       Data.Serialize.Describe.Endianness,                        Data.Serialize.Describe.Combinators,                        Data.Serialize.Describe.Combinators.LE,                        Data.Serialize.Describe.Combinators.BE,+                       Data.Serialize.Describe.Combinators.Conditional,+                       Data.Serialize.Describe.Combinators.FText,+                       Data.Serialize.Describe.Combinators.LPList,+                       Data.Serialize.Describe.Combinators.FList,+                       Data.Serialize.Describe.Combinators.Const,+                       Data.Serialize.Describe.Combinators.Isolate,+                       Data.Serialize.Describe.Combinators.ByteEnum,                        Data.Serialize.Describe.Class   hs-source-dirs:      src 

@@ -6,16 +6,14 @@ import GHC.TypeNats import Control.Monad import qualified Data.Vector.Fixed as V+import Data.Serialize.Get+import Data.Serialize.Put import Data.Vector.Fixed.Boxed (Vec) import Data.Int import Data.Proxy import Data.Word import Data.Serialize.Describe.Descriptor-import Data.Serialize.Describe.Endianness-import qualified Data.Serialize.Describe.Combinators.LE as LE-import qualified Data.Serialize.Describe.Combinators.BE as BE - class Describe a where   describe :: (s -> a) -> Descriptor s a @@ -44,65 +42,17 @@     where       extract (K1 x) = x +instance Describe () where+  describe _ = pure ()+ instance Describe Bool where     describe f = toEnum . fromIntegral <$> describe (fromIntegral @_ @Word8 . fromEnum . f)  instance Describe Word8 where-    describe f = Descriptor (unwrapGet (LE.w8 f), \s -> unwrapPut s (LE.w8 f >> pure (f s)))--instance Describe (LE Word16) where-    describe f = Descriptor (unwrapGet (LE <$> LE.w16 (unwrapLE . f)), \s -> unwrapPut s (LE.w16 (unwrapLE . f) >> pure (f s)))--instance Describe (LE Word32) where-    describe f = Descriptor (unwrapGet (LE <$> LE.w32 (unwrapLE . f)), \s -> unwrapPut s (LE.w32 (unwrapLE . f) >> pure (f s)))--instance Describe (LE Word64) where-    describe f = Descriptor (unwrapGet (LE <$> LE.w64 (unwrapLE . f)), \s -> unwrapPut s (LE.w64 (unwrapLE . f) >> pure (f s)))--instance Describe (BE Word16) where-    describe f = Descriptor (unwrapGet (BE <$> BE.w16 (unwrapBE . f)), \s -> unwrapPut s (BE.w16 (unwrapBE . f) >> pure (f s)))--instance Describe (BE Word32) where-    describe f = Descriptor (unwrapGet (BE <$> BE.w32 (unwrapBE . f)), \s -> unwrapPut s (BE.w32 (unwrapBE . f) >> pure (f s)))--instance Describe (BE Word64) where-    describe f = Descriptor (unwrapGet (BE <$> BE.w64 (unwrapBE . f)), \s -> unwrapPut s (BE.w64 (unwrapBE . f) >> pure (f s)))+    describe f = Descriptor (fromIntegral <$> getWord8, \s' -> putWord8 (fromIntegral $ f s') >> pure (fromIntegral $ f s'))  instance Describe Int8 where-    describe f = Descriptor (unwrapGet (LE.i8 f), \s -> unwrapPut s (LE.i8 f >> pure (f s)))--instance Describe (LE Int16) where-    describe f = Descriptor (unwrapGet (LE <$> LE.i16 (unwrapLE . f)), \s -> unwrapPut s (LE.i16 (unwrapLE . f) >> pure (f s)))--instance Describe (LE Int32) where-    describe f = Descriptor (unwrapGet (LE <$> LE.i32 (unwrapLE . f)), \s -> unwrapPut s (LE.i32 (unwrapLE . f) >> pure (f s)))--instance Describe (LE Int64) where-    describe f = Descriptor (unwrapGet (LE <$> LE.i64 (unwrapLE . f)), \s -> unwrapPut s (LE.i64 (unwrapLE . f) >> pure (f s)))--instance Describe (BE Int16) where-    describe f = Descriptor (unwrapGet (BE <$> BE.i16 (unwrapBE . f)), \s -> unwrapPut s (BE.i16 (unwrapBE . f) >> pure (f s)))--instance Describe (BE Int32) where-    describe f = Descriptor (unwrapGet (BE <$> BE.i32 (unwrapBE . f)), \s -> unwrapPut s (BE.i32 (unwrapBE . f) >> pure (f s)))--instance Describe (BE Int64) where-    describe f = Descriptor (unwrapGet (BE <$> BE.i64 (unwrapBE . f)), \s -> unwrapPut s (BE.i64 (unwrapBE . f) >> pure (f s)))--instance Describe (LE Float) where-    describe f = Descriptor (unwrapGet (LE <$> LE.f32 (unwrapLE . f)), \s -> unwrapPut s (LE.f32 (unwrapLE . f) >> pure (f s)))--instance Describe (LE Double) where-    describe f = Descriptor (unwrapGet (LE <$> LE.f64 (unwrapLE . f)), \s -> unwrapPut s (LE.f64 (unwrapLE . f) >> pure (f s)))--instance Describe (BE Float) where-    describe f = Descriptor (unwrapGet (BE <$> BE.f32 (unwrapBE . f)), \s -> unwrapPut s (BE.f32 (unwrapBE . f) >> pure (f s)))--instance Describe (BE Double) where-    describe f = Descriptor (unwrapGet (BE <$> BE.f64 (unwrapBE . f)), \s -> unwrapPut s (BE.f64 (unwrapBE . f) >> pure (f s)))--instance Describe () where-  describe _ = pure ()+    describe f = Descriptor (fromIntegral <$> getInt8, \s' -> putInt8 (fromIntegral $ f s') >> pure (f s'))  instance (Describe a, V.Arity n, V.Vector (Vec n) a, KnownNat n) => Describe (Vec n a) where     describe f =

@@ -1,53 +1,21 @@--- | Various type-level combinators to ease generic derivation of 'Describe' module Data.Serialize.Describe.Combinators(-  isolate,-  Remaining(..),-  Optional(..),-  Predicate(..),-  Equals+  module Data.Serialize.Describe.Combinators.Isolate,+  module Data.Serialize.Describe.Combinators.Remaining,+  module Data.Serialize.Describe.Combinators.FText,+  module Data.Serialize.Describe.Combinators.FList,+  module Data.Serialize.Describe.Combinators.LPList,+  module Data.Serialize.Describe.Combinators.Const,+  module Data.Serialize.Describe.Combinators.ByteEnum,+  module Data.Serialize.Describe.Combinators.Conditional,+  module Data.Serialize.Describe.Combinators.Byte ) where -import GHC.TypeNats-import Data.Proxy-import Data.Maybe-import Data.ByteString-import Data.Serialize.Describe.Descriptor-import Data.Serialize.Describe.Class-import qualified Data.Vector.Fixed as V-import Data.Vector.Fixed.Boxed (Vec)-import qualified Data.Serialize.Get as G-import qualified Data.Serialize.Put as P--isolate :: Int -> Descriptor s a -> Descriptor s a-isolate amt desc = Descriptor (G.isolate amt $ unwrapGet desc, flip unwrapPut desc)---- | A  'Remaining' represents the rest of the buffer. Upon serialization, the entire wrapped ByteString will be written.-newtype Remaining = Remaining { unwrapRemaining :: ByteString }--instance Describe Remaining where-  describe f = Descriptor (fmap Remaining . G.getByteString =<< G.remaining, \s -> P.putByteString (unwrapRemaining (f s)) >> pure (f s))---- | An 'Optional' represents a field which is optionally-serializable. The field will be parsed via a lookAhead and, if the value matches the 'Predicate' p, then the field exists. If not, it is assumed as though the field was never serialized in the first place and the value will be set to 'Nothing'; parsing will then continue on as usual.-newtype Optional p t = Optional { unwrapOptional :: Maybe t }--class Predicate t a where-  check :: t -> Bool--data Equals (n :: Nat)--instance (KnownNat n, Integral i) => Predicate i (Equals n) where-  check i = i == (fromIntegral $ natVal (Proxy :: Proxy n))--instance {-# OVERLAPPING #-} (KnownNat n1, KnownNat n2, V.Arity n2, V.Vector (Vec n2) i, Integral i) => Predicate (Vec n2 i) (Equals n1) where-  check = V.all (== fromIntegral (natVal (Proxy :: Proxy n1)))--instance (Describe a, Predicate a p) => Describe (Optional p a) where-  describe f = Descriptor (g, p)-    where-      g = do -        let d = unwrapGet $ describe @a $ fromJust . unwrapOptional . f-        v <- G.lookAhead d-        Optional <$> if check @a @p v then Just <$> d else pure Nothing-      p s = case unwrapOptional $ f s of-        Just x -> Optional . Just <$> unwrapPut s (describe $ const x)-        Nothing -> pure $ Optional Nothing+import Data.Serialize.Describe.Combinators.Isolate+import Data.Serialize.Describe.Combinators.Remaining+import Data.Serialize.Describe.Combinators.FText+import Data.Serialize.Describe.Combinators.FList+import Data.Serialize.Describe.Combinators.LPList+import Data.Serialize.Describe.Combinators.Const+import Data.Serialize.Describe.Combinators.ByteEnum+import Data.Serialize.Describe.Combinators.Conditional+import Data.Serialize.Describe.Combinators.Byte

@@ -4,8 +4,9 @@ -- Most of the time, this will be one of the structure's fields, which are all functions from the structure to the field type.  module Data.Serialize.Describe.Combinators.BE(-  w8, w16, w32, w64,-  i8, i16, i32, i64,+  BE(..),+  w16, w32, w64,+  i16, i32, i64,   f32, f64 ) where @@ -15,33 +16,56 @@ import Data.Serialize.Get import Data.Serialize.Put import Data.Serialize.Describe.Descriptor+import Data.Serialize.Describe.Class -w8 :: (a -> Word8) -> Descriptor a Word8-w8 f = Descriptor (getWord8, \s' -> putWord8 (f s') >> pure (f s'))+w16 :: Integral i => (s -> i) -> Descriptor s i+w16 f = Descriptor (fromIntegral <$> getWord16be, \s' -> putWord16be (fromIntegral $ f s') >> pure (f s')) -w16 :: (a -> Word16) -> Descriptor a Word16-w16 f = Descriptor (getWord16be, \s' -> putWord16be (f s') >> pure (f s'))+w32 :: Integral i => (s -> i) -> Descriptor s i+w32 f = Descriptor (fromIntegral <$> getWord32be, \s' -> putWord32be (fromIntegral $ f s') >> pure (f s')) -w32 :: (a -> Word32) -> Descriptor a Word32-w32 f = Descriptor (getWord32be, \s' -> putWord32be (f s') >> pure (f s'))+w64 :: Integral i => (s -> i) -> Descriptor s i+w64 f = Descriptor (fromIntegral <$> getWord64be, \s' -> putWord64be (fromIntegral $ f s') >> pure (f s')) -w64 :: (a -> Word64) -> Descriptor a Word64-w64 f = Descriptor (getWord64be, \s' -> putWord64be (f s') >> pure (f s'))+i16 :: Integral i => (s -> i) -> Descriptor s i+i16 f = Descriptor (fromIntegral <$> getInt16be, \s' -> putInt16be (fromIntegral $ f s') >> pure (f s')) -i8 :: (a -> Int8) -> Descriptor a Int8-i8 f = Descriptor (getInt8, \s' -> putInt8 (f s') >> pure (f s'))+i32 :: Integral i => (s -> i) -> Descriptor s i+i32 f = Descriptor (fromIntegral <$> getInt32be, \s' -> putInt32be (fromIntegral $ f s') >> pure (f s')) -i16 :: (a -> Int16) -> Descriptor a Int16-i16 f = Descriptor (getInt16be, \s' -> putInt16be (f s') >> pure (f s'))+i64 :: Integral i => (s -> i) -> Descriptor s i+i64 f = Descriptor (fromIntegral <$> getInt64be, \s' -> putInt64be (fromIntegral $ f s') >> pure (f s')) -i32 :: (a -> Int32) -> Descriptor a Int32-i32 f = Descriptor (getInt32be, \s' -> putInt32be (f s') >> pure (f s'))+f32 :: (Real f, Fractional f) => (s -> f) -> Descriptor s f+f32 f = Descriptor (realToFrac <$> getFloat32be, \s' -> putFloat32be (realToFrac $ f s') >> pure (f s')) -i64 :: (a -> Int64) -> Descriptor a Int64-i64 f = Descriptor (getInt64be, \s' -> putInt64be (f s') >> pure (f s'))+f64 :: (Real f, Fractional f) => (s -> f) -> Descriptor s f+f64 f = Descriptor (realToFrac <$> getFloat64be, \s' -> putFloat64be (realToFrac $ f s') >> pure (f s')) -f32 :: (a -> Float) -> Descriptor a Float-f32 f = Descriptor (getFloat32be, \s' -> putFloat32be (f s') >> pure (f s'))+newtype BE a = BE { unwrapBE :: a }+             deriving (Show, Read, Num, Eq, Ord, Enum, Integral, Real, Fractional) -f64 :: (a -> Double) -> Descriptor a Double-f64 f = Descriptor (getFloat64be, \s' -> putFloat64be (f s') >> pure (f s'))+instance Describe (BE Word16) where+    describe = w16++instance Describe (BE Word32) where+    describe = w32++instance Describe (BE Word64) where+    describe = w64++instance Describe (BE Int16) where+    describe = i16++instance Describe (BE Int32) where+    describe = i32++instance Describe (BE Int64) where+    describe = i64++instance Describe (BE Float) where+    describe = f32++instance Describe (BE Double) where+    describe = f64+

@@ -0,0 +1,16 @@+module Data.Serialize.Describe.Combinators.ByteEnum where++import Data.Word+import Data.Serialize.Describe.Class++-- | Wraps an @Enum@ to be described as a Word8. Intended to be used with DerivingVia so as to not introduce unnecessary newtype wrappers:+-- @+--  data MyEnum = A | B | C +--              deriving Enum+--              deriving Describe via ByteEnum MyEnum+-- @+newtype ByteEnum e = ByteEnum { unwrapByteEnum :: e }++instance Enum e => Describe (ByteEnum e) where+  describe f = ByteEnum . toEnum . fromIntegral <$> describe @Word8 (fromIntegral . fromEnum . unwrapByteEnum . f)+

@@ -0,0 +1,36 @@+module Data.Serialize.Describe.Combinators.Conditional where++import GHC.TypeNats+import Data.Proxy+import Data.Maybe+import qualified Data.Vector.Fixed as V+import Data.Vector.Fixed.Boxed+import qualified Data.Serialize.Get as G+import Data.Serialize.Describe.Descriptor+import Data.Serialize.Describe.Class++-- | An 'Optional' represents a field which is optionally-serializable. The field will be parsed via a lookAhead and, if the value matches the 'Predicate' p, then the field exists. If not, it is assumed as though the field was never serialized in the first place and the value will be set to 'Nothing'; parsing will then continue on as usual.+newtype Optional p t = Optional { unwrapOptional :: Maybe t }++class Predicate t a where+  check :: t -> Bool++data Equals (n :: Nat)++instance (KnownNat n, Integral i) => Predicate i (Equals n) where+  check i = i == (fromIntegral $ natVal (Proxy :: Proxy n))++instance {-# OVERLAPPING #-} (KnownNat n1, KnownNat n2, V.Arity n2, V.Vector (Vec n2) i, Integral i) => Predicate (Vec n2 i) (Equals n1) where+  check = V.all (== fromIntegral (natVal (Proxy :: Proxy n1)))++instance (Describe a, Predicate a p) => Describe (Optional p a) where+  describe f = Descriptor (g, p)+    where+      g = do +        let d = unwrapGet $ describe @a $ fromJust . unwrapOptional . f+        v <- G.lookAhead d+        Optional <$> if check @a @p v then Just <$> d else pure Nothing+      p s = case unwrapOptional $ f s of+        Just x -> Optional . Just <$> unwrapPut s (describe $ const x)+        Nothing -> pure $ Optional Nothing+

@@ -0,0 +1,14 @@+module Data.Serialize.Describe.Combinators.Const where++import GHC.TypeNats+import Data.Serialize.Describe+import Data.Proxy++data Const (n :: Nat) t = Const++instance KnownNat n => Show (Const n t) where+  show _ = show $ natVal (Proxy :: Proxy n)++instance (KnownNat n, Describe t, Integral t) => Describe (Const n t) where+  describe _ = (Const <$) . describe @t $ const $ fromIntegral $ natVal $ (Proxy :: Proxy n)+

@@ -0,0 +1,30 @@+module Data.Serialize.Describe.Combinators.FList where++import GHC.TypeNats+import Data.Proxy+import Data.Serialize.Describe+import Data.Word+import Data.Serialize.Describe.Combinators.Const+import Control.Monad++newtype FList (n :: Nat) a +  = FList { unwrapFList :: [a] }+  deriving (Show) via [a]++class Nullable a where+  nullVal :: a++instance Nullable Word16 where+  nullVal = 0++instance Nullable (Const n a) where+  nullVal = Const++instance (KnownNat n, Nullable a, Describe a) => Describe (FList n a) where+  describe f = do+    let fixedLen = fromIntegral (natVal $ Proxy @n)+    fmap FList . forM [0..fixedLen - 1] $ \i -> +      describe $ \l ->+        let actualLen = length . take fixedLen . unwrapFList $ f l+         in (!! i) . (<> replicate (fixedLen - actualLen) (nullVal @a)) . unwrapFList $ f l+

@@ -0,0 +1,32 @@+module Data.Serialize.Describe.Combinators.FText where++import GHC.TypeNats+import Data.Word+import Data.Char+import Data.String+import Data.Proxy+import Data.Text (Text)+import qualified Data.Text as T+import Data.Serialize.Describe.Descriptor+import Data.Serialize.Describe.Class+import Control.Monad++-- | A fixed text descriptor which reads a fixed amount of bytes, discarding all trailing '\0' characters. Upon serializing, the text will either be truncated to the specified fixed length, or padded with '\0' characters to meet it.+ftext :: Int -> (s -> Text) -> Descriptor s Text+ftext maxLen f = +  fmap (T.takeWhile (/= '\0') . fromString . (fmap (chr . fromIntegral))) <$> forM [0..maxLen-1] $ \i -> describe $ \s -> +    let t = f s+        p = (<> T.replicate (maxLen - T.length t) "\0") . T.take maxLen $ t+     in fromIntegral @_ @Word8 . ord $ T.index p i++-- | Type-level variant of @ftext@.+newtype KnownNat n => FText n = FText { unwrapFText :: Text }+                              deriving (Show) via Text++instance KnownNat n => IsString (FText n) where+  fromString = FText . T.pack++instance KnownNat n => Describe (FText n) where+  describe f = +    FText <$> ftext (fromIntegral (natVal (Proxy :: Proxy n))) (fmap unwrapFText f)+

@@ -0,0 +1,7 @@+module Data.Serialize.Describe.Combinators.Isolate where++import qualified Data.Serialize.Get as G+import Data.Serialize.Describe.Descriptor++isolate :: Int -> Descriptor s a -> Descriptor s a+isolate amt desc = Descriptor (G.isolate amt $ unwrapGet desc, flip unwrapPut desc)

@@ -2,11 +2,10 @@ -- -- All combinators take a function that takes the structure being described ('a') and produces the specified data type from it. -- Most of the time, this will be one of the structure's fields, which are all functions from the structure to the field type.-- module Data.Serialize.Describe.Combinators.LE(-  w8, w16, w32, w64,-  i8, i16, i32, i64,+  LE(..),+  w16, w32, w64,+  i16, i32, i64,   f32, f64 ) where @@ -16,33 +15,55 @@ import Data.Serialize.Get import Data.Serialize.Put import Data.Serialize.Describe.Descriptor+import Data.Serialize.Describe.Class -w8 :: (a -> Word8) -> Descriptor a Word8-w8 f = Descriptor (getWord8, \s' -> putWord8 (f s') >> pure (f s'))+w16 :: Integral i => (s -> i) -> Descriptor s i+w16 f = Descriptor (fromIntegral <$> getWord16le, \s' -> putWord16le (fromIntegral $ f s') >> pure (f s')) -w16 :: (a -> Word16) -> Descriptor a Word16-w16 f = Descriptor (getWord16le, \s' -> putWord16le (f s') >> pure (f s'))+w32 :: Integral i => (s -> i) -> Descriptor s i+w32 f = Descriptor (fromIntegral <$> getWord32le, \s' -> putWord32le (fromIntegral $ f s') >> pure (f s')) -w32 :: (a -> Word32) -> Descriptor a Word32-w32 f = Descriptor (getWord32le, \s' -> putWord32le (f s') >> pure (f s'))+w64 :: Integral i => (s -> i) -> Descriptor s i+w64 f = Descriptor (fromIntegral <$> getWord64le, \s' -> putWord64le (fromIntegral $ f s') >> pure (f s')) -w64 :: (a -> Word64) -> Descriptor a Word64-w64 f = Descriptor (getWord64le, \s' -> putWord64le (f s') >> pure (f s'))+i16 :: Integral i => (s -> i) -> Descriptor s i+i16 f = Descriptor (fromIntegral <$> getInt16le, \s' -> putInt16le (fromIntegral $ f s') >> pure (f s')) -i8 :: (a -> Int8) -> Descriptor a Int8-i8 f = Descriptor (getInt8, \s' -> putInt8 (f s') >> pure (f s'))+i32 :: Integral i => (s -> i) -> Descriptor s i+i32 f = Descriptor (fromIntegral <$> getInt32le, \s' -> putInt32le (fromIntegral $ f s') >> pure (f s')) -i16 :: (a -> Int16) -> Descriptor a Int16-i16 f = Descriptor (getInt16le, \s' -> putInt16le (f s') >> pure (f s'))+i64 :: Integral i => (s -> i) -> Descriptor s i+i64 f = Descriptor (fromIntegral <$> getInt64le, \s' -> putInt64le (fromIntegral $ f s') >> pure (f s')) -i32 :: (a -> Int32) -> Descriptor a Int32-i32 f = Descriptor (getInt32le, \s' -> putInt32le (f s') >> pure (f s'))+f32 :: (Real f, Fractional f) => (s -> f) -> Descriptor s f+f32 f = Descriptor (realToFrac <$> getFloat32le, \s' -> putFloat32le (realToFrac $ f s') >> pure (f s')) -i64 :: (a -> Int64) -> Descriptor a Int64-i64 f = Descriptor (getInt64le, \s' -> putInt64le (f s') >> pure (f s'))+f64 :: (Real f, Fractional f) => (s -> f) -> Descriptor s f+f64 f = Descriptor (realToFrac <$> getFloat64le, \s' -> putFloat64le (realToFrac $ f s') >> pure (f s')) -f32 :: (a -> Float) -> Descriptor a Float-f32 f = Descriptor (getFloat32le, \s' -> putFloat32le (f s') >> pure (f s'))+newtype LE a = LE { unwrapLE :: a }+             deriving (Show, Read, Num, Eq, Ord, Enum, Integral, Real, Fractional) -f64 :: (a -> Double) -> Descriptor a Double-f64 f = Descriptor (getFloat64le, \s' -> putFloat64le (f s') >> pure (f s'))+instance Describe (LE Word16) where+    describe = w16++instance Describe (LE Word32) where+    describe = w32++instance Describe (LE Word64) where+    describe = w64++instance Describe (LE Int16) where+    describe = i16++instance Describe (LE Int32) where+    describe = i32++instance Describe (LE Int64) where+    describe = i64++instance Describe (LE Float) where+    describe = f32++instance Describe (LE Double) where+    describe = f64

@@ -0,0 +1,14 @@+module Data.Serialize.Describe.Combinators.LPList where++import Data.Serialize.Describe+import Control.Monad++newtype LPList t a +  = LPList { unwrapLPList :: [a] }+  deriving (Show) via [a]++instance (Describe t, Describe a, Integral t) => Describe (LPList t a) where+  describe f = do+    len <- describe @t $ fromIntegral . length . unwrapLPList . f+    fmap LPList $ forM [0..fromIntegral len-1] $ \i -> describe @a $ (!! i) . unwrapLPList . f +

@@ -1,9 +0,0 @@-module Data.Serialize.Describe.Endianness(-  LE(..),-  BE(..)-) where--newtype LE a = LE { unwrapLE :: a }--newtype BE a = BE { unwrapBE :: a }-