A block of memory containing unpacked bytes representing values of type ty

A Mutable block of memory containing unpacked bytes representing values of type ty

Return the length of a Mutable Block

note: we don't allow resizing yet, so this can remain a pure function

Use the Ptr to a mutable block in a safer construct

If the block is not pinned, this is a _dangerous_ operation

Create a pointer on the beginning of the MutableBlock and call a function f.

The mutable block can be mutated by the f function and the change will be reflected in the mutable block

If the mutable block is unpinned, a trampoline buffer is created and the data is only copied when f return.

it is all-in-all highly inefficient as this cause 2 copies

Same as withMutablePtr but allow to specify 2 optimisations which is only useful when the MutableBlock is unpinned and need a pinned trampoline to be called safely.

If skipCopy is True, then the first copy which happen before the call to f, is skipped. The Ptr is now effectively pointing to uninitialized data in a new mutable Block.

If skipCopyBack is True, then the second copy which happen after the call to f, is skipped. Then effectively in the case of a trampoline being used the memory changed by f will not be reflected in the original Mutable Block.

If using the wrong parameters, it will lead to difficult to debug issue of corrupted buffer which only present themselves with certain Mutable Block that happened to have been allocated unpinned.

If unsure use withMutablePtr, which default to *not* skip any copy.

Create a new unpinned mutable block of a specific N size of ty elements

If the size exceeds a GHC-defined threshold, then the memory will be pinned. To be certain about pinning status with small size, use newPinned

Create a new pinned mutable block of a specific N size of ty elements

Set all mutable block element to a value

read a cell in a mutable array.

If the index is out of bounds, an error is raised.

Write to a cell in a mutable array.

If the index is out of bounds, an error is raised.

Create a new mutable block of a specific size in bytes.

Note that no checks are made to see if the size in bytes is compatible with the size of the underlaying element ty in the block.

use new if unsure

write to a cell in a mutable block without bounds checking.

Writing with invalid bounds will corrupt memory and your program will become unreliable. use write if unsure.

read from a cell in a mutable block without bounds checking.

Reading from invalid memory can return unpredictable and invalid values. use read if unsure.

Freeze a mutable block into a block.

If the mutable block is still use after freeze, then the modification will be reflected in an unexpected way in the Block.

Thaw an immutable block.

If the immutable block is modified, then the original immutable block will be modified too, but lead to unexpected results when querying

Copy a number of elements from an array to another array with offsets

Copy a number of bytes from a MutableBlock to another MutableBlock with specific byte offsets

Copy a number of bytes from a Block to a MutableBlock with specific byte offsets

Copy a number of bytes from a Ptr to a MutableBlock with specific byte offsets

Copy from a pointer, count elements, into the Mutable Block at a starting offset ofs

if the source pointer is invalid (size or bad allocation), bad things will happen

Copy all the block content to the memory starting at the destination address

If the destination pointer is invalid (size or bad allocation), bad things will happen