#ifndef MIN_VERSION_base
#define MIN_VERSION_base(x,y,z) 1
#endif
module Data.Vector.Mixed.Mutable
( MVector
, IOVector
, STVector
, length, null
, slice, init, tail, take, drop, splitAt
, unsafeSlice, unsafeInit, unsafeTail, unsafeTake, unsafeDrop
, overlaps
, replicateM, move, unsafeMove
, new, unsafeNew, replicate, clone
, grow, unsafeGrow
, clear
, read, write, swap
, unsafeRead, unsafeWrite, unsafeSwap
, set, copy, unsafeCopy
) where
import Control.Monad (liftM)
import Control.Monad.Primitive
import qualified Data.Vector.Generic.Mutable as G
import Data.Vector.Mixed.Internal
import Prelude hiding (length, null, replicate, reverse, map, read, take, drop, init, tail, splitAt)
type IOVector = MVector RealWorld
type STVector = MVector
length :: G.MVector u a => u s a -> Int
length = G.length
null :: G.MVector u a => u s a -> Bool
null = G.null
slice :: Mixed u v a => Int -> Int -> u s a -> MVector s a
slice i j m = mmix (G.slice i j m)
take :: Mixed u v a => Int -> u s a -> MVector s a
take i m = mmix (G.take i m)
drop :: Mixed u v a => Int -> u s a -> MVector s a
drop i m = mmix (G.drop i m)
splitAt :: Mixed u v a => Int -> u s a -> (MVector s a, MVector s a)
splitAt i m = case G.splitAt i m of
(l,r) -> (mmix l, mmix r)
init :: Mixed u v a => u s a -> MVector s a
init m = mmix (G.init m)
tail :: Mixed u v a => u s a -> MVector s a
tail m = mmix (G.tail m)
unsafeSlice :: Mixed u v a => Int
-> Int
-> u s a
-> MVector s a
unsafeSlice i j m = mmix (G.unsafeSlice i j m)
unsafeTake :: Mixed u v a => Int -> u s a -> MVector s a
unsafeTake i m = mmix (G.unsafeTake i m)
unsafeDrop :: Mixed u v a => Int -> u s a -> MVector s a
unsafeDrop i m = mmix (G.unsafeDrop i m)
unsafeInit :: Mixed u v a => u s a -> MVector s a
unsafeInit m = mmix (G.unsafeInit m)
unsafeTail :: Mixed u v a => u s a -> MVector s a
unsafeTail m = mmix (G.unsafeTail m)
overlaps :: (Mixed u v a, Mixed u' v' a) => u s a -> u' s a -> Bool
overlaps m n = G.overlaps (mmix m) (mmix n)
new :: PrimMonad m => Int -> m (MVector (PrimState m) a)
new = G.new
unsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) a)
unsafeNew n = liftM mboxed (G.unsafeNew n)
replicate :: PrimMonad m => Int -> a -> m (MVector (PrimState m) a)
replicate n a = liftM mboxed (G.replicate n a)
replicateM :: PrimMonad m => Int -> m a -> m (MVector (PrimState m) a)
replicateM n m = liftM mboxed (G.replicateM n m)
clone :: (PrimMonad m, Mixed u v a) => u (PrimState m) a -> m (MVector (PrimState m) a)
clone m = liftM mmix (G.clone m)
grow :: (PrimMonad m, Mixed u v a) => u (PrimState m) a -> Int -> m (MVector (PrimState m) a)
grow m n = liftM mmix (G.grow m n)
unsafeGrow :: (PrimMonad m, Mixed u v a) => u (PrimState m) a -> Int -> m (MVector (PrimState m) a)
unsafeGrow m n = liftM mmix (G.unsafeGrow m n)
clear :: (PrimMonad m, G.MVector u a) => u (PrimState m) a -> m ()
clear = G.clear
read :: (PrimMonad m, G.MVector u a) => u (PrimState m) a -> Int -> m a
read = G.read
write :: (PrimMonad m, G.MVector u a) => u (PrimState m) a -> Int -> a -> m ()
write = G.write
swap :: (PrimMonad m, G.MVector u a) => u (PrimState m) a -> Int -> Int -> m ()
swap = G.swap
unsafeRead :: (PrimMonad m, G.MVector u a) => u (PrimState m) a -> Int -> m a
unsafeRead = G.unsafeRead
unsafeWrite :: (PrimMonad m, G.MVector u a) => u (PrimState m) a -> Int -> a -> m ()
unsafeWrite = G.unsafeWrite
unsafeSwap :: (PrimMonad m, G.MVector u a) => u (PrimState m) a -> Int -> Int -> m ()
unsafeSwap = G.unsafeSwap
set :: (PrimMonad m, G.MVector u a) => u (PrimState m) a -> a -> m ()
set = G.set
copy :: (PrimMonad m, Mixed u v a, Mixed u' v' a) => u (PrimState m) a -> u' (PrimState m) a -> m ()
copy dst src = G.copy (mmix dst) (mmix src)
unsafeCopy
:: (PrimMonad m, Mixed u v a, Mixed u' v' a)
=> u (PrimState m) a
-> u' (PrimState m) a
-> m ()
unsafeCopy dst src = G.unsafeCopy (mmix dst) (mmix src)
move :: (PrimMonad m, Mixed u v a, Mixed u' v' a) => u (PrimState m) a -> u' (PrimState m) a -> m ()
move dst src = G.move (mmix dst) (mmix src)
unsafeMove :: (PrimMonad m, Mixed u v a, Mixed u' v' a)
=> u (PrimState m) a
-> u' (PrimState m) a
-> m ()
unsafeMove dst src = G.unsafeMove (mmix dst) (mmix src)