Modulebasement-0.0.16Haskell2010

Basement.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
It's unpackable in any constructor
It uses unpinned memory by default

Contents

Properties
Lowlevel functions
safer api
Foreign interfaces

Synopsis

data Block
data MutableBlock
value length
value unsafeThaw
value unsafeFreeze
value unsafeIndex
value thaw
value freeze
value copy
value unsafeCast
value cast
value empty
value create
value isPinned
value isMutablePinned
value singleton
value replicate
value index
value map
value foldl'
value foldr
value foldl1'
value foldr1
value cons
value snoc
value uncons
value unsnoc
value sub
value splitAt
value revSplitAt
value splitOn
value break
value breakEnd
value span
value elem
value all
value any
value find
value filter
value reverse
value sortBy
value intersperse
value createFromPtr
value unsafeCopyToPtr
value withPtr

Packagebasement-0.0.16
Exports45
LanguageHaskell2010
LicenceBSD-3-Clause
SourceBlock.hs

datadata Block ty

Source#

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

Constructors

Block ByteArray#

Instances17IsList, Eq, Data, Ord, Show, Semigroup, …

PrimType ty => IsList (Block ty)Defined in basement-0.0.16 · Basement.Block.Base
(PrimType ty, Eq ty) => Eq (Block ty)Defined in basement-0.0.16 · Basement.Block.Base
Data ty => Data (Block ty)Defined in basement-0.0.16 · Basement.Block.Base
(PrimType ty, Ord ty) => Ord (Block ty)Defined in basement-0.0.16 · Basement.Block.Base
(PrimType ty, Show ty) => Show (Block ty)Defined in basement-0.0.16 · Basement.Block.Base
PrimType ty => Semigroup (Block ty)Defined in basement-0.0.16 · Basement.Block.Base
PrimType ty => Monoid (Block ty)Defined in basement-0.0.16 · Basement.Block.Base
NormalForm (Block ty)Defined in basement-0.0.16 · Basement.Block.Base
Indexable (Block Word8) Word64Defined in basement-0.0.16 · Basement.Block · orphan
PrimType ty => Indexable (Block ty) tyDefined in basement-0.0.16 · Basement.Block · orphan
Cast (Block a) (Block Word8)Defined in basement-0.0.16 · Basement.Cast
PrimType ty => From (Block ty) (UArray ty)Defined in basement-0.0.16 · Basement.From
PrimType ty => From (Array ty) (Block ty)Defined in basement-0.0.16 · Basement.From
PrimType ty => From (UArray ty) (Block ty)Defined in basement-0.0.16 · Basement.From
(NatWithinBound (CountOf ty) n, KnownNat n, PrimType ty) => TryFrom (Block ty) (BlockN n ty)Defined in basement-0.0.16 · Basement.From
From (BlockN n ty) (Block ty)Defined in basement-0.0.16 · Basement.From
type Item (Block ty) = tyDefined in basement-0.0.16 · Basement.Block.Base

datadata MutableBlock ty st

Source#

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

Constructors

MutableBlock (MutableByteArray# st)

Instances1RandomAccess

(PrimMonad prim, st ~ PrimState prim, PrimType ty) => RandomAccess (MutableBlock ty st) prim tyDefined in basement-0.0.16 · Basement.Block · orphan

Properties

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

Lowlevel functions

valueunsafeThaw

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

Source#

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

valueunsafeFreeze

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

Source#

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.

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

Source#

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.

valuethaw

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

Source#

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

valuefreeze

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

Source#

Freeze a MutableBlock into a Block, copying all the data

If the data is modified in the mutable block after this call, then the immutable Block resulting is not impacted.

valuecopy :: PrimType ty => Block ty -> Block ty

Source#

Copy every cells of an existing Block to a new Block

valueunsafeCast :: PrimType b => Block a -> Block b

Source#

Unsafely recast an UArray containing a to an UArray containing b

The offset and size are converted from units of a to units of b, but no check are performed to make sure this is compatible.

use cast if unsure.

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

Source#

Cast a Block of a to a Block of b

The requirement is that the size of type a need to be a multiple or dividend of the size of type b.

If this requirement is not met, the InvalidRecast exception is thrown

safer api

valueempty :: Block ty

Source#

Create an empty block of memory

valuecreate

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

Source#

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

valueisPinned :: Block ty -> PinnedStatus

valueisMutablePinned :: MutableBlock s ty -> PinnedStatus

valuesingleton :: PrimType ty => ty -> Block ty

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

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

Source#

Return the element at a specific index from an array.

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

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

Source#

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

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

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

valuefoldl1' :: PrimType ty => (ty -> ty -> ty) -> NonEmpty (Block ty) -> ty

valuefoldr1 :: PrimType ty => (ty -> ty -> ty) -> NonEmpty (Block ty) -> ty

valuecons :: PrimType ty => ty -> Block ty -> Block ty

valuesnoc :: PrimType ty => Block ty -> ty -> Block ty

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

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

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

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

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

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

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

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

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

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

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

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

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

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

valuereverse :: PrimType ty => Block ty -> Block ty

valuesortBy :: PrimType ty => (ty -> ty -> Ordering) -> Block ty -> Block ty

valueintersperse :: PrimType ty => ty -> Block ty -> Block ty

Foreign interfaces

valuecreateFromPtr :: PrimType ty => Ptr ty -> CountOf ty -> IO (Block ty)

Source#

Freeze a chunk of memory pointed, of specific size into a new unboxed array

valueunsafeCopyToPtr

:: PrimMonad prim
=> Block ty
the source block to copy
-> Ptr ty
The destination address where the copy is going to start
-> prim ()

Source#

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

valuewithPtr :: PrimMonad prim => Block ty -> (Ptr ty -> prim a) -> prim a

Source#

Get a Ptr pointing to the data in the Block.

Since a Block is immutable, this Ptr shouldn't be to use to modify the contents

If the Block is pinned, then its address is returned as is, however if it's unpinned, a pinned copy of the Block is made before getting the address.

Orphan instances

3 instances

Indexable (Block Word8) Word64
PrimType ty => Indexable (Block ty) ty
(PrimMonad prim, st ~ PrimState prim, PrimType ty) => RandomAccess (MutableBlock ty st) prim ty