Data.Massiv.Array.Manifest

Manifest

class Source r ix e => Manifest r ix e

Manifest arrays are backed by actual memory and values are looked up versus computed as it is with delayed arrays. Because of this fact indexing functions (!), (!?), etc. are constrained to manifest arrays only.

Minimal complete definition

unsafeLinearIndexM

Instances

Index ix => Manifest M ix e

Methods

unsafeLinearIndexM :: Array M ix e -> Int -> e

(Unbox e, Index ix) => Manifest U ix e

Methods

unsafeLinearIndexM :: Array U ix e -> Int -> e

(Index ix, Storable e) => Manifest S ix e

Methods

unsafeLinearIndexM :: Array S ix e -> Int -> e

(Index ix, Prim e) => Manifest P ix e

Methods

unsafeLinearIndexM :: Array P ix e -> Int -> e

(Index ix, NFData e) => Manifest N ix e

Methods

unsafeLinearIndexM :: Array N ix e -> Int -> e

Index ix => Manifest B ix e

Methods

unsafeLinearIndexM :: Array B ix e -> Int -> e

toManifest :: Manifest r ix e => Array r ix e -> Array M ix e

O(1) - Conversion of Manifest arrays to M representation.

data M

General Manifest representation

Instances

Index ix => Manifest M ix e

Methods

unsafeLinearIndexM :: Array M ix e -> Int -> e

(Index ix, Index (Lower ix), (~) * (Elt M ix e) (Array M (Lower ix) e)) => Slice M ix e

Methods

unsafeSlice :: Array M ix e -> ix -> ix -> Dim -> Maybe (Elt M ix e)

Slice M Ix1 e

Methods

unsafeSlice :: Array M Ix1 e -> Ix1 -> Ix1 -> Dim -> Maybe (Elt M Ix1 e)

((~) * (Elt M ix e) (Array M (Lower ix) e), Index ix, Index (Lower ix)) => InnerSlice M ix e

Methods

unsafeInnerSlice :: Array M ix e -> (Lower ix, Int) -> Int -> Elt M ix e

InnerSlice M Ix1 e

Methods

unsafeInnerSlice :: Array M Ix1 e -> (Lower Ix1, Int) -> Int -> Elt M Ix1 e

((~) * (Elt M ix e) (Array M (Lower ix) e), Index ix, Index (Lower ix)) => OuterSlice M ix e

Methods

unsafeOuterSlice :: Array M ix e -> Int -> Elt M ix e

outerLength :: Array M ix e -> Int

OuterSlice M Ix1 e

Methods

unsafeOuterSlice :: Array M Ix1 e -> Int -> Elt M Ix1 e

outerLength :: Array M Ix1 e -> Int

Index ix => Load M ix e

Methods

loadS :: Monad m => Array M ix e -> (Int -> m e) -> (Int -> e -> m ()) -> m ()

loadP :: [Int] -> Array M ix e -> (Int -> IO e) -> (Int -> e -> IO ()) -> IO ()

Index ix => Source M ix e

Methods

unsafeIndex :: Array M ix e -> ix -> e

unsafeLinearIndex :: Array M ix e -> Int -> e

Index ix => Size M ix e

Methods

size :: Array M ix e -> ix

unsafeResize :: Index ix' => ix' -> Array M ix e -> Array M ix' e

unsafeExtract :: ix -> ix -> Array M ix e -> Array (EltRepr M ix) ix e

Index ix => Construct M ix e

Methods

getComp :: Array M ix e -> Comp

setComp :: Comp -> Array M ix e -> Array M ix e

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array M ix e

Index ix => Foldable (Array M ix)

Row-major sequential folding over a Manifest array.

Methods

fold :: Monoid m => Array M ix m -> m

foldMap :: Monoid m => (a -> m) -> Array M ix a -> m

foldr :: (a -> b -> b) -> b -> Array M ix a -> b

foldr' :: (a -> b -> b) -> b -> Array M ix a -> b

foldl :: (b -> a -> b) -> b -> Array M ix a -> b

foldl' :: (b -> a -> b) -> b -> Array M ix a -> b

foldr1 :: (a -> a -> a) -> Array M ix a -> a

foldl1 :: (a -> a -> a) -> Array M ix a -> a

toList :: Array M ix a -> [a]

null :: Array M ix a -> Bool

length :: Array M ix a -> Int

elem :: Eq a => a -> Array M ix a -> Bool

maximum :: Ord a => Array M ix a -> a

minimum :: Ord a => Array M ix a -> a

sum :: Num a => Array M ix a -> a

product :: Num a => Array M ix a -> a

data Array M

data Array M = MArray {

• mComp :: !Comp
• mSize :: !ix
• mUnsafeLinearIndex :: Int -> e

}

type EltRepr M ix

type EltRepr M ix = M

Boxed

data B

Array representation for Boxed elements. This structure is element and spine strict, but elements are strict to Weak Head Normal Form (WHNF) only.

Constructors

B

Instances

Show B

Methods

showsPrec :: Int -> B -> ShowS

show :: B -> String

showList :: [B] -> ShowS

Index ix => Mutable B ix e

Associated Types

data MArray s B ix e :: *

Methods

msize :: MArray s B ix e -> ix

unsafeThaw :: PrimMonad m => Array B ix e -> m (MArray (PrimState m) B ix e)

unsafeFreeze :: PrimMonad m => Comp -> MArray (PrimState m) B ix e -> m (Array B ix e)

unsafeNew :: PrimMonad m => ix -> m (MArray (PrimState m) B ix e)

unsafeNewZero :: PrimMonad m => ix -> m (MArray (PrimState m) B ix e)

unsafeLinearRead :: PrimMonad m => MArray (PrimState m) B ix e -> Int -> m e

unsafeLinearWrite :: PrimMonad m => MArray (PrimState m) B ix e -> Int -> e -> m ()

unsafeNewA :: Applicative f => ix -> WorldState -> f (WorldState, MArray RealWorld B ix e)

unsafeThawA :: Applicative m => Array B ix e -> WorldState -> m (WorldState, MArray RealWorld B ix e)

unsafeFreezeA :: Applicative m => Comp -> MArray RealWorld B ix e -> WorldState -> m (WorldState, Array B ix e)

unsafeLinearWriteA :: Applicative m => MArray RealWorld B ix e -> Int -> e -> WorldState -> m WorldState

Index ix => Manifest B ix e

Methods

unsafeLinearIndexM :: Array B ix e -> Int -> e

(NFData e, Index ix, Index (Lower ix), (~) * (Elt M ix e) (Array M (Lower ix) e), (~) * (Elt B ix e) (Array M (Lower ix) e)) => InnerSlice B ix e

