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


-- | Unified interface for memory managemenet.
--   
--   Please see the README on GitHub at
--   <a>https://github.com/lehins/primal#readme</a>
@package primal-memory
@version 0.1.0.0


module Data.Prim.Memory.Ptr
copyPtrToMBytes :: (MonadPrim s m, Prim e) => Ptr e -> Off e -> MBytes p s -> Off e -> Count e -> m ()
movePtrToMBytes :: (MonadPrim s m, Prim e) => Ptr e -> Off e -> MBytes p s -> Off e -> Count e -> m ()
copyBytesToPtr :: (MonadPrim s m, Prim e) => Bytes p -> Off e -> Ptr e -> Off e -> Count e -> m ()
copyMBytesToPtr :: (MonadPrim s m, Prim e) => MBytes p s -> Off e -> Ptr e -> Off e -> Count e -> m ()
moveMBytesToPtr :: (MonadPrim s m, Prim e) => MBytes p s -> Off e -> Ptr e -> Off e -> Count e -> m ()
copyByteOffPtrToMBytes :: (MonadPrim s m, Prim e) => Ptr e -> Off Word8 -> MBytes p s -> Off Word8 -> Count e -> m ()
moveByteOffPtrToMBytes :: (MonadPrim s m, Prim e) => Ptr e -> Off Word8 -> MBytes p s -> Off Word8 -> Count e -> m ()
copyByteOffBytesToPtr :: (MonadPrim s m, Prim e) => Bytes p -> Off Word8 -> Ptr e -> Off Word8 -> Count e -> m ()
copyByteOffMBytesToPtr :: (MonadPrim s m, Prim e) => MBytes p s -> Off Word8 -> Ptr e -> Off Word8 -> Count e -> m ()
moveByteOffMBytesToPtr :: (MonadPrim s m, Prim e) => MBytes p s -> Off Word8 -> Ptr e -> Off Word8 -> Count e -> m ()
compareByteOffBytesToPtr :: Prim e => Bytes p -> Off Word8 -> Ptr e -> Off Word8 -> Count e -> Ordering
compareByteOffPtrToBytes :: Prim e => Ptr e -> Off Word8 -> Bytes p -> Off Word8 -> Count e -> Ordering


module Data.Prim.Memory.ByteString

-- | Mutable version of a <a>ByteString</a>
newtype MByteString s
MByteString :: ByteString -> MByteString s

-- | <a>Builder</a>s denote sequences of bytes. They are <a>Monoid</a>s
--   where <a>mempty</a> is the zero-length sequence and <a>mappend</a> is
--   concatenation, which runs in <i>O(1)</i>.
data Builder

-- | Convert <a>Bytes</a> into a bytestring <a>Builder</a>
toBuilderBytes :: Bytes p -> Builder

-- | <i>O(n)</i> - Allocate <a>Bytes</a> and fill them using the supplied
--   <a>Builder</a>
fromBuilderBytes :: Builder -> Bytes  'Pin

