Foundation.Primitive.Block

A block of memory that contains elements of a type, very similar to an unboxed array but with the key difference:

• It doesn't have slicing capability (no cheap take or drop)
• It consume less memory: 1 Offset, 1 CountOf, 1 Pinning status trimmed
• It's unpackable in any constructor
• It uses unpinned memory by default

Documentation

data Block ty

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

Constructors

Block ByteArray#

Instances

PrimType ty => IsList (Block ty)

Associated Types

type Item (Block ty) :: *

Methods

fromList :: [Item (Block ty)] -> Block ty

fromListN :: Int -> [Item (Block ty)] -> Block ty

toList :: Block ty -> [Item (Block ty)]

(PrimType ty, Eq ty) => Eq (Block ty)

Methods

(==) :: Block ty -> Block ty -> Bool

(/=) :: Block ty -> Block ty -> Bool

Data ty => Data (Block ty)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Block ty -> c (Block ty)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Block ty)

toConstr :: Block ty -> Constr

dataTypeOf :: Block ty -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> Block ty -> Block ty

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Block ty -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Block ty -> r

gmapQ :: (forall d. Data d => d -> u) -> Block ty -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Block ty -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Block ty -> m (Block ty)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Block ty -> m (Block ty)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Block ty -> m (Block ty)

(PrimType ty, Ord ty) => Ord (Block ty)

Methods

compare :: Block ty -> Block ty -> Ordering

(<) :: Block ty -> Block ty -> Bool

(<=) :: Block ty -> Block ty -> Bool

(>) :: Block ty -> Block ty -> Bool

(>=) :: Block ty -> Block ty -> Bool

max :: Block ty -> Block ty -> Block ty

min :: Block ty -> Block ty -> Block ty

(PrimType ty, Show ty) => Show (Block ty)

Methods

showsPrec :: Int -> Block ty -> ShowS

show :: Block ty -> String

showList :: [Block ty] -> ShowS

PrimType ty => Monoid (Block ty)

Methods

mempty :: Block ty

mappend :: Block ty -> Block ty -> Block ty

mconcat :: [Block ty] -> Block ty

NormalForm (Block ty)

Methods

toNormalForm :: Block ty -> ()

PrimType ty => Copy (Block ty)

Methods

copy :: Block ty -> Block ty

PrimType ty => Collection (Block ty)

Methods

null :: Block ty -> Bool

length :: Block ty -> CountOf (Element (Block ty))

elem :: (Eq a, (* ~ a) (Element (Block ty))) => Element (Block ty) -> Block ty -> Bool

notElem :: (Eq a, (* ~ a) (Element (Block ty))) => Element (Block ty) -> Block ty -> Bool

maximum :: (Ord a, (* ~ a) (Element (Block ty))) => NonEmpty (Block ty) -> Element (Block ty)

minimum :: (Ord a, (* ~ a) (Element (Block ty))) => NonEmpty (Block ty) -> Element (Block ty)

any :: (Element (Block ty) -> Bool) -> Block ty -> Bool

all :: (Element (Block ty) -> Bool) -> Block ty -> Bool

PrimType ty => Foldable (Block ty)

Methods

foldl :: (a -> Element (Block ty) -> a) -> a -> Block ty -> a

foldl' :: (a -> Element (Block ty) -> a) -> a -> Block ty -> a

foldr :: (Element (Block ty) -> a -> a) -> a -> Block ty -> a

foldr' :: (Element (Block ty) -> a -> a) -> a -> Block ty -> a

PrimType ty => IndexedCollection (Block ty)

Methods

(!) :: Block ty -> Offset (Element (Block ty)) -> Maybe (Element (Block ty))

findIndex :: (Element (Block ty) -> Bool) -> Block ty -> Maybe (Offset (Element (Block ty)))

PrimType ty => Sequential (Block ty)

Methods

take :: CountOf (Element (Block ty)) -> Block ty -> Block ty

revTake :: CountOf (Element (Block ty)) -> Block ty -> Block ty