Methods

unsafeInnerSlice :: Array B ix e -> (Lower ix, Int) -> Int -> Elt B ix e

(NFData e, Index ix, Index (Lower ix), (~) * (Elt M ix e) (Array M (Lower ix) e), (~) * (Elt B ix e) (Array M (Lower ix) e)) => OuterSlice B ix e

Methods

unsafeOuterSlice :: Array B ix e -> Int -> Elt B ix e

outerLength :: Array B ix e -> Int

Index ix => Source B ix e

Methods

unsafeIndex :: Array B ix e -> ix -> e

unsafeLinearIndex :: Array B ix e -> Int -> e

Index ix => Size B ix e

Methods

size :: Array B ix e -> ix

unsafeResize :: Index ix' => ix' -> Array B ix e -> Array B ix' e

unsafeExtract :: ix -> ix -> Array B ix e -> Array (EltRepr B ix) ix e

Index ix => Construct B ix e

Methods

getComp :: Array B ix e -> Comp

setComp :: Comp -> Array B ix e -> Array B ix e

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array B ix e

Index ix => Foldable (Array B ix)

Row-major sequential folding over a Boxed array.

Methods

fold :: Monoid m => Array B ix m -> m

foldMap :: Monoid m => (a -> m) -> Array B ix a -> m

foldr :: (a -> b -> b) -> b -> Array B ix a -> b

foldr' :: (a -> b -> b) -> b -> Array B ix a -> b

foldl :: (b -> a -> b) -> b -> Array B ix a -> b

foldl' :: (b -> a -> b) -> b -> Array B ix a -> b

foldr1 :: (a -> a -> a) -> Array B ix a -> a

foldl1 :: (a -> a -> a) -> Array B ix a -> a

toList :: Array B ix a -> [a]

null :: Array B ix a -> Bool

length :: Array B ix a -> Int

elem :: Eq a => a -> Array B ix a -> Bool

maximum :: Ord a => Array B ix a -> a

minimum :: Ord a => Array B ix a -> a

sum :: Num a => Array B ix a -> a

product :: Num a => Array B ix a -> a

(IsList (Array L ix e), Nested LN ix e, Nested L ix e, Ragged L ix e) => IsList (Array B ix e)

Associated Types

type Item (Array B ix e) :: *

Methods

fromList :: [Item (Array B ix e)] -> Array B ix e

fromListN :: Int -> [Item (Array B ix e)] -> Array B ix e

toList :: Array B ix e -> [Item (Array B ix e)]

(Index ix, Eq e) => Eq (Array B ix e)

Methods

(==) :: Array B ix e -> Array B ix e -> Bool

(/=) :: Array B ix e -> Array B ix e -> Bool

(Index ix, Ord e) => Ord (Array B ix e)

Methods

compare :: Array B ix e -> Array B ix e -> Ordering

(<) :: Array B ix e -> Array B ix e -> Bool

(<=) :: Array B ix e -> Array B ix e -> Bool

(>) :: Array B ix e -> Array B ix e -> Bool

(>=) :: Array B ix e -> Array B ix e -> Bool

max :: Array B ix e -> Array B ix e -> Array B ix e

min :: Array B ix e -> Array B ix e -> Array B ix e

(Index ix, NFData e) => NFData (Array B ix e)

Methods

rnf :: Array B ix e -> ()

data Array B

data Array B = BArray {

• bComp :: !Comp
• bSize :: !ix
• bData :: !(Array e)

}

type VRepr B

type VRepr B = Vector

data MArray s B

data MArray s B = MBArray !ix !(MutableArray s e)

type EltRepr B ix

type EltRepr B ix = M

type Item (Array B ix e)

type Item (Array B ix e) = Item (Array L ix e)

data N

Array representation for Boxed elements. This structure is element and spine strict, and elements are always in Normal Form (NF), therefore NFData instance is required.

Constructors

N

Instances

Show N

Methods

showsPrec :: Int -> N -> ShowS

show :: N -> String

showList :: [N] -> ShowS

(Index ix, NFData e) => Mutable N ix e

Associated Types

data MArray s N ix e :: *

Methods

msize :: MArray s N ix e -> ix

unsafeThaw :: PrimMonad m => Array N ix e -> m (MArray (PrimState m) N ix e)

unsafeFreeze :: PrimMonad m => Comp -> MArray (PrimState m) N ix e -> m (Array N ix e)

unsafeNew :: PrimMonad m => ix -> m (MArray (PrimState m) N ix e)

unsafeNewZero :: PrimMonad m => ix -> m (MArray (PrimState m) N ix e)

unsafeLinearRead :: PrimMonad m => MArray (PrimState m) N ix e -> Int -> m e

unsafeLinearWrite :: PrimMonad m => MArray (PrimState m) N ix e -> Int -> e -> m ()

unsafeNewA :: Applicative f => ix -> WorldState -> f (WorldState, MArray RealWorld N ix e)

unsafeThawA :: Applicative m => Array N ix e -> WorldState -> m (WorldState, MArray RealWorld N ix e)

unsafeFreezeA :: Applicative m => Comp -> MArray RealWorld N ix e -> WorldState -> m (WorldState, Array N ix e)

unsafeLinearWriteA :: Applicative m => MArray RealWorld N ix e -> Int -> e -> WorldState -> m WorldState

(Index ix, NFData e) => Manifest N ix e

Methods

unsafeLinearIndexM :: Array N ix e -> Int -> e

(NFData e, Index ix, Index (Lower ix), (~) * (Elt M ix e) (Array M (Lower ix) e), (~) * (Elt N ix e) (Array M (Lower ix) e)) => InnerSlice N ix e

Methods

unsafeInnerSlice :: Array N ix e -> (Lower ix, Int) -> Int -> Elt N ix e

(NFData e, Index ix, Index (Lower ix), (~) * (Elt M ix e) (Array M (Lower ix) e), (~) * (Elt N ix e) (Array M (Lower ix) e)) => OuterSlice N ix e

Methods

unsafeOuterSlice :: Array N ix e -> Int -> Elt N ix e

outerLength :: Array N ix e -> Int

(Index ix, NFData e) => Source N ix e

Methods

unsafeIndex :: Array N ix e -> ix -> e

unsafeLinearIndex :: Array N ix e -> Int -> e

(Index ix, NFData e) => Size N ix e

Methods

size :: Array N ix e -> ix

unsafeResize :: Index ix' => ix' -> Array N ix e -> Array N ix' e

unsafeExtract :: ix -> ix -> Array N ix e -> Array (EltRepr N ix) ix e

(Index ix, NFData e) => Construct N ix e

Methods

getComp :: Array N ix e -> Comp

