{-# LANGUAGE CPP, DeriveDataTypeable, FlexibleInstances, MagicHash, MultiParamTypeClasses, ScopedTypeVariables #-}
module Data.Vector.Storable.Mutable(
MVector(..), IOVector, STVector, Storable,
length, null,
slice, init, tail, take, drop, splitAt,
unsafeSlice, unsafeInit, unsafeTail, unsafeTake, unsafeDrop,
overlaps,
new, unsafeNew, replicate, replicateM, clone,
grow, unsafeGrow,
clear,
read, write, modify, swap,
unsafeRead, unsafeWrite, unsafeModify, unsafeSwap,
set, copy, move, unsafeCopy, unsafeMove,
unsafeCast,
unsafeFromForeignPtr, unsafeFromForeignPtr0,
unsafeToForeignPtr, unsafeToForeignPtr0,
unsafeWith
) where
import Control.DeepSeq ( NFData(rnf)
#if MIN_VERSION_deepseq(1,4,3)
, NFData1(liftRnf)
#endif
)
import qualified Data.Vector.Generic.Mutable as G
import Data.Vector.Storable.Internal
import Foreign.Storable
import Foreign.ForeignPtr
#if __GLASGOW_HASKELL__ >= 706
import GHC.ForeignPtr (mallocPlainForeignPtrAlignedBytes)
#elif __GLASGOW_HASKELL__ >= 700
import Data.Primitive.ByteArray (MutableByteArray(..), newAlignedPinnedByteArray,
unsafeFreezeByteArray)
import GHC.Prim (byteArrayContents#, unsafeCoerce#)
import GHC.ForeignPtr
#endif
import GHC.Base ( Int(..) )
import Foreign.Ptr (castPtr,plusPtr)
import Foreign.Marshal.Array ( advancePtr, copyArray, moveArray )
import Control.Monad.Primitive
import Data.Primitive.Types (Prim)
import qualified Data.Primitive.Types as DPT
import GHC.Word (Word8, Word16, Word32, Word64)
import GHC.Ptr (Ptr(..))
import Prelude hiding ( length, null, replicate, reverse, map, read,
take, drop, splitAt, init, tail )
import Data.Typeable ( Typeable )
#define NOT_VECTOR_MODULE
#include "vector.h"
data MVector s a = MVector {-# UNPACK #-} !Int
{-# UNPACK #-} !(ForeignPtr a)
deriving ( Typeable )
type IOVector = MVector RealWorld
type STVector s = MVector s
instance NFData (MVector s a) where
rnf :: MVector s a -> ()
rnf (MVector _ _) = ()
#if MIN_VERSION_deepseq(1,4,3)
instance NFData1 (MVector s) where
liftRnf :: (a -> ()) -> MVector s a -> ()
liftRnf _ (MVector _ _) = ()
#endif
instance Storable a => G.MVector MVector a where
{-# INLINE basicLength #-}
basicLength :: MVector s a -> Int
basicLength (MVector n :: Int
n _) = Int
n
{-# INLINE basicUnsafeSlice #-}
basicUnsafeSlice :: Int -> Int -> MVector s a -> MVector s a
basicUnsafeSlice j :: Int
j m :: Int
m (MVector _ fp :: ForeignPtr a
fp) = Int -> ForeignPtr a -> MVector s a
forall s a. Int -> ForeignPtr a -> MVector s a
MVector Int
m ((Ptr a -> Ptr a) -> ForeignPtr a -> ForeignPtr a
forall a. (Ptr a -> Ptr a) -> ForeignPtr a -> ForeignPtr a
updPtr (Ptr a -> Int -> Ptr a
forall a. Storable a => Ptr a -> Int -> Ptr a
`advancePtr` Int
j) ForeignPtr a
fp)
{-# INLINE basicOverlaps #-}
basicOverlaps :: MVector s a -> MVector s a -> Bool
basicOverlaps (MVector m :: Int
m fp :: ForeignPtr a
fp) (MVector n :: Int
n fq :: ForeignPtr a
fq)
= Ptr a -> Ptr a -> Ptr a -> Bool
forall a. Ord a => a -> a -> a -> Bool
between Ptr a
p Ptr a
q (Ptr a
q Ptr a -> Int -> Ptr a
forall a. Storable a => Ptr a -> Int -> Ptr a
`advancePtr` Int
n) Bool -> Bool -> Bool
|| Ptr a -> Ptr a -> Ptr a -> Bool
forall a. Ord a => a -> a -> a -> Bool
between Ptr a
q Ptr a
p (Ptr a
p Ptr a -> Int -> Ptr a
forall a. Storable a => Ptr a -> Int -> Ptr a
`advancePtr` Int
m)
where
between :: a -> a -> a -> Bool
between x :: a
x y :: a
y z :: a
z = a
x a -> a -> Bool
forall a. Ord a => a -> a -> Bool
>= a
y Bool -> Bool -> Bool
&& a
x a -> a -> Bool
forall a. Ord a => a -> a -> Bool
< a
z
p :: Ptr a
p = ForeignPtr a -> Ptr a
forall a. ForeignPtr a -> Ptr a
getPtr ForeignPtr a
fp
q :: Ptr a
q = ForeignPtr a -> Ptr a
forall a. ForeignPtr a -> Ptr a
getPtr ForeignPtr a
fq
{-# INLINE basicUnsafeNew #-}
basicUnsafeNew :: Int -> m (MVector (PrimState m) a)
basicUnsafeNew n :: Int
n
| Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< 0 = [Char] -> m (MVector (PrimState m) a)
forall a. HasCallStack => [Char] -> a
error ([Char] -> m (MVector (PrimState m) a))
-> [Char] -> m (MVector (PrimState m) a)
forall a b. (a -> b) -> a -> b
$ "Storable.basicUnsafeNew: negative length: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
n
| Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
mx = [Char] -> m (MVector (PrimState m) a)
forall a. HasCallStack => [Char] -> a
error ([Char] -> m (MVector (PrimState m) a))
-> [Char] -> m (MVector (PrimState m) a)
forall a b. (a -> b) -> a -> b
$ "Storable.basicUnsafeNew: length too large: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
n
| Bool
otherwise = IO (MVector (PrimState m) a) -> m (MVector (PrimState m) a)
forall (m1 :: * -> *) (m2 :: * -> *) a.
(PrimBase m1, PrimMonad m2) =>
m1 a -> m2 a
unsafePrimToPrim (IO (MVector (PrimState m) a) -> m (MVector (PrimState m) a))
-> IO (MVector (PrimState m) a) -> m (MVector (PrimState m) a)
forall a b. (a -> b) -> a -> b
$ do
ForeignPtr a
fp <- Int -> IO (ForeignPtr a)
forall a. Storable a => Int -> IO (ForeignPtr a)
mallocVector Int
n
MVector (PrimState m) a -> IO (MVector (PrimState m) a)
forall (m :: * -> *) a. Monad m => a -> m a
return (MVector (PrimState m) a -> IO (MVector (PrimState m) a))
-> MVector (PrimState m) a -> IO (MVector (PrimState m) a)
forall a b. (a -> b) -> a -> b
$ Int -> ForeignPtr a -> MVector (PrimState m) a
forall s a. Int -> ForeignPtr a -> MVector s a
MVector Int
n ForeignPtr a
fp
where
size :: Int
size = a -> Int
forall a. Storable a => a -> Int
sizeOf (a
forall a. HasCallStack => a
undefined :: a) Int -> Int -> Int
forall a. Ord a => a -> a -> a
`max` 1
mx :: Int
mx = Int
forall a. Bounded a => a
maxBound Int -> Int -> Int
forall a. Integral a => a -> a -> a
`quot` Int
size :: Int
{-# INLINE basicInitialize #-}
basicInitialize :: MVector (PrimState m) a -> m ()
basicInitialize = MVector (PrimState m) a -> m ()
forall a (m :: * -> *).
(Storable a, PrimMonad m) =>
MVector (PrimState m) a -> m ()
storableZero
{-# INLINE basicUnsafeRead #-}
basicUnsafeRead :: MVector (PrimState m) a -> Int -> m a
basicUnsafeRead (MVector _ fp :: ForeignPtr a
fp) i :: Int
i
= IO a -> m a
forall (m1 :: * -> *) (m2 :: * -> *) a.
(PrimBase m1, PrimMonad m2) =>
m1 a -> m2 a
unsafePrimToPrim
(IO a -> m a) -> IO a -> m a
forall a b. (a -> b) -> a -> b
$ ForeignPtr a -> (Ptr a -> IO a) -> IO a
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr a
fp (Ptr a -> Int -> IO a
forall a. Storable a => Ptr a -> Int -> IO a
`peekElemOff` Int
i)
{-# INLINE basicUnsafeWrite #-}
basicUnsafeWrite :: MVector (PrimState m) a -> Int -> a -> m ()
basicUnsafeWrite (MVector _ fp :: ForeignPtr a
fp) i :: Int
i x :: a
x
= IO () -> m ()
forall (m1 :: * -> *) (m2 :: * -> *) a.
(PrimBase m1, PrimMonad m2) =>
m1 a -> m2 a
unsafePrimToPrim
(IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ForeignPtr a -> (Ptr a -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr a
fp ((Ptr a -> IO ()) -> IO ()) -> (Ptr a -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \p :: Ptr a
p -> Ptr a -> Int -> a -> IO ()
forall a. Storable a => Ptr a -> Int -> a -> IO ()
pokeElemOff Ptr a
p Int
i a
x
{-# INLINE basicSet #-}
basicSet :: MVector (PrimState m) a -> a -> m ()
basicSet = MVector (PrimState m) a -> a -> m ()
forall a (m :: * -> *).
(Storable a, PrimMonad m) =>
MVector (PrimState m) a -> a -> m ()
storableSet
{-# INLINE basicUnsafeCopy #-}
basicUnsafeCopy :: MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
basicUnsafeCopy (MVector n :: Int
n fp :: ForeignPtr a
fp) (MVector _ fq :: ForeignPtr a
fq)
= IO () -> m ()
forall (m1 :: * -> *) (m2 :: * -> *) a.
(PrimBase m1, PrimMonad m2) =>
m1 a -> m2 a
unsafePrimToPrim
(IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ForeignPtr a -> (Ptr a -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr a
fp ((Ptr a -> IO ()) -> IO ()) -> (Ptr a -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \p :: Ptr a
p ->
ForeignPtr a -> (Ptr a -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr a
fq ((Ptr a -> IO ()) -> IO ()) -> (Ptr a -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \q :: Ptr a
q ->
Ptr a -> Ptr a -> Int -> IO ()
forall a. Storable a => Ptr a -> Ptr a -> Int -> IO ()
copyArray Ptr a
p Ptr a
q Int
n
{-# INLINE basicUnsafeMove #-}
basicUnsafeMove :: MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
basicUnsafeMove (MVector n :: Int
n fp :: ForeignPtr a
fp) (MVector _ fq :: ForeignPtr a
fq)
= IO () -> m ()
forall (m1 :: * -> *) (m2 :: * -> *) a.
(PrimBase m1, PrimMonad m2) =>
m1 a -> m2 a
unsafePrimToPrim
(IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ ForeignPtr a -> (Ptr a -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr a
fp ((Ptr a -> IO ()) -> IO ()) -> (Ptr a -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \p :: Ptr a
p ->
ForeignPtr a -> (Ptr a -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr a
fq ((Ptr a -> IO ()) -> IO ()) -> (Ptr a -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \q :: Ptr a
q ->
Ptr a -> Ptr a -> Int -> IO ()
forall a. Storable a => Ptr a -> Ptr a -> Int -> IO ()
moveArray Ptr a
p Ptr a
q Int
n
storableZero :: forall a m. (Storable a, PrimMonad m) => MVector (PrimState m) a -> m ()
{-# INLINE storableZero #-}
storableZero :: MVector (PrimState m) a -> m ()
storableZero (MVector n :: Int
n fp :: ForeignPtr a
fp) = IO () -> m ()
forall (m1 :: * -> *) (m2 :: * -> *) a.
(PrimBase m1, PrimMonad m2) =>
m1 a -> m2 a
unsafePrimToPrim (IO () -> m ())
-> ((Ptr a -> IO ()) -> IO ()) -> (Ptr a -> IO ()) -> m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ForeignPtr a -> (Ptr a -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr a
fp ((Ptr a -> IO ()) -> m ()) -> (Ptr a -> IO ()) -> m ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr a
ptr-> do
Ptr Any -> Int -> Word8 -> IO ()
forall a c (m :: * -> *).
(Prim c, PrimMonad m) =>
Ptr a -> Int -> c -> m ()
memsetPrimPtr_vector (Ptr a -> Ptr Any
forall a b. Ptr a -> Ptr b
castPtr Ptr a
ptr) Int
byteSize (0 :: Word8)
where
x :: a
x :: a
x = a
forall a. HasCallStack => a
undefined
byteSize :: Int
byteSize :: Int
byteSize = Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
* a -> Int
forall a. Storable a => a -> Int
sizeOf a
x
storableSet :: (Storable a, PrimMonad m) => MVector (PrimState m) a -> a -> m ()
{-# INLINE storableSet #-}
storableSet :: MVector (PrimState m) a -> a -> m ()
storableSet (MVector n :: Int
n fp :: ForeignPtr a
fp) x :: a
x
| Int
n Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== 0 = () -> m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
| Bool
otherwise = IO () -> m ()
forall (m1 :: * -> *) (m2 :: * -> *) a.
(PrimBase m1, PrimMonad m2) =>
m1 a -> m2 a
unsafePrimToPrim (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$
case a -> Int
forall a. Storable a => a -> Int
sizeOf a
x of
1 -> Int -> ForeignPtr a -> a -> Word8 -> IO ()
forall a b.
(Storable a, Prim b) =>
Int -> ForeignPtr a -> a -> b -> IO ()
storableSetAsPrim Int
n ForeignPtr a
fp a
x (Word8
forall a. HasCallStack => a
undefined :: Word8)
2 -> Int -> ForeignPtr a -> a -> Word16 -> IO ()
forall a b.
(Storable a, Prim b) =>
Int -> ForeignPtr a -> a -> b -> IO ()
storableSetAsPrim Int
n ForeignPtr a
fp a
x (Word16
forall a. HasCallStack => a
undefined :: Word16)
4 -> Int -> ForeignPtr a -> a -> Word32 -> IO ()
forall a b.
(Storable a, Prim b) =>
Int -> ForeignPtr a -> a -> b -> IO ()
storableSetAsPrim Int
n ForeignPtr a
fp a
x (Word32
forall a. HasCallStack => a
undefined :: Word32)
8 -> Int -> ForeignPtr a -> a -> Word64 -> IO ()
forall a b.
(Storable a, Prim b) =>
Int -> ForeignPtr a -> a -> b -> IO ()
storableSetAsPrim Int
n ForeignPtr a
fp a
x (Word64
forall a. HasCallStack => a
undefined :: Word64)
_ -> ForeignPtr a -> (Ptr a -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr a
fp ((Ptr a -> IO ()) -> IO ()) -> (Ptr a -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \p :: Ptr a
p -> do
Ptr a -> a -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr a
p a
x
let do_set :: Int -> IO ()
do_set i :: Int
i
| 2Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
n = do
Ptr a -> Ptr a -> Int -> IO ()
forall a. Storable a => Ptr a -> Ptr a -> Int -> IO ()
copyArray (Ptr a
p Ptr a -> Int -> Ptr a
forall a. Storable a => Ptr a -> Int -> Ptr a
`advancePtr` Int
i) Ptr a
p Int
i
Int -> IO ()
do_set (2Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
i)
| Bool
otherwise = Ptr a -> Ptr a -> Int -> IO ()
forall a. Storable a => Ptr a -> Ptr a -> Int -> IO ()
copyArray (Ptr a
p Ptr a -> Int -> Ptr a
forall a. Storable a => Ptr a -> Int -> Ptr a
`advancePtr` Int
i) Ptr a
p (Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
i)
Int -> IO ()
do_set 1
storableSetAsPrim
:: forall a b . (Storable a, Prim b) => Int -> ForeignPtr a -> a -> b -> IO ()
{-# INLINE [0] storableSetAsPrim #-}
storableSetAsPrim :: Int -> ForeignPtr a -> a -> b -> IO ()
storableSetAsPrim n :: Int
n fp :: ForeignPtr a
fp x :: a
x _y :: b
_y = ForeignPtr a -> (Ptr a -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr a
fp ((Ptr a -> IO ()) -> IO ()) -> (Ptr a -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ ptr :: Ptr a
ptr -> do
Ptr a -> a -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr a
ptr a
x
b
w<- Ptr b -> Int -> IO b
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
Ptr a -> Int -> m a
peakPrimPtr_vector ((Ptr a -> Ptr b
forall a b. Ptr a -> Ptr b
castPtr Ptr a
ptr) :: Ptr b) 0
Ptr Any -> Int -> b -> IO ()
forall a c (m :: * -> *).
(Prim c, PrimMonad m) =>
Ptr a -> Int -> c -> m ()
memsetPrimPtr_vector ((Ptr a -> Ptr Any
forall a b. Ptr a -> Ptr b
castPtr Ptr a
ptr) Ptr Any -> Int -> Ptr Any
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` a -> Int
forall a. Storable a => a -> Int
sizeOf a
x ) (Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-1) b
w
memsetPrimPtr_vector :: forall a c m. (Prim c, PrimMonad m) => Ptr a -> Int -> c -> m ()
memsetPrimPtr_vector :: Ptr a -> Int -> c -> m ()
memsetPrimPtr_vector (Ptr addr# :: Addr#
addr#) (I# n# :: Int#
n#) x :: c
x = (State# (PrimState m) -> State# (PrimState m)) -> m ()
forall (m :: * -> *).
PrimMonad m =>
(State# (PrimState m) -> State# (PrimState m)) -> m ()
primitive_ (Addr#
-> Int#
-> Int#
-> c
-> State# (PrimState m)
-> State# (PrimState m)
forall a s.
Prim a =>
Addr# -> Int# -> Int# -> a -> State# s -> State# s
DPT.setOffAddr# Addr#
addr# 0# Int#
n# c
x)
{-# INLINE memsetPrimPtr_vector #-}
peakPrimPtr_vector :: (Prim a, PrimMonad m) => Ptr a -> Int -> m a
peakPrimPtr_vector :: Ptr a -> Int -> m a
peakPrimPtr_vector (Ptr addr# :: Addr#
addr#) (I# i# :: Int#
i#) = (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
forall (m :: * -> *) a.
PrimMonad m =>
(State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
primitive (Addr#
-> Int# -> State# (PrimState m) -> (# State# (PrimState m), a #)
forall a s.
Prim a =>
Addr# -> Int# -> State# s -> (# State# s, a #)
DPT.readOffAddr# Addr#
addr# Int#
i#)
{-# INLINE peakPrimPtr_vector #-}
{-# INLINE mallocVector #-}
mallocVector :: Storable a => Int -> IO (ForeignPtr a)
mallocVector :: Int -> IO (ForeignPtr a)
mallocVector =
#if __GLASGOW_HASKELL__ >= 706
a -> Int -> IO (ForeignPtr a)
forall b. Storable b => b -> Int -> IO (ForeignPtr b)
doMalloc a
forall a. HasCallStack => a
undefined
where
doMalloc :: Storable b => b -> Int -> IO (ForeignPtr b)
doMalloc :: b -> Int -> IO (ForeignPtr b)
doMalloc dummy :: b
dummy size :: Int
size =
Int -> Int -> IO (ForeignPtr b)
forall a. Int -> Int -> IO (ForeignPtr a)
mallocPlainForeignPtrAlignedBytes (Int
size Int -> Int -> Int
forall a. Num a => a -> a -> a
* b -> Int
forall a. Storable a => a -> Int
sizeOf b
dummy) (b -> Int
forall a. Storable a => a -> Int
alignment b
dummy)
#elif __GLASGOW_HASKELL__ >= 700
doMalloc undefined
where
doMalloc :: Storable b => b -> Int -> IO (ForeignPtr b)
doMalloc dummy size = do
arr@(MutableByteArray arr#) <- newAlignedPinnedByteArray arrSize arrAlign
newConcForeignPtr
(Ptr (byteArrayContents# (unsafeCoerce# arr#)))
(touch arr)
where
arrSize = size * sizeOf dummy
arrAlign = alignment dummy
#else
mallocForeignPtrArray
#endif
length :: Storable a => MVector s a -> Int
{-# INLINE length #-}
length :: MVector s a -> Int
length = MVector s a -> Int
forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int
G.length
null :: Storable a => MVector s a -> Bool
{-# INLINE null #-}
null :: MVector s a -> Bool
null = MVector s a -> Bool
forall (v :: * -> * -> *) a s. MVector v a => v s a -> Bool
G.null
slice :: Storable a
=> Int
-> Int
-> MVector s a
-> MVector s a
{-# INLINE slice #-}
slice :: Int -> Int -> MVector s a -> MVector s a
slice = Int -> Int -> MVector s a -> MVector s a
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> Int -> v s a -> v s a
G.slice
take :: Storable a => Int -> MVector s a -> MVector s a
{-# INLINE take #-}
take :: Int -> MVector s a -> MVector s a
take = Int -> MVector s a -> MVector s a
forall (v :: * -> * -> *) a s. MVector v a => Int -> v s a -> v s a
G.take
drop :: Storable a => Int -> MVector s a -> MVector s a
{-# INLINE drop #-}
drop :: Int -> MVector s a -> MVector s a
drop = Int -> MVector s a -> MVector s a
forall (v :: * -> * -> *) a s. MVector v a => Int -> v s a -> v s a
G.drop
splitAt :: Storable a => Int -> MVector s a -> (MVector s a, MVector s a)
{-# INLINE splitAt #-}
splitAt :: Int -> MVector s a -> (MVector s a, MVector s a)
splitAt = Int -> MVector s a -> (MVector s a, MVector s a)
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> v s a -> (v s a, v s a)
G.splitAt
init :: Storable a => MVector s a -> MVector s a
{-# INLINE init #-}
init :: MVector s a -> MVector s a
init = MVector s a -> MVector s a
forall (v :: * -> * -> *) a s. MVector v a => v s a -> v s a
G.init
tail :: Storable a => MVector s a -> MVector s a
{-# INLINE tail #-}
tail :: MVector s a -> MVector s a
tail = MVector s a -> MVector s a
forall (v :: * -> * -> *) a s. MVector v a => v s a -> v s a
G.tail
unsafeSlice :: Storable a
=> Int
-> Int
-> MVector s a
-> MVector s a
{-# INLINE unsafeSlice #-}
unsafeSlice :: Int -> Int -> MVector s a -> MVector s a
unsafeSlice = Int -> Int -> MVector s a -> MVector s a
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> Int -> v s a -> v s a
G.unsafeSlice
unsafeTake :: Storable a => Int -> MVector s a -> MVector s a
{-# INLINE unsafeTake #-}
unsafeTake :: Int -> MVector s a -> MVector s a
unsafeTake = Int -> MVector s a -> MVector s a
forall (v :: * -> * -> *) a s. MVector v a => Int -> v s a -> v s a
G.unsafeTake
unsafeDrop :: Storable a => Int -> MVector s a -> MVector s a
{-# INLINE unsafeDrop #-}
unsafeDrop :: Int -> MVector s a -> MVector s a
unsafeDrop = Int -> MVector s a -> MVector s a
forall (v :: * -> * -> *) a s. MVector v a => Int -> v s a -> v s a
G.unsafeDrop
unsafeInit :: Storable a => MVector s a -> MVector s a
{-# INLINE unsafeInit #-}
unsafeInit :: MVector s a -> MVector s a
unsafeInit = MVector s a -> MVector s a
forall (v :: * -> * -> *) a s. MVector v a => v s a -> v s a
G.unsafeInit
unsafeTail :: Storable a => MVector s a -> MVector s a
{-# INLINE unsafeTail #-}
unsafeTail :: MVector s a -> MVector s a
unsafeTail = MVector s a -> MVector s a
forall (v :: * -> * -> *) a s. MVector v a => v s a -> v s a
G.unsafeTail
overlaps :: Storable a => MVector s a -> MVector s a -> Bool
{-# INLINE overlaps #-}
overlaps :: MVector s a -> MVector s a -> Bool
overlaps = MVector s a -> MVector s a -> Bool
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> Bool
G.overlaps
new :: (PrimMonad m, Storable a) => Int -> m (MVector (PrimState m) a)
{-# INLINE new #-}
new :: Int -> m (MVector (PrimState m) a)
new = Int -> m (MVector (PrimState m) a)
forall (m :: * -> *) (v :: * -> * -> *) a.
(PrimMonad m, MVector v a) =>
Int -> m (v (PrimState m) a)
G.new
unsafeNew :: (PrimMonad m, Storable a) => Int -> m (MVector (PrimState m) a)
{-# INLINE unsafeNew #-}
unsafeNew :: Int -> m (MVector (PrimState m) a)
unsafeNew = Int -> m (MVector (PrimState m) a)
forall (m :: * -> *) (v :: * -> * -> *) a.
(PrimMonad m, MVector v a) =>
Int -> m (v (PrimState m) a)
G.unsafeNew
replicate :: (PrimMonad m, Storable a) => Int -> a -> m (MVector (PrimState m) a)
{-# INLINE replicate #-}
replicate :: Int -> a -> m (MVector (PrimState m) a)
replicate = Int -> a -> m (MVector (PrimState m) a)
forall (m :: * -> *) (v :: * -> * -> *) a.
(PrimMonad m, MVector v a) =>
Int -> a -> m (v (PrimState m) a)
G.replicate
replicateM :: (PrimMonad m, Storable a) => Int -> m a -> m (MVector (PrimState m) a)
{-# INLINE replicateM #-}
replicateM :: Int -> m a -> m (MVector (PrimState m) a)
replicateM = Int -> m a -> m (MVector (PrimState m) a)
forall (m :: * -> *) (v :: * -> * -> *) a.
(PrimMonad m, MVector v a) =>
Int -> m a -> m (v (PrimState m) a)
G.replicateM
clone :: (PrimMonad m, Storable a)
=> MVector (PrimState m) a -> m (MVector (PrimState m) a)
{-# INLINE clone #-}
clone :: MVector (PrimState m) a -> m (MVector (PrimState m) a)
clone = MVector (PrimState m) a -> m (MVector (PrimState m) a)
forall (m :: * -> *) (v :: * -> * -> *) a.
(PrimMonad m, MVector v a) =>
v (PrimState m) a -> m (v (PrimState m) a)
G.clone
grow :: (PrimMonad m, Storable a)
=> MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
{-# INLINE grow #-}
grow :: MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
grow = MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
forall (m :: * -> *) (v :: * -> * -> *) a.
(PrimMonad m, MVector v a) =>
v (PrimState m) a -> Int -> m (v (PrimState m) a)
G.grow
unsafeGrow :: (PrimMonad m, Storable a)
=> MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
{-# INLINE unsafeGrow #-}
unsafeGrow :: MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
unsafeGrow = MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
forall (m :: * -> *) (v :: * -> * -> *) a.
(PrimMonad m, MVector v a) =>
v (PrimState m) a -> Int -> m (v (PrimState m) a)
G.unsafeGrow
clear :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> m ()
{-# INLINE clear #-}
clear :: MVector (PrimState m) a -> m ()
clear = MVector (PrimState m) a -> m ()
forall (m :: * -> *) (v :: * -> * -> *) a.
(PrimMonad m, MVector v a) =>
v (PrimState m) a -> m ()
G.clear
read :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> m a
{-# INLINE read #-}
read :: MVector (PrimState m) a -> Int -> m a
read = MVector (PrimState m) a -> Int -> m a
forall (m :: * -> *) (v :: * -> * -> *) a.
(PrimMonad m, MVector v a) =>
v (PrimState m) a -> Int -> m a
G.read
write
:: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> a -> m ()
{-# INLINE write #-}
write :: MVector (PrimState m) a -> Int -> a -> m ()
write = MVector (PrimState m) a -> Int -> a -> m ()
forall (m :: * -> *) (v :: * -> * -> *) a.
(PrimMonad m, MVector v a) =>
v (PrimState m) a -> Int -> a -> m ()
G.write
modify :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> (a -> a) -> Int -> m ()
{-# INLINE modify #-}
modify :: MVector (PrimState m) a -> (a -> a) -> Int -> m ()
modify = MVector (PrimState m) a -> (a -> a) -> Int -> m ()
forall (m :: * -> *) (v :: * -> * -> *) a.
(PrimMonad m, MVector v a) =>
v (PrimState m) a -> (a -> a) -> Int -> m ()
G.modify
swap
:: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> Int -> m ()
{-# INLINE swap #-}
swap :: MVector (PrimState m) a -> Int -> Int -> m ()
swap = MVector (PrimState m) a -> Int -> Int -> m ()
forall (m :: * -> *) (v :: * -> * -> *) a.
(PrimMonad m, MVector v a) =>
v (PrimState m) a -> Int -> Int -> m ()
G.swap
unsafeRead :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> m a
{-# INLINE unsafeRead #-}
unsafeRead :: MVector (PrimState m) a -> Int -> m a
unsafeRead = MVector (PrimState m) a -> Int -> m a
forall (m :: * -> *) (v :: * -> * -> *) a.
(PrimMonad m, MVector v a) =>
v (PrimState m) a -> Int -> m a
G.unsafeRead
unsafeWrite
:: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> a -> m ()
{-# INLINE unsafeWrite #-}
unsafeWrite :: MVector (PrimState m) a -> Int -> a -> m ()
unsafeWrite = MVector (PrimState m) a -> Int -> a -> m ()
forall (m :: * -> *) (v :: * -> * -> *) a.
(PrimMonad m, MVector v a) =>
v (PrimState m) a -> Int -> a -> m ()
G.unsafeWrite
unsafeModify :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> (a -> a) -> Int -> m ()
{-# INLINE unsafeModify #-}
unsafeModify :: MVector (PrimState m) a -> (a -> a) -> Int -> m ()
unsafeModify = MVector (PrimState m) a -> (a -> a) -> Int -> m ()
forall (m :: * -> *) (v :: * -> * -> *) a.
(PrimMonad m, MVector v a) =>
v (PrimState m) a -> (a -> a) -> Int -> m ()
G.unsafeModify
unsafeSwap
:: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> Int -> m ()
{-# INLINE unsafeSwap #-}
unsafeSwap :: MVector (PrimState m) a -> Int -> Int -> m ()
unsafeSwap = MVector (PrimState m) a -> Int -> Int -> m ()
forall (m :: * -> *) (v :: * -> * -> *) a.
(PrimMonad m, MVector v a) =>
v (PrimState m) a -> Int -> Int -> m ()
G.unsafeSwap
set :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> a -> m ()
{-# INLINE set #-}
set :: MVector (PrimState m) a -> a -> m ()
set = MVector (PrimState m) a -> a -> m ()
forall (m :: * -> *) (v :: * -> * -> *) a.
(PrimMonad m, MVector v a) =>
v (PrimState m) a -> a -> m ()
G.set
copy :: (PrimMonad m, Storable a)
=> MVector (PrimState m) a
-> MVector (PrimState m) a
-> m ()
{-# INLINE copy #-}
copy :: MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
copy = MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
forall (m :: * -> *) (v :: * -> * -> *) a.
(PrimMonad m, MVector v a) =>
v (PrimState m) a -> v (PrimState m) a -> m ()
G.copy
unsafeCopy :: (PrimMonad m, Storable a)
=> MVector (PrimState m) a
-> MVector (PrimState m) a
-> m ()
{-# INLINE unsafeCopy #-}
unsafeCopy :: MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
unsafeCopy = MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
forall (m :: * -> *) (v :: * -> * -> *) a.
(PrimMonad m, MVector v a) =>
v (PrimState m) a -> v (PrimState m) a -> m ()
G.unsafeCopy
move :: (PrimMonad m, Storable a)
=> MVector (PrimState m) a
-> MVector (PrimState m) a
-> m ()
{-# INLINE move #-}
move :: MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
move = MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
forall (m :: * -> *) (v :: * -> * -> *) a.
(PrimMonad m, MVector v a) =>
v (PrimState m) a -> v (PrimState m) a -> m ()
G.move
unsafeMove :: (PrimMonad m, Storable a)
=> MVector (PrimState m) a
-> MVector (PrimState m) a
-> m ()
{-# INLINE unsafeMove #-}
unsafeMove :: MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
unsafeMove = MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
forall (m :: * -> *) (v :: * -> * -> *) a.
(PrimMonad m, MVector v a) =>
v (PrimState m) a -> v (PrimState m) a -> m ()
G.unsafeMove
unsafeCast :: forall a b s.
(Storable a, Storable b) => MVector s a -> MVector s b
{-# INLINE unsafeCast #-}
unsafeCast :: MVector s a -> MVector s b
unsafeCast (MVector n :: Int
n fp :: ForeignPtr a
fp)
= Int -> ForeignPtr b -> MVector s b
forall s a. Int -> ForeignPtr a -> MVector s a
MVector ((Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
* a -> Int
forall a. Storable a => a -> Int
sizeOf (a
forall a. HasCallStack => a
undefined :: a)) Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` b -> Int
forall a. Storable a => a -> Int
sizeOf (b
forall a. HasCallStack => a
undefined :: b))
(ForeignPtr a -> ForeignPtr b
forall a b. ForeignPtr a -> ForeignPtr b
castForeignPtr ForeignPtr a
fp)
unsafeFromForeignPtr :: Storable a
=> ForeignPtr a
-> Int
-> Int
-> MVector s a
{-# INLINE_FUSED unsafeFromForeignPtr #-}
unsafeFromForeignPtr :: ForeignPtr a -> Int -> Int -> MVector s a
unsafeFromForeignPtr fp :: ForeignPtr a
fp i :: Int
i n :: Int
n = ForeignPtr a -> Int -> MVector s a
forall a s. Storable a => ForeignPtr a -> Int -> MVector s a
unsafeFromForeignPtr0 ForeignPtr a
fp' Int
n
where
fp' :: ForeignPtr a
fp' = (Ptr a -> Ptr a) -> ForeignPtr a -> ForeignPtr a
forall a. (Ptr a -> Ptr a) -> ForeignPtr a -> ForeignPtr a
updPtr (Ptr a -> Int -> Ptr a
forall a. Storable a => Ptr a -> Int -> Ptr a
`advancePtr` Int
i) ForeignPtr a
fp
{-# RULES
"unsafeFromForeignPtr fp 0 n -> unsafeFromForeignPtr0 fp n " forall fp n.
unsafeFromForeignPtr fp 0 n = unsafeFromForeignPtr0 fp n #-}
unsafeFromForeignPtr0 :: Storable a
=> ForeignPtr a
-> Int
-> MVector s a
{-# INLINE unsafeFromForeignPtr0 #-}
unsafeFromForeignPtr0 :: ForeignPtr a -> Int -> MVector s a
unsafeFromForeignPtr0 fp :: ForeignPtr a
fp n :: Int
n = Int -> ForeignPtr a -> MVector s a
forall s a. Int -> ForeignPtr a -> MVector s a
MVector Int
n ForeignPtr a
fp
unsafeToForeignPtr :: Storable a => MVector s a -> (ForeignPtr a, Int, Int)
{-# INLINE unsafeToForeignPtr #-}
unsafeToForeignPtr :: MVector s a -> (ForeignPtr a, Int, Int)
unsafeToForeignPtr (MVector n :: Int
n fp :: ForeignPtr a
fp) = (ForeignPtr a
fp, 0, Int
n)
unsafeToForeignPtr0 :: Storable a => MVector s a -> (ForeignPtr a, Int)
{-# INLINE unsafeToForeignPtr0 #-}
unsafeToForeignPtr0 :: MVector s a -> (ForeignPtr a, Int)
unsafeToForeignPtr0 (MVector n :: Int
n fp :: ForeignPtr a
fp) = (ForeignPtr a
fp, Int
n)
unsafeWith :: Storable a => IOVector a -> (Ptr a -> IO b) -> IO b
{-# INLINE unsafeWith #-}
unsafeWith :: IOVector a -> (Ptr a -> IO b) -> IO b
unsafeWith (MVector _ fp :: ForeignPtr a
fp) = ForeignPtr a -> (Ptr a -> IO b) -> IO b
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr a
fp