Foreign.Prim.Ptr

Documentation

module GHC.Ptr

plusOffPtr :: Prim e => Ptr e -> Off e -> Ptr e

plusByteOffPtr :: Ptr e -> Off Word8 -> Ptr e

minusOffPtr :: Prim e => Ptr e -> Ptr e -> Off 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.

Since: 0.1.0

minusOffRemPtr :: Prim e => Ptr e -> Ptr e -> (Off e, Off Word8)

Same as minusOffPtr, but will also return the remainder in bytes that is left over.

Since: 0.1.0

minusByteOffPtr :: Ptr e -> Ptr e -> Off Word8

Find the offset in bytes that is between the two pointers by subtracting one address from another.

Since: 0.1.0

readPtr :: (MonadPrim s m, Prim e) => Ptr e -> m e

readOffPtr :: (MonadPrim s m, Prim e) => Ptr e -> Off e -> m e

readByteOffPtr :: (MonadPrim s m, Prim e) => Ptr e -> Off Word8 -> m e

writePtr :: (MonadPrim s m, Prim e) => Ptr e -> e -> m ()

writeOffPtr :: (MonadPrim s m, Prim e) => Ptr e -> Off e -> e -> m ()

writeByteOffPtr :: (MonadPrim s m, Prim e) => Ptr e -> Off Word8 -> e -> m ()

setOffPtr

Arguments

:: (MonadPrim s m, Prim e)

=> Ptr e

Chunk of memory to fill

-> Off e

Offset in number of elements

-> Count e

Number of cells to fill

-> e

A value to fill the cells with

-> m ()

copyPtrToPtr :: (MonadPrim s m, Prim e) => Ptr e -> Off e -> Ptr e -> Off e -> Count e -> m ()

copyByteOffPtrToPtr :: (MonadPrim s m, Prim e) => Ptr e -> Off Word8 -> Ptr e -> Off Word8 -> Count e -> m ()

movePtrToPtr :: (MonadPrim s m, Prim e) => Ptr e -> Off e -> Ptr e -> Off e -> Count e -> m ()

moveByteOffPtrToPtr :: (MonadPrim s m, Prim e) => Ptr e -> Off Word8 -> Ptr e -> Off Word8 -> Count e -> m ()

comparePtrToPtr :: Prim e => Ptr e -> Off e -> Ptr e -> Off e -> Count e -> Ordering

Compare memory between two pointers. Offsets and count is in number of elements, instead of byte count. Use compareByteOffPtrToPtr when offset in bytes is required.

compareByteOffPtrToPtr :: Prim e => Ptr e -> Off Word8 -> Ptr e -> Off Word8 -> Count e -> Ordering

Same as comparePtrToPtr, except offset is in bytes instead of number of elements.

freeHaskellFunPtr :: MonadPrim s m => FunPtr a -> m ()

Same as freeHaskellFunPtr

Since: 0.1.0

data Ptr a

A value of type Ptr a represents a pointer to an object, or an array of objects, which may be marshalled to or from Haskell values of type a.

The type a will often be an instance of class Storable 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 struct.

Instances

NFData1 Ptr

Since: deepseq-1.4.3.0

Defined in Control.DeepSeq

Methods

liftRnf :: (a -> ()) -> Ptr a -> ()

Generic1 (URec (Ptr ()) :: k -> Type)

Defined in GHC.Generics

Associated Types

type Rep1 (URec (Ptr ())) :: k -> Type

Methods

from1 :: URec (Ptr ()) a -> Rep1 (URec (Ptr ())) a

to1 :: Rep1 (URec (Ptr ())) a -> URec (Ptr ()) a

Eq (Ptr a)

Since: base-2.1

Defined in GHC.Ptr

Methods

(==) :: Ptr a -> Ptr a -> Bool

(/=) :: Ptr a -> Ptr a -> Bool

Ord (Ptr a)

Since: base-2.1

Defined in GHC.Ptr

Methods

compare :: Ptr a -> Ptr a -> Ordering

(<) :: Ptr a -> Ptr a -> Bool

(<=) :: Ptr a -> Ptr a -> Bool

(>) :: Ptr a -> Ptr a -> Bool

(>=) :: Ptr a -> Ptr a -> Bool

max :: Ptr a -> Ptr a -> Ptr a

min :: Ptr a -> Ptr a -> Ptr a

Show (Ptr a)

Since: base-2.1

Defined in GHC.Ptr

Methods

showsPrec :: Int -> Ptr a -> ShowS

show :: Ptr a -> String

showList :: [Ptr a] -> ShowS

NFData (Ptr a)

Since: deepseq-1.4.2.0

Defined in Control.DeepSeq

Methods

rnf :: Ptr a -> ()

Prim (Ptr a)

Defined in Data.Prim.Class

Associated Types

type PrimBase (Ptr a) :: Type

type SizeOf (Ptr a) :: Nat

type Alignment (Ptr a) :: Nat

Methods

toPrimBase :: Ptr a -> PrimBase (Ptr a)

fromPrimBase :: PrimBase (Ptr a) -> Ptr a

sizeOf# :: Proxy# (Ptr a) -> Int#

alignment# :: Proxy# (Ptr a) -> Int#

indexByteOffByteArray# :: ByteArray# -> Int# -> Ptr a

indexByteArray# :: ByteArray# -> Int# -> Ptr a

indexOffAddr# :: Addr# -> Int# -> Ptr a

readByteOffMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Ptr a#)

readMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Ptr a#)

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Ptr a#)

writeByteOffMutableByteArray# :: MutableByteArray# s -> Int# -> Ptr a -> State# s -> State# s

writeMutableByteArray# :: MutableByteArray# s -> Int# -> Ptr a -> State# s -> State# s

writeOffAddr# :: Addr# -> Int# -> Ptr a -> State# s -> State# s