-- | A space-efficient representation of a <a>Word8</a> vector, supporting
--   many efficient operations.
--   
--   A <a>ByteString</a> contains 8-bit bytes, or by using the operations
--   from <a>Data.ByteString.Char8</a> it can be interpreted as containing
--   8-bit characters.
data ByteString
PS :: {-# UNPACK #-} !ForeignPtr Word8 -> {-# UNPACK #-} !Int -> {-# UNPACK #-} !Int -> ByteString

-- | <i>O(1)</i> - Cast an immutable <a>Bytes</a> to an immutable
--   <a>ByteString</a>
toByteStringBytes :: Bytes  'Pin -> ByteString

-- | <i>O(n)</i> - Allocate <a>Bytes</a> and fill them with the contents of
--   a strict <a>ByteString</a>
fromByteStringBytes :: Typeable p => ByteString -> Bytes p

-- | <i>O(n)</i> - Allocate <a>Bytes</a> and fill them with the contents of
--   a lazy <a>ByteString</a>
fromLazyByteStringBytes :: ByteString -> Bytes  'Pin
withPtrByteString :: MonadPrim s m => ByteString -> (Ptr a -> m b) -> m b
withNoHaltPtrByteString :: MonadUnliftPrim s m => ByteString -> (Ptr a -> m b) -> m b

-- | A compact representation of a <a>Word8</a> vector.
--   
--   It has a lower memory overhead than a <a>ByteString</a> and and does
--   not contribute to heap fragmentation. It can be converted to or from a
--   <a>ByteString</a> (at the cost of copying the string data). It
--   supports very few other operations.
--   
--   It is suitable for use as an internal representation for code that
--   needs to keep many short strings in memory, but it <i>should not</i>
--   be used as an interchange type. That is, it should not generally be
--   used in public APIs. The <a>ByteString</a> type is usually more
--   suitable for use in interfaces; it is more flexible and it supports a
--   wide range of operations.
data ShortByteString
SBS :: ByteArray# -> ShortByteString

-- | <i>O(1)</i> - Cast an immutable <a>Bytes</a> to an immutable
--   <a>ShortByteString</a>
toShortByteStringBytes :: Bytes p -> ShortByteString

-- | <i>O(1)</i> - Cast an immutable <a>ShortByteString</a> to an immutable
--   <a>Bytes</a>
fromShortByteStringBytes :: ShortByteString -> Bytes  'Inc
byteStringConvertError :: String -> a


module Data.Prim.Memory.ForeignPtr

-- | For memory allocated as pinned it is possible to operate on it with a
--   <a>Ptr</a>. Any data type that is backed by such memory can have a
--   <a>PtrAccess</a> instance. The simplest way is to convert it to a
--   <a>ForeignPtr</a> and other functions will come for free.
class PtrAccess s p

-- | Convert to <a>ForeignPtr</a>.
toForeignPtr :: (PtrAccess s p, MonadPrim s m) => p -> m (ForeignPtr a)

-- | Apply an action to the raw memory <a>Ptr</a> to which the data type
--   point to. Type of data stored in memory is left ambiguous
--   intentionaly, so that the user can choose how to treat the memory
--   content.
withPtrAccess :: (PtrAccess s p, MonadPrim s m) => p -> (Ptr a -> m b) -> m b

-- | See this GHC <a>issue #18061</a> and related to get more insight why
--   this is needed.
withNoHaltPtrAccess :: (PtrAccess s p, MonadUnliftPrim s m) => p -> (Ptr a -> m b) -> m 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
ForeignPtr :: Addr# -> ForeignPtrContents -> ForeignPtr a

-- | This function casts a <a>ForeignPtr</a> parameterised by one type into
--   another type.
castForeignPtr :: () => ForeignPtr a -> ForeignPtr b

-- | This function extracts the pointer component of a foreign pointer.
--   This is a potentially dangerous operations, as if the argument to
--   <a>unsafeForeignPtrToPtr</a> is the last usage occurrence of the given
--   foreign pointer, then its finalizer(s) will be run, which potentially
--   invalidates the plain pointer just obtained. Hence,
--   <a>touchForeignPtr</a> must be used wherever it has to be guaranteed
--   that the pointer lives on - i.e., has another usage occurrence.
--   
--   To avoid subtle coding errors, hand written marshalling code should
--   preferably use <a>withForeignPtr</a> rather than combinations of
--   <a>unsafeForeignPtrToPtr</a> and <a>touchForeignPtr</a>. However, the
--   latter routines are occasionally preferred in tool generated
--   marshalling code.
unsafeForeignPtrToPtr :: () => ForeignPtr a -> Ptr a
data ForeignPtrContents
PlainForeignPtr :: !IORef Finalizers -> ForeignPtrContents
MallocPtr :: MutableByteArray# RealWorld -> !IORef Finalizers -> ForeignPtrContents
PlainPtr :: MutableByteArray# RealWorld -> ForeignPtrContents

-- | Advances the given address by the given offset in number of elemeents.
--   This operation does not affect associated finalizers in any way.
plusOffForeignPtr :: Prim e => ForeignPtr e -> Off e -> ForeignPtr e

-- | Advances the given address by the given offset in bytes. This
--   operation does not affect associated finalizers in any way.
plusByteOffForeignPtr :: ForeignPtr e -> Off Word8 -> ForeignPtr e

-- | Find the offset in number of elements that is between the two pointers
--   by subtracting one address from another and dividing the result by the
--   size of an element.
minusOffForeignPtr :: Prim e => ForeignPtr e -> ForeignPtr e -> Off e

-- | Same as <a>minusOffForeignPtr</a>, but will also return the remainder
--   in bytes that is left over.
minusOffRemForeignPtr :: Prim e => ForeignPtr e -> ForeignPtr e -> (Off e, Off Word8)

-- | Find the offset in bytes that is between the two pointers by
--   subtracting one address from another.
minusByteOffForeignPtr :: ForeignPtr e -> ForeignPtr e -> Off Word8

-- | Apply an action to the raw pointer. It is unsafe to return the actual
--   pointer back from the action because memory itself might get garbage
--   collected or cleaned up by finalizers.
--   
--   It is also important not to run non-terminating actions, because GHC
--   can optimize away the logic that runs after the action and GC will
--   happen before the action get's a chance to finish resulting in corrupt
--   memory. Whenever you have an action that runs an infinite loop or ends
--   in an exception throwing, make sure to use <a>withNoHaltForeignPtr</a>
--   instead.
withForeignPtr :: MonadPrim s m => ForeignPtr e -> (Ptr e -> m b) -> m b

-- | Same thing as <a>withForeignPtr</a> except it should be used for never
--   ending actions. See <a>withNoHaltPtrAccess</a> for more information on
--   how this differes from <a>withForeignPtr</a>.
withNoHaltForeignPtr :: MonadUnliftPrim s m => ForeignPtr e -> (Ptr e -> m b) -> m b

-- | Similar to <a>mallocPlainForeignPtr</a>, except instead of
--   <tt>Storable</tt> we use <a>Prim</a> and we are not restricted to
--   <a>IO</a>, since finalizers are not possible with <tt>PlaintPtr</tt>
mallocPlainForeignPtr :: forall e m s. (MonadPrim s m, Prim e) => m (ForeignPtr e)

-- | Similar to <a>mallocPlainForeignPtrArray</a>, except instead of
--   <tt>Storable</tt> we use <a>Prim</a>.
mallocCountPlainForeignPtr :: (MonadPrim s m, Prim e) => Count e -> m (ForeignPtr e)

-- | Just like <a>mallocCountForeignPtr</a>, but memory is also aligned
--   according to <a>Prim</a> instance
mallocCountPlainForeignPtrAligned :: forall e m s. (MonadPrim s m, Prim e) => Count e -> m (ForeignPtr e)

-- | Lifted version of <a>mallocForeignPtrBytes</a>.
mallocByteCountPlainForeignPtr :: MonadPrim s m => Count Word8 -> m (ForeignPtr e)

-- | Lifted version of <a>mallocForeignPtrAlignedBytes</a>.
mallocByteCountPlainForeignPtrAligned :: MonadPrim s m => Count Word8 -> Int -> m (ForeignPtr e)

-- | Lifted version of <a>finalizeForeignPtr</a>.
finalizeForeignPtr :: MonadPrim RW m => ForeignPtr e -> m ()

-- | A finalizer is represented as a pointer to a foreign function that, at
--   finalisation time, gets as an argument a plain pointer variant of the
--   foreign pointer that the finalizer is associated with.
--   
--   Note that the foreign function <i>must</i> use the <tt>ccall</tt>
--   calling convention.
type FinalizerPtr a = FunPtr Ptr a -> IO ()

-- | Lifted version of <a>newForeignPtr</a>.
newForeignPtr :: MonadPrim RW m => FinalizerPtr e -> Ptr e -> m (ForeignPtr e)

-- | Lifted version of <a>newForeignPtr_</a>.
newForeignPtr_ :: MonadPrim RW m => Ptr e -> m (ForeignPtr e)

-- | Lifted version of <a>touchForeignPtr</a>.
touchForeignPtr :: MonadPrim s m => ForeignPtr e -> m ()

-- | Simila to <a>mallocForeignPtr</a>, except it operates on <a>Prim</a>,
--   instead of <tt>Storable</tt>.
mallocForeignPtr :: forall e m. (MonadPrim RW m, Prim e) => m (ForeignPtr e)

-- | Similar to <a>mallocForeignPtrArray</a>, except instead of
--   <tt>Storable</tt> we use <a>Prim</a>.
mallocCountForeignPtr :: (MonadPrim RW m, Prim e) => Count e -> m (ForeignPtr e)

-- | Just like <a>mallocCountForeignPtr</a>, but memory is also aligned
--   according to <a>Prim</a> instance
mallocCountForeignPtrAligned :: (MonadPrim RW m, Prim e) => Count e -> m (ForeignPtr e)

-- | Lifted version of <a>mallocForeignPtrBytes</a>.
mallocByteCountForeignPtr :: MonadPrim RW m => Count Word8 -> m (ForeignPtr e)

-- | Lifted version of <a>mallocForeignPtrAlignedBytes</a>.
mallocByteCountForeignPtrAligned :: MonadPrim RW m => Count Word8 -> Int -> m (ForeignPtr e)

-- | Lifted version of <a>addForeignPtrFinalizer</a>
addForeignPtrFinalizer :: MonadPrim RW m => FinalizerPtr e -> ForeignPtr e -> m ()
type FinalizerEnvPtr env a = FunPtr Ptr env -> Ptr a -> IO ()

-- | Lifted version of <a>newForeignPtrEnv</a>.
newForeignPtrEnv :: MonadPrim RW m => FinalizerEnvPtr env e -> Ptr env -> Ptr e -> m (ForeignPtr e)

-- | Lifted version of <a>addForeignPtrFinalizerEnv</a>
addForeignPtrFinalizerEnv :: MonadPrim RW m => FinalizerEnvPtr env e -> Ptr env -> ForeignPtr e -> m ()

-- | Unlifted version of <a>newConcForeignPtr</a>
newConcForeignPtr :: MonadUnliftPrim RW m => Ptr e -> m () -> m (ForeignPtr e)

-- | Unlifted version of <a>addForeignPtrConcFinalizer</a>
addForeignPtrConcFinalizer :: MonadUnliftPrim RW m => ForeignPtr a -> m () -> m ()
toForeignPtrBytes :: Bytes  'Pin -> ForeignPtr e
toForeignPtrMBytes :: MBytes  'Pin s -> ForeignPtr e
instance Data.Prim.Memory.ForeignPtr.PtrAccess s (GHC.ForeignPtr.ForeignPtr a)
instance Data.Prim.Memory.ForeignPtr.PtrAccess s Data.ByteString.Internal.ByteString
instance Data.Prim.Memory.ForeignPtr.PtrAccess s (Data.Prim.Memory.ByteString.MByteString s)
instance Data.Prim.Memory.ForeignPtr.PtrAccess s (Data.Prim.Memory.Bytes.Internal.Bytes 'Data.Prim.Memory.Bytes.Internal.Pin)
instance Data.Prim.Memory.ForeignPtr.PtrAccess s (Data.Prim.Memory.Bytes.Internal.MBytes 'Data.Prim.Memory.Bytes.Internal.Pin s)


module Data.Prim.Memory.Internal

-- | An immutable region of memory which was allocated either as pinned or
--   unpinned.
--   
--   Constructor is not exported for safety. Violating type level
--   <a>Pinned</a> kind is very dangerous. Type safe constructor
--   <a>fromByteArray#</a> and unwrapper <a>toByteArray#</a> should be used
--   instead. As a backdoor, of course, the actual constructor is available
--   in <a>Data.Prim.Memory.Internal</a> module and specially unsafe
--   function <a>castPinnedBytes</a> was crafted.
data Bytes (p :: Pinned)
Bytes :: ByteArray# -> Bytes

-- | Mutable region of memory which was allocated either as pinned or
--   unpinned.
--   
--   Constructor is not exported for safety. Violating type level
--   <a>Pinned</a> kind is very dangerous. Type safe constructor
--   <a>fromMutableByteArray#</a> and unwrapper <a>toMutableByteArray#</a>
--   should be used instead. As a backdoor, of course, the actual
--   constructor is available in <a>Data.Prim.Memory.Internal</a> module
--   and specially unsafe function <a>castPinnedMBytes</a> was crafted.
data MBytes (p :: Pinned) s
MBytes :: MutableByteArray# s -> MBytes s

-- | In Haskell there is a distinction between pinned or unpinned memory.
--   
--   Pinned memory is such, when allocated, it is guaranteed not to move
--   throughout the lifetime of a program. In other words the address
--   pointer that refers to allocated bytes will not change until it gets
--   garbage collected because it is no longer referenced by anything.
--   Unpinned memory on the other hand can be moved around during GC, which
--   helps to reduce memory fragmentation.
--   
--   Pinned/unpinnned choice during allocation is a bit of a lie, because
--   when attempt is made to allocate memory as unpinned, but requested
--   size is a bit more than a certain threashold (somewhere around 3KiB)
--   it might still be allocated as pinned. Because of that fact through
--   out the "primal" universe there is a distinction between memory that
--   is either <tt><a>Pin</a>ned</tt> or <tt><a>Inc</a>onclusive</tt>.
--   
--   It is possible to use one of <a>toPinnedBytes</a> or
--   <a>toPinnedMBytes</a> to get a conclusive type.
data Pinned
Pin :: Pinned
Inc :: Pinned
data MMemView a s
MMemView :: {-# UNPACK #-} !Off Word8 -> {-# UNPACK #-} !Count Word8 -> !a s -> MMemView a s
[mmvOffset] :: MMemView a s -> {-# UNPACK #-} !Off Word8
[mmvCount] :: MMemView a s -> {-# UNPACK #-} !Count Word8
[mmvMem] :: MMemView a s -> !a s
data MemView a
MemView :: {-# UNPACK #-} !Off Word8 -> {-# UNPACK #-} !Count Word8 -> !a -> MemView a
[mvOffset] :: MemView a -> {-# UNPACK #-} !Off Word8
[mvCount] :: MemView a -> {-# UNPACK #-} !Count Word8
[mvMem] :: MemView a -> !a

-- | A wrapper that adds a phantom state token. It can be use with types
--   that either doesn't have such state token or are designed to work in
--   <a>IO</a> and therefore restricted to <a>RW</a>. Using this wrapper is
--   very much unsafe, so make sure you know what you are doing.
newtype MemState a s
MemState :: a -> MemState a s
[unMemState] :: MemState a s -> a
class MemWrite w
readOffMem :: (MemWrite w, MonadPrim s m, Prim e) => w s -> Off e -> m e
readByteOffMem :: (MemWrite w, MonadPrim s m, Prim e) => w s -> Off Word8 -> m e
writeOffMem :: (MemWrite w, MonadPrim s m, Prim e) => w s -> Off e -> e -> m ()
writeByteOffMem :: (MemWrite w, MonadPrim s m, Prim e) => w s -> Off Word8 -> e -> m ()

-- | Source and target can be overlapping memory chunks
moveByteOffToMBytesMem :: (MemWrite w, MonadPrim s m, Prim e) => w s -> Off Word8 -> MBytes p s -> Off Word8 -> Count e -> m ()

-- | Source and target can be overlapping memory chunks
moveByteOffToPtrMem :: (MemWrite w, MonadPrim s m, Prim e) => w s -> Off Word8 -> Ptr e -> Off Word8 -> Count e -> m ()
copyByteOffMem :: (MemWrite w, MonadPrim s m, MemRead r, Prim e) => r -> Off Word8 -> w s -> Off Word8 -> Count e -> m ()
moveByteOffMem :: (MemWrite w, MonadPrim s m, MemWrite w', Prim e) => w' s -> Off Word8 -> w s -> Off Word8 -> Count e -> m ()

-- | Write the same value into each cell starting at an offset.
setMem :: (MemWrite w, MonadPrim s m, Prim e) => w s -> Off e -> Count e -> e -> m ()

-- | Generalized memory allocation and pure/mutable state conversion.
class (MemRead (FrozenMem a), MemWrite a) => MemAlloc a where {
    type family FrozenMem a = (fa :: Type) | fa -> a;
}
getByteCountMem :: (MemAlloc a, MonadPrim s m) => a s -> m (Count Word8)
allocByteCountMem :: (MemAlloc a, MonadPrim s m) => Count Word8 -> m (a s)
thawMem :: (MemAlloc a, MonadPrim s m) => FrozenMem a -> m (a s)
freezeMem :: (MemAlloc a, MonadPrim s m) => a s -> m (FrozenMem a)
resizeMem :: (MemAlloc a, MonadPrim s m, Prim e) => a s -> Count e -> m (a s)
class MemRead r
byteCountMem :: MemRead r => r -> Count Word8
indexOffMem :: (MemRead r, Prim e) => r -> Off e -> e
indexByteOffMem :: (MemRead r, Prim e) => r -> Off Word8 -> e

-- | Source and target can't refer to the same memory chunks
copyByteOffToMBytesMem :: (MemRead r, MonadPrim s m, Prim e) => r -> Off Word8 -> MBytes p s -> Off Word8 -> Count e -> m ()

-- | Source and target can't refer to the same memory chunks
copyByteOffToPtrMem :: (MemRead r, MonadPrim s m, Prim e) => r -> Off Word8 -> Ptr e -> Off Word8 -> Count e -> m ()
compareByteOffToPtrMem :: (MemRead r, MonadPrim s m, Prim e) => r -> Off Word8 -> Ptr e -> Off Word8 -> Count e -> m Ordering
compareByteOffToBytesMem :: (MemRead r, MonadPrim s m, Prim e) => r -> Off Word8 -> Bytes p -> Off Word8 -> Count e -> m Ordering
compareByteOffMem :: (MemRead r, MemRead r', Prim e) => r' -> Off Word8 -> r -> Off Word8 -> Count e -> Ordering
modifyFetchOldMem :: (MemWrite w, MonadPrim s m, Prim b) => w s -> Off b -> (b -> b) -> m b
modifyFetchNewMem :: (MemWrite w, MonadPrim s m, Prim b) => w s -> Off b -> (b -> b) -> m b
modifyFetchOldMemM :: (MemWrite w, MonadPrim s m, Prim b) => w s -> Off b -> (b -> m b) -> m b
modifyFetchNewMemM :: (MemWrite w, MonadPrim s m, Prim b) => w s -> Off b -> (b -> m b) -> m b
defaultResizeMem :: (Prim e, MemAlloc a, MonadPrim s m) => a s -> Count e -> m (a s)

-- | Make <tt>n</tt> copies of supplied region of memory into a contiguous
--   chunk of memory.
cycleMemN :: (MemAlloc a, MemRead r) => Int -> r -> FrozenMem a

-- | Chunk of empty memory.
emptyMem :: MemAlloc a => FrozenMem a

-- | A region of memory that hold a single element.
singletonMem :: forall e a. (MemAlloc a, Prim e) => e -> FrozenMem a

-- | Allocate enough memory for number of elements. Memory is not
--   initialized and may contain garbage. Use <a>allocZeroMem</a> if clean
--   memory is needed.
--   
--   <ul>
--   <li><i>Unsafe Count</i> Negative element count will result in
--   unpredictable behavior</li>
--   </ul>
allocMem :: (MemAlloc a, MonadPrim s m, Prim e) => Count e -> m (a s)

-- | Same as <a>allocMem</a>, but also use <tt>memset</tt> to initialize
--   all the new memory to zeros.
--   
--   <ul>
--   <li><i>Unsafe Count</i> Negative element count will result in
--   unpredictable behavior</li>
--   </ul>
allocZeroMem :: (MemAlloc a, MonadPrim s m, Prim e) => Count e -> m (a s)
createMemST :: (MemAlloc a, Prim e) => Count e -> (forall s. a s -> ST s b) -> (b, FrozenMem a)
createMemST_ :: (MemAlloc a, Prim e) => Count e -> (forall s. a s -> ST s b) -> FrozenMem a
createZeroMemST :: (MemAlloc a, Prim e) => Count e -> (forall s. a s -> ST s b) -> (b, FrozenMem a)
createZeroMemST_ :: (MemAlloc a, Prim e) => Count e -> (forall s. a s -> ST s b) -> FrozenMem a
copyMem :: (MonadPrim s m, MemRead r, MemWrite w, Prim e) => r -> Off e -> w s -> Off e -> Count e -> m ()
moveMem :: (MonadPrim s m, MemWrite w1, MemWrite w2, Prim e) => w1 s -> Off e -> w2 s -> Off e -> Count e -> m ()
appendMem :: (MemRead r1, MemRead r2, MemAlloc a) => r1 -> r2 -> FrozenMem a
concatMem :: (MemRead r, MemAlloc a) => [r] -> FrozenMem a
thawCopyMem :: (MemRead r, MemAlloc a, MonadPrim s m, Prim e) => r -> Off e -> Count e -> m (a s)
freezeCopyMem :: (MemAlloc a, MonadPrim s m, Prim e) => a s -> Off e -> Count e -> m (FrozenMem a)
thawCloneMem :: (MemRead r, MemAlloc a, MonadPrim s m) => r -> m (a s)
freezeCloneMem :: (MemAlloc a, MonadPrim s m) => a s -> m (FrozenMem a)

-- | <i>O(n)</i> - Convert a read-only memory region into a newly allocated
--   other type of memory region
--   
--   <pre>
--   &gt;&gt;&gt; import Data.ByteString
--   
--   &gt;&gt;&gt; bs = pack [0x10 .. 0x20]
--   
--   &gt;&gt;&gt; bs
--   "\DLE\DC1\DC2\DC3\DC4\NAK\SYN\ETB\CAN\EM\SUB\ESC\FS\GS\RS\US "
--   
--   &gt;&gt;&gt; convertMem bs :: Bytes 'Inc
--   [0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20]
--   </pre>
convertMem :: (MemRead r, MemAlloc a) => r -> FrozenMem a

-- | Figure out how many elements can fit into the region of memory. It is
--   possible that there is a remainder of bytes left, see
--   <a>countRemMem</a> for getting that too.
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; b = fromListMem [0 .. 5 :: Word8] :: Bytes 'Pin
--   
--   &gt;&gt;&gt; b
--   [0x00,0x01,0x02,0x03,0x04,0x05]
--   
--   &gt;&gt;&gt; countMem b :: Count Word16
--   Count {unCount = 3}
--   
--   &gt;&gt;&gt; countMem b :: Count Word32
--   Count {unCount = 1}
--   </pre>
countMem :: forall e r. (MemRead r, Prim e) => r -> Count e

-- | Compute how many elements and a byte size remainder that can fit into
--   the region of memory.
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; b = fromListMem [0 .. 5 :: Word8] :: Bytes 'Pin
--   
--   &gt;&gt;&gt; b
--   [0x00,0x01,0x02,0x03,0x04,0x05]
--   
--   &gt;&gt;&gt; countRemMem @Word16 b
--   (Count {unCount = 3},0)
--   
--   &gt;&gt;&gt; countRemMem @Word32 b
--   (Count {unCount = 1},2)
--   </pre>
countRemMem :: forall e r. (MemRead r, Prim e) => r -> (Count e, Count Word8)
getCountMem :: (MemAlloc r, MonadPrim s m, Prim e) => r s -> m (Count e)
getCountRemMem :: (MemAlloc r, MonadPrim s m, Prim e) => r s -> m (Count e, Count Word8)
clone :: (MemAlloc r, MonadPrim s m) => r s -> m (r s)
eqMem :: (MemRead r1, MemRead r2) => r1 -> r2 -> Bool

-- | Compare two regions of memory byte-by-byte. It will return <a>EQ</a>
--   whenever both regions are exactly the same and <a>LT</a> or <a>GT</a>
--   as soon as the first byte is reached that is less than or greater than
--   respectfully in the first region when compared to the second one. It
--   is safe for both regions to refer to the same part of memory, since
--   this is a pure function and both regions of memory are read-only.
compareMem :: (MemRead r1, MemRead r2, Prim e) => r1 -> Off e -> r2 -> Off e -> Count e -> Ordering

-- | It is only guaranteed to convert the whole memory to a list whenever
--   the size of allocated memory is exactly divisible by the size of the
--   element, otherwise there will be some slack left unaccounted for.
toListMem :: (MemRead r, Prim e) => r -> [e]

-- | Same as <a>toListMem</a>, except if there is some slack at the end of
--   the memory that didn't fit in a list it will be returned as a list of
--   bytes
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; import Data.Word
--   
--   &gt;&gt;&gt; :set -XDataKinds
--   
--   &gt;&gt;&gt; a = fromListMem [0 .. 10 :: Word8] :: Bytes 'Pin
--   
--   &gt;&gt;&gt; a
--   [0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a]
--   
--   &gt;&gt;&gt; toListSlackMem a :: ([Word8], [Word8])
--   ([0,1,2,3,4,5,6,7,8,9,10],[])
--   
--   &gt;&gt;&gt; toListSlackMem a :: ([Word16], [Word8])
--   ([256,770,1284,1798,2312],[10])
--   
--   &gt;&gt;&gt; toListSlackMem a :: ([Word32], [Word8])
--   ([50462976,117835012],[8,9,10])
--   
--   &gt;&gt;&gt; toListSlackMem a :: ([Word64], [Word8])
--   ([506097522914230528],[8,9,10])
--   </pre>
toListSlackMem :: forall e r. (MemRead r, Prim e) => r -> ([e], [Word8])

-- | Right fold that is useful for converting to list while tapping into
--   list fusion.
foldrCountMem :: (MemRead r, Prim e) => Count e -> (e -> b -> b) -> b -> r -> b
loadListMemN :: (MemWrite r, MonadPrim s m, Prim e) => Count e -> Count Word8 -> [e] -> r s -> m Ordering
loadListMemN_ :: (MemWrite r, MonadPrim s m, Prim e) => Count e -> [e] -> r s -> m ()

-- | Returns <a>EQ</a> if the full list did fit into the supplied memory
--   chunk exactly. Otherwise it will return either <a>LT</a> if the list
--   was smaller than allocated memory or <a>GT</a> if the list was bigger
--   than the available memory and did not fit into <a>MBytes</a>.
loadListMem :: (MonadPrim s m, MemAlloc r, Prim e) => [e] -> r s -> m Ordering
loadListMem_ :: (MonadPrim s m, MemAlloc r, Prim e) => [e] -> r s -> m ()
fromListMemN :: (MemAlloc a, Prim e) => Count e -> [e] -> (Ordering, FrozenMem a)
fromListMemN_ :: (MemAlloc a, Prim e) => Count e -> [e] -> FrozenMem a
fromListMem :: (MemAlloc a, Prim e) => [e] -> FrozenMem a

-- | Load a list of bytes into a newly allocated memory region. Equivalent
--   to <a>pack</a> for <a>ByteString</a>
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; fromByteListMem [0..10] :: Bytes 'Pin
--   [0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a]
--   </pre>
fromByteListMem :: MemAlloc a => [Word8] -> FrozenMem a

-- | Convert a memory region to a list of bytes. Equivalent to
--   <a>unpack</a> for <a>ByteString</a>
--   
--   <pre>
--   &gt;&gt;&gt; toByteListMem (fromByteListMem [0..10] :: Bytes 'Pin)
--   [0,1,2,3,4,5,6,7,8,9,10]
--   </pre>
toByteListMem :: MemAlloc a => FrozenMem a -> [Word8]
mapByteMem :: (MemRead r, MemAlloc a, Prim e) => (Word8 -> e) -> r -> FrozenMem a

-- | Map an index aware function over memory region
--   
--   <pre>
--   &gt;&gt;&gt; a = fromListMem [1 .. 10 :: Word8] :: Bytes 'Inc
--   
--   &gt;&gt;&gt; a
--   [0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a]
--   
--   &gt;&gt;&gt; imapMem (\i e -&gt; (fromIntegral i :: Int8, e + 0xf0)) a :: Bytes 'Pin
--   [0x00,0xf1,0x01,0xf2,0x02,0xf3,0x03,0xf4,0x04,0xf5,0x05,0xf6,0x06,0xf7,0x07,0xf8,0x08,0xf9,0x09,0xfa]
--   </pre>
mapByteOffMem :: (MemRead r, MemAlloc a, Prim e) => (Off Word8 -> Word8 -> e) -> r -> FrozenMem a
mapByteMemM :: (MemRead r, MemAlloc a, MonadPrim s m, Prim e) => (Word8 -> m e) -> r -> m (FrozenMem a)
mapByteOffMemM :: (MemRead r, MemAlloc a, MonadPrim s m, Prim e) => (Off Word8 -> Word8 -> m e) -> r -> m (FrozenMem a)

-- | Iterate over a region of memory
forByteOffMemM_ :: (MemRead r, MonadPrim s m, Prim e) => r -> Off Word8 -> Count e -> (Off Word8 -> e -> m b) -> m (Off Word8)
loopShortM :: Monad m => Int -> (Int -> a -> Bool) -> (Int -> Int) -> a -> (Int -> a -> m a) -> m a
loopShortM' :: Monad m => Int -> (Int -> a -> m Bool) -> (Int -> Int) -> a -> (Int -> a -> m a) -> m a
izipWithByteOffMemM_ :: (MemRead r1, MemRead r2, MonadPrim s m, Prim e) => r1 -> Off Word8 -> r2 -> Off Word8 -> Count e -> (Off Word8 -> e -> Off Word8 -> e -> m b) -> m (Off Word8)
izipWithOffMemM_ :: (MemRead r1, MemRead r2, MonadPrim s m, Prim e1, Prim e2) => r1 -> Off e1 -> r2 -> Off e2 -> Int -> (Off e1 -> e1 -> Off e2 -> e2 -> m b) -> m ()

-- | A list of <a>ShowS</a> that covert bytes to base16 encoded strings.
--   Each element of the list is a function that will convert one byte.
--   
--   <pre>
--   &gt;&gt;&gt; mb &lt;- newPinnedMBytes (Count 5 :: Count Int)
--   
--   &gt;&gt;&gt; mapM_ (\i -&gt; writeOffMBytes mb (pred i) i) [1 .. 5]
--   
--   &gt;&gt;&gt; foldr ($) "" . showsBytesHex &lt;$&gt; freezeMBytes mb
--   "01000000000000000200000000000000030000000000000004000000000000000500000000000000"
--   </pre>
showsHexMem :: MemRead r => r -> [ShowS]

-- | Ensure that memory is filled with zeros before and after it is used.
withScrubbedMem :: (MonadUnliftPrim RW m, Prim e, MemAlloc mem) => Count e -> (mem RW -> m a) -> m a
instance Data.Prim.Memory.Internal.MemWrite (Data.Prim.Memory.Internal.MemState (GHC.ForeignPtr.ForeignPtr a))
instance Data.Prim.Memory.Internal.MemAlloc Data.Prim.Memory.ByteString.MByteString
instance Data.Typeable.Internal.Typeable p => Data.Prim.Memory.Internal.MemAlloc (Data.Prim.Memory.Bytes.Internal.MBytes p)
instance Data.Prim.Memory.Internal.MemWrite Data.Prim.Memory.ByteString.MByteString
instance Data.Prim.Memory.Internal.MemWrite (Data.Prim.Memory.Bytes.Internal.MBytes p)
instance Data.Prim.Memory.Internal.MemRead Data.ByteString.Internal.ByteString
instance Data.Prim.Memory.Internal.MemRead Data.ByteString.Short.Internal.ShortByteString
instance Data.Prim.Memory.Internal.MemRead (Data.Prim.Memory.Bytes.Internal.Bytes p)
instance GHC.Show.Show (Data.Prim.Memory.Bytes.Internal.Bytes p)
instance Data.Typeable.Internal.Typeable p => GHC.Exts.IsList (Data.Prim.Memory.Bytes.Internal.Bytes p)
instance GHC.Classes.Eq (Data.Prim.Memory.Bytes.Internal.Bytes p)
instance GHC.Classes.Ord (Data.Prim.Memory.Bytes.Internal.Bytes p)
instance Data.Typeable.Internal.Typeable p => GHC.Base.Semigroup (Data.Prim.Memory.Bytes.Internal.Bytes p)
instance Data.Typeable.Internal.Typeable p => GHC.Base.Monoid (Data.Prim.Memory.Bytes.Internal.Bytes p)


module Data.Prim.Memory.Bytes

-- | An immutable region of memory which was allocated either as pinned or
--   unpinned.
--   
--   Constructor is not exported for safety. Violating type level
--   <a>Pinned</a> kind is very dangerous. Type safe constructor
--   <a>fromByteArray#</a> and unwrapper <a>toByteArray#</a> should be used
--   instead. As a backdoor, of course, the actual constructor is available
--   in <a>Data.Prim.Memory.Internal</a> module and specially unsafe
--   function <a>castPinnedBytes</a> was crafted.
data Bytes (p :: Pinned)

-- | Wrap <a>ByteArray#</a> into <a>Bytes</a>
toByteArray# :: Bytes p -> ByteArray#

-- | Unwrap <a>Bytes</a> to get the underlying <a>ByteArray#</a>.
fromByteArray# :: ByteArray# -> Bytes  'Inc
cloneBytes :: Typeable p => Bytes p -> Bytes p
emptyBytes :: Bytes p
eqBytes :: Bytes p1 -> Bytes p2 -> Bool
singletonBytes :: forall e p. (Prim e, Typeable p) => e -> Bytes p
isEmptyBytes :: Bytes p -> Bool

-- | Allocated memory is not cleared, so make sure to fill it in properly,
--   otherwise you might find some garbage there.
createBytes :: forall p e b s m. (Prim e, Typeable p, MonadPrim s m) => Count e -> (MBytes p s -> m b) -> m (b, Bytes p)
createBytes_ :: forall p e b s m. (Prim e, Typeable p, MonadPrim s m) => Count e -> (MBytes p s -> m b) -> m (Bytes p)
createBytesST :: forall p e b. (Prim e, Typeable p) => Count e -> (forall s. MBytes p s -> ST s b) -> (b, Bytes p)
createBytesST_ :: forall p e b. (Prim e, Typeable p) => Count e -> (forall s. MBytes p s -> ST s b) -> Bytes p

-- | In Haskell there is a distinction between pinned or unpinned memory.
--   
--   Pinned memory is such, when allocated, it is guaranteed not to move
--   throughout the lifetime of a program. In other words the address
--   pointer that refers to allocated bytes will not change until it gets
--   garbage collected because it is no longer referenced by anything.
--   Unpinned memory on the other hand can be moved around during GC, which
--   helps to reduce memory fragmentation.
--   
--   Pinned/unpinnned choice during allocation is a bit of a lie, because
--   when attempt is made to allocate memory as unpinned, but requested
--   size is a bit more than a certain threashold (somewhere around 3KiB)
--   it might still be allocated as pinned. Because of that fact through
--   out the "primal" universe there is a distinction between memory that
--   is either <tt><a>Pin</a>ned</tt> or <tt><a>Inc</a>onclusive</tt>.
--   
--   It is possible to use one of <a>toPinnedBytes</a> or
--   <a>toPinnedMBytes</a> to get a conclusive type.
data Pinned
Pin :: Pinned
Inc :: Pinned
isPinnedBytes :: Bytes p -> Bool
isPinnedMBytes :: MBytes p d -> Bool
toPinnedBytes :: Bytes p -> Maybe (Bytes  'Pin)
toPinnedMBytes :: MBytes p s -> Maybe (MBytes  'Pin s)
relaxPinnedBytes :: Bytes p -> Bytes  'Inc
relaxPinnedMBytes :: MBytes p e -> MBytes  'Inc e
ensurePinnedBytes :: Bytes p -> Bytes  'Pin
ensurePinnedMBytes :: MonadPrim s m => MBytes p s -> m (MBytes  'Pin s)

-- | Mutable region of memory which was allocated either as pinned or
--   unpinned.
--   
--   Constructor is not exported for safety. Violating type level
--   <a>Pinned</a> kind is very dangerous. Type safe constructor
--   <a>fromMutableByteArray#</a> and unwrapper <a>toMutableByteArray#</a>
--   should be used instead. As a backdoor, of course, the actual
--   constructor is available in <a>Data.Prim.Memory.Internal</a> module
--   and specially unsafe function <a>castPinnedMBytes</a> was crafted.
data MBytes (p :: Pinned) s

-- | Wrap <a>MutableByteArray#</a> into <a>MBytes</a>
toMutableByteArray# :: MBytes p s -> MutableByteArray# s

-- | Unwrap <a>MBytes</a> to get the underlying <a>MutableByteArray#</a>.
fromMutableByteArray# :: MutableByteArray# s -> MBytes  'Inc s

-- | Check if two byte arrays refer to pinned memory and compare their
--   pointers.
isSameBytes :: Bytes p1 -> Bytes p2 -> Bool

-- | Perform pointer equality on pinned <a>Bytes</a>.
isSamePinnedBytes :: Bytes  'Pin -> Bytes  'Pin -> Bool

-- | Check if two mutable bytes pointers refer to the same memory
isSameMBytes :: MBytes p1 s -> MBytes p2 s -> Bool
indexOffBytes :: Prim e => Bytes p -> Off e -> e
indexByteOffBytes :: Prim e => Bytes p -> Off Word8 -> e
byteCountBytes :: Bytes p -> Count Word8

-- | How many elements of type <tt>a</tt> fits into bytes completely. In
--   order to get a possible count of leftover bytes use
--   <tt>countRemBytes</tt>
countBytes :: Prim e => Bytes p -> Count e

-- | Get the count of elements of type <tt>a</tt> that can fit into bytes
--   as well as the slack number of bytes that would be leftover in case
--   when total number of bytes available is not exactly divisable by the
--   size of the element that will be stored in the memory chunk.
countRemBytes :: forall e p. Prim e => Bytes p -> (Count e, Count Word8)
compareBytes :: Prim e => Bytes p1 -> Off e -> Bytes p2 -> Off e -> Count e -> Ordering
compareByteOffBytes :: Prim e => Bytes p1 -> Off Word8 -> Bytes p2 -> Off Word8 -> Count e -> Ordering
thawBytes :: MonadPrim s m => Bytes p -> m (MBytes p s)
freezeMBytes :: MonadPrim s m => MBytes p s -> m (Bytes p)
allocMBytes :: forall p e s m. (Typeable p, Prim e, MonadPrim s m) => Count e -> m (MBytes p s)
singletonMBytes :: forall e p m s. (Prim e, Typeable p, MonadPrim s m) => e -> m (MBytes p s)
allocPinnedMBytes :: (MonadPrim s m, Prim e) => Count e -> m (MBytes  'Pin s)
allocAlignedMBytes :: forall e m s. (MonadPrim s m, Prim e) => Count e -> m (MBytes  'Pin s)
allocUnpinnedMBytes :: (MonadPrim s m, Prim e) => Count e -> m (MBytes  'Inc s)
callocMBytes :: (MonadPrim s m, Prim e, Typeable p) => Count e -> m (MBytes p s)
callocAlignedMBytes :: (MonadPrim s m, Prim e) => Count e -> m (MBytes  'Pin s)

-- | Shrink mutable bytes to new specified count of elements. The new count
--   must be less than or equal to the current count as reported by
--   <a>getCountMBytes</a>.
shrinkMBytes :: (MonadPrim s m, Prim e) => MBytes p s -> Count e -> m ()

-- | Attempt to resize mutable bytes in place.
--   
--   <ul>
--   <li>New bytes might be allocated, with the copy of an old one.</li>
--   <li>Old references should not be kept around to allow GC to claim
--   it</li>
--   <li>Old references should not be used to avoid undefined behavior</li>
--   </ul>
resizeMBytes :: (MonadPrim s m, Prim e) => MBytes p s -> Count e -> m (MBytes  'Inc s)
reallocMBytes :: forall e p m s. (MonadPrim s m, Typeable p, Prim e) => MBytes p s -> Count e -> m (MBytes p s)

-- | This function allows the change of state token. Use with care, because
--   it can allow mutation to escape the <a>ST</a> monad.
coerceStateMBytes :: MBytes p s' -> MBytes p s
cloneMBytes :: (MonadPrim s m, Typeable p) => MBytes p s -> m (MBytes p s)
withCloneMBytes :: (MonadPrim s m, Typeable p) => Bytes p -> (MBytes p s -> m a) -> m (a, Bytes p)
withCloneMBytes_ :: (MonadPrim s m, Typeable p) => Bytes p -> (MBytes p s -> m a) -> m (Bytes p)
withCloneMBytesST :: Typeable p => Bytes p -> (forall s. MBytes p s -> ST s a) -> (a, Bytes p)
withCloneMBytesST_ :: Typeable p => Bytes p -> (forall s. MBytes p s -> ST s a) -> Bytes p

-- | Returns <a>EQ</a> if the full list did fit into the supplied memory
--   chunk exactly. Otherwise it will return either <a>LT</a> if the list
--   was smaller than allocated memory or <a>GT</a> if the list was bigger
--   than the available memory and did not fit into <a>MBytes</a>.
loadListMBytes :: (MonadPrim s m, Prim e) => [e] -> MBytes p s -> m Ordering
loadListMBytes_ :: (MonadPrim s m, Prim e) => [e] -> MBytes p s -> m ()
copyBytesToMBytes :: (MonadPrim s m, Prim e) => Bytes ps -> Off e -> MBytes pd s -> Off e -> Count e -> m ()
moveMBytesToMBytes :: (MonadPrim s m, Prim e) => MBytes ps s -> Off e -> MBytes pd s -> Off e -> Count e -> m ()
getByteCountMBytes :: MonadPrim s m => MBytes p s -> m (Count Word8)

-- | How many elements of type <tt>a</tt> fits into bytes completely. In
--   order to get any number of leftover bytes use <tt>countRemBytes</tt>
getCountMBytes :: (MonadPrim s m, Prim e) => MBytes p s -> m (Count e)

-- | Get the number of elements of type <tt>a</tt> that can fit into bytes
--   as well as the slack number of bytes that would be leftover in case
--   when total number of bytes available is not exactly divisable by the
--   size of the element that will be stored in the memory chunk.
getCountRemOfMBytes :: forall e p s m. (MonadPrim s m, Prim e) => MBytes p s -> m (Count e, Count Word8)
readOffMBytes :: (MonadPrim s m, Prim e) => MBytes p s -> Off e -> m e
readByteOffMBytes :: (MonadPrim s m, Prim e) => MBytes p s -> Off Word8 -> m e
writeOffMBytes :: (MonadPrim s m, Prim e) => MBytes p s -> Off e -> e -> m ()
writeByteOffMBytes :: (MonadPrim s m, Prim e) => MBytes p s -> Off Word8 -> e -> m ()
setMBytes :: (MonadPrim s m, Prim e) => MBytes p s -> Off e -> Count e -> e -> m ()

-- | Fill the mutable array with zeros efficiently.
zeroMBytes :: MonadPrim s m => MBytes p s -> m ()

-- | Pointer access to immutable <a>Bytes</a> should be for read only
--   purposes, but it is not enforced. Any mutation will break referential
--   transparency
withPtrBytes :: MonadPrim s m => Bytes  'Pin -> (Ptr e -> m b) -> m b

-- | Same as <a>withPtrBytes</a>, but is suitable for actions that don't
--   terminate
withNoHaltPtrBytes :: MonadUnliftPrim s m => Bytes  'Pin -> (Ptr e -> m b) -> m b
withPtrMBytes :: MonadPrim s m => MBytes  'Pin s -> (Ptr e -> m b) -> m b
withNoHaltPtrMBytes :: MonadUnliftPrim s m => MBytes  'Pin s -> (Ptr e -> m b) -> m b
toPtrBytes :: Bytes  'Pin -> Ptr e
toPtrMBytes :: MBytes  'Pin s -> Ptr e
toForeignPtrBytes :: Bytes  'Pin -> ForeignPtr e
toForeignPtrMBytes :: MBytes  'Pin s -> ForeignPtr e
fromListBytes :: forall e p. (Prim e, Typeable p) => [e] -> Bytes p

-- | If the list is bigger than the supplied <tt><a>Count</a> a</tt> then
--   <a>GT</a> ordering will be returned, along with the <a>Bytes</a> fully
--   filled with the prefix of the list. On the other hand if the list is
--   smaller than the supplied <a>Count</a>, <a>LT</a> with partially
--   filled <a>Bytes</a> will returned. In the latter case expect some
--   garbage at the end of the allocated memory, since no attempt is made
--   to zero it out. Exact match obviously results in an <a>EQ</a>.
fromListBytesN :: (Prim e, Typeable p) => Count e -> [e] -> (Ordering, Bytes p)
fromListBytesN_ :: (Prim e, Typeable p) => Count e -> [e] -> Bytes p

-- | Allocate new memory region and append second bytes region after the
--   first one
appendBytes :: Typeable p => Bytes p1 -> Bytes p2 -> Bytes p
concatBytes :: Typeable p => [Bytes p'] -> Bytes p

-- | It is only guaranteed to convert the whole memory to a list whenever
--   the size of allocated memory is exactly divisible by the size of the
--   element, otherwise there will be some slack left unaccounted for.
toListBytes :: Prim e => Bytes p -> [e]
toListSlackBytes :: Prim e => Bytes p -> ([e], [Word8])

-- | Perform atomic modification of an element in the <a>MBytes</a> at the
--   supplied index. Returns the actual value. Offset is in number of
--   elements, rather than bytes. Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
casMBytes :: (MonadPrim s m, Atomic e) => MBytes p s -> Off e -> e -> e -> m e

-- | Perform atomic modification of an element in the <a>MBytes</a> at the
--   supplied index. Returns <a>True</a> if swap was successfull and false
--   otherwise. Offset is in number of elements, rather than bytes. Implies
--   a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
casBoolMBytes :: (MonadPrim s m, Atomic e) => MBytes p s -> Off e -> e -> e -> m Bool

-- | Just like <a>casBoolMBytes</a>, but also returns the actual value,
--   which will match the supplied expected value if the returned flag is
--   <a>True</a>
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
casBoolFetchMBytes :: (MonadPrim s m, Atomic e) => MBytes p s -> Off e -> e -> e -> m (Bool, e)

-- | Perform atomic read of <a>MBytes</a> at the supplied index. Offset is
--   in number of elements, rather than bytes. Implies a full memory
--   barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicReadMBytes :: (MonadPrim s m, Atomic e) => MBytes p s -> Off e -> m e

-- | Perform a write into <a>MBytes</a> at the supplied index atomically.
--   Offset is in number of elements, rather than bytes. Implies a full
--   memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicWriteMBytes :: (MonadPrim s m, Atomic e) => MBytes p s -> Off e -> e -> m ()

-- | Perform atomic modification of an element in the <a>MBytes</a> at the
--   supplied index. Returns the artifact of computation <tt><b>b</b></tt>.
--   Offset is in number of elements, rather than bytes. Implies a full
--   memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicModifyMBytes :: (MonadPrim s m, Atomic e) => MBytes p s -> Off e -> (e -> (e, b)) -> m b

-- | Perform atomic modification of an element in the <a>MBytes</a> at the
--   supplied index. Offset is in number of elements, rather than bytes.
--   Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicModifyMBytes_ :: (MonadPrim s m, Atomic e) => MBytes p s -> Off e -> (e -> e) -> m ()

-- | Perform atomic modification of an element in the <a>MBytes</a> at the
--   supplied index. Returns the previous value. Offset is in number of
--   elements, rather than bytes. Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicBoolModifyFetchOldMBytes :: (MonadPrim s m, Atomic e) => MBytes p s -> Off e -> (e -> e) -> m e

-- | Perform atomic modification of an element in the <a>MBytes</a> at the
--   supplied index. Returns the previous value. Offset is in number of
--   elements, rather than bytes. Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicModifyFetchOldMBytes :: (MonadPrim s m, Atomic e) => MBytes p s -> Off e -> (e -> e) -> m e

-- | Perform atomic modification of an element in the <a>MBytes</a> at the
--   supplied index. Offset is in number of elements, rather than bytes.
--   Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicModifyFetchNewMBytes :: (MonadPrim s m, Atomic e) => MBytes p s -> Off e -> (e -> e) -> m e

-- | Add a numeric value to an element of a <a>MBytes</a>, corresponds to
--   <tt>(<a>+</a>)</tt> done atomically. Returns the previous value.
--   Offset is in number of elements, rather than bytes. Implies a full
--   memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicAddFetchOldMBytes :: (MonadPrim s m, AtomicCount e) => MBytes p s -> Off e -> e -> m e

-- | Add a numeric value to an element of a <a>MBytes</a>, corresponds to
--   <tt>(<a>+</a>)</tt> done atomically. Returns the new value. Offset is
--   in number of elements, rather than bytes. Implies a full memory
--   barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicAddFetchNewMBytes :: (MonadPrim s m, AtomicCount e) => MBytes p s -> Off e -> e -> m e

-- | Subtract a numeric value from an element of a <a>MBytes</a>,
--   corresponds to <tt>(<a>-</a>)</tt> done atomically. Returns the
--   previous value. Offset is in number of elements, rather than bytes.
--   Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicSubFetchOldMBytes :: (MonadPrim s m, AtomicCount e) => MBytes p s -> Off e -> e -> m e

-- | Subtract a numeric value from an element of a <a>MBytes</a>,
--   corresponds to <tt>(<a>-</a>)</tt> done atomically. Returns the new
--   value. Offset is in number of elements, rather than bytes. Implies a
--   full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicSubFetchNewMBytes :: (MonadPrim s m, AtomicCount e) => MBytes p s -> Off e -> e -> m e

-- | Binary conjunction (AND) of an element of a <a>MBytes</a> with the
--   supplied value, corresponds to <tt>(<a>.&amp;.</a>)</tt> done
--   atomically. Returns the previous value. Offset is in number of
--   elements, rather than bytes. Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicAndFetchOldMBytes :: (MonadPrim s m, AtomicBits e) => MBytes p s -> Off e -> e -> m e

-- | Binary conjunction (AND) of an element of a <a>MBytes</a> with the
--   supplied value, corresponds to <tt>(<a>.&amp;.</a>)</tt> done
--   atomically. Returns the new value. Offset is in number of elements,
--   rather than bytes. Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicAndFetchNewMBytes :: (MonadPrim s m, AtomicBits e) => MBytes p s -> Off e -> e -> m e

-- | Negation of binary conjunction (NAND) of an element of a <a>MBytes</a>
--   with the supplied value, corresponds to <tt>\x y -&gt;
--   <a>complement</a> (x <a>.&amp;.</a> y)</tt> done atomically. Returns
--   the previous value. Offset is in number of elements, rather than
--   bytes. Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicNandFetchOldMBytes :: (MonadPrim s m, AtomicBits e) => MBytes p s -> Off e -> e -> m e

-- | Negation of binary conjunction (NAND) of an element of a <a>MBytes</a>
--   with the supplied value, corresponds to <tt>\x y -&gt;
--   <a>complement</a> (x <a>.&amp;.</a> y)</tt> done atomically. Returns
--   the new value. Offset is in number of elements, rather than bytes.
--   Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicNandFetchNewMBytes :: (MonadPrim s m, AtomicBits e) => MBytes p s -> Off e -> e -> m e

-- | Binary disjunction (OR) of an element of a <a>MBytes</a> with the
--   supplied value, corresponds to <tt>(<a>.|.</a>)</tt> done atomically.
--   Returns the previous value. Offset is in number of elements, rather
--   than bytes. Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicOrFetchOldMBytes :: (MonadPrim s m, AtomicBits e) => MBytes p s -> Off e -> e -> m e

-- | Binary disjunction (OR) of an element of a <a>MBytes</a> with the
--   supplied value, corresponds to <tt>(<a>.|.</a>)</tt> done atomically.
--   Returns the new value. Offset is in number of elements, rather than
--   bytes. Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicOrFetchNewMBytes :: (MonadPrim s m, AtomicBits e) => MBytes p s -> Off e -> e -> m e

-- | Binary exclusive disjunction (XOR) of an element of a <a>MBytes</a>
--   with the supplied value, corresponds to <tt><a>xor</a></tt> done
--   atomically. Returns the previous value. Offset is in number of
--   elements, rather than bytes. Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicXorFetchOldMBytes :: (MonadPrim s m, AtomicBits e) => MBytes p s -> Off e -> e -> m e

-- | Binary exclusive disjunction (XOR) of an element of a <a>MBytes</a>
--   with the supplied value, corresponds to <tt><a>xor</a></tt> done
--   atomically. Returns the new value. Offset is in number of elements,
--   rather than bytes. Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicXorFetchNewMBytes :: (MonadPrim s m, AtomicBits e) => MBytes p s -> Off e -> e -> m e

-- | Binary negation (NOT) of an element of a <a>MBytes</a>, corresponds to
--   <tt>(<a>complement</a>)</tt> done atomically. Returns the previous
--   value. Offset is in number of elements, rather than bytes. Implies a
--   full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicNotFetchOldMBytes :: (MonadPrim s m, AtomicBits e) => MBytes p s -> Off e -> m e

-- | Binary negation (NOT) of an element of a <a>MBytes</a>, corresponds to
--   <tt>(<a>complement</a>)</tt> done atomically. Returns the new value.
--   Offset is in number of elements, rather than bytes. Implies a full
--   memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicNotFetchNewMBytes :: (MonadPrim s m, AtomicBits e) => MBytes p s -> Off e -> m e
prefetchBytes0 :: (MonadPrim s m, Prim e) => Bytes p -> Off e -> m ()
prefetchMBytes0 :: (MonadPrim s m, Prim e) => MBytes p s -> Off e -> m ()
prefetchBytes1 :: (MonadPrim s m, Prim e) => Bytes p -> Off e -> m ()
prefetchMBytes1 :: (MonadPrim s m, Prim e) => MBytes p s -> Off e -> m ()
prefetchBytes2 :: (MonadPrim s m, Prim e) => Bytes p -> Off e -> m ()
prefetchMBytes2 :: (MonadPrim s m, Prim e) => MBytes p s -> Off e -> m ()
prefetchBytes3 :: (MonadPrim s m, Prim e) => Bytes p -> Off e -> m ()
prefetchMBytes3 :: (MonadPrim s m, Prim e) => MBytes p s -> Off e -> m ()


module Data.Prim.Memory

-- | In Haskell there is a distinction between pinned or unpinned memory.
--   
--   Pinned memory is such, when allocated, it is guaranteed not to move
--   throughout the lifetime of a program. In other words the address
--   pointer that refers to allocated bytes will not change until it gets
--   garbage collected because it is no longer referenced by anything.
--   Unpinned memory on the other hand can be moved around during GC, which
--   helps to reduce memory fragmentation.
--   
--   Pinned/unpinnned choice during allocation is a bit of a lie, because
--   when attempt is made to allocate memory as unpinned, but requested
--   size is a bit more than a certain threashold (somewhere around 3KiB)
--   it might still be allocated as pinned. Because of that fact through
--   out the "primal" universe there is a distinction between memory that
--   is either <tt><a>Pin</a>ned</tt> or <tt><a>Inc</a>onclusive</tt>.
--   
--   It is possible to use one of <a>toPinnedBytes</a> or
--   <a>toPinnedMBytes</a> to get a conclusive type.
data Pinned
Pin :: Pinned
Inc :: Pinned

-- | An immutable region of memory which was allocated either as pinned or
--   unpinned.
--   
--   Constructor is not exported for safety. Violating type level
--   <a>Pinned</a> kind is very dangerous. Type safe constructor
--   <a>fromByteArray#</a> and unwrapper <a>toByteArray#</a> should be used
--   instead. As a backdoor, of course, the actual constructor is available
--   in <a>Data.Prim.Memory.Internal</a> module and specially unsafe
--   function <a>castPinnedBytes</a> was crafted.
data Bytes (p :: Pinned)
class MemRead r

-- | Figure out how many elements can fit into the region of memory. It is
--   possible that there is a remainder of bytes left, see
--   <a>countRemMem</a> for getting that too.
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; b = fromListMem [0 .. 5 :: Word8] :: Bytes 'Pin
--   
--   &gt;&gt;&gt; b
--   [0x00,0x01,0x02,0x03,0x04,0x05]
--   
--   &gt;&gt;&gt; countMem b :: Count Word16
--   Count {unCount = 3}
--   
--   &gt;&gt;&gt; countMem b :: Count Word32
--   Count {unCount = 1}
--   </pre>
countMem :: forall e r. (MemRead r, Prim e) => r -> Count e

-- | Compute how many elements and a byte size remainder that can fit into
--   the region of memory.
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; b = fromListMem [0 .. 5 :: Word8] :: Bytes 'Pin
--   
--   &gt;&gt;&gt; b
--   [0x00,0x01,0x02,0x03,0x04,0x05]
--   
--   &gt;&gt;&gt; countRemMem @Word16 b
--   (Count {unCount = 3},0)
--   
--   &gt;&gt;&gt; countRemMem @Word32 b
--   (Count {unCount = 1},2)
--   </pre>
countRemMem :: forall e r. (MemRead r, Prim e) => r -> (Count e, Count Word8)
indexOffMem :: (MemRead r, Prim e) => r -> Off e -> e
eqMem :: (MemRead r1, MemRead r2) => r1 -> r2 -> Bool

-- | Compare two regions of memory byte-by-byte. It will return <a>EQ</a>
--   whenever both regions are exactly the same and <a>LT</a> or <a>GT</a>
--   as soon as the first byte is reached that is less than or greater than
--   respectfully in the first region when compared to the second one. It
--   is safe for both regions to refer to the same part of memory, since
--   this is a pure function and both regions of memory are read-only.
compareMem :: (MemRead r1, MemRead r2, Prim e) => r1 -> Off e -> r2 -> Off e -> Count e -> Ordering

-- | Mutable region of memory which was allocated either as pinned or
--   unpinned.
--   
--   Constructor is not exported for safety. Violating type level
--   <a>Pinned</a> kind is very dangerous. Type safe constructor
--   <a>fromMutableByteArray#</a> and unwrapper <a>toMutableByteArray#</a>
--   should be used instead. As a backdoor, of course, the actual
--   constructor is available in <a>Data.Prim.Memory.Internal</a> module
--   and specially unsafe function <a>castPinnedMBytes</a> was crafted.
data MBytes (p :: Pinned) s

-- | Generalized memory allocation and pure/mutable state conversion.
class (MemRead (FrozenMem a), MemWrite a) => MemAlloc a where {
    type family FrozenMem a = (fa :: Type) | fa -> a;
}
class MemWrite w
getCountMem :: (MemAlloc r, MonadPrim s m, Prim e) => r s -> m (Count e)
getCountRemMem :: (MemAlloc r, MonadPrim s m, Prim e) => r s -> m (Count e, Count Word8)
readOffMem :: (MemWrite w, MonadPrim s m, Prim e) => w s -> Off e -> m e
writeOffMem :: (MemWrite w, MonadPrim s m, Prim e) => w s -> Off e -> e -> m ()
modifyFetchOldMem :: (MemWrite w, MonadPrim s m, Prim b) => w s -> Off b -> (b -> b) -> m b
modifyFetchOldMemM :: (MemWrite w, MonadPrim s m, Prim b) => w s -> Off b -> (b -> m b) -> m b
modifyFetchNewMem :: (MemWrite w, MonadPrim s m, Prim b) => w s -> Off b -> (b -> b) -> m b
modifyFetchNewMemM :: (MemWrite w, MonadPrim s m, Prim b) => w s -> Off b -> (b -> m b) -> m b

-- | Write the same value into each cell starting at an offset.
setMem :: (MemWrite w, MonadPrim s m, Prim e) => w s -> Off e -> Count e -> e -> m ()
copyMem :: (MonadPrim s m, MemRead r, MemWrite w, Prim e) => r -> Off e -> w s -> Off e -> Count e -> m ()
moveMem :: (MonadPrim s m, MemWrite w1, MemWrite w2, Prim e) => w1 s -> Off e -> w2 s -> Off e -> Count e -> m ()

-- | A wrapper that adds a phantom state token. It can be use with types
--   that either doesn't have such state token or are designed to work in
--   <a>IO</a> and therefore restricted to <a>RW</a>. Using this wrapper is
--   very much unsafe, so make sure you know what you are doing.
newtype MemState a s
MemState :: a -> MemState a s
[unMemState] :: MemState a s -> a

-- | Allocate enough memory for number of elements. Memory is not
--   initialized and may contain garbage. Use <a>allocZeroMem</a> if clean
--   memory is needed.
--   
--   <ul>
--   <li><i>Unsafe Count</i> Negative element count will result in
--   unpredictable behavior</li>
--   </ul>
allocMem :: (MemAlloc a, MonadPrim s m, Prim e) => Count e -> m (a s)

-- | Same as <a>allocMem</a>, but also use <tt>memset</tt> to initialize
--   all the new memory to zeros.
--   
--   <ul>
--   <li><i>Unsafe Count</i> Negative element count will result in
--   unpredictable behavior</li>
--   </ul>
allocZeroMem :: (MemAlloc a, MonadPrim s m, Prim e) => Count e -> m (a s)
thawMem :: (MemAlloc a, MonadPrim s m) => FrozenMem a -> m (a s)
thawCloneMem :: (MemRead r, MemAlloc a, MonadPrim s m) => r -> m (a s)
thawCopyMem :: (MemRead r, MemAlloc a, MonadPrim s m, Prim e) => r -> Off e -> Count e -> m (a s)
freezeMem :: (MemAlloc a, MonadPrim s m) => a s -> m (FrozenMem a)
freezeCloneMem :: (MemAlloc a, MonadPrim s m) => a s -> m (FrozenMem a)
freezeCopyMem :: (MemAlloc a, MonadPrim s m, Prim e) => a s -> Off e -> Count e -> m (FrozenMem a)
createMemST :: (MemAlloc a, Prim e) => Count e -> (forall s. a s -> ST s b) -> (b, FrozenMem a)
createMemST_ :: (MemAlloc a, Prim e) => Count e -> (forall s. a s -> ST s b) -> FrozenMem a
createZeroMemST :: (MemAlloc a, Prim e) => Count e -> (forall s. a s -> ST s b) -> (b, FrozenMem a)
createZeroMemST_ :: (MemAlloc a, Prim e) => Count e -> (forall s. a s -> ST s b) -> FrozenMem a

-- | Chunk of empty memory.
emptyMem :: MemAlloc a => FrozenMem a

-- | A region of memory that hold a single element.
singletonMem :: forall e a. (MemAlloc a, Prim e) => e -> FrozenMem a

-- | Make <tt>n</tt> copies of supplied region of memory into a contiguous
--   chunk of memory.
cycleMemN :: (MemAlloc a, MemRead r) => Int -> r -> FrozenMem a
byteCountMem :: MemRead r => r -> Count Word8
indexByteOffMem :: (MemRead r, Prim e) => r -> Off Word8 -> e
compareByteOffMem :: (MemRead r, MemRead r', Prim e) => r' -> Off Word8 -> r -> Off Word8 -> Count e -> Ordering
allocByteCountMem :: (MemAlloc a, MonadPrim s m) => Count Word8 -> m (a s)
getByteCountMem :: (MemAlloc a, MonadPrim s m) => a s -> m (Count Word8)
readByteOffMem :: (MemWrite w, MonadPrim s m, Prim e) => w s -> Off Word8 -> m e
writeByteOffMem :: (MemWrite w, MonadPrim s m, Prim e) => w s -> Off Word8 -> e -> m ()
copyByteOffMem :: (MemWrite w, MonadPrim s m, MemRead r, Prim e) => r -> Off Word8 -> w s -> Off Word8 -> Count e -> m ()
moveByteOffMem :: (MemWrite w, MonadPrim s m, MemWrite w', Prim e) => w' s -> Off Word8 -> w s -> Off Word8 -> Count e -> m ()

-- | <i>O(n)</i> - Convert a read-only memory region into a newly allocated
--   other type of memory region
--   
--   <pre>
--   &gt;&gt;&gt; import Data.ByteString
--   
--   &gt;&gt;&gt; bs = pack [0x10 .. 0x20]
--   
--   &gt;&gt;&gt; bs
--   "\DLE\DC1\DC2\DC3\DC4\NAK\SYN\ETB\CAN\EM\SUB\ESC\FS\GS\RS\US "
--   
--   &gt;&gt;&gt; convertMem bs :: Bytes 'Inc
--   [0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1a,0x1b,0x1c,0x1d,0x1e,0x1f,0x20]
--   </pre>
convertMem :: (MemRead r, MemAlloc a) => r -> FrozenMem a

-- | It is only guaranteed to convert the whole memory to a list whenever
--   the size of allocated memory is exactly divisible by the size of the
--   element, otherwise there will be some slack left unaccounted for.
toListMem :: (MemRead r, Prim e) => r -> [e]

-- | Same as <a>toListMem</a>, except if there is some slack at the end of
--   the memory that didn't fit in a list it will be returned as a list of
--   bytes
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; import Data.Word
--   
--   &gt;&gt;&gt; :set -XDataKinds
--   
--   &gt;&gt;&gt; a = fromListMem [0 .. 10 :: Word8] :: Bytes 'Pin
--   
--   &gt;&gt;&gt; a
--   [0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a]
--   
--   &gt;&gt;&gt; toListSlackMem a :: ([Word8], [Word8])
--   ([0,1,2,3,4,5,6,7,8,9,10],[])
--   
--   &gt;&gt;&gt; toListSlackMem a :: ([Word16], [Word8])
--   ([256,770,1284,1798,2312],[10])
--   
--   &gt;&gt;&gt; toListSlackMem a :: ([Word32], [Word8])
--   ([50462976,117835012],[8,9,10])
--   
--   &gt;&gt;&gt; toListSlackMem a :: ([Word64], [Word8])
--   ([506097522914230528],[8,9,10])
--   </pre>
toListSlackMem :: forall e r. (MemRead r, Prim e) => r -> ([e], [Word8])

-- | Convert a memory region to a list of bytes. Equivalent to
--   <a>unpack</a> for <a>ByteString</a>
--   
--   <pre>
--   &gt;&gt;&gt; toByteListMem (fromByteListMem [0..10] :: Bytes 'Pin)
--   [0,1,2,3,4,5,6,7,8,9,10]
--   </pre>
toByteListMem :: MemAlloc a => FrozenMem a -> [Word8]

-- | Load a list of bytes into a newly allocated memory region. Equivalent
--   to <a>pack</a> for <a>ByteString</a>
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; fromByteListMem [0..10] :: Bytes 'Pin
--   [0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a]
--   </pre>
fromByteListMem :: MemAlloc a => [Word8] -> FrozenMem a
fromListMem :: (MemAlloc a, Prim e) => [e] -> FrozenMem a
fromListMemN :: (MemAlloc a, Prim e) => Count e -> [e] -> (Ordering, FrozenMem a)

-- | Returns <a>EQ</a> if the full list did fit into the supplied memory
--   chunk exactly. Otherwise it will return either <a>LT</a> if the list
--   was smaller than allocated memory or <a>GT</a> if the list was bigger
--   than the available memory and did not fit into <a>MBytes</a>.
loadListMem :: (MonadPrim s m, MemAlloc r, Prim e) => [e] -> r s -> m Ordering
loadListMem_ :: (MonadPrim s m, MemAlloc r, Prim e) => [e] -> r s -> m ()
loadListMemN :: (MemWrite r, MonadPrim s m, Prim e) => Count e -> Count Word8 -> [e] -> r s -> m Ordering
loadListMemN_ :: (MemWrite r, MonadPrim s m, Prim e) => Count e -> [e] -> r s -> m ()

-- | Right fold that is useful for converting to list while tapping into
--   list fusion.
foldrCountMem :: (MemRead r, Prim e) => Count e -> (e -> b -> b) -> b -> r -> b


module Data.Prim.Memory.ByteArray

-- | An immutable array of bytes of type <tt>e</tt>
newtype ByteArray (p :: Pinned) e
ByteArray :: Bytes p -> ByteArray e

-- | A mutable array of bytes of type <tt>e</tt>
newtype MByteArray (p :: Pinned) e s
MByteArray :: MBytes p s -> MByteArray e s

-- | In Haskell there is a distinction between pinned or unpinned memory.
--   
--   Pinned memory is such, when allocated, it is guaranteed not to move
--   throughout the lifetime of a program. In other words the address
--   pointer that refers to allocated bytes will not change until it gets
--   garbage collected because it is no longer referenced by anything.
--   Unpinned memory on the other hand can be moved around during GC, which
--   helps to reduce memory fragmentation.
--   
--   Pinned/unpinnned choice during allocation is a bit of a lie, because
--   when attempt is made to allocate memory as unpinned, but requested
--   size is a bit more than a certain threashold (somewhere around 3KiB)
--   it might still be allocated as pinned. Because of that fact through
--   out the "primal" universe there is a distinction between memory that
--   is either <tt><a>Pin</a>ned</tt> or <tt><a>Inc</a>onclusive</tt>.
--   
--   It is possible to use one of <a>toPinnedBytes</a> or
--   <a>toPinnedMBytes</a> to get a conclusive type.
data Pinned
Pin :: Pinned
Inc :: Pinned
fromBytesByteArray :: Bytes p -> ByteArray p e
toBytesByteArray :: ByteArray p e -> Bytes p
castByteArray :: ByteArray p e' -> ByteArray p e
fromMBytesMByteArray :: MBytes p s -> MByteArray p e s
toMBytesMByteArray :: MByteArray p e s -> MBytes p s
castMByteArray :: MByteArray p e' s -> MByteArray p e s
allocMByteArray :: forall e p m s. (Typeable p, Prim e, MonadPrim s m) => Size -> m (MByteArray p e s)
allocPinnedMByteArray :: forall e m s. (MonadPrim s m, Prim e) => Size -> m (MByteArray  'Pin e s)
allocAlignedMByteArray :: (MonadPrim s m, Prim e) => Count e -> m (MByteArray  'Pin e s)
allocUnpinnedMByteArray :: forall e m s. (MonadPrim s m, Prim e) => Size -> m (MByteArray  'Inc e s)

-- | Shrink mutable bytes to new specified count of elements. The new count
--   must be less than or equal to the current count as reported by
--   <tt>getCountMByteArray</tt>.
shrinkMByteArray :: forall e p m s. (MonadPrim s m, Prim e) => MByteArray p e s -> Size -> m ()

-- | Attempt to resize mutable bytes in place.
--   
--   <ul>
--   <li>New bytes might be allocated, with the copy of an old one.</li>
--   <li>Old references should not be kept around to allow GC to claim
--   it</li>
--   <li>Old references should not be used to avoid undefined behavior</li>
--   </ul>
resizeMByteArray :: forall e p m s. (MonadPrim s m, Prim e) => MByteArray p e s -> Size -> m (MByteArray  'Inc e s)
reallocMByteArray :: forall e p m s. (MonadPrim s m, Typeable p, Prim e) => MByteArray p e s -> Size -> m (MByteArray p e s)
isPinnedByteArray :: ByteArray p e -> Bool
isPinnedMByteArray :: MByteArray p e s -> Bool
thawByteArray :: MonadPrim s m => ByteArray p e -> m (MByteArray p e s)
freezeMByteArray :: MonadPrim s m => MByteArray p e s -> m (ByteArray p e)
sizeByteArray :: forall e p. Prim e => ByteArray p e -> Size
getSizeMByteArray :: forall e p m s. (MonadPrim s m, Prim e) => MByteArray p e s -> m Size
readMByteArray :: (MonadPrim s m, Prim e) => MByteArray p e s -> Int -> m e
writeMByteArray :: (MonadPrim s m, Prim e) => MByteArray p e s -> Int -> e -> m ()
setMByteArray :: (MonadPrim s m, Prim e) => MByteArray p e s -> Int -> Size -> e -> m ()
copyByteArrayToMByteArray :: (MonadPrim s m, Prim e) => ByteArray p e -> Int -> MByteArray p e s -> Int -> Size -> m ()
moveMByteArrayToMByteArray :: forall e p m s. (MonadPrim s m, Prim e) => MByteArray p e s -> Int -> MByteArray p e s -> Int -> Size -> m ()
instance Data.Prim.Memory.Internal.MemWrite (Data.Prim.Memory.ByteArray.MByteArray p e)
instance Control.DeepSeq.NFData (Data.Prim.Memory.ByteArray.MByteArray p e s)
instance Data.Prim.Memory.Internal.MemRead (Data.Prim.Memory.ByteArray.ByteArray p e)
instance Data.Typeable.Internal.Typeable p => GHC.Base.Monoid (Data.Prim.Memory.ByteArray.ByteArray p e)
instance Data.Typeable.Internal.Typeable p => GHC.Base.Semigroup (Data.Prim.Memory.ByteArray.ByteArray p e)
instance Control.DeepSeq.NFData (Data.Prim.Memory.ByteArray.ByteArray p e)
instance Data.Prim.Memory.ForeignPtr.PtrAccess s (Data.Prim.Memory.ByteArray.MByteArray 'Data.Prim.Memory.Bytes.Internal.Pin e s)
instance Data.Typeable.Internal.Typeable p => Data.Prim.Memory.Internal.MemAlloc (Data.Prim.Memory.ByteArray.MByteArray p e)
instance Data.Prim.Memory.ForeignPtr.PtrAccess s (Data.Prim.Memory.ByteArray.ByteArray 'Data.Prim.Memory.Bytes.Internal.Pin e)
instance (Data.Typeable.Internal.Typeable p, Data.Prim.Class.Prim e) => GHC.Exts.IsList (Data.Prim.Memory.ByteArray.ByteArray p e)
instance Data.Typeable.Internal.Typeable p => Data.String.IsString (Data.Prim.Memory.ByteArray.ByteArray p GHC.Types.Char)
instance (GHC.Show.Show e, Data.Prim.Class.Prim e) => GHC.Show.Show (Data.Prim.Memory.ByteArray.ByteArray p e)


module Data.Prim.Memory.Addr
data Addr e
Addr :: Addr# -> {-# UNPACK #-} !Bytes  'Pin -> Addr e
[addrAddr#] :: Addr e -> Addr#
[addrBytes] :: Addr e -> {-# UNPACK #-} !Bytes  'Pin
castAddr :: Addr e -> Addr b
fromBytesAddr :: Bytes  'Pin -> Addr e
curOffAddr :: Prim e => Addr e -> Off e
byteCountAddr :: Addr e -> Count Word8
countAddr :: forall e. Prim e => Addr e -> Count e
plusOffAddr :: Prim e => Addr e -> Off e -> Addr e
indexAddr :: Prim e => Addr e -> e
indexOffAddr :: Prim e => Addr e -> Off e -> e
indexByteOffAddr :: Prim e => Addr e -> Off Word8 -> e
readAddr :: (MonadPrim s m, Prim e) => Addr e -> m e
readOffAddr :: (MonadPrim s m, Prim e) => Addr e -> Off e -> m e
readByteOffAddr :: (MonadPrim s m, Prim e) => Addr e -> Off Word8 -> m e
thawAddr :: MonadPrim s m => Addr e -> m (MAddr e s)
freezeMAddr :: MonadPrim s m => MAddr e s -> m (Addr e)
withPtrAddr :: MonadPrim s m => Addr e -> (Ptr e -> m b) -> m b
withAddrAddr# :: MonadPrim s m => Addr e -> (Addr# -> m b) -> m b
withNoHaltPtrAddr :: MonadUnliftPrim s m => Addr e -> (Ptr e -> m b) -> m b
data MAddr e s
MAddr :: Addr# -> {-# UNPACK #-} !MBytes  'Pin s -> MAddr e s
[mAddrAddr#] :: MAddr e s -> Addr#
[mAddrMBytes] :: MAddr e s -> {-# UNPACK #-} !MBytes  'Pin s
castMAddr :: MAddr e s -> MAddr b s
allocMAddr :: (MonadPrim s m, Prim e) => Count e -> m (MAddr e s)
callocMAddr :: (MonadPrim s m, Prim e) => Count e -> m (MAddr e s)
reallocMAddr :: (MonadPrim s m, Prim e) => MAddr e s -> Count e -> m (MAddr e s)

-- | Shrink mutable address to new specified size in number of elements.
--   The new count must be less than or equal to the current as reported by
--   <a>getCountMAddr</a>.
shrinkMAddr :: (MonadPrim s m, Prim e) => MAddr e s -> Count e -> m ()

-- | Shrink mutable address to new specified size in bytes. The new count
--   must be less than or equal to the current as reported by
--   <a>getByteCountMAddr</a>.
shrinkByteCountMAddr :: MonadPrim s m => MAddr e s -> Count Word8 -> m ()
setMAddr :: (MonadPrim s m, Prim e) => MAddr e s -> Off e -> Count e -> e -> m ()
curOffMAddr :: forall e s. Prim e => MAddr e s -> Off e
getByteCountMAddr :: MonadPrim s m => MAddr e s -> m (Count Word8)
getCountMAddr :: (MonadPrim s m, Prim e) => MAddr e s -> m (Count e)
plusOffMAddr :: Prim e => MAddr e s -> Off e -> MAddr e s
readMAddr :: (MonadPrim s m, Prim e) => MAddr e s -> m e
readOffMAddr :: (MonadPrim s m, Prim e) => MAddr e s -> Off e -> m e
readByteOffMAddr :: (MonadPrim s m, Prim e) => MAddr e s -> Off Word8 -> m e
writeMAddr :: (MonadPrim s m, Prim e) => MAddr e s -> e -> m ()
writeOffMAddr :: (MonadPrim s m, Prim e) => MAddr e s -> Off e -> e -> m ()
writeByteOffMAddr :: (MonadPrim s m, Prim e) => MAddr e s -> Off Word8 -> e -> m ()
copyAddrToMAddr :: (MonadPrim s m, Prim e) => Addr e -> Off e -> MAddr e s -> Off e -> Count e -> m ()
moveMAddrToMAddr :: (MonadPrim s m, Prim e) => MAddr e s -> Off e -> MAddr e s -> Off e -> Count e -> m ()
withPtrMAddr :: MonadPrim s m => MAddr e s -> (Ptr e -> m b) -> m b
withAddrMAddr# :: MonadPrim s m => MAddr e s -> (Addr# -> m b) -> m b
withNoHaltPtrMAddr :: MonadUnliftPrim s m => MAddr e s -> (Ptr e -> m b) -> m b
toForeignPtrAddr :: Addr e -> ForeignPtr e
toForeignPtrMAddr :: MAddr e s -> ForeignPtr e

-- | Discarding the original <a>ForeignPtr</a> will trigger finalizers that
--   were attached to it, because <a>Addr</a> does not retain any
--   finalizers. This is a unsafe cast therefore modification of
--   <a>ForeignPtr</a> will be reflected in resulting immutable
--   <a>Addr</a>. Pointer created with <tt>malloc</tt> cannot be converted
--   to <a>Addr</a> and will result in <a>Nothing</a>
fromForeignPtrAddr :: ForeignPtr e -> Maybe (Addr e)

-- | Discarding the original ForeignPtr will trigger finalizers that were
--   attached to it, because <a>MAddr</a> does not retain any finalizers.
--   Pointer created with <tt>malloc</tt> cannot be converted to
--   <a>MAddr</a> and will result in <a>Nothing</a>
fromForeignPtrMAddr :: ForeignPtr e -> Maybe (MAddr e s)

-- | <i>O(1)</i> - Cast an immutable <a>Addr</a> to an immutable
--   <a>ByteString</a>
toByteStringAddr :: Addr Word8 -> ByteString

-- | <i>O(1)</i> - Cast an immutable <a>Addr</a> to an immutable
--   <a>ShortByteString</a>
toShortByteStringAddr :: Addr Word8 -> (ShortByteString, Off Word8)

-- | <i>O(1)</i> - Cast an immutable <a>ShortByteString</a> to an immutable
--   <a>Addr</a>. In a most common case when <a>ShortByteString</a> is not
--   backed by pinned memory, this function will return <a>Nothing</a>.
fromShortByteStringAddr :: ShortByteString -> Addr Word8

-- | <i>O(1)</i> - Cast an immutable <a>ByteString</a> to <a>Addr</a>. Also
--   returns the original length of ByteString, which will be less or equal
--   to <tt>countOfAddr</tt> in the produced <a>Addr</a>.
fromByteStringAddr :: ByteString -> (Addr Word8, Count Word8)

-- | <i>O(1)</i> - Cast an immutable <a>ByteString</a> to a mutable
--   <a>MAddr</a>. Also returns the original length of ByteString, which
--   will be less or equal to <tt>getCountOfMAddr</tt> in the produced
--   <a>MAddr</a>.
--   
--   <b>Unsafe</b> - Further modification of <a>MAddr</a> will affect the
--   source <a>ByteString</a>
fromByteStringMAddr :: ByteString -> (MAddr Word8 s, Count Word8)

-- | Perform atomic modification of an element in the <a>MAddr</a> at the
--   supplied index. Returns the artifact of computation <tt><b>b</b></tt>.
--   Offset is in number of elements, rather than bytes. Implies a full
--   memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
casOffMAddr :: (MonadPrim s m, Atomic e) => MAddr e s -> Off e -> e -> e -> m e

-- | Perform atomic modification of an element in the <a>MAddr</a> at the
--   supplied index. Returns <a>True</a> if swap was successfull and false
--   otherwise. Offset is in number of elements, rather than bytes. Implies
--   a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
casBoolOffMAddr :: (MonadPrim s m, Atomic e) => MAddr e s -> Off e -> e -> e -> m Bool

-- | Just like <a>casBoolOffMAddr</a>, but also returns the actual value,
--   which will match the supplied expected value if the returned flag is
--   <a>True</a>
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
casBoolFetchOffMAddr :: (MonadPrim s m, Atomic e) => MAddr e s -> Off e -> e -> e -> m (Bool, e)

-- | Perform atomic read of an element in the <a>MAddr</a> at the supplied
--   offset. Offset is in number of elements, rather than bytes. Implies a
--   full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicReadOffMAddr :: (MonadPrim s m, Atomic e) => MAddr e s -> Off e -> m e

-- | Perform atomic write of an element in the <a>MAddr</a> at the supplied
--   offset. Offset is in number of elements, rather than bytes. Implies a
--   full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicWriteOffMAddr :: (MonadPrim s m, Atomic e) => MAddr e s -> Off e -> e -> m ()

-- | Perform atomic modification of an element in the <a>MAddr</a> at the
--   supplied index. Returns the artifact of computation <tt><b>b</b></tt>.
--   Offset is in number of elements, rather than bytes. Implies a full
--   memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicModifyOffMAddr :: (MonadPrim s m, Atomic e) => MAddr e s -> Off e -> (e -> (e, b)) -> m b

-- | Perform atomic modification of an element in the <a>MAddr</a> at the
--   supplied index. Offset is in number of elements, rather than bytes.
--   Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicModifyOffMAddr_ :: (MonadPrim s m, Atomic e) => MAddr e s -> Off e -> (e -> e) -> m ()

-- | Perform atomic modification of an element in the <a>MAddr</a> at the
--   supplied index. Returns the previous value. Offset is in number of
--   elements, rather than bytes. Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicModifyFetchOldOffMAddr :: (MonadPrim s m, Atomic e) => MAddr e s -> Off e -> (e -> e) -> m e

-- | Perform atomic modification of an element in the <a>MAddr</a> at the
--   supplied index. Offset is in number of elements, rather than bytes.
--   Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicModifyFetchNewOffMAddr :: (MonadPrim s m, Atomic e) => MAddr e s -> Off e -> (e -> e) -> m e

-- | Add a numeric value to an element of a <a>MAddr</a>, corresponds to
--   <tt>(<a>+</a>)</tt> done atomically. Returns the previous value.
--   Offset is in number of elements, rather than bytes. Implies a full
--   memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicAddFetchOldOffMAddr :: (MonadPrim s m, AtomicCount e) => MAddr e s -> Off e -> e -> m e

-- | Add a numeric value to an element of a <a>MAddr</a>, corresponds to
--   <tt>(<a>+</a>)</tt> done atomically. Returns the new value. Offset is
--   in number of elements, rather than bytes. Implies a full memory
--   barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicAddFetchNewOffMAddr :: (MonadPrim s m, AtomicCount e) => MAddr e s -> Off e -> e -> m e

-- | Subtract a numeric value from an element of a <a>MAddr</a>,
--   corresponds to <tt>(<a>-</a>)</tt> done atomically. Returns the
--   previous value. Offset is in number of elements, rather than bytes.
--   Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicSubFetchOldOffMAddr :: (MonadPrim s m, AtomicCount e) => MAddr e s -> Off e -> e -> m e

-- | Subtract a numeric value from an element of a <a>MAddr</a>,
--   corresponds to <tt>(<a>-</a>)</tt> done atomically. Returns the new
--   value. Offset is in number of elements, rather than bytes. Implies a
--   full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicSubFetchNewOffMAddr :: (MonadPrim s m, AtomicCount e) => MAddr e s -> Off e -> e -> m e

-- | Binary conjunction (AND) of an element of a <a>MAddr</a> with the
--   supplied value, corresponds to <tt>(<a>.&amp;.</a>)</tt> done
--   atomically. Returns the previous value. Offset is in number of
--   elements, rather than bytes. Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicAndFetchOldOffMAddr :: (MonadPrim s m, AtomicBits e) => MAddr e s -> Off e -> e -> m e

-- | Binary conjunction (AND) of an element of a <a>MAddr</a> with the
--   supplied value, corresponds to <tt>(<a>.&amp;.</a>)</tt> done
--   atomically. Returns the new value. Offset is in number of elements,
--   rather than bytes. Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicAndFetchNewOffMAddr :: (MonadPrim s m, AtomicBits e) => MAddr e s -> Off e -> e -> m e

-- | Negation of binary conjunction (NAND) of an element of a <a>MAddr</a>
--   with the supplied value, corresponds to <tt>\x y -&gt;
--   <a>complement</a> (x <a>.&amp;.</a> y)</tt> done atomically. Returns
--   the previous value. Offset is in number of elements, rather than
--   bytes. Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicNandFetchOldOffMAddr :: (MonadPrim s m, AtomicBits e) => MAddr e s -> Off e -> e -> m e

-- | Negation of binary conjunction (NAND) of an element of a <a>MAddr</a>
--   with the supplied value, corresponds to <tt>\x y -&gt;
--   <a>complement</a> (x <a>.&amp;.</a> y)</tt> done atomically. Returns
--   the new value. Offset is in number of elements, rather than bytes.
--   Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicNandFetchNewOffMAddr :: (MonadPrim s m, AtomicBits e) => MAddr e s -> Off e -> e -> m e

-- | Binary disjunction (OR) of an element of a <a>MAddr</a> with the
--   supplied value, corresponds to <tt>(<a>.|.</a>)</tt> done atomically.
--   Returns the previous value. Offset is in number of elements, rather
--   than bytes. Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicOrFetchOldOffMAddr :: (MonadPrim s m, AtomicBits e) => MAddr e s -> Off e -> e -> m e

-- | Binary disjunction (OR) of an element of a <a>MAddr</a> with the
--   supplied value, corresponds to <tt>(<a>.|.</a>)</tt> done atomically.
--   Returns the new value. Offset is in number of elements, rather than
--   bytes. Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicOrFetchNewOffMAddr :: (MonadPrim s m, AtomicBits e) => MAddr e s -> Off e -> e -> m e

-- | Binary exclusive disjunction (XOR) of an element of a <a>MAddr</a>
--   with the supplied value, corresponds to <tt><a>xor</a></tt> done
--   atomically. Returns the previous value. Offset is in number of
--   elements, rather than bytes. Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicXorFetchOldOffMAddr :: (MonadPrim s m, AtomicBits e) => MAddr e s -> Off e -> e -> m e

-- | Binary exclusive disjunction (XOR) of an element of a <a>MAddr</a>
--   with the supplied value, corresponds to <tt><a>xor</a></tt> done
--   atomically. Returns the new value. Offset is in number of elements,
--   rather than bytes. Implies a full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicXorFetchNewOffMAddr :: (MonadPrim s m, AtomicBits e) => MAddr e s -> Off e -> e -> m e

-- | Binary negation (NOT) of an element of a <a>MAddr</a>, corresponds to
--   <tt>(<a>complement</a>)</tt> done atomically. Returns the previous
--   value. Offset is in number of elements, rather than bytes. Implies a
--   full memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicNotFetchOldOffMAddr :: (MonadPrim s m, AtomicBits e) => MAddr e s -> Off e -> m e

-- | Binary negation (NOT) of an element of a <a>MAddr</a>, corresponds to
--   <tt>(<a>complement</a>)</tt> done atomically. Returns the new value.
--   Offset is in number of elements, rather than bytes. Implies a full
--   memory barrier.
--   
--   <i>Note</i> - Bounds are not checked, therefore this function is
--   unsafe.
atomicNotFetchNewOffMAddr :: (MonadPrim s m, AtomicBits e) => MAddr e s -> Off e -> m e
prefetchAddr0 :: MonadPrim s m => Addr e -> m ()
prefetchMAddr0 :: MonadPrim s m => MAddr e s -> m ()
prefetchAddr1 :: MonadPrim s m => Addr e -> m ()
prefetchMAddr1 :: MonadPrim s m => MAddr e s -> m ()
prefetchAddr2 :: MonadPrim s m => Addr e -> m ()
prefetchMAddr2 :: MonadPrim s m => MAddr e s -> m ()
prefetchAddr3 :: MonadPrim s m => Addr e -> m ()
prefetchMAddr3 :: MonadPrim s m => MAddr e s -> m ()
prefetchOffAddr0 :: (MonadPrim s m, Prim e) => Addr e -> Off e -> m ()
prefetchOffMAddr0 :: (MonadPrim s m, Prim e) => MAddr e s -> Off e -> m ()
prefetchOffAddr1 :: (MonadPrim s m, Prim e) => Addr e -> Off e -> m ()
prefetchOffMAddr1 :: (MonadPrim s m, Prim e) => MAddr e s -> Off e -> m ()
prefetchOffAddr2 :: (MonadPrim s m, Prim e) => Addr e -> Off e -> m ()
prefetchOffMAddr2 :: (MonadPrim s m, Prim e) => MAddr e s -> Off e -> m ()
prefetchOffAddr3 :: (MonadPrim s m, Prim e) => Addr e -> Off e -> m ()
prefetchOffMAddr3 :: (MonadPrim s m, Prim e) => MAddr e s -> Off e -> m ()
instance Control.DeepSeq.NFData (Data.Prim.Memory.Addr.MAddr e s)
instance Data.Prim.Memory.ForeignPtr.PtrAccess s (Data.Prim.Memory.Addr.MAddr e s)
instance Data.Prim.Memory.Internal.MemAlloc (Data.Prim.Memory.Addr.MAddr e)
instance Data.Prim.Memory.Internal.MemWrite (Data.Prim.Memory.Addr.MAddr e)
instance GHC.Classes.Eq (Data.Prim.Memory.Addr.Addr e)
instance (GHC.Show.Show e, Data.Prim.Class.Prim e) => GHC.Show.Show (Data.Prim.Memory.Addr.Addr e)
instance Data.String.IsString (Data.Prim.Memory.Addr.Addr GHC.Types.Char)
instance Data.Prim.Class.Prim e => GHC.Exts.IsList (Data.Prim.Memory.Addr.Addr e)
instance GHC.Base.Semigroup (Data.Prim.Memory.Addr.Addr e)
instance GHC.Base.Monoid (Data.Prim.Memory.Addr.Addr e)
instance Control.DeepSeq.NFData (Data.Prim.Memory.Addr.Addr e)
instance Data.Prim.Memory.ForeignPtr.PtrAccess s (Data.Prim.Memory.Addr.Addr e)
instance Data.Prim.Memory.Internal.MemRead (Data.Prim.Memory.Addr.Addr e)