{-# LANGUAGE CPP, DeriveDataTypeable, MultiParamTypeClasses, FlexibleInstances, BangPatterns, TypeFamilies #-}
module Data.Vector.Mutable (
MVector(..), IOVector, STVector,
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,
nextPermutation,
set, copy, move, unsafeCopy, unsafeMove
) where
import Control.Monad (when)
import qualified Data.Vector.Generic.Mutable as G
import Data.Primitive.Array
import Control.Monad.Primitive
import Prelude hiding ( length, null, replicate, reverse, read,
take, drop, splitAt, init, tail )
import Data.Typeable ( Typeable )
#include "vector.h"
data MVector s a = MVector {-# UNPACK #-} !Int
{-# UNPACK #-} !Int
{-# UNPACK #-} !(MutableArray s a)
deriving ( Typeable )
type IOVector = MVector RealWorld
type STVector s = MVector s
instance 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 i :: Int
i _ arr :: MutableArray s a
arr) = Int -> Int -> MutableArray s a -> MVector s a
forall s a. Int -> Int -> MutableArray s a -> MVector s a
MVector (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
j) Int
m MutableArray s a
arr
{-# INLINE basicOverlaps #-}
basicOverlaps :: MVector s a -> MVector s a -> Bool
basicOverlaps (MVector i :: Int
i m :: Int
m arr1 :: MutableArray s a
arr1) (MVector j :: Int
j n :: Int
n arr2 :: MutableArray s a
arr2)
= MutableArray s a -> MutableArray s a -> Bool
forall s a. MutableArray s a -> MutableArray s a -> Bool
sameMutableArray MutableArray s a
arr1 MutableArray s a
arr2
Bool -> Bool -> Bool
&& (Int -> Int -> Int -> Bool
forall a. Ord a => a -> a -> a -> Bool
between Int
i Int
j (Int
jInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
n) Bool -> Bool -> Bool
|| Int -> Int -> Int -> Bool
forall a. Ord a => a -> a -> a -> Bool
between Int
j Int
i (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+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
{-# INLINE basicUnsafeNew #-}
basicUnsafeNew :: Int -> m (MVector (PrimState m) a)
basicUnsafeNew n :: Int
n
= do
MutableArray (PrimState m) a
arr <- Int -> a -> m (MutableArray (PrimState m) a)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (MutableArray (PrimState m) a)
newArray Int
n a
forall a. a
uninitialised
MVector (PrimState m) a -> m (MVector (PrimState m) a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int
-> Int -> MutableArray (PrimState m) a -> MVector (PrimState m) a
forall s a. Int -> Int -> MutableArray s a -> MVector s a
MVector 0 Int
n MutableArray (PrimState m) a
arr)
{-# INLINE basicInitialize #-}
basicInitialize :: MVector (PrimState m) a -> m ()
basicInitialize _ = () -> m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
{-# INLINE basicUnsafeReplicate #-}
basicUnsafeReplicate :: Int -> a -> m (MVector (PrimState m) a)
basicUnsafeReplicate n :: Int
n x :: a
x
= do
MutableArray (PrimState m) a
arr <- Int -> a -> m (MutableArray (PrimState m) a)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (MutableArray (PrimState m) a)
newArray Int
n a
x
MVector (PrimState m) a -> m (MVector (PrimState m) a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Int
-> Int -> MutableArray (PrimState m) a -> MVector (PrimState m) a
forall s a. Int -> Int -> MutableArray s a -> MVector s a
MVector 0 Int
n MutableArray (PrimState m) a
arr)
{-# INLINE basicUnsafeRead #-}
basicUnsafeRead :: MVector (PrimState m) a -> Int -> m a
basicUnsafeRead (MVector i :: Int
i _ arr :: MutableArray (PrimState m) a
arr) j :: Int
j = MutableArray (PrimState m) a -> Int -> m a
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> m a
readArray MutableArray (PrimState m) a
arr (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
j)
{-# INLINE basicUnsafeWrite #-}
basicUnsafeWrite :: MVector (PrimState m) a -> Int -> a -> m ()
basicUnsafeWrite (MVector i :: Int
i _ arr :: MutableArray (PrimState m) a
arr) j :: Int
j x :: a
x = MutableArray (PrimState m) a -> Int -> a -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
writeArray MutableArray (PrimState m) a
arr (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
j) a
x
{-# INLINE basicUnsafeCopy #-}
basicUnsafeCopy :: MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
basicUnsafeCopy (MVector i :: Int
i n :: Int
n dst :: MutableArray (PrimState m) a
dst) (MVector j :: Int
j _ src :: MutableArray (PrimState m) a
src)
= MutableArray (PrimState m) a
-> Int -> MutableArray (PrimState m) a -> Int -> Int -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a
-> Int -> MutableArray (PrimState m) a -> Int -> Int -> m ()
copyMutableArray MutableArray (PrimState m) a
dst Int
i MutableArray (PrimState m) a
src Int
j Int
n
basicUnsafeMove :: MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
basicUnsafeMove dst :: MVector (PrimState m) a
dst@(MVector iDst :: Int
iDst n :: Int
n arrDst :: MutableArray (PrimState m) a
arrDst) src :: MVector (PrimState m) a
src@(MVector iSrc :: Int
iSrc _ arrSrc :: MutableArray (PrimState m) a
arrSrc)
= case Int
n of
0 -> () -> m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
1 -> MutableArray (PrimState m) a -> Int -> m a
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> m a
readArray MutableArray (PrimState m) a
arrSrc Int
iSrc m a -> (a -> m ()) -> m ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= MutableArray (PrimState m) a -> Int -> a -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
writeArray MutableArray (PrimState m) a
arrDst Int
iDst
2 -> do
a
x <- MutableArray (PrimState m) a -> Int -> m a
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> m a
readArray MutableArray (PrimState m) a
arrSrc Int
iSrc
a
y <- MutableArray (PrimState m) a -> Int -> m a
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> m a
readArray MutableArray (PrimState m) a
arrSrc (Int
iSrc Int -> Int -> Int
forall a. Num a => a -> a -> a
+ 1)
MutableArray (PrimState m) a -> Int -> a -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
writeArray MutableArray (PrimState m) a
arrDst Int
iDst a
x
MutableArray (PrimState m) a -> Int -> a -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
writeArray MutableArray (PrimState m) a
arrDst (Int
iDst Int -> Int -> Int
forall a. Num a => a -> a -> a
+ 1) a
y
_
| MVector (PrimState m) a -> MVector (PrimState m) a -> Bool
forall s a. MVector s a -> MVector s a -> Bool
overlaps MVector (PrimState m) a
dst MVector (PrimState m) a
src
-> case Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Int
iDst Int
iSrc of
LT -> MutableArray (PrimState m) a -> Int -> Int -> Int -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> Int -> Int -> m ()
moveBackwards MutableArray (PrimState m) a
arrDst Int
iDst Int
iSrc Int
n
EQ -> () -> m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
GT | (Int
iDst Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
iSrc) Int -> Int -> Int
forall a. Num a => a -> a -> a
* 2 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
n
-> MutableArray (PrimState m) a -> Int -> Int -> Int -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> Int -> Int -> m ()
moveForwardsLargeOverlap MutableArray (PrimState m) a
arrDst Int
iDst Int
iSrc Int
n
| Bool
otherwise
-> MutableArray (PrimState m) a -> Int -> Int -> Int -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> Int -> Int -> m ()
moveForwardsSmallOverlap MutableArray (PrimState m) a
arrDst Int
iDst Int
iSrc Int
n
| Bool
otherwise -> MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> v (PrimState m) a -> m ()
G.basicUnsafeCopy MVector (PrimState m) a
dst MVector (PrimState m) a
src
{-# INLINE basicClear #-}
basicClear :: MVector (PrimState m) a -> m ()
basicClear v :: MVector (PrimState m) a
v = MVector (PrimState m) a -> a -> m ()
forall (m :: * -> *) (v :: * -> * -> *) a.
(PrimMonad m, MVector v a) =>
v (PrimState m) a -> a -> m ()
G.set MVector (PrimState m) a
v a
forall a. a
uninitialised
{-# INLINE moveBackwards #-}
moveBackwards :: PrimMonad m => MutableArray (PrimState m) a -> Int -> Int -> Int -> m ()
moveBackwards :: MutableArray (PrimState m) a -> Int -> Int -> Int -> m ()
moveBackwards !MutableArray (PrimState m) a
arr !Int
dstOff !Int
srcOff !Int
len =
INTERNAL_CHECK(check) "moveBackwards" "not a backwards move" (dstOff < srcOff)
(m () -> m ()) -> m () -> m ()
forall a b. (a -> b) -> a -> b
$ Int -> (Int -> m ()) -> m ()
forall (m :: * -> *) a. Monad m => Int -> (Int -> m a) -> m ()
loopM Int
len ((Int -> m ()) -> m ()) -> (Int -> m ()) -> m ()
forall a b. (a -> b) -> a -> b
$ \ i :: Int
i -> MutableArray (PrimState m) a -> Int -> m a
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> m a
readArray MutableArray (PrimState m) a
arr (Int
srcOff Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i) m a -> (a -> m ()) -> m ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= MutableArray (PrimState m) a -> Int -> a -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
writeArray MutableArray (PrimState m) a
arr (Int
dstOff Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i)
{-# INLINE moveForwardsSmallOverlap #-}
moveForwardsSmallOverlap :: PrimMonad m => MutableArray (PrimState m) a -> Int -> Int -> Int -> m ()
moveForwardsSmallOverlap :: MutableArray (PrimState m) a -> Int -> Int -> Int -> m ()
moveForwardsSmallOverlap !MutableArray (PrimState m) a
arr !Int
dstOff !Int
srcOff !Int
len =
INTERNAL_CHECK(check) "moveForwardsSmallOverlap" "not a forward move" (dstOff > srcOff)
(m () -> m ()) -> m () -> m ()
forall a b. (a -> b) -> a -> b
$ do
MutableArray (PrimState m) a
tmp <- Int -> a -> m (MutableArray (PrimState m) a)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (MutableArray (PrimState m) a)
newArray Int
overlap a
forall a. a
uninitialised
Int -> (Int -> m ()) -> m ()
forall (m :: * -> *) a. Monad m => Int -> (Int -> m a) -> m ()
loopM Int
overlap ((Int -> m ()) -> m ()) -> (Int -> m ()) -> m ()
forall a b. (a -> b) -> a -> b
$ \ i :: Int
i -> MutableArray (PrimState m) a -> Int -> m a
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> m a
readArray MutableArray (PrimState m) a
arr (Int
dstOff Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i) m a -> (a -> m ()) -> m ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= MutableArray (PrimState m) a -> Int -> a -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
writeArray MutableArray (PrimState m) a
tmp Int
i
Int -> (Int -> m ()) -> m ()
forall (m :: * -> *) a. Monad m => Int -> (Int -> m a) -> m ()
loopM Int
nonOverlap ((Int -> m ()) -> m ()) -> (Int -> m ()) -> m ()
forall a b. (a -> b) -> a -> b
$ \ i :: Int
i -> MutableArray (PrimState m) a -> Int -> m a
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> m a
readArray MutableArray (PrimState m) a
arr (Int
srcOff Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i) m a -> (a -> m ()) -> m ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= MutableArray (PrimState m) a -> Int -> a -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
writeArray MutableArray (PrimState m) a
arr (Int
dstOff Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i)
Int -> (Int -> m ()) -> m ()
forall (m :: * -> *) a. Monad m => Int -> (Int -> m a) -> m ()
loopM Int
overlap ((Int -> m ()) -> m ()) -> (Int -> m ()) -> m ()
forall a b. (a -> b) -> a -> b
$ \ i :: Int
i -> MutableArray (PrimState m) a -> Int -> m a
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> m a
readArray MutableArray (PrimState m) a
tmp Int
i m a -> (a -> m ()) -> m ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= MutableArray (PrimState m) a -> Int -> a -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
writeArray MutableArray (PrimState m) a
arr (Int
dstOff Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
nonOverlap Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i)
where nonOverlap :: Int
nonOverlap = Int
dstOff Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
srcOff; overlap :: Int
overlap = Int
len Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
nonOverlap
moveForwardsLargeOverlap :: PrimMonad m => MutableArray (PrimState m) a -> Int -> Int -> Int -> m ()
moveForwardsLargeOverlap :: MutableArray (PrimState m) a -> Int -> Int -> Int -> m ()
moveForwardsLargeOverlap !MutableArray (PrimState m) a
arr !Int
dstOff !Int
srcOff !Int
len =
INTERNAL_CHECK(check) "moveForwardsLargeOverlap" "not a forward move" (dstOff > srcOff)
(m () -> m ()) -> m () -> m ()
forall a b. (a -> b) -> a -> b
$ do
MutableArray (PrimState m) a
queue <- Int -> a -> m (MutableArray (PrimState m) a)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (MutableArray (PrimState m) a)
newArray Int
nonOverlap a
forall a. a
uninitialised
Int -> (Int -> m ()) -> m ()
forall (m :: * -> *) a. Monad m => Int -> (Int -> m a) -> m ()
loopM Int
nonOverlap ((Int -> m ()) -> m ()) -> (Int -> m ()) -> m ()
forall a b. (a -> b) -> a -> b
$ \ i :: Int
i -> MutableArray (PrimState m) a -> Int -> m a
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> m a
readArray MutableArray (PrimState m) a
arr (Int
srcOff Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
i) m a -> (a -> m ()) -> m ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= MutableArray (PrimState m) a -> Int -> a -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
writeArray MutableArray (PrimState m) a
queue Int
i
let mov :: Int -> Int -> m ()
mov !Int
i !Int
qTop = Bool -> m () -> m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
dstOff Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
len) (m () -> m ()) -> m () -> m ()
forall a b. (a -> b) -> a -> b
$ do
a
x <- MutableArray (PrimState m) a -> Int -> m a
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> m a
readArray MutableArray (PrimState m) a
arr Int
i
a
y <- MutableArray (PrimState m) a -> Int -> m a
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> m a
readArray MutableArray (PrimState m) a
queue Int
qTop
MutableArray (PrimState m) a -> Int -> a -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
writeArray MutableArray (PrimState m) a
arr Int
i a
y
MutableArray (PrimState m) a -> Int -> a -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
writeArray MutableArray (PrimState m) a
queue Int
qTop a
x
Int -> Int -> m ()
mov (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+1) (if Int
qTop Int -> Int -> Int
forall a. Num a => a -> a -> a
+ 1 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
nonOverlap then 0 else Int
qTop Int -> Int -> Int
forall a. Num a => a -> a -> a
+ 1)
Int -> Int -> m ()
mov Int
dstOff 0
where nonOverlap :: Int
nonOverlap = Int
dstOff Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
srcOff
{-# INLINE loopM #-}
loopM :: Monad m => Int -> (Int -> m a) -> m ()
loopM :: Int -> (Int -> m a) -> m ()
loopM !Int
n k :: Int -> m a
k = let
go :: Int -> m ()
go i :: Int
i = Bool -> m () -> m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
n) (Int -> m a
k Int
i m a -> m () -> m ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> m ()
go (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+1))
in Int -> m ()
go 0
uninitialised :: a
uninitialised :: a
uninitialised = String -> a
forall a. HasCallStack => String -> a
error "Data.Vector.Mutable: uninitialised element. If you are trying to compact a vector, use the 'force' function to remove uninitialised elements from the underlying array."
length :: 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 :: 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 :: 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 :: 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 :: 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
{-# INLINE splitAt #-}
splitAt :: Int -> MVector s a -> (MVector s a, MVector s a)
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 :: 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 :: 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 :: 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 :: 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 :: 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 :: 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 :: 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 :: 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 => 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 => 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 => 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 => 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 => 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
=> 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
=> 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 => 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 => 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 => 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 => 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 => 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 => 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 => 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 => 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 => 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 => 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 => 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 => 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 => 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 => 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
nextPermutation :: (PrimMonad m,Ord e) => MVector (PrimState m) e -> m Bool
{-# INLINE nextPermutation #-}
nextPermutation :: MVector (PrimState m) e -> m Bool
nextPermutation = MVector (PrimState m) e -> m Bool
forall (m :: * -> *) e (v :: * -> * -> *).
(PrimMonad m, Ord e, MVector v e) =>
v (PrimState m) e -> m Bool
G.nextPermutation