drop :: CountOf (Element (Block ty)) -> Block ty -> Block ty

revDrop :: CountOf (Element (Block ty)) -> Block ty -> Block ty

splitAt :: CountOf (Element (Block ty)) -> Block ty -> (Block ty, Block ty)

revSplitAt :: CountOf (Element (Block ty)) -> Block ty -> (Block ty, Block ty)

splitOn :: (Element (Block ty) -> Bool) -> Block ty -> [Block ty]

break :: (Element (Block ty) -> Bool) -> Block ty -> (Block ty, Block ty)

breakElem :: Element (Block ty) -> Block ty -> (Block ty, Block ty)

intersperse :: Element (Block ty) -> Block ty -> Block ty

intercalate :: Element (Block ty) -> Block ty -> Element (Block ty)

span :: (Element (Block ty) -> Bool) -> Block ty -> (Block ty, Block ty)

filter :: (Element (Block ty) -> Bool) -> Block ty -> Block ty

partition :: (Element (Block ty) -> Bool) -> Block ty -> (Block ty, Block ty)

reverse :: Block ty -> Block ty

uncons :: Block ty -> Maybe (Element (Block ty), Block ty)

unsnoc :: Block ty -> Maybe (Block ty, Element (Block ty))

snoc :: Block ty -> Element (Block ty) -> Block ty

cons :: Element (Block ty) -> Block ty -> Block ty

find :: (Element (Block ty) -> Bool) -> Block ty -> Maybe (Element (Block ty))

sortBy :: (Element (Block ty) -> Element (Block ty) -> Ordering) -> Block ty -> Block ty

singleton :: Element (Block ty) -> Block ty

head :: NonEmpty (Block ty) -> Element (Block ty)

last :: NonEmpty (Block ty) -> Element (Block ty)

tail :: NonEmpty (Block ty) -> Block ty

init :: NonEmpty (Block ty) -> Block ty

replicate :: CountOf (Element (Block ty)) -> Element (Block ty) -> Block ty

isPrefixOf :: Block ty -> Block ty -> Bool

isSuffixOf :: Block ty -> Block ty -> Bool

isInfixOf :: Block ty -> Block ty -> Bool

type Item (Block ty)

type Item (Block ty) = ty

type Element (Block ty)

type Element (Block ty) = ty

data MutableBlock ty st

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

Constructors