setComp :: Comp -> Array N ix e -> Array N ix e

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array N ix e

(NFData e, IsList (Array L ix e), Nested LN ix e, Nested L ix e, Ragged L ix e) => IsList (Array N ix e)

Associated Types

type Item (Array N ix e) :: *

Methods

fromList :: [Item (Array N ix e)] -> Array N ix e

fromListN :: Int -> [Item (Array N ix e)] -> Array N ix e

toList :: Array N ix e -> [Item (Array N ix e)]

(Index ix, NFData e, Eq e) => Eq (Array N ix e)

Methods

(==) :: Array N ix e -> Array N ix e -> Bool

(/=) :: Array N ix e -> Array N ix e -> Bool

(Index ix, NFData e, Ord e) => Ord (Array N ix e)

Methods

compare :: Array N ix e -> Array N ix e -> Ordering

(<) :: Array N ix e -> Array N ix e -> Bool

(<=) :: Array N ix e -> Array N ix e -> Bool

(>) :: Array N ix e -> Array N ix e -> Bool

(>=) :: Array N ix e -> Array N ix e -> Bool

max :: Array N ix e -> Array N ix e -> Array N ix e

min :: Array N ix e -> Array N ix e -> Array N ix e

(Index ix, NFData e) => NFData (Array N ix e)

Methods

rnf :: Array N ix e -> ()

data Array N

data Array N = NArray {

• nComp :: Comp
• nSize :: !ix
• nData :: !(Array e)

}

type VRepr N

type VRepr N = Vector

data MArray s N

data MArray s N = MNArray !ix !(MutableArray s e)

type EltRepr N ix

type EltRepr N ix = M

type Item (Array N ix e)

type Item (Array N ix e) = Item (Array L ix e)

Primitive

data P

Representation for Primitive elements

Constructors

P

Instances

Show P

Methods

showsPrec :: Int -> P -> ShowS

show :: P -> String

showList :: [P] -> ShowS

(Index ix, Prim e) => Mutable P ix e

Associated Types

data MArray s P ix e :: *

Methods

msize :: MArray s P ix e -> ix

unsafeThaw :: PrimMonad m => Array P ix e -> m (MArray (PrimState m) P ix e)

unsafeFreeze :: PrimMonad m => Comp -> MArray (PrimState m) P ix e -> m (Array P ix e)

unsafeNew :: PrimMonad m => ix -> m (MArray (PrimState m) P ix e)

unsafeNewZero :: PrimMonad m => ix -> m (MArray (PrimState m) P ix e)

unsafeLinearRead :: PrimMonad m => MArray (PrimState m) P ix e -> Int -> m e

unsafeLinearWrite :: PrimMonad m => MArray (PrimState m) P ix e -> Int -> e -> m ()

unsafeNewA :: Applicative f => ix -> WorldState -> f (WorldState, MArray RealWorld P ix e)

unsafeThawA :: Applicative m => Array P ix e -> WorldState -> m (WorldState, MArray RealWorld P ix e)

unsafeFreezeA :: Applicative m => Comp -> MArray RealWorld P ix e -> WorldState -> m (WorldState, Array P ix e)

unsafeLinearWriteA :: Applicative m => MArray RealWorld P ix e -> Int -> e -> WorldState -> m WorldState

(Index ix, Prim e) => Manifest P ix e

Methods

unsafeLinearIndexM :: Array P ix e -> Int -> e

(Prim e, Index ix, Index (Lower ix), (~) * (Elt P ix e) (Elt M ix e), (~) * (Elt M ix e) (Array M (Lower ix) e)) => Slice P ix e

Methods

unsafeSlice :: Array P ix e -> ix -> ix -> Dim -> Maybe (Elt P ix e)

Prim e => Slice P Ix1 e

Methods

unsafeSlice :: Array P Ix1 e -> Ix1 -> Ix1 -> Dim -> Maybe (Elt P Ix1 e)

(Prim e, Index ix, Index (Lower ix), (~) * (Elt M ix e) (Array M (Lower ix) e), (~) * (Elt P ix e) (Array M (Lower ix) e)) => InnerSlice P ix e

Methods

unsafeInnerSlice :: Array P ix e -> (Lower ix, Int) -> Int -> Elt P ix e

Prim e => InnerSlice P Ix1 e

Methods

unsafeInnerSlice :: Array P Ix1 e -> (Lower Ix1, Int) -> Int -> Elt P Ix1 e

(Prim e, Index ix, Index (Lower ix), (~) * (Elt M ix e) (Array M (Lower ix) e), (~) * (Elt P ix e) (Array M (Lower ix) e)) => OuterSlice P ix e

Methods

unsafeOuterSlice :: Array P ix e -> Int -> Elt P ix e

outerLength :: Array P ix e -> Int

Prim e => OuterSlice P Ix1 e

Methods

unsafeOuterSlice :: Array P Ix1 e -> Int -> Elt P Ix1 e

outerLength :: Array P Ix1 e -> Int

(Prim e, Index ix) => Source P ix e

Methods

unsafeIndex :: Array P ix e -> ix -> e

unsafeLinearIndex :: Array P ix e -> Int -> e

(Prim e, Index ix) => Size P ix e

Methods

size :: Array P ix e -> ix

unsafeResize :: Index ix' => ix' -> Array P ix e -> Array P ix' e

unsafeExtract :: ix -> ix -> Array P ix e -> Array (EltRepr P ix) ix e

(Prim e, Index ix) => Construct P ix e

Methods

getComp :: Array P ix e -> Comp

setComp :: Comp -> Array P ix e -> Array P ix e

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array P ix e

(Prim e, IsList (Array L ix e), Nested LN ix e, Nested L ix e, Ragged L ix e) => IsList (Array P ix e)

Associated Types

type Item (Array P ix e) :: *

Methods

fromList :: [Item (Array P ix e)] -> Array P ix e

fromListN :: Int -> [Item (Array P ix e)] -> Array P ix e

toList :: Array P ix e -> [Item (Array P ix e)]

(Prim e, Eq e, Index ix) => Eq (Array P ix e)

Methods

(==) :: Array P ix e -> Array P ix e -> Bool

(/=) :: Array P ix e -> Array P ix e -> Bool

(Prim e, Ord e, Index ix) => Ord (Array P ix e)

Methods

compare :: Array P ix e -> Array P ix e -> Ordering

(<) :: Array P ix e -> Array P ix e -> Bool

(<=) :: Array P ix e -> Array P ix e -> Bool

(>) :: Array P ix e -> Array P ix e -> Bool

(>=) :: Array P ix e -> Array P ix e -> Bool

max :: Array P ix e -> Array P ix e -> Array P ix e

