Data.Primitive.PrimRef

Note: Edward Kmett wrote everything in this module. It was sitting unpackaged on github, so I took it and published it.

Primitive References

newtype PrimRef s a

Constructors

PrimRef (MutableByteArray s)

Instances

Eq (PrimRef s a)

Methods

(==) :: PrimRef s a -> PrimRef s a -> Bool

(/=) :: PrimRef s a -> PrimRef s a -> Bool

newPrimRef :: (PrimMonad m, Prim a) => a -> m (PrimRef (PrimState m) a)

Create a primitive reference.

newPinnedPrimRef :: (PrimMonad m, Prim a) => a -> m (PrimRef (PrimState m) a)

Create a pinned primitive reference.

newAlignedPinnedPrimRef :: (PrimMonad m, Prim a) => a -> m (PrimRef (PrimState m) a)

Create a pinned primitive reference with the appropriate alignment for its contents.

readPrimRef :: (PrimMonad m, Prim a) => PrimRef (PrimState m) a -> m a

Read a primitive value from the reference

writePrimRef :: (PrimMonad m, Prim a) => PrimRef (PrimState m) a -> a -> m ()

Write a primitive value to the reference

primRefContents :: PrimRef s a -> Addr

Yield a pointer to the data of a PrimRef. This operation is only safe on pinned byte arrays allocated by newPinnedPrimRef or newAlignedPinnedPrimRef.

Frozen Primitive References

newtype FrozenPrimRef a

Constructors

FrozenPrimRef ByteArray

Instances

(Prim a, Data a) => Data (FrozenPrimRef a)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FrozenPrimRef a -> c (FrozenPrimRef a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FrozenPrimRef a)

toConstr :: FrozenPrimRef a -> Constr

dataTypeOf :: FrozenPrimRef a -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (FrozenPrimRef a))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FrozenPrimRef a))

gmapT :: (forall b. Data b => b -> b) -> FrozenPrimRef a -> FrozenPrimRef a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FrozenPrimRef a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FrozenPrimRef a -> r

gmapQ :: (forall d. Data d => d -> u) -> FrozenPrimRef a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> FrozenPrimRef a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FrozenPrimRef a -> m (FrozenPrimRef a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FrozenPrimRef a -> m (FrozenPrimRef a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FrozenPrimRef a -> m (FrozenPrimRef a)

newFrozenPrimRef :: Prim a => a -> FrozenPrimRef a

unsafeFreezePrimRef :: PrimMonad m => PrimRef (PrimState m) a -> m (FrozenPrimRef a)

Convert a mutable PrimRef to an immutable one without copying. The reference should not be modified after the conversion.

unsafeThawPrimRef :: PrimMonad m => FrozenPrimRef a -> m (PrimRef (PrimState m) a)

Convert an immutable primitive reference to a mutable one without copying. The original reference should not be used after the conversion.

indexFrozenPrimRef :: Prim a => FrozenPrimRef a -> a

Read the stored primitive value from the frozen reference.

frozenPrimRefContents :: FrozenPrimRef a -> Addr

Yield a pointer to the data of a FrozenPrimRef. This operation is only safe on pinned byte arrays allocated by newPinnedPrimRef or newAlignedPinnedPrimRef and then subsequently frozen.

Atomic Operations

casInt :: PrimMonad m => PrimRef (PrimState m) Int -> Int -> Int -> m Int

Given a primitive reference, the expected old value, and the new value, perform an atomic compare and swap i.e. write the new value if the current value matches the provided old value. Returns the value of the element before the operation. Implies a full memory barrier.

fetchAddInt :: PrimMonad m => PrimRef (PrimState m) Int -> Int -> m Int

Given a reference, and a value to add, atomically add the value to the element. Returns the value of the element before the operation. Implies a full memory barrier.

fetchSubInt :: PrimMonad m => PrimRef (PrimState m) Int -> Int -> m Int

Given a reference, and a value to subtract, atomically subtract the value from the element. Returns the value of the element before the operation. Implies a full memory barrier.

fetchAndInt :: PrimMonad m => PrimRef (PrimState m) Int -> Int -> m Int

Given a reference, and a value to bitwise and, atomically and the value with the element. Returns the value of the element before the operation. Implies a full memory barrier.

fetchNandInt :: PrimMonad m => PrimRef (PrimState m) Int -> Int -> m Int

Given a reference, and a value to bitwise nand, atomically nand the value with the element. Returns the value of the element before the operation. Implies a full memory barrier.

fetchOrInt :: PrimMonad m => PrimRef (PrimState m) Int -> Int -> m Int

Given a reference, and a value to bitwise or, atomically or the value with the element. Returns the value of the element before the operation. Implies a full memory barrier.

fetchXorInt :: PrimMonad m => PrimRef (PrimState m) Int -> Int -> m Int

Given a reference, and a value to bitwise xor, atomically xor the value with the element. Returns the value of the element before the operation. Implies a full memory barrier.

atomicReadInt :: PrimMonad m => PrimRef (PrimState m) Int -> m Int

Given a reference, read an element. Implies a full memory barrier.

atomicWriteInt :: PrimMonad m => PrimRef (PrimState m) Int -> Int -> m ()

Given a reference, write an element. Implies a full memory barrier.