module Data.Vector.Mutable (
MVector(..), IOVector, STVector,
length, null,
slice, init, tail, take, drop,
unsafeSlice, unsafeInit, unsafeTail, unsafeTake, unsafeDrop,
overlaps,
new, unsafeNew, replicate, clone,
grow, unsafeGrow,
clear,
read, write, swap,
unsafeRead, unsafeWrite, unsafeSwap,
set, copy, unsafeCopy,
newWith, unsafeNewWith
) where
import qualified Data.Vector.Generic.Mutable as G
import Data.Primitive.Array
import Control.Monad.Primitive
import Prelude hiding ( length, null, replicate, reverse, map, read,
take, drop, init, tail )
import Data.Typeable ( Typeable )
#include "vector.h"
data MVector s a = MVector !Int
!Int
!(MutableArray s a)
deriving ( Typeable )
type IOVector = MVector RealWorld
type STVector s = MVector s
instance G.MVector MVector a where
basicLength (MVector _ n _) = n
basicUnsafeSlice j m (MVector i n arr) = MVector (i+j) m arr
basicOverlaps (MVector i m arr1) (MVector j n arr2)
= sameMutableArray arr1 arr2
&& (between i j (j+n) || between j i (i+m))
where
between x y z = x >= y && x < z
basicUnsafeNew n
= do
arr <- newArray n uninitialised
return (MVector 0 n arr)
basicUnsafeReplicate n x
= do
arr <- newArray n x
return (MVector 0 n arr)
basicUnsafeRead (MVector i n arr) j = readArray arr (i+j)
basicUnsafeWrite (MVector i n arr) j x = writeArray arr (i+j) x
basicClear v = G.set v uninitialised
uninitialised :: a
uninitialised = error "Data.Vector.Mutable: uninitialised element"
length :: MVector s a -> Int
length = G.length
null :: MVector s a -> Bool
null = G.null
slice :: Int -> Int -> MVector s a -> MVector s a
slice = G.slice
take :: Int -> MVector s a -> MVector s a
take = G.take
drop :: Int -> MVector s a -> MVector s a
drop = G.drop
init :: MVector s a -> MVector s a
init = G.init
tail :: MVector s a -> MVector s a
tail = G.tail
unsafeSlice :: Int
-> Int
-> MVector s a
-> MVector s a
unsafeSlice = G.unsafeSlice
unsafeTake :: Int -> MVector s a -> MVector s a
unsafeTake = G.unsafeTake
unsafeDrop :: Int -> MVector s a -> MVector s a
unsafeDrop = G.unsafeDrop
unsafeInit :: MVector s a -> MVector s a
unsafeInit = G.unsafeInit
unsafeTail :: MVector s a -> MVector s a
unsafeTail = G.unsafeTail
overlaps :: MVector s a -> MVector s a -> Bool
overlaps = G.overlaps
new :: PrimMonad m => Int -> m (MVector (PrimState m) a)
new = G.new
unsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) a)
unsafeNew = G.unsafeNew
replicate :: PrimMonad m => Int -> a -> m (MVector (PrimState m) a)
replicate = G.replicate
clone :: PrimMonad m => MVector (PrimState m) a -> m (MVector (PrimState m) a)
clone = G.clone
grow :: PrimMonad m
=> MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
grow = G.grow
unsafeGrow :: PrimMonad m
=> MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
unsafeGrow = G.unsafeGrow
clear :: PrimMonad m => MVector (PrimState m) a -> m ()
clear = G.clear
read :: PrimMonad m => MVector (PrimState m) a -> Int -> m a
read = G.read
write :: PrimMonad m => MVector (PrimState m) a -> Int -> a -> m ()
write = G.write
swap :: PrimMonad m => MVector (PrimState m) a -> Int -> Int -> m ()
swap = G.swap
unsafeRead :: PrimMonad m => MVector (PrimState m) a -> Int -> m a
unsafeRead = G.unsafeRead
unsafeWrite :: PrimMonad m => MVector (PrimState m) a -> Int -> a -> m ()
unsafeWrite = G.unsafeWrite
unsafeSwap :: PrimMonad m => MVector (PrimState m) a -> Int -> Int -> m ()
unsafeSwap = G.unsafeSwap
set :: PrimMonad m => MVector (PrimState m) a -> a -> m ()
set = G.set
copy :: PrimMonad m
=> MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
copy = G.copy
unsafeCopy :: PrimMonad m => MVector (PrimState m) a
-> MVector (PrimState m) a
-> m ()
unsafeCopy = G.unsafeCopy
newWith :: PrimMonad m => Int -> a -> m (MVector (PrimState m) a)
newWith = G.replicate
unsafeNewWith :: PrimMonad m => Int -> a -> m (MVector (PrimState m) a)
unsafeNewWith = G.replicate