min :: Array P ix e -> Array P ix e -> Array P ix e

(Index ix, NFData e) => NFData (Array P ix e)

Methods

rnf :: Array P ix e -> ()

data Array P

data Array P = PArray {

• pComp :: !Comp
• pSize :: !ix
• pData :: !ByteArray

}

type VRepr P

type VRepr P = Vector

data MArray s P

data MArray s P = MPArray !ix !(MutableByteArray s)

type EltRepr P ix

type EltRepr P ix = M

type Item (Array P ix e)

type Item (Array P ix e) = Item (Array L ix e)

class Prim a

Class of types supporting primitive array operations

Minimal complete definition

sizeOf#, alignment#, indexByteArray#, readByteArray#, writeByteArray#, setByteArray#, indexOffAddr#, readOffAddr#, writeOffAddr#, setOffAddr#

Instances

Prim Char

Methods

sizeOf# :: Char -> Int#

alignment# :: Char -> Int#

indexByteArray# :: ByteArray# -> Int# -> Char

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Char#)

writeByteArray# :: MutableByteArray# s -> Int# -> Char -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Char -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Char

readOffAddr# :: Addr# -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Char#)

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

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

Prim Double

Methods

sizeOf# :: Double -> Int#

alignment# :: Double -> Int#

indexByteArray# :: ByteArray# -> Int# -> Double

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Double#)

writeByteArray# :: MutableByteArray# s -> Int# -> Double -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Double -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Double

readOffAddr# :: Addr# -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Double#)

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

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

Prim Float

Methods

sizeOf# :: Float -> Int#

alignment# :: Float -> Int#

indexByteArray# :: ByteArray# -> Int# -> Float

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Float#)

writeByteArray# :: MutableByteArray# s -> Int# -> Float -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Float -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Float

readOffAddr# :: Addr# -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Float#)

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

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

Prim Int

Methods

sizeOf# :: Int -> Int#

alignment# :: Int -> Int#

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

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int#)

writeByteArray# :: MutableByteArray# s -> Int# -> Int -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int -> State# s -> State# s

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

readOffAddr# :: Addr# -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int#)

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

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

Prim Int8

Methods

sizeOf# :: Int8 -> Int#

alignment# :: Int8 -> Int#

indexByteArray# :: ByteArray# -> Int# -> Int8

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int8#)

writeByteArray# :: MutableByteArray# s -> Int# -> Int8 -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int8 -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Int8

readOffAddr# :: Addr# -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int8#)

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

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

Prim Int16

Methods

sizeOf# :: Int16 -> Int#

alignment# :: Int16 -> Int#

indexByteArray# :: ByteArray# -> Int# -> Int16

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int16#)

writeByteArray# :: MutableByteArray# s -> Int# -> Int16 -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int16 -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Int16

readOffAddr# :: Addr# -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int16#)

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

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

Prim Int32

Methods

sizeOf# :: Int32 -> Int#

alignment# :: Int32 -> Int#

indexByteArray# :: ByteArray# -> Int# -> Int32

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int32#)

writeByteArray# :: MutableByteArray# s -> Int# -> Int32 -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int32 -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Int32

readOffAddr# :: Addr# -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int32#)

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

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

Prim Int64

Methods

sizeOf# :: Int64 -> Int#

alignment# :: Int64 -> Int#

indexByteArray# :: ByteArray# -> Int# -> Int64

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int64#)

writeByteArray# :: MutableByteArray# s -> Int# -> Int64 -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Int64 -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Int64

readOffAddr# :: Addr# -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Int64#)

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

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

Prim Word

Methods

sizeOf# :: Word -> Int#

alignment# :: Word -> Int#

indexByteArray# :: ByteArray# -> Int# -> Word

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word#)

writeByteArray# :: MutableByteArray# s -> Int# -> Word -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Word

readOffAddr# :: Addr# -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word#)

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

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

Prim Word8

Methods

sizeOf# :: Word8 -> Int#

alignment# :: Word8 -> Int#

indexByteArray# :: ByteArray# -> Int# -> Word8

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word8#)

writeByteArray# :: MutableByteArray# s -> Int# -> Word8 -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word8 -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Word8

readOffAddr# :: Addr# -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word8#)

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

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

Prim Word16

Methods

sizeOf# :: Word16 -> Int#

alignment# :: Word16 -> Int#

indexByteArray# :: ByteArray# -> Int# -> Word16

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word16#)

writeByteArray# :: MutableByteArray# s -> Int# -> Word16 -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word16 -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Word16

readOffAddr# :: Addr# -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word16#)

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

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

Prim Word32

Methods

sizeOf# :: Word32 -> Int#

alignment# :: Word32 -> Int#

indexByteArray# :: ByteArray# -> Int# -> Word32

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word32#)

writeByteArray# :: MutableByteArray# s -> Int# -> Word32 -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word32 -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Word32

readOffAddr# :: Addr# -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word32#)

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

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

Prim Word64

Methods

sizeOf# :: Word64 -> Int#

alignment# :: Word64 -> Int#

indexByteArray# :: ByteArray# -> Int# -> Word64

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word64#)

writeByteArray# :: MutableByteArray# s -> Int# -> Word64 -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Word64 -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Word64

readOffAddr# :: Addr# -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Word64#)

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

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

Prim Addr

Methods

sizeOf# :: Addr -> Int#

alignment# :: Addr -> Int#

indexByteArray# :: ByteArray# -> Int# -> Addr

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Addr#)

writeByteArray# :: MutableByteArray# s -> Int# -> Addr -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Addr -> State# s -> State# s

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

readOffAddr# :: Addr# -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Addr#)

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

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

Prim (Ptr a)

Methods

sizeOf# :: Ptr a -> Int#

alignment# :: Ptr a -> Int#

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

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Ptr a#)

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

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

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

readOffAddr# :: Addr# -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Ptr a#)

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

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

Prim (FunPtr a)

Methods

sizeOf# :: FunPtr a -> Int#

alignment# :: FunPtr a -> Int#

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

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, FunPtr a#)

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

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

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

readOffAddr# :: Addr# -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, FunPtr a#)

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

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

Storable

data S

Representation for Storable elements

Constructors

S

Instances

Show S

Methods

showsPrec :: Int -> S -> ShowS

show :: S -> String

showList :: [S] -> ShowS

(Index ix, Storable e) => Mutable S ix e

Associated Types

data MArray s S ix e :: *

Methods

msize :: MArray s S ix e -> ix

unsafeThaw :: PrimMonad m => Array S ix e -> m (MArray (PrimState m) S ix e)

unsafeFreeze :: PrimMonad m => Comp -> MArray (PrimState m) S ix e -> m (Array S ix e)