setMutableByteArray# :: MutableByteArray# s -> Int# -> Int# -> Ptr a -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Ptr a -> State# s -> State# s

Atomic (Ptr a)

Defined in Data.Prim.Atomic

Methods

atomicReadMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, Ptr a#)

atomicWriteMutableByteArray# :: MutableByteArray# s -> Int# -> Ptr a -> State# s -> State# s

atomicReadOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, Ptr a#)

atomicWriteOffAddr# :: Addr# -> Int# -> Ptr a -> State# s -> State# s

casMutableByteArray# :: MutableByteArray# s -> Int# -> Ptr a -> Ptr a -> State# s -> (#State# s, Ptr a#)

casOffAddr# :: Addr# -> Int# -> Ptr a -> Ptr a -> State# s -> (#State# s, Ptr a#)

casBoolMutableByteArray# :: MutableByteArray# s -> Int# -> Ptr a -> Ptr a -> State# s -> (#State# s, Bool#)

casBoolOffAddr# :: Addr# -> Int# -> Ptr a -> Ptr a -> State# s -> (#State# s, Bool#)

atomicModifyMutableByteArray# :: MutableByteArray# s -> Int# -> (Ptr a -> (#Ptr a, b#)) -> State# s -> (#State# s, b#)

atomicModifyOffAddr# :: Addr# -> Int# -> (Ptr a -> (#Ptr a, b#)) -> State# s -> (#State# s, b#)

