-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Haskus binary format manipulation
--   
--   A set of types and tools to manipulate binary data, memory, etc. In
--   particular to interface Haskell data types with foreign data types (C
--   structs, unions, enums, etc.).
@package haskus-binary
@version 0.6.0.0


-- | Unsigned and signed words
module Haskus.Format.Binary.Word

-- | 8-bit signed integer type
data Int8 :: *

-- | 16-bit signed integer type
data Int16 :: *

-- | 32-bit signed integer type
data Int32 :: *

-- | 64-bit signed integer type
data Int64 :: *

-- | Bit size

-- | Return a Word with at least <tt>n</tt> bits

-- | Haskell type representing the C <tt>size_t</tt> type.
newtype CSize :: *
CSize :: Word64 -> CSize

-- | Haskell type representing the C <tt>unsigned short</tt> type.
data CUShort :: *

-- | Haskell type representing the C <tt>short</tt> type.
data CShort :: *

-- | Haskell type representing the C <tt>unsigned int</tt> type.
data CUInt :: *

-- | Haskell type representing the C <tt>int</tt> type.
data CInt :: *

-- | Haskell type representing the C <tt>unsigned long</tt> type.
data CULong :: *

-- | Haskell type representing the C <tt>long</tt> type.
data CLong :: *
data Word# :: TYPE WordRep
data Int# :: TYPE IntRep
plusWord# :: Word# -> Word# -> Word#
minusWord# :: Word# -> Word# -> Word#
(+#) :: Int# -> Int# -> Int#
infixl 6 +#
(-#) :: Int# -> Int# -> Int#
infixl 6 -#
(==#) :: Int# -> Int# -> Int#
infix 4 ==#
(>#) :: Int# -> Int# -> Int#
infix 4 >#
(<#) :: Int# -> Int# -> Int#
infix 4 <#
(>=#) :: Int# -> Int# -> Int#
infix 4 >=#
(<=#) :: Int# -> Int# -> Int#
infix 4 <=#
ltWord# :: Word# -> Word# -> Int#
leWord# :: Word# -> Word# -> Int#
gtWord# :: Word# -> Word# -> Int#
geWord# :: Word# -> Word# -> Int#
eqWord# :: Word# -> Word# -> Int#

-- | Alias for <a>tagToEnum#</a>. Returns True if its parameter is 1# and
--   False if it is 0#.
isTrue# :: Int# -> Bool


-- | Memory layout
--   
--   Describe a memory region
module Haskus.Format.Binary.Layout

-- | Type obtained when following path p

-- | Offset obtained when following path p
type LayoutRoot = LayoutPath '[]

-- | Path in a layout
data LayoutPath (path :: [*])
LayoutPath :: LayoutPath

-- | Index in a layout path
data LayoutIndex (n :: Nat)
LayoutIndex :: LayoutIndex

-- | Symbol in a layout path
data LayoutSymbol (s :: Symbol)
LayoutSymbol :: LayoutSymbol

-- | Index in the layout path
layoutIndex :: forall n. LayoutPath '[LayoutIndex n]

-- | Symbol in the layout path
layoutSymbol :: forall s. LayoutPath '[LayoutSymbol s]


-- | Pointers
--   
--   A pointer is a number: an offset into a memory. This is the `Addr#`
--   type.
--   
--   We want the type-system to help us avoid errors when we use pointers,
--   hence we decorate them with phantom types describing the memory layout
--   at the pointed address. This is the `Ptr a` data type that wraps an
--   `Addr#`.
--   
--   We often want to associate finalizers to pointers, i.e., actions to be
--   run when the pointer is collected by the GC. These actions take the
--   pointer as a parameter. This is the `ForeignPtr a` data type.
--   
--   A `ForeignPtr a` cannot be manipulated like a number because somehow
--   we need to keep the pointer value that will be passed to the
--   finalizers. Moreover we don't want finalizers to be executed too
--   early, so we can't easily create a new ForeignPtr from another (it
--   would require a way to disable the existing finalizers of a
--   ForeignPtr, which would in turn open a whole can of worms). Hence we
--   use the `FinalizedPtr a` pointer type, which has an additional offset
--   field.
module Haskus.Format.Binary.Ptr

-- | Pointer operations
class PtrLike (p :: * -> *) where castPtr = unsafeCoerce indexField p _ = castPtr (p `indexPtr` natValue @(LayoutPathOffset l path)) (-->) l _ = indexField l (layoutSymbol :: LayoutPath '[LayoutSymbol s]) (-#>) l _ = indexField l (layoutIndex :: LayoutPath '[LayoutIndex n])

-- | Cast a pointer from one type to another
castPtr :: PtrLike p => p a -> p b

-- | Null pointer (offset is 0)
nullPtr :: forall a. PtrLike p => p a

-- | Advance a pointer by the given amount of bytes (may be negative)
indexPtr :: PtrLike p => p a -> Int -> p a

-- | Distance between two pointers in bytes (p2 - p1)
ptrDistance :: PtrLike p => p a -> p b -> Int

-- | Use the pointer
withPtr :: PtrLike p => p a -> (Ptr a -> IO b) -> IO b

-- | Malloc the given number of bytes
mallocBytes :: (PtrLike p, MonadIO m) => Word -> m (p a)

-- | Add offset to the given layout field
indexField :: forall path l. (PtrLike p, KnownNat (LayoutPathOffset l path)) => p l -> path -> p (LayoutPathType l path)

-- | Add offset corresponding to the layout field with the given symbol
(-->) :: forall s l. (PtrLike p, KnownNat (LayoutPathOffset l (LayoutPath '[LayoutSymbol s]))) => p l -> LayoutSymbol s -> p (LayoutPathType l (LayoutPath '[LayoutSymbol s]))

-- | Add offset corresponding to the layout field with the given index
(-#>) :: forall n l. (PtrLike p, KnownNat (LayoutPathOffset l (LayoutPath '[LayoutIndex n]))) => p l -> LayoutIndex n -> p (LayoutPathType l (LayoutPath '[LayoutIndex n]))

-- | Generalized version of <a>indexPtr</a>
indexPtr' :: Integral b => Ptr a -> b -> Ptr a

-- | A value of type <tt><a>Ptr</a> a</tt> represents a pointer to an
--   object, or an array of objects, which may be marshalled to or from
--   Haskell values of type <tt>a</tt>.
--   
--   The type <tt>a</tt> will often be an instance of class <a>Storable</a>
--   which provides the marshalling operations. However this is not
--   essential, and you can provide your own operations to access the
--   pointer. For example you might write small foreign functions to get or
--   set the fields of a C <tt>struct</tt>.
data Ptr a :: * -> *
Ptr :: Addr# -> Ptr a

-- | Free a malloced memory
free :: MonadIO m => Ptr a -> m ()

-- | A finalized pointer
--   
--   We use an offset because we can't modify the pointer directly (it is
--   passed to the foreign pointer destructors)
data FinalizedPtr l
FinalizedPtr :: {-# UNPACK #-} !(ForeignPtr l) -> {-# UNPACK #-} !Word -> FinalizedPtr l

-- | Use a finalized pointer
withFinalizedPtr :: FinalizedPtr a -> (Ptr a -> IO b) -> IO b

-- | The type <a>ForeignPtr</a> represents references to objects that are
--   maintained in a foreign language, i.e., that are not part of the data
--   structures usually managed by the Haskell storage manager. The
--   essential difference between <a>ForeignPtr</a>s and vanilla memory
--   references of type <tt>Ptr a</tt> is that the former may be associated
--   with <i>finalizers</i>. A finalizer is a routine that is invoked when
--   the Haskell storage manager detects that - within the Haskell heap and
--   stack - there are no more references left that are pointing to the
--   <a>ForeignPtr</a>. Typically, the finalizer will, then, invoke
--   routines in the foreign language that free the resources bound by the
--   foreign object.
--   
--   The <a>ForeignPtr</a> is parameterised in the same way as <a>Ptr</a>.
--   The type argument of <a>ForeignPtr</a> should normally be an instance
--   of class <a>Storable</a>.
data ForeignPtr a :: * -> *

-- | Use a foreign pointer
withForeignPtr :: (MonadInIO m) => ForeignPtr a -> (Ptr a -> m b) -> m b

-- | Malloc a foreign pointer
mallocForeignPtrBytes :: MonadIO m => Word -> m (ForeignPtr a)

-- | Null foreign pointer
nullForeignPtr :: ForeignPtr a

-- | A value of type <tt><a>FunPtr</a> a</tt> is a pointer to a function
--   callable from foreign code. The type <tt>a</tt> will normally be a
--   <i>foreign type</i>, a function type with zero or more arguments where
--   
--   <ul>
--   <li>the argument types are <i>marshallable foreign types</i>, i.e.
--   <a>Char</a>, <a>Int</a>, <a>Double</a>, <a>Float</a>, <a>Bool</a>,
--   <a>Int8</a>, <a>Int16</a>, <a>Int32</a>, <a>Int64</a>, <a>Word8</a>,
--   <a>Word16</a>, <a>Word32</a>, <a>Word64</a>, <tt><a>Ptr</a> a</tt>,
--   <tt><a>FunPtr</a> a</tt>, <tt><a>StablePtr</a> a</tt> or a renaming of
--   any of these using <tt>newtype</tt>.</li>
--   <li>the return type is either a marshallable foreign type or has the
--   form <tt><a>IO</a> t</tt> where <tt>t</tt> is a marshallable foreign
--   type or <tt>()</tt>.</li>
--   </ul>
--   
--   A value of type <tt><a>FunPtr</a> a</tt> may be a pointer to a foreign
--   function, either returned by another foreign function or imported with
--   a a static address import like
--   
--   <pre>
--   foreign import ccall "stdlib.h &amp;free"
--     p_free :: FunPtr (Ptr a -&gt; IO ())
--   </pre>
--   
--   or a pointer to a Haskell function created using a <i>wrapper</i> stub
--   declared to produce a <a>FunPtr</a> of the correct type. For example:
--   
--   <pre>
--   type Compare = Int -&gt; Int -&gt; Bool
--   foreign import ccall "wrapper"
--     mkCompare :: Compare -&gt; IO (FunPtr Compare)
--   </pre>
--   
--   Calls to wrapper stubs like <tt>mkCompare</tt> allocate storage, which
--   should be released with <a>freeHaskellFunPtr</a> when no longer
--   required.
--   
--   To convert <a>FunPtr</a> values to corresponding Haskell functions,
--   one can define a <i>dynamic</i> stub for the specific foreign type,
--   e.g.
--   
--   <pre>
--   type IntFunction = CInt -&gt; IO ()
--   foreign import ccall "dynamic"
--     mkFun :: FunPtr IntFunction -&gt; IntFunction
--   </pre>
data FunPtr a :: * -> *

-- | The constant <a>nullFunPtr</a> contains a distinguished value of
--   <a>FunPtr</a> that is not associated with a valid memory location.
nullFunPtr :: FunPtr a

-- | Casts a <a>Ptr</a> to a <a>FunPtr</a>.
--   
--   <i>Note:</i> this is valid only on architectures where data and
--   function pointers range over the same set of addresses, and should
--   only be used for bindings to external libraries whose interface
--   already relies on this assumption.
castPtrToFunPtr :: Ptr a -> FunPtr b

-- | Casts a <a>FunPtr</a> to a <a>Ptr</a>.
--   
--   <i>Note:</i> this is valid only on architectures where data and
--   function pointers range over the same set of addresses, and should
--   only be used for bindings to external libraries whose interface
--   already relies on this assumption.
castFunPtrToPtr :: FunPtr a -> Ptr b

-- | An unsigned integral type that can be losslessly converted to and from
--   <tt>Ptr</tt>. This type is also compatible with the C99 type
--   <tt>uintptr_t</tt>, and can be marshalled to and from that type
--   safely.
data WordPtr :: *

-- | casts a <tt>WordPtr</tt> to a <tt>Ptr</tt>
wordPtrToPtr :: WordPtr -> Ptr a

-- | casts a <tt>Ptr</tt> to a <tt>WordPtr</tt>
ptrToWordPtr :: Ptr a -> WordPtr
instance GHC.Show.Show (Haskus.Format.Binary.Ptr.FinalizedPtr l)
instance Haskus.Format.Binary.Ptr.PtrLike GHC.Ptr.Ptr
instance Haskus.Format.Binary.Ptr.PtrLike Haskus.Format.Binary.Ptr.FinalizedPtr


-- | Storable class
module Haskus.Format.Binary.Storable

-- | A storable data in constant space whose size is known at compile time
class StaticStorable a where type SizeOf a :: Nat type Alignment a :: Nat where {
    type family SizeOf a :: Nat;
    type family Alignment a :: Nat;
}

-- | Peek (read) a value from a memory address
staticPeekIO :: StaticStorable a => Ptr a -> IO a

-- | Poke (write) a value at the given memory address
staticPokeIO :: StaticStorable a => Ptr a -> a -> IO ()

-- | Peek (read) a value from a memory address
staticPeek :: (StaticStorable a, MonadIO m) => Ptr a -> m a

-- | Poke (write) a value at the given memory address
staticPoke :: (StaticStorable a, MonadIO m) => Ptr a -> a -> m ()

-- | Compute the required padding between a and b to respect b's alignment

-- | Compute the required padding between the size sz and b to respect b's
--   alignment

-- | Get statically known size
staticSizeOf :: forall a. (KnownNat (SizeOf a)) => a -> Word

-- | Get statically known alignment
staticAlignment :: forall a. (KnownNat (Alignment a)) => a -> Word

-- | Get bytes in host-endianness order
wordBytes :: forall a. (Storable a, KnownNat (SizeOf a)) => a -> [Word8]

-- | Storable data-types
--   
--   Currently we cannot automatically derive a Storable class with
--   type-level naturals for "alignment" and "sizeOf". Instead we define a
--   Storable class isomorphic to the Foreign.Storable's one but with
--   default methods using DefaultSignatures (i.e., the Storable instance
--   can be automatically derived from a Generic instance).
class Storable a where peekIO p = fmap to $ gcPeek 0 (castPtr p) pokeIO p x = gcPoke 0 (castPtr p) $ from x alignment = gcAlignment . from sizeOf = gcSizeOf 0 . from
peekIO :: Storable a => Ptr a -> IO a
peekIO :: (Storable a, Generic a, GStorable (Rep a)) => Ptr a -> IO a
pokeIO :: Storable a => Ptr a -> a -> IO ()
pokeIO :: (Storable a, Generic a, GStorable (Rep a)) => Ptr a -> a -> IO ()
alignment :: Storable a => a -> Word
alignment :: (Storable a, Generic a, GStorable (Rep a)) => a -> Word
sizeOf :: Storable a => a -> Word
sizeOf :: (Storable a, Generic a, GStorable (Rep a)) => a -> Word

-- | Peek a value from a pointer
peek :: (Storable a, MonadIO m) => Ptr a -> m a

-- | Poke a value to a pointer
poke :: (Storable a, MonadIO m) => Ptr a -> a -> m ()

-- | Generalized <a>sizeOf</a>
sizeOf' :: (Integral b, Storable a) => a -> b

-- | SizeOf (for type-application)
sizeOfT :: forall a. (Storable a) => Word

-- | SizeOf' (for type-application)
sizeOfT' :: forall a b. (Storable a, Integral b) => b

-- | Generalized <a>alignment</a>
alignment' :: (Integral b, Storable a) => a -> b

-- | Alignment (for type-application)
alignmentT :: forall a. (Storable a) => Word

-- | Alignment' (for type-application)
alignmentT' :: forall a b. (Storable a, Integral b) => b

-- | Peek with byte offset
peekByteOff :: (MonadIO m, Storable a) => Ptr a -> Int -> m a

-- | Poke with byte offset
pokeByteOff :: (MonadIO m, Storable a) => Ptr a -> Int -> a -> m ()

-- | Peek with element size offset
peekElemOff :: forall a m. (MonadIO m, Storable a) => Ptr a -> Int -> m a

-- | Poke with element size offset
pokeElemOff :: (MonadIO m, Storable a) => Ptr a -> Int -> a -> m ()

-- | <tt><a>alloca</a> f</tt> executes the computation <tt>f</tt>, passing
--   as argument a pointer to a temporarily allocated block of memory
--   sufficient to hold values of type <tt>a</tt>.
--   
--   The memory is freed when <tt>f</tt> terminates (either normally or via
--   an exception), so the pointer passed to <tt>f</tt> must <i>not</i> be
--   used after this.
alloca :: forall a b m. (MonadInIO m, Storable a) => (Ptr a -> m b) -> m b

-- | Allocate some bytes
allocaBytes :: MonadInIO m => Word -> (Ptr a -> m b) -> m b

-- | Allocate some aligned bytes
allocaBytesAligned :: MonadInIO m => Word -> Word -> (Ptr a -> m b) -> m b

-- | Allocate a block of memory that is sufficient to hold values of type
--   <tt>a</tt>. The size of the area allocated is determined by the
--   <a>sizeOf</a> method from the instance of <a>Storable</a> for the
--   appropriate type.
--   
--   The memory may be deallocated using <a>free</a> or
--   <tt>finalizerFree</tt> when no longer required.
malloc :: forall a m. (MonadIO m, Storable a) => m (Ptr a)

-- | <tt><a>with</a> val f</tt> executes the computation <tt>f</tt>,
--   passing as argument a pointer to a temporarily allocated block of
--   memory into which <tt>val</tt> has been marshalled (the combination of
--   <a>alloca</a> and <a>poke</a>).
--   
--   The memory is freed when <tt>f</tt> terminates (either normally or via
--   an exception), so the pointer passed to <tt>f</tt> must <i>not</i> be
--   used after this.
with :: (MonadInIO m, Storable a) => a -> (Ptr a -> m b) -> m b

-- | Replicates a <tt>withXXX</tt> combinator over a list of objects,
--   yielding a list of marshalled objects
withMany :: (a -> (b -> res) -> res) -> [a] -> ([b] -> res) -> res

-- | Temporarily allocate space for the given number of elements (like
--   <a>alloca</a>, but for multiple elements).
allocaArray :: forall a b m. (MonadInIO m, Storable a) => Word -> (Ptr a -> m b) -> m b

-- | Allocate space for the given number of elements (like <a>malloc</a>,
--   but for multiple elements).
mallocArray :: forall a m. (MonadIO m, Storable a) => Word -> m (Ptr a)

-- | Temporarily store a list of storable values in memory (like
--   <a>with</a>, but for multiple elements).
withArray :: (MonadInIO m, Storable a) => [a] -> (Ptr a -> m b) -> m b

-- | Like <a>withArray</a>, but the action gets the number of values as an
--   additional parameter
withArrayLen :: (MonadInIO m, Storable a) => [a] -> (Word -> Ptr a -> m b) -> m b

-- | Convert an array of given length into a Haskell list. The
--   implementation is tail-recursive and so uses constant stack space.
peekArray :: (MonadIO m, Storable a) => Word -> Ptr a -> m [a]

-- | Write the list elements consecutive into memory
pokeArray :: (MonadIO m, Storable a) => Ptr a -> [a] -> m ()
instance Haskus.Format.Binary.Storable.GStorable GHC.Generics.U1
instance (Haskus.Format.Binary.Storable.GStorable a, Haskus.Format.Binary.Storable.GStorable b) => Haskus.Format.Binary.Storable.GStorable (a GHC.Generics.:*: b)
instance Haskus.Format.Binary.Storable.GStorable a => Haskus.Format.Binary.Storable.GStorable (GHC.Generics.M1 i c a)
instance Haskus.Format.Binary.Storable.Storable a => Haskus.Format.Binary.Storable.GStorable (GHC.Generics.K1 i a)
instance Haskus.Format.Binary.Storable.StaticStorable GHC.Word.Word8
instance Haskus.Format.Binary.Storable.StaticStorable GHC.Word.Word16
instance Haskus.Format.Binary.Storable.StaticStorable GHC.Word.Word32
instance Haskus.Format.Binary.Storable.StaticStorable GHC.Word.Word64
instance Haskus.Format.Binary.Storable.StaticStorable GHC.Int.Int8
instance Haskus.Format.Binary.Storable.StaticStorable GHC.Int.Int16
instance Haskus.Format.Binary.Storable.StaticStorable GHC.Int.Int32
instance Haskus.Format.Binary.Storable.StaticStorable GHC.Int.Int64
instance Haskus.Format.Binary.Storable.Storable GHC.Word.Word8
instance Haskus.Format.Binary.Storable.Storable GHC.Word.Word16
instance Haskus.Format.Binary.Storable.Storable GHC.Word.Word32
instance Haskus.Format.Binary.Storable.Storable GHC.Word.Word64
instance Haskus.Format.Binary.Storable.Storable GHC.Int.Int8
instance Haskus.Format.Binary.Storable.Storable GHC.Int.Int16
instance Haskus.Format.Binary.Storable.Storable GHC.Int.Int32
instance Haskus.Format.Binary.Storable.Storable GHC.Int.Int64
instance Haskus.Format.Binary.Storable.Storable GHC.Types.Float
instance Haskus.Format.Binary.Storable.Storable GHC.Types.Double
instance Haskus.Format.Binary.Storable.Storable GHC.Types.Char
instance Haskus.Format.Binary.Storable.Storable GHC.Types.Word
instance Haskus.Format.Binary.Storable.Storable GHC.Types.Int
instance Haskus.Format.Binary.Storable.Storable (GHC.Ptr.Ptr a)
instance Haskus.Format.Binary.Storable.Storable Foreign.C.Types.CSize
instance Haskus.Format.Binary.Storable.Storable Foreign.C.Types.CChar
instance Haskus.Format.Binary.Storable.Storable Foreign.C.Types.CULong
instance Haskus.Format.Binary.Storable.Storable Foreign.C.Types.CLong
instance Haskus.Format.Binary.Storable.Storable Foreign.C.Types.CUInt
instance Haskus.Format.Binary.Storable.Storable Foreign.C.Types.CInt
instance Haskus.Format.Binary.Storable.Storable Foreign.C.Types.CUShort
instance Haskus.Format.Binary.Storable.Storable Foreign.C.Types.CShort
instance Haskus.Format.Binary.Storable.Storable Foreign.Ptr.WordPtr


-- | Memory utilities
module Haskus.Utils.Memory

-- | Copy memory
memCopy :: MonadIO m => Ptr a -> Ptr b -> Word64 -> m ()

-- | Set memory
memSet :: MonadIO m => Ptr a -> Word64 -> Word8 -> m ()

-- | Allocate several arrays
allocaArrays :: (MonadInIO m, Storable s, Integral a) => [a] -> ([Ptr s] -> m b) -> m b

-- | Peek several arrays
peekArrays :: (MonadIO m, Storable s, Integral a) => [a] -> [Ptr s] -> m [[s]]

-- | Poke several arrays
pokeArrays :: (MonadIO m, Storable s) => [Ptr s] -> [[s]] -> m ()

-- | Allocate several arrays
withArrays :: (MonadInIO m, Storable s) => [[s]] -> ([Ptr s] -> m b) -> m b

-- | Execute f with a pointer to <tt>a</tt> or NULL
withMaybeOrNull :: (Storable a, MonadInIO m) => Maybe a -> (Ptr a -> m b) -> m b


-- | Record (similar to C struct)
module Haskus.Format.Binary.Record

-- | Record
data Record (fields :: [*])

-- | Field
data Field (name :: Symbol) typ

-- | Get record size without the ending padding bytes

-- | Modulo
data Path (fs :: [Symbol])

-- | Get record size
recordSize :: forall fs. (KnownNat (FullRecordSize fs)) => Record fs -> Word

-- | Get record alignment
recordAlignment :: forall fs. (KnownNat (RecordAlignment fs 1)) => Record fs -> Word

-- | Get a field
recordField :: forall (name :: Symbol) a fs. (KnownNat (FieldOffset name fs 0), a ~ FieldType name fs, StaticStorable a) => Record fs -> a

-- | Get a field offset
recordFieldOffset :: forall (name :: Symbol) fs. (KnownNat (FieldOffset name fs 0)) => Record fs -> Int

-- | Get a field from its path
recordFieldPath :: forall path a fs o. (o ~ FieldPathOffset fs path 0, a ~ FieldPathType fs path, KnownNat o, StaticStorable a) => Path path -> Record fs -> a

-- | Get a field offset from its path
recordFieldPathOffset :: forall path fs o. (o ~ FieldPathOffset fs path 0, KnownNat o) => Path path -> Record fs -> Int

-- | Convert a record into a HList
recordToList :: forall fs. (HFoldr' Extract (Record fs, HList '[]) fs (Record fs, HList fs)) => Record fs -> HList fs
instance (s ~ Haskus.Format.Binary.Record.FullRecordSize fs, GHC.TypeLits.KnownNat s) => Haskus.Format.Binary.Storable.StaticStorable (Haskus.Format.Binary.Record.Record fs)
instance (rec ~ Haskus.Format.Binary.Record.Record fs, b ~ Haskus.Format.Binary.Record.Field name typ, i ~ (rec, Haskus.Utils.HList.HList l2), typ ~ Haskus.Format.Binary.Record.FieldType name fs, GHC.TypeLits.KnownNat (Haskus.Format.Binary.Record.FieldOffset name fs 0), Haskus.Format.Binary.Storable.StaticStorable typ, GHC.TypeLits.KnownSymbol name, r ~ (rec, Haskus.Utils.HList.HList ((GHC.Base.String, typ) : l2))) => Haskus.Utils.HList.Apply Haskus.Format.Binary.Record.Extract (b, i) r
instance (Haskus.Utils.HList.HFoldr' Haskus.Format.Binary.Record.Extract (Haskus.Format.Binary.Record.Record fs, Haskus.Utils.HList.HList '[]) fs (Haskus.Format.Binary.Record.Record fs, Haskus.Utils.HList.HList fs), GHC.Show.Show (Haskus.Utils.HList.HList fs)) => GHC.Show.Show (Haskus.Format.Binary.Record.Record fs)


-- | Union (as in C)
--   
--   Unions are storable and can contain any storable data.
--   
--   Use <a>fromUnion</a> to read a alternative:
--   
--   <pre>
--   {--}
--   
--   getUnion :: IO (Union '[Word16, Word32, Word64])
--   getUnion = ...
--   
--   test = do
--      u &lt;- getUnion
--   
--      -- to get one of the member
--      let v = fromUnion u :: Word16
--      let v = fromUnion u :: Word32
--      let v = fromUnion u :: Word64
--   
--      -- This won't compile (Word8 is not a member of the union)
--      let v = fromUnion u :: Word8
--   </pre>
--   
--   Use <a>toUnion</a> to create a new union: @
--   
--   let u2 :: Union '[Word32, Vector 4 Word8] u2 = toUnion (0x12345678 ::
--   Word32) @
module Haskus.Format.Binary.Union

-- | An union
--   
--   We use a list of types as a parameter.
--   
--   The union is just a pointer to a buffer containing the value(s). The
--   size of the buffer is implicitly known from the types in the list.
data Union (x :: [*])

-- | Retrieve a union member from its type
fromUnion :: (Storable a, IsMember a l ~ True) => Union l -> a

-- | Create a new union from one of the union types
toUnion :: forall a l. (Storable (Union l), Storable a, IsMember a l ~ True) => a -> Union l

-- | Like <a>toUnion</a> but set the remaining bytes to 0
toUnionZero :: forall a l. (Storable (Union l), Storable a, IsMember a l ~ True) => a -> Union l
instance GHC.Show.Show (Haskus.Format.Binary.Union.Union x)
instance (GHC.TypeLits.KnownNat (Haskus.Utils.Types.List.Max (Haskus.Format.Binary.Union.MapSizeOf fs)), GHC.TypeLits.KnownNat (Haskus.Utils.Types.List.Max (Haskus.Format.Binary.Union.MapAlignment fs))) => Haskus.Format.Binary.Storable.StaticStorable (Haskus.Format.Binary.Union.Union fs)
instance (r ~ GHC.Types.Word, Haskus.Format.Binary.Storable.Storable a) => Haskus.Utils.HList.Apply Haskus.Format.Binary.Union.FoldSizeOf (a, GHC.Types.Word) r
instance (r ~ GHC.Types.Word, Haskus.Format.Binary.Storable.Storable a) => Haskus.Utils.HList.Apply Haskus.Format.Binary.Union.FoldAlignment (a, GHC.Types.Word) r
instance (Haskus.Utils.HList.HFoldr' Haskus.Format.Binary.Union.FoldSizeOf GHC.Types.Word l GHC.Types.Word, Haskus.Utils.HList.HFoldr' Haskus.Format.Binary.Union.FoldAlignment GHC.Types.Word l GHC.Types.Word) => Haskus.Format.Binary.Storable.Storable (Haskus.Format.Binary.Union.Union l)
instance (Haskus.Utils.HList.HFoldr' Haskus.Format.Binary.Union.FoldSizeOf GHC.Types.Word l GHC.Types.Word, Haskus.Utils.HList.HFoldr' Haskus.Format.Binary.Union.FoldAlignment GHC.Types.Word l GHC.Types.Word) => Foreign.Storable.Storable (Haskus.Format.Binary.Union.Union l)


-- | Store an Enum in the given backing word type
module Haskus.Format.Binary.Enum

-- | Store enum <tt>a</tt> as a <tt>b</tt>
data EnumField b a

-- | By default, use fromEnum<i>toEnum to convert from</i>to an Integral.
--   
--   But it can be overloaded to perform transformation before using
--   fromEnum/toEnum. E.g. if values are shifted by 1 compared to Enum
--   values, define fromCEnum = (+1) . fromIntegral . fromEnum
class CEnum a where fromCEnum = fromIntegral . fromEnum toCEnum = toEnum . fromIntegral
fromCEnum :: (CEnum a, Integral b) => a -> b
fromCEnum :: (CEnum a, Enum a, Integral b) => a -> b
toCEnum :: (CEnum a, Integral b) => b -> a
toCEnum :: (CEnum a, Enum a, Integral b) => b -> a

-- | Read an enum field
fromEnumField :: EnumField b a -> a

-- | Create an enum field
toEnumField :: a -> EnumField b a

-- | Make an enum from a number (0 indexed)
makeEnum :: forall a i. (Data a, Integral i) => i -> a

-- | Make an enum with the last constructor taking a parameter for the rest
--   of the range, but don't build the last constructor
--   
--   E.g., data T = A | B | C | D Word8 makeEnumMaybe :: Int -&gt; T
--   makeEnumMaybe x = case x of 0 -&gt; Just A 1 -&gt; Just B 2 -&gt; Just
--   C n -&gt; Nothing
makeEnumMaybe :: forall a i. (Data a, Integral i) => i -> Maybe a

-- | Make an enum with the last constructor taking a parameter for the rest
--   of the range
--   
--   E.g., data T = A | B | C | D Word8 makeEnumWithCustom :: Int -&gt; T
--   makeEnumWithCustom x = case x of 0 -&gt; A 1 -&gt; B 2 -&gt; C n -&gt;
--   D (n - 3)
makeEnumWithCustom :: forall a i. (Data a, Integral i) => i -> a
instance GHC.Classes.Eq a => GHC.Classes.Eq (Haskus.Format.Binary.Enum.EnumField b a)
instance GHC.Show.Show a => GHC.Show.Show (Haskus.Format.Binary.Enum.EnumField b a)
instance (Haskus.Format.Binary.Storable.Storable b, GHC.Real.Integral b, Haskus.Format.Binary.Enum.CEnum a) => Haskus.Format.Binary.Storable.Storable (Haskus.Format.Binary.Enum.EnumField b a)
instance (GHC.Real.Integral b, Haskus.Format.Binary.Storable.StaticStorable b, Haskus.Format.Binary.Enum.CEnum a) => Haskus.Format.Binary.Storable.StaticStorable (Haskus.Format.Binary.Enum.EnumField b a)


-- | Bit orderings
module Haskus.Format.Binary.Bits.Order

-- | Bit order
--   
--   The first letter indicates the outer bit ordering, i.e. how bytes are
--   filled: B*: from left to right (B is for BigEndian) L*: from right to
--   left (L is for LittleEndian)
--   
--   The second letter indicates the inner bit ordering, i.e. how words are
--   stored: *B: the most significant bit is stored first (in the outer bit
--   order!) *L: the least-significant bit is stored first (in the outer
--   bit order!)
--   
--   E.g. two successive words of 5 bits: ABCDE, VWXYZ - BB: ABCDEVWX
--   YZxxxxxx - BL: EDCBAZYX WVxxxxxx - LB: XWVEDCBA xxxxxxZY - LL:
--   XYZABCDE xxxxxxVW
data BitOrder
BB :: BitOrder
LB :: BitOrder
BL :: BitOrder
LL :: BitOrder
instance GHC.Classes.Eq Haskus.Format.Binary.Bits.Order.BitOrder
instance GHC.Show.Show Haskus.Format.Binary.Bits.Order.BitOrder


-- | Basic operations on bits
module Haskus.Format.Binary.Bits.Basic


-- | A memory buffer with a fixed address
--   
--   A buffer is a strict ByteString but with:
--   
--   <ul>
--   <li>a better interface: use Word instead of Int for sizes</li>
--   <li>a better name: "string" is misleading</li>
--   <li>some additional primitives</li>
--   </ul>
module Haskus.Format.Binary.Buffer

-- | A buffer
newtype Buffer
Buffer :: ByteString -> Buffer

-- | Unsafe: be careful if you modify the buffer contents or you may break
--   referential transparency
withBufferPtr :: Buffer -> (Ptr b -> IO a) -> IO a

-- | Buffer size
bufferSize :: Buffer -> Word

-- | Test if the buffer is empty
isBufferEmpty :: Buffer -> Bool

-- | Empty buffer
emptyBuffer :: Buffer

-- | Buffer filled with zero
bufferZero :: Word -> Buffer

-- | Map
bufferMap :: (Word8 -> Word8) -> Buffer -> Buffer

-- | Reverse
bufferReverse :: Buffer -> Buffer

-- | Drop some bytes O(1)
bufferDrop :: Word -> Buffer -> Buffer

-- | Tail
bufferTail :: Buffer -> Buffer

-- | Append
bufferAppend :: Buffer -> Buffer -> Buffer

-- | Cons
bufferCons :: Word8 -> Buffer -> Buffer

-- | Snoc
bufferSnoc :: Buffer -> Word8 -> Buffer

-- | Init
bufferInit :: Buffer -> Buffer

-- | Split on the given Byte values
bufferSplitOn :: Word8 -> Buffer -> [Buffer]

-- | Head
bufferHead :: Buffer -> Word8

-- | Index
bufferIndex :: Buffer -> Word -> Word8

-- | Take some bytes O(1)
bufferTake :: Word -> Buffer -> Buffer

-- | Take some bytes O(n)
bufferTakeWhile :: (Word8 -> Bool) -> Buffer -> Buffer

-- | Take some bytes O(1)
bufferTakeAtMost :: Word -> Buffer -> Buffer

-- | Zip two buffers with the given function
bufferZipWith :: (Word8 -> Word8 -> Word8) -> Buffer -> Buffer -> Buffer

-- | Duplicate a buffer
bufferDup :: Buffer -> IO Buffer

-- | Peek a storable
bufferPeekStorable :: forall a. Storable a => Buffer -> a

-- | Peek a storable at the given offset
bufferPeekStorableAt :: forall a. (Storable a) => Buffer -> Word -> a

-- | Pop a Storable and return the new buffer
bufferPopStorable :: forall a. Storable a => Buffer -> (Buffer, a)

-- | Poke a buffer
bufferPoke :: Ptr a -> Buffer -> IO ()

-- | Pack a ByteString
bufferPackByteString :: ByteString -> Buffer

-- | Pack a list of bytes
bufferPackByteList :: [Word8] -> Buffer

-- | Pack a Storable
bufferPackStorable :: forall a. Storable a => a -> Buffer

-- | Pack a list of Storable
bufferPackStorableList :: forall a. Storable a => [a] -> Buffer

-- | Pack from a pointer (copy)
bufferPackPtr :: MonadIO m => Word -> Ptr () -> m Buffer

-- | Unpack
bufferUnpackByteList :: Buffer -> [Word8]

-- | Unpack
bufferUnpackByteString :: Buffer -> ByteString

-- | Unsafe drop (don't check the size)
bufferUnsafeDrop :: Word -> Buffer -> Buffer

-- | Unsafe take (don't check the size)
bufferUnsafeTake :: Word -> Buffer -> Buffer

-- | Unsafe tail (don't check the size)
bufferUnsafeTail :: Buffer -> Buffer

-- | Unsafe head (don't check the size)
bufferUnsafeHead :: Buffer -> Word8

-- | Unsafe last (don't check the size)
bufferUnsafeLast :: Buffer -> Word8

-- | Unsafe init (don't check the size)
bufferUnsafeInit :: Buffer -> Buffer

-- | Unsafe index (don't check the size)
bufferUnsafeIndex :: Buffer -> Word -> Word8

-- | Map memory
bufferUnsafeMapMemory :: MonadIO m => Word -> Ptr () -> m Buffer

-- | Use buffer pointer
bufferUnsafeUsePtr :: MonadInIO m => Buffer -> (Ptr () -> Word -> m a) -> m a

-- | Pack from a pointer (add finalizer)
bufferUnsafePackPtr :: MonadIO m => Word -> Ptr a -> m Buffer

-- | Read file
bufferReadFile :: MonadIO m => FilePath -> m Buffer

-- | Write file
bufferWriteFile :: MonadIO m => FilePath -> Buffer -> m ()
instance GHC.Classes.Ord Haskus.Format.Binary.Buffer.Buffer
instance GHC.Classes.Eq Haskus.Format.Binary.Buffer.Buffer
instance GHC.Show.Show Haskus.Format.Binary.Buffer.Buffer
instance Data.Bits.Bits Haskus.Format.Binary.Buffer.Buffer


-- | Reverse bits
--   
--   There are several algorithms performing the same thing here (reversing
--   bits into words of different sizes). There are benchmarks for them in
--   Haskus's "bench" directory. The fastest one for the current
--   architecture should be selected below. If you find that another
--   algorithm is faster on your architecture, please report it.
module Haskus.Format.Binary.Bits.Reverse

-- | Data whose bits can be reversed
class BitReversable w
reverseBits :: BitReversable w => w -> w

-- | Reverse bits in a Word
reverseBitsGeneric :: (FiniteBits a, Integral a) => a -> a

-- | Obvious recursive verion
reverseBitsObvious :: FiniteBits a => a -> a

-- | Reverse bits in a Word8 (3 64-bit operations, modulus division)
reverseBits3Ops :: Word8 -> Word8

-- | Reverse bits in a Word8 (4 64-bit operations, no division)
reverseBits4Ops :: Word8 -> Word8

-- | Reverse bits using a lookup table
reverseBitsTable :: Word8 -> Word8

-- | Reverse bits in a Word8 (7 no 64-bit operations, no division)
reverseBits7Ops :: Word8 -> Word8

-- | <a>Parallel</a> recursive version
reverseBits5LgN :: FiniteBits a => a -> a

-- | Convert a function working on Word8 to one working on any Word
--   
--   The number of bits in the Word must be a multiple of 8
liftReverseBits :: (FiniteBits a, Integral a) => (Word8 -> Word8) -> a -> a
instance Haskus.Format.Binary.Bits.Reverse.BitReversable GHC.Word.Word8
instance Haskus.Format.Binary.Bits.Reverse.BitReversable GHC.Word.Word16
instance Haskus.Format.Binary.Bits.Reverse.BitReversable GHC.Word.Word32
instance Haskus.Format.Binary.Bits.Reverse.BitReversable GHC.Word.Word64
instance Haskus.Format.Binary.Bits.Reverse.BitReversable GHC.Types.Word


-- | Buffer list
--   
--   BufferList is a lazy ByteString
module Haskus.Format.Binary.BufferList

-- | BufferList
newtype BufferList
BufferList :: ByteString -> BufferList

-- | Convert to a buffer
toBuffer :: BufferList -> Buffer

-- | Convert from a buffer
toBufferList :: Buffer -> BufferList

-- | Convert to a lazy ByteString
toLazyByteString :: BufferList -> ByteString


-- | Buffer builder
module Haskus.Format.Binary.BufferBuilder

-- | Buffer builder
data BufferBuilder

-- | Empty buffer builder
emptyBufferBuilder :: BufferBuilder

-- | Execute a Builder and return the generated chunks as a BufferList. The
--   work is performed lazily, i.e., only when a chunk of the BufferList is
--   forced.
toBufferList :: BufferBuilder -> BufferList

-- | Execute a Builder and return the generated chunks as a Buffer.
toBuffer :: BufferBuilder -> Buffer

-- | Create a Builder denoting the same sequence of bytes as a strict
--   ByteString. The Builder inserts large ByteStrings directly, but copies
--   small ones to ensure that the generated chunks are large on average.
fromBuffer :: Buffer -> BufferBuilder

-- | Encode a single unsigned byte as-is.
fromWord8 :: Word8 -> BufferBuilder
instance GHC.Base.Monoid Haskus.Format.Binary.BufferBuilder.BufferBuilder


-- | Put monad
module Haskus.Format.Binary.Put

-- | Put merely lifts Builder into a Writer monad, applied to ().
type Put = PutM ()

-- | Execute Put
runPut :: Put -> Buffer

-- | Put a buffer
putBuffer :: Buffer -> Put

-- | Put a ByteString
putByteString :: ByteString -> Put

-- | Put null bytes
putPadding :: Word -> Put

-- | Put null bytes to align the given value to the second
putPaddingAlign :: Word -> Word -> Put

-- | Put a Word8
putWord8 :: Word8 -> Put

-- | Put a Word16 little-endian
putWord16le :: Word16 -> Put

-- | Put a Word16 big-endian
putWord16be :: Word16 -> Put

-- | Put a Word32 little-endian
putWord32le :: Word32 -> Put

-- | Put a Word32 big-endian
putWord32be :: Word32 -> Put

-- | Put a Word64 little-endian
putWord64le :: Word64 -> Put

-- | Put a Word64 big-endian
putWord64be :: Word64 -> Put


-- | Vector with size in the type
module Haskus.Format.Binary.Vector

-- | Vector with type-checked size
data Vector (n :: Nat) a
Vector :: Buffer -> Vector a

-- | Return the buffer backing the vector
vectorBuffer :: Vector n a -> Buffer

-- | Yield the first n elements
take :: forall n m a. (KnownNat (SizeOf a * n)) => Vector (m + n) a -> Vector n a

-- | Drop the first n elements
drop :: forall n m a. (KnownNat (SizeOf a * n)) => Vector (m + n) a -> Vector m a

-- | <i>O(1)</i> Index safely into the vector using a type level index.
index :: forall i a n. (KnownNat (ElemOffset a i n), Storable a) => Vector n a -> a

-- | Convert a list into a vector if the number of elements matches
fromList :: forall a (n :: Nat). (KnownNat n, Storable a) => [a] -> Maybe (Vector n a)

-- | Take at most n element from the list, then use z
fromFilledList :: forall a (n :: Nat). (KnownNat n, Storable a) => a -> [a] -> Vector n a

-- | Take at most (n-1) element from the list, then use z
fromFilledListZ :: forall a (n :: Nat). (KnownNat n, Storable a) => a -> [a] -> Vector n a

-- | Convert a vector into a list
toList :: forall a (n :: Nat). (KnownNat n, Storable a) => Vector n a -> [a]

-- | Create a vector by replicating a value
replicate :: forall a (n :: Nat). (KnownNat n, Storable a) => a -> Vector n a

-- | Concat several vectors into a single one
concat :: forall l (n :: Nat) a. (n ~ WholeSize l, KnownNat n, Storable a, StaticStorable a, HFoldr StoreVector (IO (Ptr a)) l (IO (Ptr a))) => HList l -> Vector n a
instance (Haskus.Format.Binary.Storable.Storable a, GHC.Show.Show a, GHC.TypeLits.KnownNat n) => GHC.Show.Show (Haskus.Format.Binary.Vector.Vector n a)
instance GHC.TypeLits.KnownNat (Haskus.Format.Binary.Storable.SizeOf a GHC.TypeLits.* n) => Haskus.Format.Binary.Storable.StaticStorable (Haskus.Format.Binary.Vector.Vector n a)
instance (GHC.TypeLits.KnownNat n, Haskus.Format.Binary.Storable.Storable a) => Haskus.Format.Binary.Storable.Storable (Haskus.Format.Binary.Vector.Vector n a)
instance (v ~ Haskus.Format.Binary.Vector.Vector n a, r ~ GHC.Types.IO (GHC.Ptr.Ptr a), GHC.TypeLits.KnownNat n, GHC.TypeLits.KnownNat (Haskus.Format.Binary.Storable.SizeOf a), Haskus.Format.Binary.Storable.StaticStorable a, Haskus.Format.Binary.Storable.Storable a) => Haskus.Utils.HList.Apply Haskus.Format.Binary.Vector.StoreVector (v, GHC.Types.IO (GHC.Ptr.Ptr a)) r


-- | Operations on bits
module Haskus.Format.Binary.Bits

-- | Data whose bits can be reversed
class BitReversable w
reverseBits :: BitReversable w => w -> w

-- | Reverse bits in a Word
reverseBitsGeneric :: (FiniteBits a, Integral a) => a -> a

-- | Reverse the <tt>n</tt> least important bits of the given value. The
--   higher bits are set to 0.
reverseLeastBits :: (FiniteBits a, BitReversable a) => Word -> a -> a

-- | makeMask 3 = 00000111
makeMask :: (FiniteBits a) => Word -> a

-- | Keep only the n least-significant bits of the given value
maskLeastBits :: (FiniteBits a) => Word -> a -> a

-- | Convert bits into a string composed of '0' and '1' chars
bitsToString :: FiniteBits a => a -> String

-- | Convert a string of '0' and '1' chars into a word
bitsFromString :: Bits a => String -> a

-- | Take n bits at offset o and put them in the least-significant bits of
--   the result
getBitRange :: (BitReversable b, FiniteBits b) => BitOrder -> Word -> Word -> b -> b

-- | Compute bit offset (equivalent to x <a>mod</a> 8 but faster)
bitOffset :: Word -> Word

-- | Compute byte offset (equivalent to x <a>div</a> 8 but faster)
byteOffset :: Word -> Word


-- | Bit getter
module Haskus.Format.Binary.Bits.Get

-- | BitGet state
data BitGetState
BitGetState :: {-# UNPACK #-} !Buffer -> {-# UNPACK #-} !Word -> !BitOrder -> BitGetState

-- | Input
[bitGetStateInput] :: BitGetState -> {-# UNPACK #-} !Buffer

-- | Bit offset (0-7)
[bitGetStateBitOffset] :: BitGetState -> {-# UNPACK #-} !Word

-- | Bit order
[bitGetStateBitOrder] :: BitGetState -> !BitOrder

-- | Create a new BitGetState
newBitGetState :: BitOrder -> Buffer -> BitGetState

-- | Indicate that the source is empty
isEmpty :: BitGetState -> Bool

-- | Skip the given number of bits from the input
skipBits :: Word -> BitGetState -> BitGetState

-- | Skip the required number of bits to be aligned on 8-bits
skipBitsToAlignOnWord8 :: BitGetState -> BitGetState

-- | Read the given number of bits and put the result in a word
getBits :: (Integral a, FiniteBits a) => Word -> BitGetState -> a

-- | Perform some checks before calling getBits
--   
--   Check that the number of bits to read is not greater than the first
--   parameter
getBitsChecked :: (Integral a, FiniteBits a, BitReversable a) => Word -> Word -> BitGetState -> a

-- | Read the given number of Word8 and return them in a Buffer
--   
--   Examples: BB: xxxABCDE FGHIJKLM NOPxxxxx -&gt; ABCDEFGH IJKLMNOP LL:
--   LMNOPxxx DEFGHIJK xxxxxABC -&gt; ABCDEFGH IJKLMNOP BL: xxxPONML
--   KJIHGFED CBAxxxxx -&gt; ABCDEFGH IJKLMNOP LB: EDCBAxxx MLKJIHGF
--   xxxxxPON -&gt; ABCDEFGH IJKLMNOP
getBitsBuffer :: Word -> BitGetState -> Buffer

-- | BitGet monad
type BitGet a = BitGetT Identity a

-- | BitGet monad transformer
type BitGetT m a = StateT BitGetState m a

-- | Evaluate a BitGet monad
runBitGet :: BitOrder -> BitGet a -> Buffer -> a

-- | Evaluate a BitGet monad
runBitGetT :: Monad m => BitOrder -> BitGetT m a -> Buffer -> m a

-- | Evaluate a BitGet monad, return the remaining state
runBitGetPartialT :: BitOrder -> BitGetT m a -> Buffer -> m (a, BitGetState)

-- | Evaluate a BitGet monad, return the remaining state
runBitGetPartial :: BitOrder -> BitGet a -> Buffer -> (a, BitGetState)

-- | Resume a BitGet evaluation
resumeBitGetPartialT :: BitGetT m a -> BitGetState -> m (a, BitGetState)

-- | Resume a BitGet evaluation
resumeBitGetPartial :: BitGet a -> BitGetState -> (a, BitGetState)

-- | Indicate if all bits have been read
isEmptyM :: Monad m => BitGetT m Bool

-- | Skip the given number of bits from the input (monadic version)
skipBitsM :: Monad m => Word -> BitGetT m ()

-- | Skip the required number of bits to be aligned on 8-bits (monadic
--   version)
skipBitsToAlignOnWord8M :: Monad m => BitGetT m ()

-- | Read the given number of bits and put the result in a word
getBitsM :: (Integral a, FiniteBits a, Monad m) => Word -> BitGetT m a

-- | Perform some checks before calling getBitsM
getBitsCheckedM :: (Integral a, FiniteBits a, BitReversable a, Monad m) => Word -> Word -> BitGetT m a

-- | Get a bit and convert it into a Bool
getBitBoolM :: (Monad m) => BitGetT m Bool

-- | Get the given number of Word8
getBitsBSM :: (Monad m) => Word -> BitGetT m Buffer

-- | Change the current bit ordering
--   
--   Be careful to change the outer bit ordering (B* to L* or the inverse)
--   only on bytes boundaries! Otherwise, you will read the same bits more
--   than once.
changeBitGetOrder :: Monad m => BitOrder -> BitGetT m ()

-- | Change the bit ordering for the wrapped BitGet
--   
--   Be careful, this function uses changeBitGetOrder internally.
withBitGetOrder :: Monad m => BitOrder -> BitGetT m a -> BitGetT m a
instance GHC.Show.Show Haskus.Format.Binary.Bits.Get.BitGetState


-- | Get utilities
module Haskus.Format.Binary.Get

-- | The Get monad is an Exception and State monad.
data Get a :: * -> *

-- | Run the Get monad
runGet :: Get a -> Buffer -> Either String a

-- | Run a getter and throw an exception on error
runGetOrFail :: Get a -> Buffer -> a

-- | Test whether all input *in the current chunk* has been consumed
isEmpty :: Get Bool

-- | Get the number of remaining unparsed bytes *in the current chunk*
remaining :: Get Word

-- | Skip ahead n bytes. Fails if fewer than n bytes are available.
skip :: Word -> Get ()

-- | Skip ahead n bytes. No error if there isn't enough bytes.
uncheckedSkip :: Word -> Get ()

-- | Skip to align n to al. Fails if fewer than n bytes are available.
skipAlign :: Word -> Word -> Get ()

-- | Skip to align n to al. Fails if fewer than n bytes are available.
uncheckedSkipAlign :: Word -> Word -> Get ()

-- | Count the number of bytes consumed by a getter
countBytes :: Get a -> Get (Word, a)

-- | Execute the getter and align on the given number of Word8
alignAfter :: Word -> Get a -> Get a

-- | Require an action to consume exactly the given number of bytes, fail
--   otherwise
consumeExactly :: Word -> Get a -> Get a

-- | Require an action to consume at most the given number of bytes, fail
--   otherwise
consumeAtMost :: Word -> Get a -> Get a

-- | Run the getter without consuming its input. Fails if it fails
lookAhead :: Get a -> Get a

-- | Run the getter. Consume its input if Just _ returned. Fails if it
--   fails
lookAheadM :: Get (Maybe a) -> Get (Maybe a)

-- | Run the getter. Consume its input if Right _ returned. Fails if it
--   fails
lookAheadE :: Get (Either a b) -> Get (Either a b)

-- | Get remaining bytes
getRemaining :: Get Buffer

-- | Pull n bytes from the input, as a Buffer
getBuffer :: Word -> Get Buffer

-- | Get Buffer terminated with 0 (consume 0)
getBufferNul :: Get Buffer

-- | Get Word8
getWord8 :: Get Word8

-- | Get Word16 little-endian
getWord16le :: Get Word16

-- | Get Word16 big-endian
getWord16be :: Get Word16

-- | Get Word32 little-endian
getWord32le :: Get Word32

-- | Get Word32 big-endian
getWord32be :: Get Word32

-- | Get Word64 little-endian
getWord64le :: Get Word64

-- | Get Word64 big-endian
getWord64be :: Get Word64

-- | Get while True (read and discard the ending element)
getWhile :: (a -> Bool) -> Get a -> Get [a]

-- | Repeat the getter to read the whole bytestring
getWhole :: Get a -> Get [a]

-- | Get bits from a BitGet.
--   
--   Discard last bits to align on a Word8 boundary
--   
--   FIXME: we use a continuation because Data.Serialize.Get doesn't export
--   "put"
getBitGet :: BitOrder -> BitGet a -> (a -> Get b) -> Get b

-- | Apply the getter at most <a>max</a> times
getManyAtMost :: Word -> Get (Maybe a) -> Get [a]

-- | Apply the getter at least <a>min</a> times and at most <a>max</a>
--   times
getManyBounded :: Maybe Word -> Maybe Word -> Get (Maybe a) -> Get (Maybe [a])


-- | Bit putter
module Haskus.Format.Binary.Bits.Put

-- | BitPut state
data BitPutState
BitPutState :: !BufferBuilder -> !Word8 -> !Word -> !BitOrder -> BitPutState

-- | Builder
[bitPutStateBuilder] :: BitPutState -> !BufferBuilder

-- | Current byte
[bitPutStateCurrent] :: BitPutState -> !Word8

-- | Current offset
[bitPutStateOffset] :: BitPutState -> !Word

-- | Bit order
[bitPutStateBitOrder] :: BitPutState -> !BitOrder

-- | Create a new BitPut state
newBitPutState :: BitOrder -> BitPutState

-- | Put bits
putBits :: (Integral a, FiniteBits a, BitReversable a) => Word -> a -> BitPutState -> BitPutState

-- | Put a Buffer
--   
--   Examples: 3 bits are already written in the current byte BB: ABCDEFGH
--   IJKLMNOP -&gt; xxxABCDE FGHIJKLM NOPxxxxx LL: ABCDEFGH IJKLMNOP -&gt;
--   LMNOPxxx DEFGHIJK xxxxxABC BL: ABCDEFGH IJKLMNOP -&gt; xxxPONML
--   KJIHGFED CBAxxxxx LB: ABCDEFGH IJKLMNOP -&gt; EDCBAxxx MLKJIHGF
--   xxxxxPON
putBitsBuffer :: Buffer -> BitPutState -> BitPutState

-- | Get a Buffer
getBitPutBuffer :: BitPutState -> Buffer

-- | Get a lazy byte string
getBitPutBufferList :: BitPutState -> BufferList

-- | BitPut monad
type BitPut a = BitPutT Identity a

-- | BitPut monad transformer
type BitPutT m a = StateT BitPutState m a

-- | Evaluate a BitPut monad
runBitPut :: BitOrder -> BitPut a -> Buffer

-- | Evaluate a BitPut monad
runBitPutT :: Monad m => BitOrder -> BitPutT m a -> m Buffer

-- | Put bits (monadic)
putBitsM :: (Monad m, Integral a, FiniteBits a, BitReversable a) => Word -> a -> BitPutT m ()

-- | Put a single bit (monadic)
putBitBoolM :: (Monad m) => Bool -> BitPutT m ()

-- | Put a Buffer (monadic)
putBitsBufferM :: Monad m => Buffer -> BitPutT m ()

-- | Change the current bit ordering
--   
--   Be careful to change the outer bit ordering (B* to L* or the inverse)
--   only on bytes boundaries! Otherwise, you will write the same bits more
--   than once.
changeBitPutOrder :: Monad m => BitOrder -> BitPutT m ()

-- | Change the bit ordering for the wrapped BitPut
--   
--   Be careful, this function uses changeBitPutOrder internally.
withBitPutOrder :: Monad m => BitOrder -> BitPutT m a -> BitPutT m a


-- | Byte order ("endianness")
--   
--   Indicate in which order bytes are stored in memory for multi-bytes
--   types. Big-endian means that most-significant bytes come first.
--   Little-endian means that least-significant bytes come first.
module Haskus.Format.Binary.Endianness

-- | Endianness
data Endianness

-- | Less significant bytes first
LittleEndian :: Endianness

-- | Most significant bytes first
BigEndian :: Endianness

-- | Word getter
data WordGetters
WordGetters :: Get Word8 -> Get Word16 -> Get Word32 -> Get Word64 -> WordGetters

-- | Read a Word8
[wordGetter8] :: WordGetters -> Get Word8

-- | Read a Word16
[wordGetter16] :: WordGetters -> Get Word16

-- | Read a Word132
[wordGetter32] :: WordGetters -> Get Word32

-- | Read a Word64
[wordGetter64] :: WordGetters -> Get Word64

-- | Word putters
data WordPutters
WordPutters :: (Word8 -> Put) -> (Word16 -> Put) -> (Word32 -> Put) -> (Word64 -> Put) -> WordPutters

-- | Write a Word8
[wordPutter8] :: WordPutters -> Word8 -> Put

-- | Write a Word16
[wordPutter16] :: WordPutters -> Word16 -> Put

-- | Write a Word132
[wordPutter32] :: WordPutters -> Word32 -> Put

-- | Write a Word64
[wordPutter64] :: WordPutters -> Word64 -> Put

-- | Get getters for the given endianness
getWordGetters :: Endianness -> WordGetters

-- | Get putters for the given endianness
getWordPutters :: Endianness -> WordPutters

-- | Size of a machine word
data WordSize

-- | 32-bit
WordSize32 :: WordSize

-- | 64-bit
WordSize64 :: WordSize

-- | Extended word getters
data ExtendedWordGetters
ExtendedWordGetters :: Get Word8 -> Get Word16 -> Get Word32 -> Get Word64 -> Get Word64 -> ExtendedWordGetters

-- | Read a Word8
[extwordGetter8] :: ExtendedWordGetters -> Get Word8

-- | Read a Word16
[extwordGetter16] :: ExtendedWordGetters -> Get Word16

-- | Read a Word132
[extwordGetter32] :: ExtendedWordGetters -> Get Word32

-- | Read a Word64
[extwordGetter64] :: ExtendedWordGetters -> Get Word64

-- | Read a native size word into a Word64
[extwordGetterN] :: ExtendedWordGetters -> Get Word64

-- | Extended word putters
data ExtendedWordPutters
ExtendedWordPutters :: (Word8 -> Put) -> (Word16 -> Put) -> (Word32 -> Put) -> (Word64 -> Put) -> (Word64 -> Put) -> ExtendedWordPutters

-- | Write a Word8
[extwordPutter8] :: ExtendedWordPutters -> Word8 -> Put

-- | Write a Word16
[extwordPutter16] :: ExtendedWordPutters -> Word16 -> Put

-- | Write a Word132
[extwordPutter32] :: ExtendedWordPutters -> Word32 -> Put

-- | Write a Word64
[extwordPutter64] :: ExtendedWordPutters -> Word64 -> Put

-- | Write a Word64 into a native size word
[extwordPutterN] :: ExtendedWordPutters -> Word64 -> Put

-- | Return extended getters
getExtendedWordGetters :: Endianness -> WordSize -> ExtendedWordGetters

-- | Return extended putters
getExtendedWordPutters :: Endianness -> WordSize -> ExtendedWordPutters

-- | Detect the endianness of the host memory
getHostEndianness :: IO Endianness

-- | Detected host endianness
hostEndianness :: Endianness

-- | Reverse bytes in a word
class ByteReversable w where hostToBigEndian w = case hostEndianness of { BigEndian -> w LittleEndian -> reverseBytes w } bigEndianToHost w = case hostEndianness of { BigEndian -> w LittleEndian -> reverseBytes w } hostToLittleEndian w = case hostEndianness of { BigEndian -> reverseBytes w LittleEndian -> w } littleEndianToHost w = case hostEndianness of { BigEndian -> reverseBytes w LittleEndian -> w }
reverseBytes :: ByteReversable w => w -> w
hostToBigEndian :: ByteReversable w => w -> w
bigEndianToHost :: ByteReversable w => w -> w
hostToLittleEndian :: ByteReversable w => w -> w
littleEndianToHost :: ByteReversable w => w -> w

-- | Force a data to be read/stored as big-endian
newtype AsBigEndian a
AsBigEndian :: a -> AsBigEndian a

-- | Force a data to be read/stored as little-endian
newtype AsLittleEndian a
AsLittleEndian :: a -> AsLittleEndian a
instance GHC.Real.Real a => GHC.Real.Real (Haskus.Format.Binary.Endianness.AsLittleEndian a)
instance GHC.Real.Integral a => GHC.Real.Integral (Haskus.Format.Binary.Endianness.AsLittleEndian a)
instance GHC.Num.Num a => GHC.Num.Num (Haskus.Format.Binary.Endianness.AsLittleEndian a)
instance GHC.Enum.Enum a => GHC.Enum.Enum (Haskus.Format.Binary.Endianness.AsLittleEndian a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Haskus.Format.Binary.Endianness.AsLittleEndian a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Haskus.Format.Binary.Endianness.AsLittleEndian a)
instance GHC.Real.Real a => GHC.Real.Real (Haskus.Format.Binary.Endianness.AsBigEndian a)
instance GHC.Real.Integral a => GHC.Real.Integral (Haskus.Format.Binary.Endianness.AsBigEndian a)
instance GHC.Num.Num a => GHC.Num.Num (Haskus.Format.Binary.Endianness.AsBigEndian a)
instance GHC.Enum.Enum a => GHC.Enum.Enum (Haskus.Format.Binary.Endianness.AsBigEndian a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Haskus.Format.Binary.Endianness.AsBigEndian a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Haskus.Format.Binary.Endianness.AsBigEndian a)
instance GHC.Classes.Eq Haskus.Format.Binary.Endianness.WordSize
instance GHC.Show.Show Haskus.Format.Binary.Endianness.WordSize
instance GHC.Enum.Enum Haskus.Format.Binary.Endianness.Endianness
instance GHC.Show.Show Haskus.Format.Binary.Endianness.Endianness
instance GHC.Classes.Eq Haskus.Format.Binary.Endianness.Endianness
instance Haskus.Format.Binary.Enum.CEnum Haskus.Format.Binary.Endianness.Endianness
instance Haskus.Format.Binary.Endianness.ByteReversable GHC.Word.Word8
instance Haskus.Format.Binary.Endianness.ByteReversable GHC.Word.Word16
instance Haskus.Format.Binary.Endianness.ByteReversable GHC.Word.Word32
instance Haskus.Format.Binary.Endianness.ByteReversable GHC.Word.Word64
instance GHC.Show.Show a => GHC.Show.Show (Haskus.Format.Binary.Endianness.AsBigEndian a)
instance GHC.Show.Show a => GHC.Show.Show (Haskus.Format.Binary.Endianness.AsLittleEndian a)
instance (Haskus.Format.Binary.Endianness.ByteReversable a, Haskus.Format.Binary.Storable.StaticStorable a) => Haskus.Format.Binary.Storable.StaticStorable (Haskus.Format.Binary.Endianness.AsBigEndian a)
instance (Haskus.Format.Binary.Endianness.ByteReversable a, Haskus.Format.Binary.Storable.Storable a) => Haskus.Format.Binary.Storable.Storable (Haskus.Format.Binary.Endianness.AsBigEndian a)
instance (Haskus.Format.Binary.Endianness.ByteReversable a, Haskus.Format.Binary.Storable.StaticStorable a) => Haskus.Format.Binary.Storable.StaticStorable (Haskus.Format.Binary.Endianness.AsLittleEndian a)
instance (Haskus.Format.Binary.Endianness.ByteReversable a, Haskus.Format.Binary.Storable.Storable a) => Haskus.Format.Binary.Storable.Storable (Haskus.Format.Binary.Endianness.AsLittleEndian a)


-- | Variable length encodings
module Haskus.Format.Binary.VariableLength

-- | Get an unsigned word in Little Endian Base 128
getULEB128 :: (Integral a, Bits a) => Get a

-- | Put an unsigned word in Little Endian Base 128
putULEB128 :: (Integral a, Bits a) => a -> Put

-- | Get a signed int in Little Endian Base 128
getSLEB128 :: (Integral a, Bits a) => Get a

-- | Put a signed int in Little Endian Base 128
putSLEB128 :: (Integral a, Bits a) => a -> Put

-- | Get a bytestring containing a decoded LEB128 string
getLEB128Buffer :: BitOrder -> Get Buffer


-- | A bit set based on Enum to name the bits. Use bitwise operations and
--   minimal storage in a safer way.
--   
--   Similar to Data.Bitset.Generic from bitset package, but
--   
--   <ul>
--   <li>We don't have the Num constraint</li>
--   <li>We dont use the deprecated bitSize function</li>
--   <li>We use countTrailingZeros instead of iterating on the number of
--   bits</li>
--   <li>We add a typeclass CBitSet</li>
--   </ul>
--   
--   Example:
--   
--   <pre>
--   {--}
--   data Flag
--      = FlagXXX
--      | FlagYYY
--      | FlagWWW
--      deriving (Show,Eq,Enum,CBitSet)
--   
--   -- Adapt the backing type, here we choose Word16
--   type Flags = <a>BitSet</a> Word16 Flag
--   </pre>
--   
--   Then you can convert (for free) a Word16 into Flags with
--   <a>fromBits</a> and convert back with <a>toBits</a>.
--   
--   You can check if a flag is set or not with <a>member</a> and
--   <a>notMember</a> and get a list of set flags with <a>toList</a>. You
--   can <a>insert</a> or <a>delete</a> flags. You can also perform set
--   operations such as <a>union</a> and <a>intersection</a>.
module Haskus.Format.Binary.BitSet

-- | A bit set: use bitwise operations (fast!) and minimal storage (sizeOf
--   basetype)
--   
--   b is the base type (Bits b) a is the element type (Enum a)
--   
--   The elements in the Enum a are flags corresponding to each bit of b
--   starting from the least-significant bit.
data BitSet b a

-- | Bit set indexed with a
class CBitSet a where toBitOffset = fromEnum fromBitOffset = toEnum

-- | Return the bit offset of an element
toBitOffset :: CBitSet a => a -> Int

-- | Return the bit offset of an element
toBitOffset :: (CBitSet a, Enum a) => a -> Int

-- | Return the value associated with a bit offset
fromBitOffset :: CBitSet a => Int -> a

-- | Return the value associated with a bit offset
fromBitOffset :: (CBitSet a, Enum a) => Int -> a

-- | Indicate if the set is empty
null :: (FiniteBits b) => BitSet b a -> Bool

-- | Empty bitset
empty :: (FiniteBits b) => BitSet b a

-- | Create a BitSet from a single element
singleton :: (Bits b, CBitSet a) => a -> BitSet b a

-- | Insert an element in the set
insert :: (Bits b, CBitSet a) => BitSet b a -> a -> BitSet b a

-- | Remove an element from the set
delete :: (Bits b, CBitSet a) => BitSet b a -> a -> BitSet b a

-- | Unwrap the bitset
toBits :: BitSet b a -> b

-- | Wrap a bitset
fromBits :: (CBitSet a, FiniteBits b) => b -> BitSet b a

-- | Test if an element is in the set
member :: (CBitSet a, FiniteBits b) => BitSet b a -> a -> Bool

-- | Test if an element is in the set
elem :: (CBitSet a, FiniteBits b) => a -> BitSet b a -> Bool

-- | Test if an element is not in the set
notMember :: (CBitSet a, FiniteBits b) => BitSet b a -> a -> Bool

-- | Retrieve elements in the set
elems :: (CBitSet a, FiniteBits b) => BitSet b a -> [a]

-- | Intersection of two sets
intersection :: FiniteBits b => BitSet b a -> BitSet b a -> BitSet b a

-- | Intersection of two sets
union :: FiniteBits b => BitSet b a -> BitSet b a -> BitSet b a

-- | Intersection of several sets
unions :: FiniteBits b => [BitSet b a] -> BitSet b a

-- | Convert a list of enum elements into a bitset Warning: b must have
--   enough bits to store the given elements! (we don't perform any check,
--   for performance reason)
fromListToBits :: (CBitSet a, FiniteBits b, Foldable m) => m a -> b

-- | Convert a bitset into a list of Enum elements
toListFromBits :: (CBitSet a, FiniteBits b) => b -> [a]

-- | Convert a Foldable into a set
fromList :: (CBitSet a, FiniteBits b, Foldable m) => m a -> BitSet b a

-- | Convert a set into a list
toList :: (CBitSet a, FiniteBits b) => BitSet b a -> [a]
instance Haskus.Format.Binary.Storable.Storable b => Haskus.Format.Binary.Storable.Storable (Haskus.Format.Binary.BitSet.BitSet b a)
instance GHC.Classes.Ord b => GHC.Classes.Ord (Haskus.Format.Binary.BitSet.BitSet b a)
instance GHC.Classes.Eq b => GHC.Classes.Eq (Haskus.Format.Binary.BitSet.BitSet b a)
instance (GHC.Show.Show a, Haskus.Format.Binary.BitSet.CBitSet a, Data.Bits.FiniteBits b) => GHC.Show.Show (Haskus.Format.Binary.BitSet.BitSet b a)
instance Haskus.Format.Binary.BitSet.CBitSet GHC.Types.Int
instance (Data.Bits.FiniteBits b, Haskus.Format.Binary.BitSet.CBitSet a) => GHC.Exts.IsList (Haskus.Format.Binary.BitSet.BitSet b a)


-- | Bit fields (as in C)
--   
--   This module allows you to define bit fields over words. For instance,
--   you can have a Word16 split into 3 fields X, Y and Z composed of 5, 9
--   and 2 bits respectively.
--   
--   X Y Z w :: Word16 |0 0 0 0 0|0 0 0 0 0 0 0 0 0|0 0|
--   
--   You define it as follows: @ {--}
--   
--   w :: BitFields Word16 '[ BitField 5 <a>X</a> Word8 , BitField 9
--   <a>Y</a> Word16 , BitField 2 <a>Z</a> Word8 ] w = BitFields 0x0102 @
--   
--   Note that each field has its own associated type (e.g. Word8 for X and
--   Z) that must be large enough to hold the number of bits for the field.
--   
--   Operations on BitFields expect that the cumulated size of the fields
--   is equal to the whole word size: use a padding field if necessary.
--   Otherwise you can use unsafe versions of the functions: extractField',
--   updateField', withField'.
--   
--   You can extract and update the value of a field by its name:
--   
--   <pre>
--   x = extractField <tt><a>X</a> w
--   z = extractField </tt><a>Z</a> w
--   w' = updateField @<a>Y</a> 0x16 w
--   </pre>
--   
--   Fields can also be <a>BitSet</a> or <a>EnumField</a>: @ {--}
--   
--   data A = A0 | A1 | A2 | A3 deriving (Enum,CEnum)
--   
--   data B = B0 | B1 deriving (Enum,CBitSet)
--   
--   w :: BitFields Word16 '[ BitField 5 <a>X</a> (EnumField Word8 A) ,
--   BitField 9 <a>Y</a> Word16 , BitField 2 <a>Z</a> (BitSet Word8 B) ] w
--   = BitFields 0x0102 @
module Haskus.Format.Binary.BitField

-- | Bit fields on a base type b
newtype BitFields b (f :: [*])
BitFields :: b -> BitFields b

-- | Get backing word
bitFieldsBits :: BitFields b f -> b

-- | A field of n bits
newtype BitField (n :: Nat) (name :: Symbol) s
BitField :: s -> BitField s

-- | Get the value of a field
extractField :: forall (name :: Symbol) fields b. (KnownNat (Offset name fields), KnownNat (Size name fields), WholeSize fields ~ BitSize b, Bits b, Integral b, Field (Output name fields)) => BitFields b fields -> Output name fields

-- | Get the value of a field (without checking sizes)
extractField' :: forall (name :: Symbol) fields b. (KnownNat (Offset name fields), KnownNat (Size name fields), Bits b, Integral b, Field (Output name fields)) => BitFields b fields -> Output name fields

-- | Set the value of a field
updateField :: forall name fields b. (KnownNat (Offset name fields), KnownNat (Size name fields), WholeSize fields ~ BitSize b, Bits b, Integral b, Field (Output name fields)) => Output name fields -> BitFields b fields -> BitFields b fields

-- | Set the value of a field (without checking sizes)
updateField' :: forall name fields b. (KnownNat (Offset name fields), KnownNat (Size name fields), Bits b, Integral b, Field (Output name fields)) => Output name fields -> BitFields b fields -> BitFields b fields

-- | Modify the value of a field
withField :: forall name fields b f. (KnownNat (Offset name fields), KnownNat (Size name fields), WholeSize fields ~ BitSize b, Bits b, Integral b, f ~ Output name fields, Field f) => (f -> f) -> BitFields b fields -> BitFields b fields

-- | Modify the value of a field (without checking sizes)
withField' :: forall (name :: Symbol) fields b f. (KnownNat (Offset name fields), KnownNat (Size name fields), Bits b, Integral b, f ~ Output name fields, Field f) => (f -> f) -> BitFields b fields -> BitFields b fields

-- | Get values in a tuple
matchFields :: forall l l2 w bs t. (bs ~ BitFields w l, HFoldr' Extract (bs, HList '[]) l (bs, HList l2), HTuple' l2 t) => bs -> t

-- | Get field names and values in a tuple
matchNamedFields :: forall lt lv ln lnv w bs t. (bs ~ BitFields w lt, HFoldr' Extract (bs, HList '[]) lt (bs, HList lv), HFoldr' Name (HList '[]) lt (HList ln), HZipList ln lv lnv, HTuple' lnv t) => bs -> t
class Field f
instance Haskus.Format.Binary.Storable.Storable s => Haskus.Format.Binary.Storable.Storable (Haskus.Format.Binary.BitField.BitField n name s)
instance Haskus.Format.Binary.Storable.Storable b => Haskus.Format.Binary.Storable.Storable (Haskus.Format.Binary.BitField.BitFields b f)
instance Haskus.Format.Binary.BitField.Field GHC.Types.Bool
instance Haskus.Format.Binary.BitField.Field GHC.Types.Word
instance Haskus.Format.Binary.BitField.Field GHC.Word.Word8
instance Haskus.Format.Binary.BitField.Field GHC.Word.Word16
instance Haskus.Format.Binary.BitField.Field GHC.Word.Word32
instance Haskus.Format.Binary.BitField.Field GHC.Word.Word64
instance Haskus.Format.Binary.BitField.Field GHC.Types.Int
instance Haskus.Format.Binary.BitField.Field GHC.Int.Int8
instance Haskus.Format.Binary.BitField.Field GHC.Int.Int16
instance Haskus.Format.Binary.BitField.Field GHC.Int.Int32
instance Haskus.Format.Binary.BitField.Field GHC.Int.Int64
instance (Data.Bits.FiniteBits b, GHC.Real.Integral b, Haskus.Format.Binary.BitSet.CBitSet a) => Haskus.Format.Binary.BitField.Field (Haskus.Format.Binary.BitSet.BitSet b a)
instance Haskus.Format.Binary.Enum.CEnum a => Haskus.Format.Binary.BitField.Field (Haskus.Format.Binary.Enum.EnumField b a)
instance (bs ~ Haskus.Format.Binary.BitField.BitFields w l, b ~ Haskus.Format.Binary.BitField.BitField n name s, i ~ (bs, Haskus.Utils.HList.HList l2), r ~ (bs, Haskus.Utils.HList.HList (Haskus.Format.Binary.BitField.Output name l : l2)), Haskus.Format.Binary.Word.BitSize w ~ Haskus.Format.Binary.BitField.WholeSize l, GHC.Real.Integral w, Data.Bits.Bits w, GHC.TypeLits.KnownNat (Haskus.Format.Binary.BitField.Offset name l), GHC.TypeLits.KnownNat (Haskus.Format.Binary.BitField.Size name l), Haskus.Format.Binary.BitField.Field (Haskus.Format.Binary.BitField.Output name l)) => Haskus.Utils.HList.Apply Haskus.Format.Binary.BitField.Extract (b, i) r
instance (bs ~ Haskus.Format.Binary.BitField.BitFields w l, b ~ Haskus.Format.Binary.BitField.BitField n name s, i ~ Haskus.Utils.HList.HList l2, r ~ Haskus.Utils.HList.HList (GHC.Base.String : l2), GHC.TypeLits.KnownSymbol name) => Haskus.Utils.HList.Apply Haskus.Format.Binary.BitField.Name (b, i) r
instance (bs ~ Haskus.Format.Binary.BitField.BitFields w lt, ln ~ Haskus.Utils.Types.List.Replicate (Haskus.Utils.Types.List.Length lt) GHC.Base.String, Haskus.Utils.HList.HFoldr' Haskus.Format.Binary.BitField.Extract (bs, Haskus.Utils.HList.HList '[]) lt (bs, Haskus.Utils.HList.HList (Haskus.Format.Binary.BitField.BitFieldTypes lt)), Haskus.Utils.HList.HFoldr' Haskus.Format.Binary.BitField.Name (Haskus.Utils.HList.HList '[]) lt (Haskus.Utils.HList.HList ln), Haskus.Utils.HList.HZipList ln (Haskus.Format.Binary.BitField.BitFieldTypes lt) lnv, GHC.Show.Show (Haskus.Utils.HList.HList lnv)) => GHC.Show.Show (Haskus.Format.Binary.BitField.BitFields w lt)
instance (bs ~ Haskus.Format.Binary.BitField.BitFields w lt, Haskus.Utils.HList.HFoldr' Haskus.Format.Binary.BitField.Extract (bs, Haskus.Utils.HList.HList '[]) lt (bs, Haskus.Utils.HList.HList lt2), GHC.Classes.Eq (Haskus.Utils.HList.HList lt2), lt2 ~ Haskus.Format.Binary.BitField.BitFieldTypes lt) => GHC.Classes.Eq (Haskus.Format.Binary.BitField.BitFields w lt)


-- | Fixed-point numbers
module Haskus.Format.Binary.FixedPoint

-- | Fixed-point number <tt>w</tt> is the backing type <tt>i</tt> is the
--   number of bits for the integer part (before the readix point)
--   <tt>f</tt> is the number of bits for the fractional part (after the
--   radix point)
data FixedPoint w (i :: Nat) (f :: Nat)

-- | Convert to a fixed point value
toFixedPoint :: forall a w (n :: Nat) (d :: Nat). (RealFrac a, BitSize w ~ (n + d), KnownNat n, KnownNat d, Bits w, Field w, Num w, Integral w) => a -> FixedPoint w n d

-- | Convert from a fixed-point value
fromFixedPoint :: forall a w (n :: Nat) (d :: Nat). (RealFrac a, BitSize w ~ (n + d), KnownNat n, KnownNat d, Bits w, Field w, Num w, Integral w) => FixedPoint w n d -> a
instance Haskus.Format.Binary.Storable.Storable w => Haskus.Format.Binary.Storable.Storable (Haskus.Format.Binary.FixedPoint.FixedPoint w i f)
instance (GHC.Real.Integral w, Data.Bits.Bits w, Haskus.Format.Binary.BitField.Field w, Haskus.Format.Binary.Word.BitSize w ~ (n GHC.TypeLits.+ d), GHC.TypeLits.KnownNat n, GHC.TypeLits.KnownNat d) => GHC.Classes.Eq (Haskus.Format.Binary.FixedPoint.FixedPoint w n d)
instance (GHC.Real.Integral w, Data.Bits.Bits w, Haskus.Format.Binary.BitField.Field w, Haskus.Format.Binary.Word.BitSize w ~ (n GHC.TypeLits.+ d), GHC.TypeLits.KnownNat n, GHC.TypeLits.KnownNat d, GHC.Show.Show w) => GHC.Show.Show (Haskus.Format.Binary.FixedPoint.FixedPoint w n d)

module Haskus.Format.Binary.Unum

-- | An Unum
--   
--   0 (and its reciprocal) is always included. Numbers have to be &gt;= 1
--   and sorted.
--   
--   e.g., Unum '[] =&gt; <i>0 .. 0 .. </i>0 Unum '[I 1] =&gt; <i>0 .. -1
--   .. 0 .. 1 .. </i>0 Unum '[I 1, I 2] =&gt; <i>0 .. -2 .. -1 .. -</i>2
--   .. 0 .. <i>2 .. 1 .. 2 .. </i>0 Unum '[I 1, PI] =&gt; <i>0 .. -PI ..
--   -1 .. -</i>PI .. 0 .. <i>PI .. 1 .. PI .. </i>0
data Unum (xs :: [*])
class UnumNum a
unumLabel :: UnumNum a => a -> String
data I (n :: Nat)
newtype U u
U :: (BackingWord u) -> U u
data Neg a
data Rcp a
type Infinite = Rcp (I 0)

-- | Compute the precise numbers set

-- | Compute the number of bits required

-- | Backing word for the unum

-- | Uncertainty bit
data UBit

-- | Exact number
ExactNumber :: UBit

-- | OpenInterval above the exact number
OpenInterval :: UBit

-- | Size of an unum in bits
unumSize :: forall u. (KnownNat (UnumSize u)) => Word

-- | Zero
unumZero :: forall u. (Num (BackingWord u), Bits (BackingWord u), Encodable (I 0) u) => U u

-- | Infinite
unumInfinite :: forall u. (Num (BackingWord u), Bits (BackingWord u), Encodable Infinite u) => U u

-- | Encode a number
unumEncode :: forall u x i. (i ~ IndexOf (Simplify x) (UnumIndexables u), KnownNat i, Num (BackingWord u), Bits (BackingWord u)) => UBit -> U u
unumBits :: forall u. (FiniteBits (BackingWord u), KnownNat (UnumSize u)) => U u -> String

-- | Negate a number
unumNegate :: forall u. (FiniteBits (BackingWord u), Num (BackingWord u), KnownNat (UnumSize u)) => U u -> U u

-- | Reciprocate a number
unumReciprocate :: forall u. (FiniteBits (BackingWord u), Num (BackingWord u), KnownNat (UnumSize u)) => U u -> U u

-- | Unum labels
unumLabels :: forall u v. (HFoldr' GetLabel [String] v [String], v ~ UnumMembers u) => [String]
data Sign
Positive :: Sign
Negative :: Sign
NoSign :: Sign

-- | Get unum sign
unumSign :: forall u. (Bits (BackingWord u), KnownNat (UnumSize u)) => U u -> Sign
data SORN u

-- | Show SORN bits
sornBits :: forall u s. (FiniteBits (SORNBackingWord u), KnownNat (UnumSize u), s ~ SORNSize u, KnownNat s) => SORN u -> String

-- | Size of a SORN in bits
sornSize :: forall u s. (s ~ SORNSize u, KnownNat s) => Word

-- | Empty SORN
sornEmpty :: (Bits (SORNBackingWord u)) => SORN u

-- | Full SORN
sornFull :: forall u. (FiniteBits (SORNBackingWord u), KnownNat (SORNSize u)) => SORN u

-- | Full SORN without infinite
sornNonInfinite :: forall u. (Bits (SORNBackingWord u), Integral (BackingWord u), Bits (BackingWord u), Encodable Infinite u) => SORN u

-- | Full SORN without infinite
sornNonZero :: (Bits (SORNBackingWord u), Integral (BackingWord u), Bits (BackingWord u), Encodable (I 0) u) => SORN u

-- | SORN singleton
sornSingle :: (Integral (BackingWord u), Bits (SORNBackingWord u)) => U u -> SORN u

-- | Insert in a SORN
sornInsert :: forall u. (Bits (SORNBackingWord u), Integral (BackingWord u)) => SORN u -> U u -> SORN u

-- | Test membership in a SORN
sornMember :: forall u. (Bits (SORNBackingWord u), Integral (BackingWord u)) => SORN u -> U u -> Bool

-- | Remove in a SORN
sornRemove :: forall u. (Bits (SORNBackingWord u), Integral (BackingWord u)) => SORN u -> U u -> SORN u

-- | Union of two SORNs
sornUnion :: forall u. (Bits (SORNBackingWord u)) => SORN u -> SORN u -> SORN u

-- | Intersection of two SORNs
sornIntersect :: forall u. (Bits (SORNBackingWord u)) => SORN u -> SORN u -> SORN u

-- | Complement the SORN
sornComplement :: (Bits (SORNBackingWord u)) => SORN u -> SORN u

-- | Negate a SORN
sornNegate :: forall u. (FiniteBits (SORNBackingWord u), FiniteBits (BackingWord u), Integral (BackingWord u), KnownNat (SORNSize u), KnownNat (UnumSize u)) => SORN u -> SORN u

-- | Elements in the SORN
sornElems :: forall u s. (s ~ SORNSize u, KnownNat s, Bits (SORNBackingWord u), Num (BackingWord u)) => SORN u -> [U u]

-- | Create a SORN from its elements
sornFromElems :: (Integral (BackingWord u), Bits (SORNBackingWord u)) => [U u] -> SORN u

-- | Create a contiguous SORN from two elements
sornFromTo :: forall u. (Integral (BackingWord u), Bits (SORNBackingWord u), FiniteBits (BackingWord u), KnownNat (UnumSize u)) => U u -> U u -> SORN u
class SornAdd u where sornAdd a b = foldl sornUnion sornEmpty [sornAddU x y | x <- sornElems a, y <- sornElems b] sornAddDep a = foldl sornUnion sornEmpty [sornAddU x x | x <- sornElems a] sornSubU a b = sornAddU a (unumNegate b) sornSub a b = foldl sornUnion sornEmpty [sornSubU x y | x <- sornElems a, y <- sornElems b] sornSubDep a = foldl sornUnion sornEmpty [sornSubU x x | x <- sornElems a]

-- | Add two Unums
sornAddU :: SornAdd u => U u -> U u -> SORN u

-- | Add two SORNs
sornAdd :: (SornAdd u, KnownNat (SORNSize u), Bits (SORNBackingWord u), Num (BackingWord u)) => SORN u -> SORN u -> SORN u

-- | Add a SORN with itself
sornAddDep :: (SornAdd u, KnownNat (SORNSize u), Bits (SORNBackingWord u), Num (BackingWord u)) => SORN u -> SORN u

-- | Subtract two Unums
sornSubU :: (SornAdd u, FiniteBits (BackingWord u), Num (BackingWord u), KnownNat (UnumSize u)) => U u -> U u -> SORN u

-- | Subtract two SORNS
sornSub :: (SornAdd u, KnownNat (SORNSize u), Bits (SORNBackingWord u), FiniteBits (BackingWord u), Num (BackingWord u), KnownNat (UnumSize u)) => SORN u -> SORN u -> SORN u

-- | Subtract a SORN with itself
sornSubDep :: (SornAdd u, KnownNat (SORNSize u), Bits (SORNBackingWord u), FiniteBits (BackingWord u), Num (BackingWord u), KnownNat (UnumSize u)) => SORN u -> SORN u
newtype CSORN u
CSORN :: (BitFields (CSORNBackingWord u) '[BitField (UnumSize u) "start" (BackingWord u), BitField (UnumSize u) "count" (BackingWord u)]) -> CSORN u

-- | Size of a contiguous SORN in bits
csornSize :: forall u s. (s ~ CSORNSize u, KnownNat s) => Word

-- | Show contiguous SORN bits
csornBits :: forall u s. (FiniteBits (CSORNBackingWord u), KnownNat (UnumSize u), s ~ CSORNSize u, KnownNat s) => CSORN u -> String

-- | Convert a contiguous SORN into a SORN
csornToSorn :: forall u. (KnownNat (UnumSize u), Num (BackingWord u), Integral (BackingWord u), Integral (CSORNBackingWord u), Bits (CSORNBackingWord u), FiniteBits (BackingWord u), Bits (SORNBackingWord u), Field (BackingWord u), KnownNat (SORNSize u), FiniteBits (SORNBackingWord u)) => CSORN u -> SORN u

-- | Empty contigiuous SORN
csornEmpty :: forall u. (Bits (CSORNBackingWord u)) => CSORN u

-- | Test if a contigiuous SORN is empty
csornIsEmpty :: forall u. (Bits (CSORNBackingWord u)) => CSORN u -> Bool

-- | Contiguous SORN build
csornFromTo :: forall u. (Num (BackingWord u), Bits (BackingWord u), KnownNat (UnumSize u), KnownNat (SORNSize u), FiniteBits (BackingWord u), Integral (CSORNBackingWord u), Bits (CSORNBackingWord u), Field (BackingWord u), Integral (BackingWord u)) => U u -> U u -> CSORN u

-- | Full contiguous SORN
csornFull :: forall u. (Bits (CSORNBackingWord u), Integral (CSORNBackingWord u), Integral (BackingWord u), KnownNat (UnumSize u), Field (BackingWord u)) => CSORN u

-- | Contiguous SORN singleton
csornSingle :: forall u. (Bits (CSORNBackingWord u), Integral (CSORNBackingWord u), Integral (BackingWord u), KnownNat (UnumSize u), Field (BackingWord u)) => U u -> CSORN u
instance GHC.Classes.Eq Haskus.Format.Binary.Unum.Sign
instance GHC.Show.Show Haskus.Format.Binary.Unum.Sign
instance GHC.Classes.Eq Haskus.Format.Binary.Unum.UBit
instance GHC.Show.Show Haskus.Format.Binary.Unum.UBit
instance GHC.TypeLits.KnownNat n => Haskus.Format.Binary.Unum.UnumNum (Haskus.Format.Binary.Unum.I n)
instance Haskus.Format.Binary.Unum.UnumNum x => Haskus.Format.Binary.Unum.UnumNum (Haskus.Format.Binary.Unum.Rcp x)
instance Haskus.Format.Binary.Unum.UnumNum x => Haskus.Format.Binary.Unum.UnumNum (Haskus.Format.Binary.Unum.Neg x)
instance Haskus.Format.Binary.Unum.UnumNum x => Haskus.Format.Binary.Unum.UnumNum (Haskus.Format.Binary.Unum.Uncertain x)
instance (Haskus.Format.Binary.Unum.UnumNum a, r ~ [GHC.Base.String]) => Haskus.Utils.HList.Apply Haskus.Format.Binary.Unum.GetLabel (a, [GHC.Base.String]) r
instance GHC.Classes.Eq (Haskus.Format.Binary.Unum.BackingWord u) => GHC.Classes.Eq (Haskus.Format.Binary.Unum.U u)
instance (Haskus.Utils.HList.HFoldr' Haskus.Format.Binary.Unum.GetLabel [GHC.Base.String] v [GHC.Base.String], v ~ Haskus.Format.Binary.Unum.UnumMembers u, GHC.Real.Integral (Haskus.Format.Binary.Unum.BackingWord u)) => GHC.Show.Show (Haskus.Format.Binary.Unum.U u)
instance (GHC.TypeLits.KnownNat (Haskus.Format.Binary.Unum.SORNSize u), Data.Bits.Bits (Haskus.Format.Binary.Unum.SORNBackingWord u), GHC.Num.Num (Haskus.Format.Binary.Unum.BackingWord u), GHC.Real.Integral (Haskus.Format.Binary.Unum.BackingWord u), Haskus.Utils.HList.HFoldr' Haskus.Format.Binary.Unum.GetLabel [GHC.Base.String] v [GHC.Base.String], v ~ Haskus.Format.Binary.Unum.UnumMembers u) => GHC.Show.Show (Haskus.Format.Binary.Unum.SORN u)
instance (GHC.TypeLits.KnownNat (Haskus.Format.Binary.Unum.SORNSize u), GHC.TypeLits.KnownNat (Haskus.Format.Binary.Unum.UnumSize u), Data.Bits.FiniteBits (Haskus.Format.Binary.Unum.BackingWord u), Data.Bits.Bits (Haskus.Format.Binary.Unum.CSORNBackingWord u), GHC.Real.Integral (Haskus.Format.Binary.Unum.CSORNBackingWord u), GHC.Num.Num (Haskus.Format.Binary.Unum.BackingWord u), GHC.Real.Integral (Haskus.Format.Binary.Unum.BackingWord u), Haskus.Utils.HList.HFoldr' Haskus.Format.Binary.Unum.GetLabel [GHC.Base.String] v [GHC.Base.String], Haskus.Format.Binary.BitField.Field (Haskus.Format.Binary.Unum.BackingWord u), Data.Bits.Bits (Haskus.Format.Binary.Unum.SORNBackingWord u), Data.Bits.FiniteBits (Haskus.Format.Binary.Unum.SORNBackingWord u), v ~ Haskus.Format.Binary.Unum.UnumMembers u) => GHC.Show.Show (Haskus.Format.Binary.Unum.CSORN u)