unsafeNew :: PrimMonad m => ix -> m (MArray (PrimState m) S ix e)

unsafeNewZero :: PrimMonad m => ix -> m (MArray (PrimState m) S ix e)

unsafeLinearRead :: PrimMonad m => MArray (PrimState m) S ix e -> Int -> m e

unsafeLinearWrite :: PrimMonad m => MArray (PrimState m) S ix e -> Int -> e -> m ()

unsafeNewA :: Applicative f => ix -> WorldState -> f (WorldState, MArray RealWorld S ix e)

unsafeThawA :: Applicative m => Array S ix e -> WorldState -> m (WorldState, MArray RealWorld S ix e)

unsafeFreezeA :: Applicative m => Comp -> MArray RealWorld S ix e -> WorldState -> m (WorldState, Array S ix e)

unsafeLinearWriteA :: Applicative m => MArray RealWorld S ix e -> Int -> e -> WorldState -> m WorldState

(Index ix, Storable e) => Manifest S ix e

Methods

unsafeLinearIndexM :: Array S ix e -> Int -> e

(Storable e, Index ix, Index (Lower ix), (~) * (Elt M ix e) (Array M (Lower ix) e), (~) * (Elt S ix e) (Array M (Lower ix) e)) => InnerSlice S ix e

Methods

unsafeInnerSlice :: Array S ix e -> (Lower ix, Int) -> Int -> Elt S ix e

(Storable e, Index ix, Index (Lower ix), (~) * (Elt M ix e) (Array M (Lower ix) e), (~) * (Elt S ix e) (Array M (Lower ix) e)) => OuterSlice S ix e

Methods

unsafeOuterSlice :: Array S ix e -> Int -> Elt S ix e

outerLength :: Array S ix e -> Int

(Storable e, Index ix) => Source S ix e

Methods

unsafeIndex :: Array S ix e -> ix -> e

unsafeLinearIndex :: Array S ix e -> Int -> e

(Storable e, Index ix) => Size S ix e

Methods

size :: Array S ix e -> ix

unsafeResize :: Index ix' => ix' -> Array S ix e -> Array S ix' e

unsafeExtract :: ix -> ix -> Array S ix e -> Array (EltRepr S ix) ix e

(Storable e, Index ix) => Construct S ix e

Methods

getComp :: Array S ix e -> Comp

setComp :: Comp -> Array S ix e -> Array S ix e

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array S ix e

(Storable e, IsList (Array L ix e), Nested LN ix e, Nested L ix e, Ragged L ix e) => IsList (Array S ix e)

Associated Types

type Item (Array S ix e) :: *

Methods

fromList :: [Item (Array S ix e)] -> Array S ix e

fromListN :: Int -> [Item (Array S ix e)] -> Array S ix e

toList :: Array S ix e -> [Item (Array S ix e)]

(Storable e, Eq e, Index ix) => Eq (Array S ix e)

Methods

(==) :: Array S ix e -> Array S ix e -> Bool

(/=) :: Array S ix e -> Array S ix e -> Bool

(Storable e, Ord e, Index ix) => Ord (Array S ix e)

Methods

compare :: Array S ix e -> Array S ix e -> Ordering

(<) :: Array S ix e -> Array S ix e -> Bool

(<=) :: Array S ix e -> Array S ix e -> Bool

(>) :: Array S ix e -> Array S ix e -> Bool

(>=) :: Array S ix e -> Array S ix e -> Bool

max :: Array S ix e -> Array S ix e -> Array S ix e

min :: Array S ix e -> Array S ix e -> Array S ix e

(Index ix, NFData e) => NFData (Array S ix e)

Methods

rnf :: Array S ix e -> ()

data Array S

data Array S = SArray {

• sComp :: !Comp
• sSize :: !ix
• sData :: !(Vector e)

}

type VRepr S

type VRepr S = Vector

data MArray s S

data MArray s S = MSArray !ix !(MVector s e)

type EltRepr S ix

type EltRepr S ix = M

type Item (Array S ix e)

type Item (Array S ix e) = Item (Array L ix e)

class Storable a

The member functions of this class facilitate writing values of primitive types to raw memory (which may have been allocated with the above mentioned routines) and reading values from blocks of raw memory. The class, furthermore, includes support for computing the storage requirements and alignment restrictions of storable types.

