module Data.Vector.Unboxed.Mutable (
MVector(..), IOVector, STVector, Unbox,
length, null,
slice, init, tail, take, drop,
unsafeSlice, unsafeInit, unsafeTail, unsafeTake, unsafeDrop,
overlaps,
new, unsafeNew, replicate, clone,
grow, unsafeGrow,
clear,
zip, zip3, zip4, zip5, zip6,
unzip, unzip3, unzip4, unzip5, unzip6,
read, write, swap,
unsafeRead, unsafeWrite, unsafeSwap,
set, copy, unsafeCopy,
newWith, unsafeNewWith
) where
import Data.Vector.Unboxed.Base
import qualified Data.Vector.Generic.Mutable as G
import Control.Monad.Primitive
import Prelude hiding ( length, null, replicate, reverse, map, read,
take, drop, init, tail,
zip, zip3, unzip, unzip3 )
#include "vector.h"
length :: Unbox a => MVector s a -> Int
length = G.length
null :: Unbox a => MVector s a -> Bool
null = G.null
slice :: Unbox a => Int -> Int -> MVector s a -> MVector s a
slice = G.slice
take :: Unbox a => Int -> MVector s a -> MVector s a
take = G.take
drop :: Unbox a => Int -> MVector s a -> MVector s a
drop = G.drop
init :: Unbox a => MVector s a -> MVector s a
init = G.init
tail :: Unbox a => MVector s a -> MVector s a
tail = G.tail
unsafeSlice :: Unbox a
=> Int
-> Int
-> MVector s a
-> MVector s a
unsafeSlice = G.unsafeSlice
unsafeTake :: Unbox a => Int -> MVector s a -> MVector s a
unsafeTake = G.unsafeTake
unsafeDrop :: Unbox a => Int -> MVector s a -> MVector s a
unsafeDrop = G.unsafeDrop
unsafeInit :: Unbox a => MVector s a -> MVector s a
unsafeInit = G.unsafeInit
unsafeTail :: Unbox a => MVector s a -> MVector s a
unsafeTail = G.unsafeTail
overlaps :: Unbox a => MVector s a -> MVector s a -> Bool
overlaps = G.overlaps
new :: (PrimMonad m, Unbox a) => Int -> m (MVector (PrimState m) a)
new = G.new
unsafeNew :: (PrimMonad m, Unbox a) => Int -> m (MVector (PrimState m) a)
unsafeNew = G.unsafeNew
replicate :: (PrimMonad m, Unbox a) => Int -> a -> m (MVector (PrimState m) a)
replicate = G.replicate
clone :: (PrimMonad m, Unbox a)
=> MVector (PrimState m) a -> m (MVector (PrimState m) a)
clone = G.clone
grow :: (PrimMonad m, Unbox a)
=> MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
grow = G.grow
unsafeGrow :: (PrimMonad m, Unbox a)
=> MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
unsafeGrow = G.unsafeGrow
clear :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> m ()
clear = G.clear
read :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> m a
read = G.read
write :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> a -> m ()
write = G.write
swap :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> Int -> m ()
swap = G.swap
unsafeRead :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> m a
unsafeRead = G.unsafeRead
unsafeWrite
:: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> a -> m ()
unsafeWrite = G.unsafeWrite
unsafeSwap
:: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> Int -> Int -> m ()
unsafeSwap = G.unsafeSwap
set :: (PrimMonad m, Unbox a) => MVector (PrimState m) a -> a -> m ()
set = G.set
copy :: (PrimMonad m, Unbox a)
=> MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
copy = G.copy
unsafeCopy :: (PrimMonad m, Unbox a)
=> MVector (PrimState m) a
-> MVector (PrimState m) a
-> m ()
unsafeCopy = G.unsafeCopy
newWith :: (PrimMonad m, Unbox a) => Int -> a -> m (MVector (PrimState m) a)
newWith = G.replicate
unsafeNewWith :: (PrimMonad m, Unbox a) => Int -> a -> m (MVector (PrimState m) a)
unsafeNewWith = G.replicate
#define DEFINE_MUTABLE
#include "unbox-tuple-instances"