Functor (URec (Ptr ()) :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b

(<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a

Foldable (URec (Ptr ()) :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Foldable

Methods

fold :: Monoid m => URec (Ptr ()) m -> m

foldMap :: Monoid m => (a -> m) -> URec (Ptr ()) a -> m

foldr :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b

foldr' :: (a -> b -> b) -> b -> URec (Ptr ()) a -> b

foldl :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b

foldl' :: (b -> a -> b) -> b -> URec (Ptr ()) a -> b

foldr1 :: (a -> a -> a) -> URec (Ptr ()) a -> a

foldl1 :: (a -> a -> a) -> URec (Ptr ()) a -> a

toList :: URec (Ptr ()) a -> [a]

null :: URec (Ptr ()) a -> Bool

length :: URec (Ptr ()) a -> Int

elem :: Eq a => a -> URec (Ptr ()) a -> Bool

maximum :: Ord a => URec (Ptr ()) a -> a

minimum :: Ord a => URec (Ptr ()) a -> a

sum :: Num a => URec (Ptr ()) a -> a

product :: Num a => URec (Ptr ()) a -> a

Traversable (URec (Ptr ()) :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> URec (Ptr ()) a -> f (URec (Ptr ()) b)

sequenceA :: Applicative f => URec (Ptr ()) (f a) -> f (URec (Ptr ()) a)

mapM :: Monad m => (a -> m b) -> URec (Ptr ()) a -> m (URec (Ptr ()) b)

sequence :: Monad m => URec (Ptr ()) (m a) -> m (URec (Ptr ()) a)

Eq (URec (Ptr ()) p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

(==) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

(/=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

Ord (URec (Ptr ()) p)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

compare :: URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering

(<) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

(<=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

(>) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

(>=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool

max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p

min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p

Generic (URec (Ptr ()) p)

Defined in GHC.Generics

Associated Types

type Rep (URec (Ptr ()) p) :: Type -> Type

Methods

from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x

to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p

data URec (Ptr ()) (p :: k)

Used for marking occurrences of Addr#

Since: base-4.9.0.0

Defined in GHC.Generics

data URec (Ptr ()) (p :: k) = UAddr {

• uAddr# :: Addr#

}

type Rep1 (URec (Ptr ()) :: k -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

type Rep1 (URec (Ptr ()) :: k -> Type) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UAddr" PrefixI True) (S1 (MetaSel (Just "uAddr#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UAddr :: k -> Type)))

type PrimBase (Ptr a)

Defined in Data.Prim.Class

type PrimBase (Ptr a) = Ptr a

type SizeOf (Ptr a)

Defined in Data.Prim.Class

type SizeOf (Ptr a) = 8

type Alignment (Ptr a)

Defined in Data.Prim.Class

type Alignment (Ptr a) = 8

type Rep (URec (Ptr ()) p)

Since: base-4.9.0.0

Defined in GHC.Generics

type Rep (URec (Ptr ()) p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UAddr" PrefixI True) (S1 (MetaSel (Just "uAddr#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UAddr :: Type -> Type)))

data FunPtr a

A value of type FunPtr a is a pointer to a function callable from foreign code. The type a will normally be a foreign type, a function type with zero or more arguments where

• the argument types are marshallable foreign types, i.e. Char, Int, Double, Float, Bool, Int8, Int16, Int32, Int64, Word8, Word16, Word32, Word64, Ptr a, FunPtr a, StablePtr a or a renaming of any of these using newtype.
• the return type is either a marshallable foreign type or has the form IO t where t is a marshallable foreign type or ().

A value of type FunPtr a may be a pointer to a foreign function, either returned by another foreign function or imported with a a static address import like

foreign import ccall "stdlib.h &free"
  p_free :: FunPtr (Ptr a -> IO ())

or a pointer to a Haskell function created using a wrapper stub declared to produce a FunPtr of the correct type. For example:

type Compare = Int -> Int -> Bool
foreign import ccall "wrapper"
  mkCompare :: Compare -> IO (FunPtr Compare)

Calls to wrapper stubs like mkCompare allocate storage, which should be released with freeHaskellFunPtr when no longer required.

To convert FunPtr values to corresponding Haskell functions, one can define a dynamic stub for the specific foreign type, e.g.

type IntFunction = CInt -> IO ()
foreign import ccall "dynamic"
  mkFun :: FunPtr IntFunction -> IntFunction

Instances

NFData1 FunPtr

Since: deepseq-1.4.3.0

Defined in Control.DeepSeq

Methods

liftRnf :: (a -> ()) -> FunPtr a -> ()

Eq (FunPtr a)

Defined in GHC.Ptr

Methods

(==) :: FunPtr a -> FunPtr a -> Bool

(/=) :: FunPtr a -> FunPtr a -> Bool

Ord (FunPtr a)

Defined in GHC.Ptr

Methods

compare :: FunPtr a -> FunPtr a -> Ordering

(<) :: FunPtr a -> FunPtr a -> Bool

(<=) :: FunPtr a -> FunPtr a -> Bool

(>) :: FunPtr a -> FunPtr a -> Bool

(>=) :: FunPtr a -> FunPtr a -> Bool

max :: FunPtr a -> FunPtr a -> FunPtr a

min :: FunPtr a -> FunPtr a -> FunPtr a

Show (FunPtr a)

Since: base-2.1

Defined in GHC.Ptr

Methods

showsPrec :: Int -> FunPtr a -> ShowS

show :: FunPtr a -> String

showList :: [FunPtr a] -> ShowS

NFData (FunPtr a)

Since: deepseq-1.4.2.0

Defined in Control.DeepSeq

Methods

rnf :: FunPtr a -> ()

Prim (FunPtr a)

Defined in Data.Prim.Class

Associated Types

type PrimBase (FunPtr a) :: Type

type SizeOf (FunPtr a) :: Nat

type Alignment (FunPtr a) :: Nat

Methods

toPrimBase :: FunPtr a -> PrimBase (FunPtr a)

fromPrimBase :: PrimBase (FunPtr a) -> FunPtr a

sizeOf# :: Proxy# (FunPtr a) -> Int#

alignment# :: Proxy# (FunPtr a) -> Int#

indexByteOffByteArray# :: ByteArray# -> Int# -> FunPtr a

indexByteArray# :: ByteArray# -> Int# -> FunPtr a

indexOffAddr# :: Addr# -> Int# -> FunPtr a

readByteOffMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, FunPtr a#)

readMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, FunPtr a#)

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, FunPtr a#)

writeByteOffMutableByteArray# :: MutableByteArray# s -> Int# -> FunPtr a -> State# s -> State# s

writeMutableByteArray# :: MutableByteArray# s -> Int# -> FunPtr a -> State# s -> State# s

writeOffAddr# :: Addr# -> Int# -> FunPtr a -> State# s -> State# s

setMutableByteArray# :: MutableByteArray# s -> Int# -> Int# -> FunPtr a -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> FunPtr a -> State# s -> State# s

Atomic (FunPtr a)

Defined in Data.Prim.Atomic

Methods

atomicReadMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, FunPtr a#)

atomicWriteMutableByteArray# :: MutableByteArray# s -> Int# -> FunPtr a -> State# s -> State# s

atomicReadOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, FunPtr a#)

atomicWriteOffAddr# :: Addr# -> Int# -> FunPtr a -> State# s -> State# s

casMutableByteArray# :: MutableByteArray# s -> Int# -> FunPtr a -> FunPtr a -> State# s -> (#State# s, FunPtr a#)

casOffAddr# :: Addr# -> Int# -> FunPtr a -> FunPtr a -> State# s -> (#State# s, FunPtr a#)

casBoolMutableByteArray# :: MutableByteArray# s -> Int# -> FunPtr a -> FunPtr a -> State# s -> (#State# s, Bool#)

casBoolOffAddr# :: Addr# -> Int# -> FunPtr a -> FunPtr a -> State# s -> (#State# s, Bool#)

atomicModifyMutableByteArray# :: MutableByteArray# s -> Int# -> (FunPtr a -> (#FunPtr a, b#)) -> State# s -> (#State# s, b#)

atomicModifyOffAddr# :: Addr# -> Int# -> (FunPtr a -> (#FunPtr a, b#)) -> State# s -> (#State# s, b#)

type PrimBase (FunPtr a)

Defined in Data.Prim.Class

type PrimBase (FunPtr a) = Ptr a

type SizeOf (FunPtr a)

Defined in Data.Prim.Class

type SizeOf (FunPtr a) = SizeOf (PrimBase (FunPtr a))

type Alignment (FunPtr a)

Defined in Data.Prim.Class

type Alignment (FunPtr a) = Alignment (PrimBase (FunPtr a))

castPtrToFunPtr :: Ptr a -> FunPtr b

Casts a Ptr to a FunPtr.

Note: 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

Casts a FunPtr to a Ptr.

Note: 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.

castFunPtr :: FunPtr a -> FunPtr b

Casts a FunPtr to a FunPtr of a different type.

nullFunPtr :: FunPtr a

The constant nullFunPtr contains a distinguished value of FunPtr that is not associated with a valid memory location.

minusPtr :: Ptr a -> Ptr b -> Int

Computes the offset required to get from the second to the first argument. We have

p2 == p1 `plusPtr` (p2 `minusPtr` p1)

alignPtr :: Ptr a -> Int -> Ptr a

Given an arbitrary address and an alignment constraint, alignPtr yields the next higher address that fulfills the alignment constraint. An alignment constraint x is fulfilled by any address divisible by x. This operation is idempotent.

plusPtr :: Ptr a -> Int -> Ptr b

Advances the given address by the given offset in bytes.

castPtr :: Ptr a -> Ptr b

The castPtr function casts a pointer from one type to another.

nullPtr :: Ptr a

The constant nullPtr contains a distinguished value of Ptr that is not associated with a valid memory location.

newtype WordPtr

An unsigned integral type that can be losslessly converted to and from Ptr. This type is also compatible with the C99 type uintptr_t, and can be marshalled to and from that type safely.

Constructors

WordPtr Word

Instances

Bounded WordPtr

Defined in Foreign.Ptr

Methods

minBound :: WordPtr

maxBound :: WordPtr

Enum WordPtr

Defined in Foreign.Ptr

Methods

succ :: WordPtr -> WordPtr

pred :: WordPtr -> WordPtr

toEnum :: Int -> WordPtr

fromEnum :: WordPtr -> Int

enumFrom :: WordPtr -> [WordPtr]

enumFromThen :: WordPtr -> WordPtr -> [WordPtr]

enumFromTo :: WordPtr -> WordPtr -> [WordPtr]

enumFromThenTo :: WordPtr -> WordPtr -> WordPtr -> [WordPtr]

Eq WordPtr

Defined in Foreign.Ptr

Methods

(==) :: WordPtr -> WordPtr -> Bool

(/=) :: WordPtr -> WordPtr -> Bool

Integral WordPtr

Defined in Foreign.Ptr

Methods

quot :: WordPtr -> WordPtr -> WordPtr

rem :: WordPtr -> WordPtr -> WordPtr

div :: WordPtr -> WordPtr -> WordPtr

mod :: WordPtr -> WordPtr -> WordPtr

quotRem :: WordPtr -> WordPtr -> (WordPtr, WordPtr)

divMod :: WordPtr -> WordPtr -> (WordPtr, WordPtr)

toInteger :: WordPtr -> Integer

Num WordPtr

Defined in Foreign.Ptr

Methods

(+) :: WordPtr -> WordPtr -> WordPtr

(-) :: WordPtr -> WordPtr -> WordPtr

(*) :: WordPtr -> WordPtr -> WordPtr

negate :: WordPtr -> WordPtr

abs :: WordPtr -> WordPtr

signum :: WordPtr -> WordPtr

fromInteger :: Integer -> WordPtr

Ord WordPtr

Defined in Foreign.Ptr

Methods

compare :: WordPtr -> WordPtr -> Ordering

(<) :: WordPtr -> WordPtr -> Bool

(<=) :: WordPtr -> WordPtr -> Bool

(>) :: WordPtr -> WordPtr -> Bool

(>=) :: WordPtr -> WordPtr -> Bool

max :: WordPtr -> WordPtr -> WordPtr

min :: WordPtr -> WordPtr -> WordPtr

Read WordPtr

Defined in Foreign.Ptr

Methods

readsPrec :: Int -> ReadS WordPtr

readList :: ReadS [WordPtr]

readPrec :: ReadPrec WordPtr

readListPrec :: ReadPrec [WordPtr]

Real WordPtr

Defined in Foreign.Ptr

Methods

toRational :: WordPtr -> Rational

Show WordPtr

Defined in Foreign.Ptr

Methods

showsPrec :: Int -> WordPtr -> ShowS

show :: WordPtr -> String

showList :: [WordPtr] -> ShowS

Storable WordPtr

Defined in Foreign.Ptr

Methods

sizeOf :: WordPtr -> Int

alignment :: WordPtr -> Int

peekElemOff :: Ptr WordPtr -> Int -> IO WordPtr

pokeElemOff :: Ptr WordPtr -> Int -> WordPtr -> IO ()

peekByteOff :: Ptr b -> Int -> IO WordPtr

pokeByteOff :: Ptr b -> Int -> WordPtr -> IO ()

peek :: Ptr WordPtr -> IO WordPtr

poke :: Ptr WordPtr -> WordPtr -> IO ()

Bits WordPtr

Defined in Foreign.Ptr

Methods

(.&.) :: WordPtr -> WordPtr -> WordPtr

(.|.) :: WordPtr -> WordPtr -> WordPtr

xor :: WordPtr -> WordPtr -> WordPtr

complement :: WordPtr -> WordPtr

shift :: WordPtr -> Int -> WordPtr

rotate :: WordPtr -> Int -> WordPtr

zeroBits :: WordPtr

bit :: Int -> WordPtr

setBit :: WordPtr -> Int -> WordPtr

clearBit :: WordPtr -> Int -> WordPtr

complementBit :: WordPtr -> Int -> WordPtr

testBit :: WordPtr -> Int -> Bool

bitSizeMaybe :: WordPtr -> Maybe Int

bitSize :: WordPtr -> Int

isSigned :: WordPtr -> Bool

shiftL :: WordPtr -> Int -> WordPtr

unsafeShiftL :: WordPtr -> Int -> WordPtr

shiftR :: WordPtr -> Int -> WordPtr

unsafeShiftR :: WordPtr -> Int -> WordPtr

rotateL :: WordPtr -> Int -> WordPtr

rotateR :: WordPtr -> Int -> WordPtr

popCount :: WordPtr -> Int

FiniteBits WordPtr

Defined in Foreign.Ptr

Methods

finiteBitSize :: WordPtr -> Int

countLeadingZeros :: WordPtr -> Int

countTrailingZeros :: WordPtr -> Int

Prim WordPtr

Defined in Data.Prim.Class

Associated Types

type PrimBase WordPtr :: Type

type SizeOf WordPtr :: Nat

type Alignment WordPtr :: Nat

Methods

toPrimBase :: WordPtr -> PrimBase WordPtr

fromPrimBase :: PrimBase WordPtr -> WordPtr

sizeOf# :: Proxy# WordPtr -> Int#

alignment# :: Proxy# WordPtr -> Int#

indexByteOffByteArray# :: ByteArray# -> Int# -> WordPtr

indexByteArray# :: ByteArray# -> Int# -> WordPtr

indexOffAddr# :: Addr# -> Int# -> WordPtr

readByteOffMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, WordPtr#)

readMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, WordPtr#)

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, WordPtr#)

writeByteOffMutableByteArray# :: MutableByteArray# s -> Int# -> WordPtr -> State# s -> State# s

writeMutableByteArray# :: MutableByteArray# s -> Int# -> WordPtr -> State# s -> State# s

writeOffAddr# :: Addr# -> Int# -> WordPtr -> State# s -> State# s

setMutableByteArray# :: MutableByteArray# s -> Int# -> Int# -> WordPtr -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> WordPtr -> State# s -> State# s

AtomicBits WordPtr

Defined in Data.Prim.Atomic

Methods

atomicAndFetchOldMutableByteArray# :: MutableByteArray# s -> Int# -> WordPtr -> State# s -> (#State# s, WordPtr#)

atomicAndFetchNewMutableByteArray# :: MutableByteArray# s -> Int# -> WordPtr -> State# s -> (#State# s, WordPtr#)

atomicNandFetchOldMutableByteArray# :: MutableByteArray# s -> Int# -> WordPtr -> State# s -> (#State# s, WordPtr#)

atomicNandFetchNewMutableByteArray# :: MutableByteArray# s -> Int# -> WordPtr -> State# s -> (#State# s, WordPtr#)

atomicOrFetchOldMutableByteArray# :: MutableByteArray# s -> Int# -> WordPtr -> State# s -> (#State# s, WordPtr#)

atomicOrFetchNewMutableByteArray# :: MutableByteArray# s -> Int# -> WordPtr -> State# s -> (#State# s, WordPtr#)

atomicXorFetchOldMutableByteArray# :: MutableByteArray# s -> Int# -> WordPtr -> State# s -> (#State# s, WordPtr#)

atomicXorFetchNewMutableByteArray# :: MutableByteArray# s -> Int# -> WordPtr -> State# s -> (#State# s, WordPtr#)

atomicAndFetchOldOffAddr# :: Addr# -> Int# -> WordPtr -> State# s -> (#State# s, WordPtr#)

atomicAndFetchNewOffAddr# :: Addr# -> Int# -> WordPtr -> State# s -> (#State# s, WordPtr#)

atomicNandFetchOldOffAddr# :: Addr# -> Int# -> WordPtr -> State# s -> (#State# s, WordPtr#)

atomicNandFetchNewOffAddr# :: Addr# -> Int# -> WordPtr -> State# s -> (#State# s, WordPtr#)

atomicOrFetchOldOffAddr# :: Addr# -> Int# -> WordPtr -> State# s -> (#State# s, WordPtr#)

atomicOrFetchNewOffAddr# :: Addr# -> Int# -> WordPtr -> State# s -> (#State# s, WordPtr#)

atomicXorFetchOldOffAddr# :: Addr# -> Int# -> WordPtr -> State# s -> (#State# s, WordPtr#)

atomicXorFetchNewOffAddr# :: Addr# -> Int# -> WordPtr -> State# s -> (#State# s, WordPtr#)

AtomicCount WordPtr

Defined in Data.Prim.Atomic

Methods

atomicAddFetchOldMutableByteArray# :: MutableByteArray# s -> Int# -> WordPtr -> State# s -> (#State# s, WordPtr#)

atomicAddFetchNewMutableByteArray# :: MutableByteArray# s -> Int# -> WordPtr -> State# s -> (#State# s, WordPtr#)

atomicSubFetchOldMutableByteArray# :: MutableByteArray# s -> Int# -> WordPtr -> State# s -> (#State# s, WordPtr#)

atomicSubFetchNewMutableByteArray# :: MutableByteArray# s -> Int# -> WordPtr -> State# s -> (#State# s, WordPtr#)

atomicAddFetchOldOffAddr# :: Addr# -> Int# -> WordPtr -> State# s -> (#State# s, WordPtr#)

atomicAddFetchNewOffAddr# :: Addr# -> Int# -> WordPtr -> State# s -> (#State# s, WordPtr#)

atomicSubFetchOldOffAddr# :: Addr# -> Int# -> WordPtr -> State# s -> (#State# s, WordPtr#)

atomicSubFetchNewOffAddr# :: Addr# -> Int# -> WordPtr -> State# s -> (#State# s, WordPtr#)

Atomic WordPtr

Defined in Data.Prim.Atomic

Methods

atomicReadMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, WordPtr#)

atomicWriteMutableByteArray# :: MutableByteArray# s -> Int# -> WordPtr -> State# s -> State# s

atomicReadOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, WordPtr#)

atomicWriteOffAddr# :: Addr# -> Int# -> WordPtr -> State# s -> State# s

casMutableByteArray# :: MutableByteArray# s -> Int# -> WordPtr -> WordPtr -> State# s -> (#State# s, WordPtr#)

casOffAddr# :: Addr# -> Int# -> WordPtr -> WordPtr -> State# s -> (#State# s, WordPtr#)

casBoolMutableByteArray# :: MutableByteArray# s -> Int# -> WordPtr -> WordPtr -> State# s -> (#State# s, Bool#)

casBoolOffAddr# :: Addr# -> Int# -> WordPtr -> WordPtr -> State# s -> (#State# s, Bool#)

atomicModifyMutableByteArray# :: MutableByteArray# s -> Int# -> (WordPtr -> (#WordPtr, b#)) -> State# s -> (#State# s, b#)

atomicModifyOffAddr# :: Addr# -> Int# -> (WordPtr -> (#WordPtr, b#)) -> State# s -> (#State# s, b#)

type PrimBase WordPtr

Defined in Data.Prim.Class

type PrimBase WordPtr = Word

type SizeOf WordPtr

Defined in Data.Prim.Class

type SizeOf WordPtr = SizeOf (PrimBase WordPtr)

type Alignment WordPtr

Defined in Data.Prim.Class

type Alignment WordPtr = Alignment (PrimBase WordPtr)

ptrToWordPtr :: Ptr a -> WordPtr

casts a Ptr to a WordPtr

wordPtrToPtr :: WordPtr -> Ptr a

casts a WordPtr to a Ptr

newtype IntPtr

A signed integral type that can be losslessly converted to and from Ptr. This type is also compatible with the C99 type intptr_t, and can be marshalled to and from that type safely.

Constructors

IntPtr Int

Instances

Bounded IntPtr

Defined in Foreign.Ptr

Methods

minBound :: IntPtr

maxBound :: IntPtr

Enum IntPtr

Defined in Foreign.Ptr

Methods

succ :: IntPtr -> IntPtr

pred :: IntPtr -> IntPtr

toEnum :: Int -> IntPtr

fromEnum :: IntPtr -> Int

enumFrom :: IntPtr -> [IntPtr]

enumFromThen :: IntPtr -> IntPtr -> [IntPtr]

enumFromTo :: IntPtr -> IntPtr -> [IntPtr]

enumFromThenTo :: IntPtr -> IntPtr -> IntPtr -> [IntPtr]

Eq IntPtr

Defined in Foreign.Ptr

Methods

(==) :: IntPtr -> IntPtr -> Bool

(/=) :: IntPtr -> IntPtr -> Bool

Integral IntPtr

Defined in Foreign.Ptr

Methods

quot :: IntPtr -> IntPtr -> IntPtr

rem :: IntPtr -> IntPtr -> IntPtr

div :: IntPtr -> IntPtr -> IntPtr

mod :: IntPtr -> IntPtr -> IntPtr

quotRem :: IntPtr -> IntPtr -> (IntPtr, IntPtr)

divMod :: IntPtr -> IntPtr -> (IntPtr, IntPtr)

toInteger :: IntPtr -> Integer

Num IntPtr

Defined in Foreign.Ptr

Methods

(+) :: IntPtr -> IntPtr -> IntPtr

(-) :: IntPtr -> IntPtr -> IntPtr

(*) :: IntPtr -> IntPtr -> IntPtr

negate :: IntPtr -> IntPtr

abs :: IntPtr -> IntPtr

signum :: IntPtr -> IntPtr

fromInteger :: Integer -> IntPtr

Ord IntPtr

Defined in Foreign.Ptr

Methods

compare :: IntPtr -> IntPtr -> Ordering

(<) :: IntPtr -> IntPtr -> Bool

(<=) :: IntPtr -> IntPtr -> Bool

(>) :: IntPtr -> IntPtr -> Bool

(>=) :: IntPtr -> IntPtr -> Bool

max :: IntPtr -> IntPtr -> IntPtr

min :: IntPtr -> IntPtr -> IntPtr

Read IntPtr

Defined in Foreign.Ptr

Methods

readsPrec :: Int -> ReadS IntPtr

readList :: ReadS [IntPtr]

readPrec :: ReadPrec IntPtr

readListPrec :: ReadPrec [IntPtr]

Real IntPtr

Defined in Foreign.Ptr

Methods

toRational :: IntPtr -> Rational

Show IntPtr

Defined in Foreign.Ptr

Methods

showsPrec :: Int -> IntPtr -> ShowS

show :: IntPtr -> String

showList :: [IntPtr] -> ShowS

Storable IntPtr

Defined in Foreign.Ptr

Methods

sizeOf :: IntPtr -> Int

alignment :: IntPtr -> Int

peekElemOff :: Ptr IntPtr -> Int -> IO IntPtr

pokeElemOff :: Ptr IntPtr -> Int -> IntPtr -> IO ()

peekByteOff :: Ptr b -> Int -> IO IntPtr

pokeByteOff :: Ptr b -> Int -> IntPtr -> IO ()

peek :: Ptr IntPtr -> IO IntPtr

poke :: Ptr IntPtr -> IntPtr -> IO ()

Bits IntPtr

Defined in Foreign.Ptr

Methods

(.&.) :: IntPtr -> IntPtr -> IntPtr

(.|.) :: IntPtr -> IntPtr -> IntPtr

xor :: IntPtr -> IntPtr -> IntPtr

complement :: IntPtr -> IntPtr

shift :: IntPtr -> Int -> IntPtr

rotate :: IntPtr -> Int -> IntPtr

zeroBits :: IntPtr

bit :: Int -> IntPtr

setBit :: IntPtr -> Int -> IntPtr

clearBit :: IntPtr -> Int -> IntPtr

complementBit :: IntPtr -> Int -> IntPtr

testBit :: IntPtr -> Int -> Bool

bitSizeMaybe :: IntPtr -> Maybe Int

bitSize :: IntPtr -> Int

isSigned :: IntPtr -> Bool

shiftL :: IntPtr -> Int -> IntPtr

unsafeShiftL :: IntPtr -> Int -> IntPtr

shiftR :: IntPtr -> Int -> IntPtr

unsafeShiftR :: IntPtr -> Int -> IntPtr

rotateL :: IntPtr -> Int -> IntPtr

rotateR :: IntPtr -> Int -> IntPtr

popCount :: IntPtr -> Int

FiniteBits IntPtr

Defined in Foreign.Ptr

Methods

finiteBitSize :: IntPtr -> Int

countLeadingZeros :: IntPtr -> Int

countTrailingZeros :: IntPtr -> Int

Prim IntPtr

Defined in Data.Prim.Class

Associated Types

type PrimBase IntPtr :: Type

type SizeOf IntPtr :: Nat

type Alignment IntPtr :: Nat

Methods

toPrimBase :: IntPtr -> PrimBase IntPtr

fromPrimBase :: PrimBase IntPtr -> IntPtr

sizeOf# :: Proxy# IntPtr -> Int#

alignment# :: Proxy# IntPtr -> Int#

indexByteOffByteArray# :: ByteArray# -> Int# -> IntPtr

indexByteArray# :: ByteArray# -> Int# -> IntPtr

indexOffAddr# :: Addr# -> Int# -> IntPtr

readByteOffMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, IntPtr#)

readMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, IntPtr#)

readOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, IntPtr#)

writeByteOffMutableByteArray# :: MutableByteArray# s -> Int# -> IntPtr -> State# s -> State# s

writeMutableByteArray# :: MutableByteArray# s -> Int# -> IntPtr -> State# s -> State# s

writeOffAddr# :: Addr# -> Int# -> IntPtr -> State# s -> State# s

setMutableByteArray# :: MutableByteArray# s -> Int# -> Int# -> IntPtr -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> IntPtr -> State# s -> State# s

AtomicBits IntPtr

Defined in Data.Prim.Atomic

Methods

atomicAndFetchOldMutableByteArray# :: MutableByteArray# s -> Int# -> IntPtr -> State# s -> (#State# s, IntPtr#)

atomicAndFetchNewMutableByteArray# :: MutableByteArray# s -> Int# -> IntPtr -> State# s -> (#State# s, IntPtr#)

atomicNandFetchOldMutableByteArray# :: MutableByteArray# s -> Int# -> IntPtr -> State# s -> (#State# s, IntPtr#)

atomicNandFetchNewMutableByteArray# :: MutableByteArray# s -> Int# -> IntPtr -> State# s -> (#State# s, IntPtr#)

atomicOrFetchOldMutableByteArray# :: MutableByteArray# s -> Int# -> IntPtr -> State# s -> (#State# s, IntPtr#)

atomicOrFetchNewMutableByteArray# :: MutableByteArray# s -> Int# -> IntPtr -> State# s -> (#State# s, IntPtr#)

atomicXorFetchOldMutableByteArray# :: MutableByteArray# s -> Int# -> IntPtr -> State# s -> (#State# s, IntPtr#)

atomicXorFetchNewMutableByteArray# :: MutableByteArray# s -> Int# -> IntPtr -> State# s -> (#State# s, IntPtr#)

atomicAndFetchOldOffAddr# :: Addr# -> Int# -> IntPtr -> State# s -> (#State# s, IntPtr#)

atomicAndFetchNewOffAddr# :: Addr# -> Int# -> IntPtr -> State# s -> (#State# s, IntPtr#)

atomicNandFetchOldOffAddr# :: Addr# -> Int# -> IntPtr -> State# s -> (#State# s, IntPtr#)

atomicNandFetchNewOffAddr# :: Addr# -> Int# -> IntPtr -> State# s -> (#State# s, IntPtr#)

atomicOrFetchOldOffAddr# :: Addr# -> Int# -> IntPtr -> State# s -> (#State# s, IntPtr#)

atomicOrFetchNewOffAddr# :: Addr# -> Int# -> IntPtr -> State# s -> (#State# s, IntPtr#)

atomicXorFetchOldOffAddr# :: Addr# -> Int# -> IntPtr -> State# s -> (#State# s, IntPtr#)

atomicXorFetchNewOffAddr# :: Addr# -> Int# -> IntPtr -> State# s -> (#State# s, IntPtr#)

AtomicCount IntPtr

Defined in Data.Prim.Atomic

Methods

atomicAddFetchOldMutableByteArray# :: MutableByteArray# s -> Int# -> IntPtr -> State# s -> (#State# s, IntPtr#)

atomicAddFetchNewMutableByteArray# :: MutableByteArray# s -> Int# -> IntPtr -> State# s -> (#State# s, IntPtr#)

atomicSubFetchOldMutableByteArray# :: MutableByteArray# s -> Int# -> IntPtr -> State# s -> (#State# s, IntPtr#)

atomicSubFetchNewMutableByteArray# :: MutableByteArray# s -> Int# -> IntPtr -> State# s -> (#State# s, IntPtr#)

atomicAddFetchOldOffAddr# :: Addr# -> Int# -> IntPtr -> State# s -> (#State# s, IntPtr#)

atomicAddFetchNewOffAddr# :: Addr# -> Int# -> IntPtr -> State# s -> (#State# s, IntPtr#)

atomicSubFetchOldOffAddr# :: Addr# -> Int# -> IntPtr -> State# s -> (#State# s, IntPtr#)

atomicSubFetchNewOffAddr# :: Addr# -> Int# -> IntPtr -> State# s -> (#State# s, IntPtr#)

Atomic IntPtr

Defined in Data.Prim.Atomic

Methods

atomicReadMutableByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#State# s, IntPtr#)

atomicWriteMutableByteArray# :: MutableByteArray# s -> Int# -> IntPtr -> State# s -> State# s

atomicReadOffAddr# :: Addr# -> Int# -> State# s -> (#State# s, IntPtr#)

atomicWriteOffAddr# :: Addr# -> Int# -> IntPtr -> State# s -> State# s

casMutableByteArray# :: MutableByteArray# s -> Int# -> IntPtr -> IntPtr -> State# s -> (#State# s, IntPtr#)

casOffAddr# :: Addr# -> Int# -> IntPtr -> IntPtr -> State# s -> (#State# s, IntPtr#)

casBoolMutableByteArray# :: MutableByteArray# s -> Int# -> IntPtr -> IntPtr -> State# s -> (#State# s, Bool#)

casBoolOffAddr# :: Addr# -> Int# -> IntPtr -> IntPtr -> State# s -> (#State# s, Bool#)

atomicModifyMutableByteArray# :: MutableByteArray# s -> Int# -> (IntPtr -> (#IntPtr, b#)) -> State# s -> (#State# s, b#)

atomicModifyOffAddr# :: Addr# -> Int# -> (IntPtr -> (#IntPtr, b#)) -> State# s -> (#State# s, b#)

type PrimBase IntPtr

Defined in Data.Prim.Class

type PrimBase IntPtr = Int

type SizeOf IntPtr

Defined in Data.Prim.Class

type SizeOf IntPtr = SizeOf (PrimBase IntPtr)

type Alignment IntPtr

Defined in Data.Prim.Class

type Alignment IntPtr = Alignment (PrimBase IntPtr)

ptrToIntPtr :: Ptr a -> IntPtr

casts a Ptr to an IntPtr

intPtrToPtr :: IntPtr -> Ptr a

casts an IntPtr to a Ptr

Atomic

casOffPtr

Arguments

:: (MonadPrim s m, Atomic e)

=> Ptr e

Array to be mutated

-> Off e

Index is in elements of a, rather than bytes.

-> e

Expected old value

-> e

New value

-> m e

Perform atomic modification of an element in the Ptr at the supplied index. Returns the artifact of computation b. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicModifyOffPtr

Arguments

:: (MonadPrim s m, Atomic e)

=> Ptr e

Array to be mutated

-> Off e

Index is in elements of a, rather than bytes.

-> (e -> (e, b))

Function that is applied to the old value and returns new value and some artifact of computation b

-> m b

Perform atomic modification of an element in the Ptr at the supplied index. Returns the artifact of computation b. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicModifyOffPtr_

Arguments

:: (MonadPrim s m, Atomic e)

=> Ptr e

Array to be mutated

-> Off e

Index is in elements of a, rather than bytes.

-> (e -> e)

Function that is applied to the old value and returns new value.

-> m ()

Perform atomic modification of an element in the Ptr at the supplied index. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicModifyFetchOldOffPtr

Arguments

:: (MonadPrim s m, Atomic e)

=> Ptr e

Array to be mutated

-> Off e

Index is in elements of a, rather than bytes.

-> (e -> e)

Function that is applied to the old value and returns the new value

-> m e

Perform atomic modification of an element in the Ptr at the supplied index. Returns the previous value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicModifyFetchNewOffPtr

Arguments

:: (MonadPrim s m, Atomic e)

=> Ptr e

Array to be mutated

-> Off e

Index is in elements of a, rather than bytes.

-> (e -> e)

Function that is applied to the old value and returns the new value

-> m e

Perform atomic modification of an element in the Ptr at the supplied index. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

Numeric

atomicAddFetchOldOffPtr :: (MonadPrim s m, AtomicCount e) => Ptr e -> Off e -> e -> m e

Add a numeric value to an element of a Ptr, corresponds to (+) done atomically. Returns the previous value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicAddFetchNewOffPtr :: (MonadPrim s m, AtomicCount e) => Ptr e -> Off e -> e -> m e

Add a numeric value to an element of a Ptr, corresponds to (+) done atomically. Returns the new value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicSubFetchOldOffPtr :: (MonadPrim s m, AtomicCount e) => Ptr e -> Off e -> e -> m e

Subtract a numeric value from an element of a Ptr, corresponds to (-) done atomically. Returns the previous value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicSubFetchNewOffPtr :: (MonadPrim s m, AtomicCount e) => Ptr e -> Off e -> e -> m e

Subtract a numeric value from an element of a Ptr, corresponds to (-) done atomically. Returns the new value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

Binary

atomicAndFetchOldOffPtr :: (MonadPrim s m, AtomicBits e) => Ptr e -> Off e -> e -> m e

Binary conjunction (AND) of an element of a Ptr with the supplied value, corresponds to (.&.) done atomically. Returns the previous value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicAndFetchNewOffPtr :: (MonadPrim s m, AtomicBits e) => Ptr e -> Off e -> e -> m e

Binary conjunction (AND) of an element of a Ptr with the supplied value, corresponds to (.&.) done atomically. Returns the new value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicNandFetchOldOffPtr :: (MonadPrim s m, AtomicBits e) => Ptr e -> Off e -> e -> m e

Negation of binary conjunction (NAND) of an element of a Ptr with the supplied value, corresponds to \x y -> complement (x .&. y) done atomically. Returns the previous value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicNandFetchNewOffPtr :: (MonadPrim s m, AtomicBits e) => Ptr e -> Off e -> e -> m e

Negation of binary conjunction (NAND) of an element of a Ptr with the supplied value, corresponds to \x y -> complement (x .&. y) done atomically. Returns the new value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicOrFetchOldOffPtr :: (MonadPrim s m, AtomicBits e) => Ptr e -> Off e -> e -> m e

Binary disjunction (OR) of an element of a Ptr with the supplied value, corresponds to (.|.) done atomically. Returns the previous value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicOrFetchNewOffPtr :: (MonadPrim s m, AtomicBits e) => Ptr e -> Off e -> e -> m e

Binary disjunction (OR) of an element of a Ptr with the supplied value, corresponds to (.|.) done atomically. Returns the new value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicXorFetchOldOffPtr :: (MonadPrim s m, AtomicBits e) => Ptr e -> Off e -> e -> m e

Binary exclusive disjunction (XOR) of an element of a Ptr with the supplied value, corresponds to xor done atomically. Returns the previous value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicXorFetchNewOffPtr :: (MonadPrim s m, AtomicBits e) => Ptr e -> Off e -> e -> m e

Binary exclusive disjunction (XOR) of an element of a Ptr with the supplied value, corresponds to xor done atomically. Returns the new value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicNotFetchOldOffPtr :: (MonadPrim s m, AtomicBits e) => Ptr e -> Off e -> m e

Binary negation (NOT) of an element of a Ptr, corresponds to (complement) done atomically. Returns the previous value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicNotFetchNewOffPtr :: (MonadPrim s m, AtomicBits e) => Ptr e -> Off e -> m e

Binary negation (NOT) of an element of a Ptr, corresponds to (complement) done atomically. Returns the new value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

Prefetch

prefetchPtr0 :: MonadPrim s m => Ptr e -> m ()

prefetchPtr1 :: MonadPrim s m => Ptr a -> m ()

prefetchPtr2 :: MonadPrim s m => Ptr e -> m ()

prefetchPtr3 :: MonadPrim s m => Ptr e -> m ()

prefetchOffPtr0 :: (MonadPrim s m, Prim e) => Ptr e -> Off e -> m ()

prefetchOffPtr1 :: (MonadPrim s m, Prim e) => Ptr e -> Off e -> m ()

prefetchOffPtr2 :: (MonadPrim s m, Prim e) => Ptr e -> Off e -> m ()

prefetchOffPtr3 :: (MonadPrim s m, Prim e) => Ptr e -> Off e -> m ()