Memory addresses are represented as values of type Ptr a, for some a which is an instance of class Storable. The type argument to Ptr helps provide some valuable type safety in FFI code (you can't mix pointers of different types without an explicit cast), while helping the Haskell type system figure out which marshalling method is needed for a given pointer.

All marshalling between Haskell and a foreign language ultimately boils down to translating Haskell data structures into the binary representation of a corresponding data structure of the foreign language and vice versa. To code this marshalling in Haskell, it is necessary to manipulate primitive data types stored in unstructured memory blocks. The class Storable facilitates this manipulation on all types for which it is instantiated, which are the standard basic types of Haskell, the fixed size Int types (Int8, Int16, Int32, Int64), the fixed size Word types (Word8, Word16, Word32, Word64), StablePtr, all types from Foreign.C.Types, as well as Ptr.

Minimal complete definition

sizeOf, alignment, (peek | peekElemOff | peekByteOff), (poke | pokeElemOff | pokeByteOff)

Instances

Storable Bool

Since: 2.1

Methods

sizeOf :: Bool -> Int

alignment :: Bool -> Int

peekElemOff :: Ptr Bool -> Int -> IO Bool

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

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

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

peek :: Ptr Bool -> IO Bool

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

Storable Char

Since: 2.1

Methods

sizeOf :: Char -> Int

alignment :: Char -> Int

peekElemOff :: Ptr Char -> Int -> IO Char

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

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

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

peek :: Ptr Char -> IO Char

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

Storable Double

Since: 2.1

Methods

sizeOf :: Double -> Int

alignment :: Double -> Int

peekElemOff :: Ptr Double -> Int -> IO Double

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

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

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

peek :: Ptr Double -> IO Double

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

Storable Float

Since: 2.1

Methods

sizeOf :: Float -> Int

alignment :: Float -> Int

peekElemOff :: Ptr Float -> Int -> IO Float

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

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

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

peek :: Ptr Float -> IO Float

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

Storable Int

Since: 2.1

Methods

sizeOf :: Int -> Int

alignment :: Int -> Int

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

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

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

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

peek :: Ptr Int -> IO Int

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

Storable Int8

Since: 2.1

Methods

sizeOf :: Int8 -> Int

alignment :: Int8 -> Int

peekElemOff :: Ptr Int8 -> Int -> IO Int8

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

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

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

peek :: Ptr Int8 -> IO Int8

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

Storable Int16

Since: 2.1

Methods

sizeOf :: Int16 -> Int

alignment :: Int16 -> Int

peekElemOff :: Ptr Int16 -> Int -> IO Int16

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

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

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

peek :: Ptr Int16 -> IO Int16

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

Storable Int32

Since: 2.1

Methods

sizeOf :: Int32 -> Int

alignment :: Int32 -> Int

peekElemOff :: Ptr Int32 -> Int -> IO Int32

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

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

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

peek :: Ptr Int32 -> IO Int32

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

Storable Int64

Since: 2.1

Methods

sizeOf :: Int64 -> Int

alignment :: Int64 -> Int

peekElemOff :: Ptr Int64 -> Int -> IO Int64

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

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

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

peek :: Ptr Int64 -> IO Int64

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

Storable Word

Since: 2.1

Methods

sizeOf :: Word -> Int

alignment :: Word -> Int

peekElemOff :: Ptr Word -> Int -> IO Word

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

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

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

peek :: Ptr Word -> IO Word

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

Storable Word8

Since: 2.1

Methods

sizeOf :: Word8 -> Int

alignment :: Word8 -> Int

peekElemOff :: Ptr Word8 -> Int -> IO Word8

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

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

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

peek :: Ptr Word8 -> IO Word8

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

Storable Word16

Since: 2.1

Methods

sizeOf :: Word16 -> Int

alignment :: Word16 -> Int

peekElemOff :: Ptr Word16 -> Int -> IO Word16

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

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

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

peek :: Ptr Word16 -> IO Word16

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

Storable Word32

Since: 2.1

Methods

sizeOf :: Word32 -> Int

alignment :: Word32 -> Int

peekElemOff :: Ptr Word32 -> Int -> IO Word32

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

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

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

peek :: Ptr Word32 -> IO Word32

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

Storable Word64

Since: 2.1

Methods

sizeOf :: Word64 -> Int

alignment :: Word64 -> Int

peekElemOff :: Ptr Word64 -> Int -> IO Word64

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

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

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

peek :: Ptr Word64 -> IO Word64

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

Storable ()

Since: 4.9.0.0

Methods

sizeOf :: () -> Int

alignment :: () -> Int

peekElemOff :: Ptr () -> Int -> IO ()

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

peekByteOff :: Ptr b -> Int -> IO ()

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

peek :: Ptr () -> IO ()

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

Storable CChar

Methods

sizeOf :: CChar -> Int

alignment :: CChar -> Int

peekElemOff :: Ptr CChar -> Int -> IO CChar

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

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

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

peek :: Ptr CChar -> IO CChar

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

Storable CSChar

Methods

sizeOf :: CSChar -> Int

alignment :: CSChar -> Int

peekElemOff :: Ptr CSChar -> Int -> IO CSChar

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

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

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

peek :: Ptr CSChar -> IO CSChar

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

Storable CUChar

Methods

sizeOf :: CUChar -> Int

alignment :: CUChar -> Int

peekElemOff :: Ptr CUChar -> Int -> IO CUChar

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

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

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

peek :: Ptr CUChar -> IO CUChar

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

Storable CShort

Methods

sizeOf :: CShort -> Int

alignment :: CShort -> Int

peekElemOff :: Ptr CShort -> Int -> IO CShort

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

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

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

peek :: Ptr CShort -> IO CShort

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

Storable CUShort

Methods

sizeOf :: CUShort -> Int

alignment :: CUShort -> Int

peekElemOff :: Ptr CUShort -> Int -> IO CUShort

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

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

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

peek :: Ptr CUShort -> IO CUShort

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

Storable CInt

Methods

sizeOf :: CInt -> Int

alignment :: CInt -> Int

peekElemOff :: Ptr CInt -> Int -> IO CInt

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

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

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

peek :: Ptr CInt -> IO CInt

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

Storable CUInt

Methods

sizeOf :: CUInt -> Int

alignment :: CUInt -> Int

peekElemOff :: Ptr CUInt -> Int -> IO CUInt

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

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

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

peek :: Ptr CUInt -> IO CUInt

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

Storable CLong

Methods

sizeOf :: CLong -> Int

alignment :: CLong -> Int

peekElemOff :: Ptr CLong -> Int -> IO CLong

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

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

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

peek :: Ptr CLong -> IO CLong

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

Storable CULong

Methods

sizeOf :: CULong -> Int

alignment :: CULong -> Int

peekElemOff :: Ptr CULong -> Int -> IO CULong

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

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

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

peek :: Ptr CULong -> IO CULong

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

Storable CLLong

Methods

sizeOf :: CLLong -> Int

alignment :: CLLong -> Int

peekElemOff :: Ptr CLLong -> Int -> IO CLLong

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

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

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

peek :: Ptr CLLong -> IO CLLong

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

Storable CULLong

Methods

sizeOf :: CULLong -> Int

alignment :: CULLong -> Int

peekElemOff :: Ptr CULLong -> Int -> IO CULLong

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

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

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

peek :: Ptr CULLong -> IO CULLong

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

Storable CBool

Methods

sizeOf :: CBool -> Int

alignment :: CBool -> Int

peekElemOff :: Ptr CBool -> Int -> IO CBool

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

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

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

peek :: Ptr CBool -> IO CBool

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

Storable CFloat

Methods

sizeOf :: CFloat -> Int

alignment :: CFloat -> Int

peekElemOff :: Ptr CFloat -> Int -> IO CFloat

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

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

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

peek :: Ptr CFloat -> IO CFloat

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

Storable CDouble

Methods

sizeOf :: CDouble -> Int

alignment :: CDouble -> Int

peekElemOff :: Ptr CDouble -> Int -> IO CDouble

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

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

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

peek :: Ptr CDouble -> IO CDouble

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

Storable CPtrdiff

Methods

sizeOf :: CPtrdiff -> Int

alignment :: CPtrdiff -> Int

peekElemOff :: Ptr CPtrdiff -> Int -> IO CPtrdiff

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

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

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

peek :: Ptr CPtrdiff -> IO CPtrdiff

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

Storable CSize

Methods

sizeOf :: CSize -> Int

alignment :: CSize -> Int

peekElemOff :: Ptr CSize -> Int -> IO CSize

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

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

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

peek :: Ptr CSize -> IO CSize

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

Storable CWchar

Methods

sizeOf :: CWchar -> Int

alignment :: CWchar -> Int

peekElemOff :: Ptr CWchar -> Int -> IO CWchar

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

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

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

peek :: Ptr CWchar -> IO CWchar

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

Storable CSigAtomic

Methods

sizeOf :: CSigAtomic -> Int

alignment :: CSigAtomic -> Int

peekElemOff :: Ptr CSigAtomic -> Int -> IO CSigAtomic

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

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

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

peek :: Ptr CSigAtomic -> IO CSigAtomic

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

Storable CClock

Methods

sizeOf :: CClock -> Int

alignment :: CClock -> Int

peekElemOff :: Ptr CClock -> Int -> IO CClock

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

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

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

peek :: Ptr CClock -> IO CClock

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

Storable CTime

Methods

sizeOf :: CTime -> Int

alignment :: CTime -> Int

peekElemOff :: Ptr CTime -> Int -> IO CTime

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

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

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

peek :: Ptr CTime -> IO CTime

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

Storable CUSeconds

Methods

sizeOf :: CUSeconds -> Int

alignment :: CUSeconds -> Int

peekElemOff :: Ptr CUSeconds -> Int -> IO CUSeconds

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

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

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

peek :: Ptr CUSeconds -> IO CUSeconds

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

Storable CSUSeconds

Methods

sizeOf :: CSUSeconds -> Int

alignment :: CSUSeconds -> Int

peekElemOff :: Ptr CSUSeconds -> Int -> IO CSUSeconds

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

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

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

peek :: Ptr CSUSeconds -> IO CSUSeconds

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

Storable CIntPtr

Methods

sizeOf :: CIntPtr -> Int

alignment :: CIntPtr -> Int

peekElemOff :: Ptr CIntPtr -> Int -> IO CIntPtr

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

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

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

peek :: Ptr CIntPtr -> IO CIntPtr

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

Storable CUIntPtr

Methods

sizeOf :: CUIntPtr -> Int

alignment :: CUIntPtr -> Int

peekElemOff :: Ptr CUIntPtr -> Int -> IO CUIntPtr

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

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

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

peek :: Ptr CUIntPtr -> IO CUIntPtr

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

Storable CIntMax

Methods

sizeOf :: CIntMax -> Int

alignment :: CIntMax -> Int

peekElemOff :: Ptr CIntMax -> Int -> IO CIntMax

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

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

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

peek :: Ptr CIntMax -> IO CIntMax

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

Storable CUIntMax

Methods

sizeOf :: CUIntMax -> Int

alignment :: CUIntMax -> Int

peekElemOff :: Ptr CUIntMax -> Int -> IO CUIntMax

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

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

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

peek :: Ptr CUIntMax -> IO CUIntMax

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

Storable WordPtr

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 ()

Storable IntPtr

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 ()

Storable Fingerprint

Since: 4.4.0.0

Methods

sizeOf :: Fingerprint -> Int

alignment :: Fingerprint -> Int

peekElemOff :: Ptr Fingerprint -> Int -> IO Fingerprint

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

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

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

peek :: Ptr Fingerprint -> IO Fingerprint

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

(Storable a, Integral a) => Storable (Ratio a)

Since: 4.8.0.0

Methods

sizeOf :: Ratio a -> Int

alignment :: Ratio a -> Int

peekElemOff :: Ptr (Ratio a) -> Int -> IO (Ratio a)

pokeElemOff :: Ptr (Ratio a) -> Int -> Ratio a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Ratio a)