MutableBlock (MutableByteArray# st)

Instances

PrimType ty => MutableCollection (MutableBlock ty)

Associated Types

type MutableFreezed (MutableBlock ty :: * -> *) :: *

type MutableKey (MutableBlock ty :: * -> *) :: *

type MutableValue (MutableBlock ty :: * -> *) :: *

Methods

unsafeThaw :: PrimMonad prim => MutableFreezed (MutableBlock ty) -> prim (MutableBlock ty (PrimState prim))

unsafeFreeze :: PrimMonad prim => MutableBlock ty (PrimState prim) -> prim (MutableFreezed (MutableBlock ty))

thaw :: PrimMonad prim => MutableFreezed (MutableBlock ty) -> prim (MutableBlock ty (PrimState prim))

freeze :: PrimMonad prim => MutableBlock ty (PrimState prim) -> prim (MutableFreezed (MutableBlock ty))

mutNew :: PrimMonad prim => CountOf (MutableValue (MutableBlock ty)) -> prim (MutableBlock ty (PrimState prim))

mutUnsafeWrite :: PrimMonad prim => MutableBlock ty (PrimState prim) -> MutableKey (MutableBlock ty) -> MutableValue (MutableBlock ty) -> prim ()

mutWrite :: PrimMonad prim => MutableBlock ty (PrimState prim) -> MutableKey (MutableBlock ty) -> MutableValue (MutableBlock ty) -> prim ()

mutUnsafeRead :: PrimMonad prim => MutableBlock ty (PrimState prim) -> MutableKey (MutableBlock ty) -> prim (MutableValue (MutableBlock ty))

mutRead :: PrimMonad prim => MutableBlock ty (PrimState prim) -> MutableKey (MutableBlock ty) -> prim (MutableValue (MutableBlock ty))

type MutableFreezed (MutableBlock ty)

type MutableFreezed (MutableBlock ty) = Block ty

type MutableKey (MutableBlock ty)

type MutableKey (MutableBlock ty) = Offset ty

type MutableValue (MutableBlock ty)

type MutableValue (MutableBlock ty) = ty

Properties

length :: forall ty. PrimType ty => Block ty -> CountOf ty

Lowlevel functions

unsafeThaw :: (PrimType ty, PrimMonad prim) => Block ty -> prim (MutableBlock ty (PrimState prim))

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

unsafeFreeze :: PrimMonad prim => MutableBlock ty (PrimState prim) -> prim (Block ty)

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.

unsafeIndex :: forall ty. PrimType ty => Block ty -> Offset ty -> ty

Return the element at a specific index from an array without bounds checking.

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

thaw :: (PrimMonad prim, PrimType ty) => Block ty -> prim (MutableBlock ty (PrimState prim))

Thaw a Block into a MutableBlock

the Block is not modified, instead a new Mutable Block is created and its content is copied to the mutable block

freeze :: (PrimType ty, PrimMonad prim) => MutableBlock ty (PrimState prim) -> prim (Block ty)

copy :: PrimType ty => Block ty -> Block ty

Copy every cells of an existing Block to a new Block

safer api

create

Arguments

:: PrimType ty

=> CountOf ty

the size of the block (in element of ty)

-> (Offset ty -> ty)

the function that set the value at the index

-> Block ty

the array created

Create a new array of size n by settings each cells through the function f.

singleton :: PrimType ty => ty -> Block ty

replicate :: PrimType ty => CountOf ty -> ty -> Block ty

index :: PrimType ty => Block ty -> Offset ty -> ty

Return the element at a specific index from an array.

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

map :: (PrimType a, PrimType b) => (a -> b) -> Block a -> Block b

Map all element a from a block to a new block of b

foldl :: PrimType ty => (a -> ty -> a) -> a -> Block ty -> a

foldl' :: PrimType ty => (a -> ty -> a) -> a -> Block ty -> a

foldr :: PrimType ty => (ty -> a -> a) -> a -> Block ty -> a

cons :: PrimType ty => ty -> Block ty -> Block ty

snoc :: PrimType ty => Block ty -> ty -> Block ty

uncons :: PrimType ty => Block ty -> Maybe (ty, Block ty)

unsnoc :: PrimType ty => Block ty -> Maybe (Block ty, ty)

sub :: PrimType ty => Block ty -> Offset ty -> Offset ty -> Block ty

splitAt :: PrimType ty => CountOf ty -> Block ty -> (Block ty, Block ty)

revSplitAt :: PrimType ty => CountOf ty -> Block ty -> (Block ty, Block ty)

splitOn :: PrimType ty => (ty -> Bool) -> Block ty -> [Block ty]

break :: PrimType ty => (ty -> Bool) -> Block ty -> (Block ty, Block ty)

span :: PrimType ty => (ty -> Bool) -> Block ty -> (Block ty, Block ty)

elem :: PrimType ty => ty -> Block ty -> Bool

all :: PrimType ty => (ty -> Bool) -> Block ty -> Bool

any :: PrimType ty => (ty -> Bool) -> Block ty -> Bool

find :: PrimType ty => (ty -> Bool) -> Block ty -> Maybe ty

filter :: PrimType ty => (ty -> Bool) -> Block ty -> Block ty

reverse :: forall ty. PrimType ty => Block ty -> Block ty

sortBy :: forall ty. PrimType ty => (ty -> ty -> Ordering) -> Block ty -> Block ty

intersperse :: forall ty. PrimType ty => ty -> Block ty -> Block ty

Foreign interfaces

unsafeCopyToPtr

Arguments

:: PrimMonad prim

=> Block ty

the source block to copy

-> Ptr ty

The destination address where the copy is going to start

-> prim ()

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