pokeByteOff :: Ptr b -> Int -> Ratio a -> IO ()

peek :: Ptr (Ratio a) -> IO (Ratio a)

poke :: Ptr (Ratio a) -> Ratio a -> IO ()

Storable (StablePtr a)

Since: 2.1

Methods

sizeOf :: StablePtr a -> Int

alignment :: StablePtr a -> Int

peekElemOff :: Ptr (StablePtr a) -> Int -> IO (StablePtr a)

pokeElemOff :: Ptr (StablePtr a) -> Int -> StablePtr a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (StablePtr a)

pokeByteOff :: Ptr b -> Int -> StablePtr a -> IO ()

peek :: Ptr (StablePtr a) -> IO (StablePtr a)

poke :: Ptr (StablePtr a) -> StablePtr a -> IO ()

Storable (Ptr a)

Since: 2.1

Methods

sizeOf :: Ptr a -> Int

alignment :: Ptr a -> Int

peekElemOff :: Ptr (Ptr a) -> Int -> IO (Ptr a)

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

peekByteOff :: Ptr b -> Int -> IO (Ptr a)

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

peek :: Ptr (Ptr a) -> IO (Ptr a)

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

Storable (FunPtr a)

Since: 2.1

Methods

sizeOf :: FunPtr a -> Int

alignment :: FunPtr a -> Int

peekElemOff :: Ptr (FunPtr a) -> Int -> IO (FunPtr a)

pokeElemOff :: Ptr (FunPtr a) -> Int -> FunPtr a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (FunPtr a)

pokeByteOff :: Ptr b -> Int -> FunPtr a -> IO ()

peek :: Ptr (FunPtr a) -> IO (FunPtr a)

poke :: Ptr (FunPtr a) -> FunPtr a -> IO ()

Storable a => Storable (Complex a)

Since: 4.8.0.0

Methods

sizeOf :: Complex a -> Int

alignment :: Complex a -> Int

peekElemOff :: Ptr (Complex a) -> Int -> IO (Complex a)

pokeElemOff :: Ptr (Complex a) -> Int -> Complex a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Complex a)

pokeByteOff :: Ptr b -> Int -> Complex a -> IO ()

peek :: Ptr (Complex a) -> IO (Complex a)

poke :: Ptr (Complex a) -> Complex a -> IO ()

Storable a => Storable (Identity a)

Methods

sizeOf :: Identity a -> Int

alignment :: Identity a -> Int

peekElemOff :: Ptr (Identity a) -> Int -> IO (Identity a)

pokeElemOff :: Ptr (Identity a) -> Int -> Identity a -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Identity a)

pokeByteOff :: Ptr b -> Int -> Identity a -> IO ()

peek :: Ptr (Identity a) -> IO (Identity a)

poke :: Ptr (Identity a) -> Identity a -> IO ()

Storable a => Storable (Const k a b)

Methods

sizeOf :: Const k a b -> Int

alignment :: Const k a b -> Int

peekElemOff :: Ptr (Const k a b) -> Int -> IO (Const k a b)

pokeElemOff :: Ptr (Const k a b) -> Int -> Const k a b -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Const k a b)

pokeByteOff :: Ptr b -> Int -> Const k a b -> IO ()

peek :: Ptr (Const k a b) -> IO (Const k a b)

poke :: Ptr (Const k a b) -> Const k a b -> IO ()

withPtr :: (Index ix, Storable a) => MArray RealWorld S ix a -> (Ptr a -> IO b) -> IO b

A pointer to the beginning of the mutable array.

Since: 0.1.3

unsafeWithPtr :: Storable a => Array S ix a -> (Ptr a -> IO b) -> IO b

A pointer to the beginning of originally created array, i.e. various index manipulation functions that do slicing, extracting, etc. have no affect on this pointer.

Since: 0.1.3

Unboxed

data U

Representation for Unboxed elements

Constructors

U

Instances

Show U

Methods

showsPrec :: Int -> U -> ShowS

show :: U -> String

showList :: [U] -> ShowS

(Unbox e, Index ix) => Mutable U ix e

Associated Types

data MArray s U ix e :: *

Methods

msize :: MArray s U ix e -> ix

unsafeThaw :: PrimMonad m => Array U ix e -> m (MArray (PrimState m) U ix e)

unsafeFreeze :: PrimMonad m => Comp -> MArray (PrimState m) U ix e -> m (Array U ix e)

unsafeNew :: PrimMonad m => ix -> m (MArray (PrimState m) U ix e)

unsafeNewZero :: PrimMonad m => ix -> m (MArray (PrimState m) U ix e)

unsafeLinearRead :: PrimMonad m => MArray (PrimState m) U ix e -> Int -> m e

unsafeLinearWrite :: PrimMonad m => MArray (PrimState m) U ix e -> Int -> e -> m ()

unsafeNewA :: Applicative f => ix -> WorldState -> f (WorldState, MArray RealWorld U ix e)

unsafeThawA :: Applicative m => Array U ix e -> WorldState -> m (WorldState, MArray RealWorld U ix e)

unsafeFreezeA :: Applicative m => Comp -> MArray RealWorld U ix e -> WorldState -> m (WorldState, Array U ix e)

unsafeLinearWriteA :: Applicative m => MArray RealWorld U ix e -> Int -> e -> WorldState -> m WorldState

(Unbox e, Index ix) => Manifest U ix e

Methods

unsafeLinearIndexM :: Array U ix e -> Int -> e

(Unbox e, Index ix, Index (Lower ix), (~) * (Elt U ix e) (Elt M ix e), (~) * (Elt M ix e) (Array M (Lower ix) e)) => Slice U ix e

Methods

unsafeSlice :: Array U ix e -> ix -> ix -> Dim -> Maybe (Elt U ix e)

Unbox e => Slice U Ix1 e

Methods

unsafeSlice :: Array U Ix1 e -> Ix1 -> Ix1 -> Dim -> Maybe (Elt U Ix1 e)

(Unbox e, Index ix, Index (Lower ix), (~) * (Elt U ix e) (Elt M ix e), (~) * (Elt M ix e) (Array M (Lower ix) e)) => InnerSlice U ix e

Methods

unsafeInnerSlice :: Array U ix e -> (Lower ix, Int) -> Int -> Elt U ix e

Unbox e => InnerSlice U Ix1 e

Methods

unsafeInnerSlice :: Array U Ix1 e -> (Lower Ix1, Int) -> Int -> Elt U Ix1 e

(Unbox e, Index ix, Index (Lower ix), (~) * (Elt U ix e) (Elt M ix e), (~) * (Elt M ix e) (Array M (Lower ix) e)) => OuterSlice U ix e

Methods

unsafeOuterSlice :: Array U ix e -> Int -> Elt U ix e

outerLength :: Array U ix e -> Int

Unbox e => OuterSlice U Ix1 e

Methods

unsafeOuterSlice :: Array U Ix1 e -> Int -> Elt U Ix1 e

outerLength :: Array U Ix1 e -> Int

(Unbox e, Index ix) => Source U ix e

Methods

unsafeIndex :: Array U ix e -> ix -> e

unsafeLinearIndex :: Array U ix e -> Int -> e

(Unbox e, Index ix) => Size U ix e

Methods

size :: Array U ix e -> ix

unsafeResize :: Index ix' => ix' -> Array U ix e -> Array U ix' e

unsafeExtract :: ix -> ix -> Array U ix e -> Array (EltRepr U ix) ix e

(Unbox e, Index ix) => Construct U ix e

Methods

getComp :: Array U ix e -> Comp

setComp :: Comp -> Array U ix e -> Array U ix e

unsafeMakeArray :: Comp -> ix -> (ix -> e) -> Array U ix e

(Unbox e, IsList (Array L ix e), Nested LN ix e, Nested L ix e, Ragged L ix e) => IsList (Array U ix e)

Associated Types

type Item (Array U ix e) :: *

Methods

fromList :: [Item (Array U ix e)] -> Array U ix e

fromListN :: Int -> [Item (Array U ix e)] -> Array U ix e

toList :: Array U ix e -> [Item (Array U ix e)]

(Unbox e, Eq e, Index ix) => Eq (Array U ix e)

Methods

(==) :: Array U ix e -> Array U ix e -> Bool

(/=) :: Array U ix e -> Array U ix e -> Bool

(Unbox e, Ord e, Index ix) => Ord (Array U ix e)

Methods

compare :: Array U ix e -> Array U ix e -> Ordering

(<) :: Array U ix e -> Array U ix e -> Bool

(<=) :: Array U ix e -> Array U ix e -> Bool

(>) :: Array U ix e -> Array U ix e -> Bool

(>=) :: Array U ix e -> Array U ix e -> Bool

max :: Array U ix e -> Array U ix e -> Array U ix e

min :: Array U ix e -> Array U ix e -> Array U ix e

(Index ix, NFData e) => NFData (Array U ix e)

Methods

rnf :: Array U ix e -> ()

data Array U

data Array U = UArray {

• uComp :: !Comp
• uSize :: !ix
• uData :: !(Vector e)

}

type VRepr U

type VRepr U = Vector

data MArray s U

data MArray s U = MUArray ix (MVector s e)

type EltRepr U ix

type EltRepr U ix = M

type Item (Array U ix e)

type Item (Array U ix e) = Item (Array L ix e)

class (Vector Vector a, MVector MVector a) => Unbox a

Instances

Unbox Bool

Unbox Char

Unbox Double

Unbox Float

Unbox Int

Unbox Int8

Unbox Int16

Unbox Int32

Unbox Int64

Unbox Word

Unbox Word8

Unbox Word16

Unbox Word32

Unbox Word64

Unbox ()

Unbox Ix2

Unboxing of a Ix2.

Unbox a => Unbox (Complex a)

((<=) 3 n, Unbox (Ix ((-) n 1))) => Unbox (IxN n)

Unboxing of a IxN.

(Unbox a, Unbox b) => Unbox (a, b)

(Unbox a, Unbox b, Unbox c) => Unbox (a, b, c)

(Unbox a, Unbox b, Unbox c, Unbox d) => Unbox (a, b, c, d)

(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Unbox (a, b, c, d, e)

(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Unbox (a, b, c, d, e, f)