-- |
-- Module:      Hedgehog.Classes.MVector
-- Copyright:   (c) 2019-2020 Andrew Lelechenko
-- Licence:     BSD3
--

{-# LANGUAGE CPP #-}
{-# LANGUAGE ScopedTypeVariables #-}

#if !HAVE_VECTOR

module Hedgehog.Classes.MVector () where

#else

module Hedgehog.Classes.MVector
  ( muvectorLaws
  ) where

import Control.Monad (when)
import Control.Monad.ST
import qualified Data.Vector.Generic.Mutable as MU (basicInitialize)
import qualified Data.Vector.Unboxed.Mutable as MU

import Hedgehog
import Hedgehog.Classes.Common
import qualified Hedgehog.Gen as Gen
import qualified Hedgehog.Range as Range

-- | Test that a 'Vector.Unboxed.MVector' instance obey several laws.
muvectorLaws :: (Eq a, MU.Unbox a, Show a) => Gen a -> Laws
muvectorLaws :: forall a. (Eq a, Unbox a, Show a) => Gen a -> Laws
muvectorLaws Gen a
gen = String -> [(String, Property)] -> Laws
Laws String
"Vector.Unboxed.MVector"
  [ (String
"New-Length", forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
newLength Gen a
gen)
  , (String
"Replicate-Length", forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
replicateLength Gen a
gen)
  , (String
"Slice-Length", forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
sliceLength Gen a
gen)
  , (String
"Grow-Length", forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
growLength Gen a
gen)

  , (String
"Write-Read", forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeRead Gen a
gen)
  , (String
"Set-Read", forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
setRead Gen a
gen)
  , (String
"Sliced-Set-Read", forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
slicedSetRead Gen a
gen)
  , (String
"Replicate-Read", forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
replicateRead Gen a
gen)

  , (String
"Slice-Overlaps", forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
sliceOverlaps Gen a
gen)
  , (String
"Slice-Copy", forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
sliceCopy Gen a
gen)
  , (String
"Slice-Move", forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
sliceMove Gen a
gen)

  , (String
"Write-Copy-Read", forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeCopyRead Gen a
gen)
  , (String
"Write-Move-Read", forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeMoveRead Gen a
gen)
  , (String
"Write-Grow-Read", forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeGrowRead Gen a
gen)
  , (String
"Sliced-Write-Copy-Read", forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
slicedWriteCopyRead Gen a
gen)
  , (String
"Sliced-Write-Move-Read", forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
slicedWriteMoveRead Gen a
gen)
  , (String
"Sliced-Write-Grow-Read", forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
slicedWriteGrowRead Gen a
gen)

  , (String
"Write-InitializeAround-Read", forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeInitializeAroundRead Gen a
gen)
  , (String
"Write-ClearAround-Read", forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeClearAroundRead Gen a
gen)
  , (String
"Write-SetAround-Read", forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeSetAroundRead Gen a
gen)
  , (String
"Write-WriteAround-Read", forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeWriteAroundRead Gen a
gen)
  , (String
"Write-CopyAround-Read", forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeCopyAroundRead Gen a
gen)
  , (String
"Write-MoveAround-Read", forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeMoveAroundRead Gen a
gen)

  , (String
"Write-InitializeBetween-Read", forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeInitializeBetweenRead Gen a
gen)
  , (String
"Write-ClearBetween-Read", forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeClearBetweenRead Gen a
gen)
  , (String
"Write-SetBetween-Read", forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeSetBetweenRead Gen a
gen)
  , (String
"Write-CopyBetween-Read", forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeCopyBetweenRead Gen a
gen)
  , (String
"Write-MoveBetween-Read", forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeMoveBetweenRead Gen a
gen)
  ]

genNonNegative :: Gen Int
genNonNegative :: Gen Int
genNonNegative = forall (m :: * -> *) a. (MonadGen m, Integral a) => Range a -> m a
Gen.integral (forall a. Integral a => a -> a -> Range a
Range.linear Int
0 Int
1000)

genPositive :: Gen Int
genPositive :: Gen Int
genPositive = forall (m :: * -> *) a. (MonadGen m, Integral a) => Range a -> m a
Gen.integral (forall a. Integral a => a -> a -> Range a
Range.linear Int
1 Int
1000)

-------------------------------------------------------------------------------
-- Length

newLength :: forall a. (Eq a, MU.Unbox a, Show a) => Gen a -> Property
newLength :: forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
newLength Gen a
_ = HasCallStack => PropertyT IO () -> Property
property forall a b. (a -> b) -> a -> b
$ do
  Int
len <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  (forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== Int
len) (forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ forall a s. Unbox a => MVector s a -> Int
MU.length forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MU.new Int
len :: ST s (MU.MVector s a)))

replicateLength :: forall a. (Eq a, MU.Unbox a, Show a) => Gen a -> Property
replicateLength :: forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
replicateLength Gen a
gen = HasCallStack => PropertyT IO () -> Property
property forall a b. (a -> b) -> a -> b
$ do
  a
a   <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  Int
len <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  (forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== Int
len) (forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ forall a s. Unbox a => MVector s a -> Int
MU.length forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> a -> m (MVector (PrimState m) a)
MU.replicate Int
len a
a)

sliceLength :: forall a. (Eq a, MU.Unbox a, Show a) => Gen a -> Property
sliceLength :: forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
sliceLength Gen a
_ = HasCallStack => PropertyT IO () -> Property
property forall a b. (a -> b) -> a -> b
$ do
  Int
ix     <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
subLen <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
excess <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  (forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== Int
subLen) (forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ forall a s. Unbox a => MVector s a -> Int
MU.length forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MU.slice Int
ix Int
subLen forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MU.new (Int
ix forall a. Num a => a -> a -> a
+ Int
subLen forall a. Num a => a -> a -> a
+ Int
excess) :: ST s (MU.MVector s a)))

growLength :: forall a. (Eq a, MU.Unbox a, Show a) => Gen a -> Property
growLength :: forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
growLength Gen a
_ = HasCallStack => PropertyT IO () -> Property
property forall a b. (a -> b) -> a -> b
$ do
  Int
len <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  Int
by  <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  (forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== Int
len forall a. Num a => a -> a -> a
+ Int
by) forall a b. (a -> b) -> a -> b
$ forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
    MVector s a
arr <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MU.new Int
len :: ST s (MU.MVector s a)
    forall a s. Unbox a => MVector s a -> Int
MU.length forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
MU.grow MVector s a
arr Int
by

-------------------------------------------------------------------------------
-- Read

writeRead :: forall a. (Eq a, MU.Unbox a, Show a) => Gen a -> Property
writeRead :: forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeRead Gen a
gen = HasCallStack => PropertyT IO () -> Property
property forall a b. (a -> b) -> a -> b
$ do
  a
a      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  Int
ix     <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
excess <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  (forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== a
a) forall a b. (a -> b) -> a -> b
$ forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
    MVector s a
arr <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MU.new (Int
ix forall a. Num a => a -> a -> a
+ Int
excess)
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MU.write MVector s a
arr Int
ix a
a
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
MU.read MVector s a
arr Int
ix

setRead :: forall a. (Eq a, MU.Unbox a, Show a) => Gen a -> Property
setRead :: forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
setRead Gen a
gen = HasCallStack => PropertyT IO () -> Property
property forall a b. (a -> b) -> a -> b
$ do
  a
a      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  Int
ix     <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
excess <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  (forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== a
a) forall a b. (a -> b) -> a -> b
$ forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
    MVector s a
arr <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MU.new (Int
ix forall a. Num a => a -> a -> a
+ Int
excess)
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> a -> m ()
MU.set MVector s a
arr a
a
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
MU.read MVector s a
arr Int
ix

slicedSetRead :: forall a. (Eq a, MU.Unbox a, Show a) => Gen a -> Property
slicedSetRead :: forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
slicedSetRead Gen a
gen = HasCallStack => PropertyT IO () -> Property
property forall a b. (a -> b) -> a -> b
$ do
  a
a      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  Int
ix     <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
excess <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  Int
before <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
after  <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  (forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== a
a) forall a b. (a -> b) -> a -> b
$ forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
    MVector s a
arr <- forall a s. Unbox a => Int -> Int -> Int -> ST s (MVector s a)
newSlice Int
before Int
after (Int
ix forall a. Num a => a -> a -> a
+ Int
excess)
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> a -> m ()
MU.set MVector s a
arr a
a
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
MU.read MVector s a
arr Int
ix

replicateRead :: forall a. (Eq a, MU.Unbox a, Show a) => Gen a -> Property
replicateRead :: forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
replicateRead Gen a
gen = HasCallStack => PropertyT IO () -> Property
property forall a b. (a -> b) -> a -> b
$ do
  a
a      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  Int
ix     <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
excess <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  (forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== a
a) forall a b. (a -> b) -> a -> b
$ forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
    MVector s a
arr <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> a -> m (MVector (PrimState m) a)
MU.replicate (Int
ix forall a. Num a => a -> a -> a
+ Int
excess) a
a
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
MU.read MVector s a
arr Int
ix

-------------------------------------------------------------------------------
-- Overlaps

sliceOverlaps :: forall a. (Eq a, MU.Unbox a, Show a) => Gen a -> Property
sliceOverlaps :: forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
sliceOverlaps Gen a
_ = HasCallStack => PropertyT IO () -> Property
property forall a b. (a -> b) -> a -> b
$ do
  Int
i  <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
ij <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
jk <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
kl <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
lm <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  let j :: Int
j = Int
i forall a. Num a => a -> a -> a
+ Int
ij
      k :: Int
k = Int
j forall a. Num a => a -> a -> a
+ Int
jk
      l :: Int
l = Int
k forall a. Num a => a -> a -> a
+ Int
kl
      m :: Int
m = Int
l forall a. Num a => a -> a -> a
+ Int
lm
  forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
    MVector s a
arr <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MU.new (Int
m forall a. Num a => a -> a -> a
+ Int
1) :: ST s (MU.MVector s a)
    let slice1 :: MVector s a
slice1 = forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MU.slice Int
i (Int
k forall a. Num a => a -> a -> a
- Int
i forall a. Num a => a -> a -> a
+ Int
1) MVector s a
arr
        slice2 :: MVector s a
slice2 = forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MU.slice Int
j (Int
l forall a. Num a => a -> a -> a
- Int
j forall a. Num a => a -> a -> a
+ Int
1) MVector s a
arr
    forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). (MonadTest m, HasCallStack) => Bool -> m ()
assert forall a b. (a -> b) -> a -> b
$ forall a s. Unbox a => MVector s a -> MVector s a -> Bool
MU.overlaps MVector s a
slice1 MVector s a
slice2

sliceCopy :: forall a. (Eq a, MU.Unbox a, Show a) => Gen a -> Property
sliceCopy :: forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
sliceCopy Gen a
gen = HasCallStack => PropertyT IO () -> Property
property forall a b. (a -> b) -> a -> b
$ do
  a
a      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  Int
i      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
ix     <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
excess <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  Int
ij     <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
jk     <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  let j :: Int
j = Int
i forall a. Num a => a -> a -> a
+ Int
ix forall a. Num a => a -> a -> a
+ Int
excess forall a. Num a => a -> a -> a
+ Int
ij
      k :: Int
k = Int
j forall a. Num a => a -> a -> a
+ Int
ix forall a. Num a => a -> a -> a
+ Int
excess forall a. Num a => a -> a -> a
+ Int
jk
  forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
    MVector s a
arr <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MU.new Int
k :: ST s (MU.MVector s a)
    let src :: MVector s a
src = forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MU.slice Int
i (Int
ix forall a. Num a => a -> a -> a
+ Int
excess) MVector s a
arr
        dst :: MVector s a
dst = forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MU.slice Int
j (Int
ix forall a. Num a => a -> a -> a
+ Int
excess) MVector s a
arr
    if forall a s. Unbox a => MVector s a -> MVector s a -> Bool
MU.overlaps MVector s a
src MVector s a
dst then forall (f :: * -> *) a. Applicative f => a -> f a
pure forall (m :: * -> *). MonadTest m => m ()
success else do
      forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MU.write MVector s a
src Int
ix a
a
      forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
MU.copy MVector s a
dst MVector s a
src
      a
valSrc <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
MU.read MVector s a
src Int
ix
      a
valDst <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
MU.read MVector s a
dst Int
ix
      forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ (a
valSrc, a
valDst) forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== (a
a, a
a)

sliceMove :: forall a. (Eq a, MU.Unbox a, Show a) => Gen a -> Property
sliceMove :: forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
sliceMove Gen a
gen = HasCallStack => PropertyT IO () -> Property
property forall a b. (a -> b) -> a -> b
$ do
  a
a      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  Int
i      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
ix     <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
excess <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  Int
ij     <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
jk     <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  let j :: Int
j = Int
i forall a. Num a => a -> a -> a
+ Int
ix forall a. Num a => a -> a -> a
+ Int
excess forall a. Num a => a -> a -> a
+ Int
ij
      k :: Int
k = Int
j forall a. Num a => a -> a -> a
+ Int
ix forall a. Num a => a -> a -> a
+ Int
excess forall a. Num a => a -> a -> a
+ Int
jk
  (forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== a
a) forall a b. (a -> b) -> a -> b
$ forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
    MVector s a
arr <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MU.new Int
k :: ST s (MU.MVector s a)
    let src :: MVector s a
src = forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MU.slice Int
i (Int
ix forall a. Num a => a -> a -> a
+ Int
excess) MVector s a
arr
        dst :: MVector s a
dst = forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MU.slice Int
j (Int
ix forall a. Num a => a -> a -> a
+ Int
excess) MVector s a
arr
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MU.write MVector s a
src Int
ix a
a
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
MU.move MVector s a
dst MVector s a
src
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
MU.read MVector s a
dst Int
ix

-------------------------------------------------------------------------------
-- Write + copy/move/grow

writeCopyRead :: forall a. (Eq a, MU.Unbox a, Show a) => Gen a -> Property
writeCopyRead :: forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeCopyRead Gen a
gen = HasCallStack => PropertyT IO () -> Property
property forall a b. (a -> b) -> a -> b
$ do
  a
a      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  Int
ix     <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
excess <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  (forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== a
a) forall a b. (a -> b) -> a -> b
$ forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
    MVector s a
src <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MU.new (Int
ix forall a. Num a => a -> a -> a
+ Int
excess)
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MU.write MVector s a
src Int
ix a
a
    MVector s a
dst <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MU.new (Int
ix forall a. Num a => a -> a -> a
+ Int
excess)
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
MU.copy MVector s a
dst MVector s a
src
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> m ()
MU.clear MVector s a
src
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
MU.read MVector s a
dst Int
ix

writeMoveRead :: forall a. (Eq a, MU.Unbox a, Show a) => Gen a -> Property
writeMoveRead :: forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeMoveRead Gen a
gen = HasCallStack => PropertyT IO () -> Property
property forall a b. (a -> b) -> a -> b
$ do
  a
a      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  Int
ix     <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
excess <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  (forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== a
a) forall a b. (a -> b) -> a -> b
$ forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
    MVector s a
src <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MU.new (Int
ix forall a. Num a => a -> a -> a
+ Int
excess)
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MU.write MVector s a
src Int
ix a
a
    MVector s a
dst <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MU.new (Int
ix forall a. Num a => a -> a -> a
+ Int
excess)
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
MU.move MVector s a
dst MVector s a
src
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> m ()
MU.clear MVector s a
src
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
MU.read MVector s a
dst Int
ix

writeGrowRead :: forall a. (Eq a, MU.Unbox a, Show a) => Gen a -> Property
writeGrowRead :: forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeGrowRead Gen a
gen = HasCallStack => PropertyT IO () -> Property
property forall a b. (a -> b) -> a -> b
$ do
  a
a      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  Int
ix     <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
excess <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  Int
by     <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  (forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== a
a) forall a b. (a -> b) -> a -> b
$ forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
    MVector s a
src <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MU.new (Int
ix forall a. Num a => a -> a -> a
+ Int
excess)
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MU.write MVector s a
src Int
ix a
a
    MVector s a
dst <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
MU.grow MVector s a
src Int
by
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> m ()
MU.clear MVector s a
src
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
MU.read MVector s a
dst Int
ix

slicedWriteCopyRead :: forall a. (Eq a, MU.Unbox a, Show a) => Gen a -> Property
slicedWriteCopyRead :: forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
slicedWriteCopyRead Gen a
gen = HasCallStack => PropertyT IO () -> Property
property forall a b. (a -> b) -> a -> b
$ do
  a
a         <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  Int
ix        <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
excess    <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  Int
beforeSrc <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
afterSrc  <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
beforeDst <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
afterDst  <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  (forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== a
a) forall a b. (a -> b) -> a -> b
$ forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
    MVector s a
src <- forall a s. Unbox a => Int -> Int -> Int -> ST s (MVector s a)
newSlice Int
beforeSrc Int
afterSrc (Int
ix forall a. Num a => a -> a -> a
+ Int
excess)
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MU.write MVector s a
src Int
ix a
a
    MVector s a
dst <- forall a s. Unbox a => Int -> Int -> Int -> ST s (MVector s a)
newSlice Int
beforeDst Int
afterDst (Int
ix forall a. Num a => a -> a -> a
+ Int
excess)
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
MU.copy MVector s a
dst MVector s a
src
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> m ()
MU.clear MVector s a
src
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
MU.read MVector s a
dst Int
ix

slicedWriteMoveRead :: forall a. (Eq a, MU.Unbox a, Show a) => Gen a -> Property
slicedWriteMoveRead :: forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
slicedWriteMoveRead Gen a
gen = HasCallStack => PropertyT IO () -> Property
property forall a b. (a -> b) -> a -> b
$ do
  a
a         <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  Int
ix        <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
excess    <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  Int
beforeSrc <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
afterSrc  <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
beforeDst <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
afterDst  <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  (forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== a
a) forall a b. (a -> b) -> a -> b
$ forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
    MVector s a
src <- forall a s. Unbox a => Int -> Int -> Int -> ST s (MVector s a)
newSlice Int
beforeSrc Int
afterSrc (Int
ix forall a. Num a => a -> a -> a
+ Int
excess)
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MU.write MVector s a
src Int
ix a
a
    MVector s a
dst <- forall a s. Unbox a => Int -> Int -> Int -> ST s (MVector s a)
newSlice Int
beforeDst Int
afterDst (Int
ix forall a. Num a => a -> a -> a
+ Int
excess)
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
MU.move MVector s a
dst MVector s a
src
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> m ()
MU.clear MVector s a
src
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
MU.read MVector s a
dst Int
ix

slicedWriteGrowRead :: forall a. (Eq a, MU.Unbox a, Show a) => Gen a -> Property
slicedWriteGrowRead :: forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
slicedWriteGrowRead Gen a
gen = HasCallStack => PropertyT IO () -> Property
property forall a b. (a -> b) -> a -> b
$ do
  a
a         <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  Int
ix        <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
excess    <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  Int
by        <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  Int
beforeSrc <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
afterSrc  <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  (forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== a
a) forall a b. (a -> b) -> a -> b
$ forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
    MVector s a
src <- forall a s. Unbox a => Int -> Int -> Int -> ST s (MVector s a)
newSlice Int
beforeSrc Int
afterSrc (Int
ix forall a. Num a => a -> a -> a
+ Int
excess)
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MU.write MVector s a
src Int
ix a
a
    MVector s a
dst <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
MU.grow MVector s a
src Int
by
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> m ()
MU.clear MVector s a
src
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
MU.read MVector s a
dst Int
ix

-------------------------------------------------------------------------------
-- Write + overwrite around

writeInitializeAroundRead :: forall a. (Eq a, MU.Unbox a, Show a) => Gen a -> Property
writeInitializeAroundRead :: forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeInitializeAroundRead Gen a
gen = HasCallStack => PropertyT IO () -> Property
property forall a b. (a -> b) -> a -> b
$ do
  a
a      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  Int
ix     <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
excess <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  (forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== a
a) forall a b. (a -> b) -> a -> b
$ forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
    MVector s a
arr <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MU.new (Int
ix forall a. Num a => a -> a -> a
+ Int
excess)
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MU.write MVector s a
arr Int
ix a
a
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
ix forall a. Ord a => a -> a -> Bool
> Int
0) forall a b. (a -> b) -> a -> b
$
      forall (v :: * -> * -> *) a s. MVector v a => v s a -> ST s ()
MU.basicInitialize (forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MU.slice Int
0 Int
ix MVector s a
arr)
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
excess forall a. Ord a => a -> a -> Bool
> Int
1) forall a b. (a -> b) -> a -> b
$
      forall (v :: * -> * -> *) a s. MVector v a => v s a -> ST s ()
MU.basicInitialize (forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MU.slice (Int
ix forall a. Num a => a -> a -> a
+ Int
1) (Int
excess forall a. Num a => a -> a -> a
- Int
1) MVector s a
arr)
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
MU.read MVector s a
arr Int
ix

writeClearAroundRead :: forall a. (Eq a, MU.Unbox a, Show a) => Gen a -> Property
writeClearAroundRead :: forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeClearAroundRead Gen a
gen = HasCallStack => PropertyT IO () -> Property
property forall a b. (a -> b) -> a -> b
$ do
  a
a      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  Int
ix     <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
excess <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  (forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== a
a) forall a b. (a -> b) -> a -> b
$ forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
    MVector s a
arr <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MU.new (Int
ix forall a. Num a => a -> a -> a
+ Int
excess)
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MU.write MVector s a
arr Int
ix a
a
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
ix forall a. Ord a => a -> a -> Bool
> Int
0) forall a b. (a -> b) -> a -> b
$
      forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> m ()
MU.clear (forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MU.slice Int
0 Int
ix MVector s a
arr)
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
excess forall a. Ord a => a -> a -> Bool
> Int
1) forall a b. (a -> b) -> a -> b
$
      forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> m ()
MU.clear (forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MU.slice (Int
ix forall a. Num a => a -> a -> a
+ Int
1) (Int
excess forall a. Num a => a -> a -> a
- Int
1) MVector s a
arr)
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
MU.read MVector s a
arr Int
ix

writeSetAroundRead :: forall a. (Eq a, MU.Unbox a, Show a) => Gen a -> Property
writeSetAroundRead :: forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeSetAroundRead Gen a
gen = HasCallStack => PropertyT IO () -> Property
property forall a b. (a -> b) -> a -> b
$ do
  a
a      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  a
b      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  Int
ix     <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
excess <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  (forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== a
a) forall a b. (a -> b) -> a -> b
$ forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
    MVector s a
arr <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MU.new (Int
ix forall a. Num a => a -> a -> a
+ Int
excess)
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MU.write MVector s a
arr Int
ix a
a
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
ix forall a. Ord a => a -> a -> Bool
> Int
0) forall a b. (a -> b) -> a -> b
$
      forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> a -> m ()
MU.set (forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MU.slice Int
0 Int
ix MVector s a
arr) a
b
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
excess forall a. Ord a => a -> a -> Bool
> Int
1) forall a b. (a -> b) -> a -> b
$
      forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> a -> m ()
MU.set (forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MU.slice (Int
ix forall a. Num a => a -> a -> a
+ Int
1) (Int
excess forall a. Num a => a -> a -> a
- Int
1) MVector s a
arr) a
b
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
MU.read MVector s a
arr Int
ix

writeWriteAroundRead :: forall a. (Eq a, MU.Unbox a, Show a) => Gen a -> Property
writeWriteAroundRead :: forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeWriteAroundRead Gen a
gen = HasCallStack => PropertyT IO () -> Property
property forall a b. (a -> b) -> a -> b
$ do
  a
a      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  a
b      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  Int
ix     <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
excess <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  (forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== a
a) forall a b. (a -> b) -> a -> b
$ forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
    MVector s a
arr <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MU.new (Int
ix forall a. Num a => a -> a -> a
+ Int
excess)
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MU.write MVector s a
arr Int
ix a
a
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
ix forall a. Ord a => a -> a -> Bool
> Int
0) forall a b. (a -> b) -> a -> b
$
      forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MU.write MVector s a
arr (Int
ix forall a. Num a => a -> a -> a
- Int
1) a
b
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
excess forall a. Ord a => a -> a -> Bool
> Int
1) forall a b. (a -> b) -> a -> b
$
      forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MU.write MVector s a
arr (Int
ix forall a. Num a => a -> a -> a
+ Int
1) a
b
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
MU.read MVector s a
arr Int
ix

writeCopyAroundRead :: forall a. (Eq a, MU.Unbox a, Show a) => Gen a -> Property
writeCopyAroundRead :: forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeCopyAroundRead Gen a
gen = HasCallStack => PropertyT IO () -> Property
property forall a b. (a -> b) -> a -> b
$ do
  a
a      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  Int
ix     <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
excess <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  (forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== a
a) forall a b. (a -> b) -> a -> b
$ forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
    MVector s a
src <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MU.new (Int
ix forall a. Num a => a -> a -> a
+ Int
excess)
    MVector s a
dst <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MU.new (Int
ix forall a. Num a => a -> a -> a
+ Int
excess)
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MU.write MVector s a
dst Int
ix a
a
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
ix forall a. Ord a => a -> a -> Bool
> Int
0) forall a b. (a -> b) -> a -> b
$
      forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
MU.copy (forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MU.slice Int
0 Int
ix MVector s a
dst) (forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MU.slice Int
0 Int
ix MVector s a
src)
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
excess forall a. Ord a => a -> a -> Bool
> Int
1) forall a b. (a -> b) -> a -> b
$
      forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
MU.copy (forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MU.slice (Int
ix forall a. Num a => a -> a -> a
+ Int
1) (Int
excess forall a. Num a => a -> a -> a
- Int
1) MVector s a
dst) (forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MU.slice (Int
ix forall a. Num a => a -> a -> a
+ Int
1) (Int
excess forall a. Num a => a -> a -> a
- Int
1) MVector s a
src)
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
MU.read MVector s a
dst Int
ix

writeMoveAroundRead :: forall a. (Eq a, MU.Unbox a, Show a) => Gen a -> Property
writeMoveAroundRead :: forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeMoveAroundRead Gen a
gen = HasCallStack => PropertyT IO () -> Property
property forall a b. (a -> b) -> a -> b
$ do
  a
a      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  Int
ix     <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
excess <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  (forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== a
a) forall a b. (a -> b) -> a -> b
$ forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
    MVector s a
src <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MU.new (Int
ix forall a. Num a => a -> a -> a
+ Int
excess)
    MVector s a
dst <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MU.new (Int
ix forall a. Num a => a -> a -> a
+ Int
excess)
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MU.write MVector s a
dst Int
ix a
a
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
ix forall a. Ord a => a -> a -> Bool
> Int
0) forall a b. (a -> b) -> a -> b
$
      forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
MU.move (forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MU.slice Int
0 Int
ix MVector s a
dst) (forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MU.slice Int
0 Int
ix MVector s a
src)
    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
excess forall a. Ord a => a -> a -> Bool
> Int
1) forall a b. (a -> b) -> a -> b
$
      forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
MU.move (forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MU.slice (Int
ix forall a. Num a => a -> a -> a
+ Int
1) (Int
excess forall a. Num a => a -> a -> a
- Int
1) MVector s a
dst) (forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MU.slice (Int
ix forall a. Num a => a -> a -> a
+ Int
1) (Int
excess forall a. Num a => a -> a -> a
- Int
1) MVector s a
src)
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
MU.read MVector s a
dst Int
ix

-------------------------------------------------------------------------------
-- Two writes + overwrite in between

writeInitializeBetweenRead :: forall a. (Eq a, MU.Unbox a, Show a) => Gen a -> Property
writeInitializeBetweenRead :: forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeInitializeBetweenRead Gen a
gen = HasCallStack => PropertyT IO () -> Property
property forall a b. (a -> b) -> a -> b
$ do
  a
a      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  a
b      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  Int
ix     <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
dix    <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  Int
excess <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  (forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== (a
a, a
b)) forall a b. (a -> b) -> a -> b
$ forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
    MVector s a
arr <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MU.new (Int
ix forall a. Num a => a -> a -> a
+ Int
dix forall a. Num a => a -> a -> a
+ Int
excess)
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MU.write MVector s a
arr Int
ix a
a
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MU.write MVector s a
arr (Int
ix forall a. Num a => a -> a -> a
+ Int
dix) a
b
    forall (v :: * -> * -> *) a s. MVector v a => v s a -> ST s ()
MU.basicInitialize (forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MU.slice (Int
ix forall a. Num a => a -> a -> a
+ Int
1) (Int
dix forall a. Num a => a -> a -> a
- Int
1) MVector s a
arr)
    (,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
MU.read MVector s a
arr Int
ix forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
MU.read MVector s a
arr (Int
ix forall a. Num a => a -> a -> a
+ Int
dix)

writeClearBetweenRead :: forall a. (Eq a, MU.Unbox a, Show a) => Gen a -> Property
writeClearBetweenRead :: forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeClearBetweenRead Gen a
gen = HasCallStack => PropertyT IO () -> Property
property forall a b. (a -> b) -> a -> b
$ do
  a
a      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  a
b      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  Int
ix     <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
dix    <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  Int
excess <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  (forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== (a
a, a
b)) forall a b. (a -> b) -> a -> b
$ forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
    MVector s a
arr <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MU.new (Int
ix forall a. Num a => a -> a -> a
+ Int
dix forall a. Num a => a -> a -> a
+ Int
excess)
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MU.write MVector s a
arr Int
ix a
a
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MU.write MVector s a
arr (Int
ix forall a. Num a => a -> a -> a
+ Int
dix) a
b
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> m ()
MU.clear (forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MU.slice (Int
ix forall a. Num a => a -> a -> a
+ Int
1) (Int
dix forall a. Num a => a -> a -> a
- Int
1) MVector s a
arr)
    (,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
MU.read MVector s a
arr Int
ix forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
MU.read MVector s a
arr (Int
ix forall a. Num a => a -> a -> a
+ Int
dix)

writeSetBetweenRead :: forall a. (Eq a, MU.Unbox a, Show a) => Gen a -> Property
writeSetBetweenRead :: forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeSetBetweenRead Gen a
gen = HasCallStack => PropertyT IO () -> Property
property forall a b. (a -> b) -> a -> b
$ do
  a
a      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  a
b      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  a
c      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  Int
ix     <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
dix    <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  Int
excess <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  (forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== (a
a, a
b)) forall a b. (a -> b) -> a -> b
$ forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
    MVector s a
arr <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MU.new (Int
ix forall a. Num a => a -> a -> a
+ Int
dix forall a. Num a => a -> a -> a
+ Int
excess)
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MU.write MVector s a
arr Int
ix a
a
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MU.write MVector s a
arr (Int
ix forall a. Num a => a -> a -> a
+ Int
dix) a
b
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> a -> m ()
MU.set (forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MU.slice (Int
ix forall a. Num a => a -> a -> a
+ Int
1) (Int
dix forall a. Num a => a -> a -> a
- Int
1) MVector s a
arr) a
c
    (,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
MU.read MVector s a
arr Int
ix forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
MU.read MVector s a
arr (Int
ix forall a. Num a => a -> a -> a
+ Int
dix)

writeCopyBetweenRead :: forall a. (Eq a, MU.Unbox a, Show a) => Gen a -> Property
writeCopyBetweenRead :: forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeCopyBetweenRead Gen a
gen = HasCallStack => PropertyT IO () -> Property
property forall a b. (a -> b) -> a -> b
$ do
  a
a      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  a
b      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  Int
ix     <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
dix    <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  Int
excess <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  (forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== (a
a, a
b)) forall a b. (a -> b) -> a -> b
$ forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
    MVector s a
src <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MU.new (Int
ix forall a. Num a => a -> a -> a
+ Int
dix forall a. Num a => a -> a -> a
+ Int
excess)
    MVector s a
dst <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MU.new (Int
ix forall a. Num a => a -> a -> a
+ Int
dix forall a. Num a => a -> a -> a
+ Int
excess)
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MU.write MVector s a
dst Int
ix a
a
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MU.write MVector s a
dst (Int
ix forall a. Num a => a -> a -> a
+ Int
dix) a
b
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
MU.copy (forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MU.slice (Int
ix forall a. Num a => a -> a -> a
+ Int
1) (Int
dix forall a. Num a => a -> a -> a
- Int
1) MVector s a
dst) (forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MU.slice (Int
ix forall a. Num a => a -> a -> a
+ Int
1) (Int
dix forall a. Num a => a -> a -> a
- Int
1) MVector s a
src)
    (,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
MU.read MVector s a
dst Int
ix forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
MU.read MVector s a
dst (Int
ix forall a. Num a => a -> a -> a
+ Int
dix)

writeMoveBetweenRead :: forall a. (Eq a, MU.Unbox a, Show a) => Gen a -> Property
writeMoveBetweenRead :: forall a. (Eq a, Unbox a, Show a) => Gen a -> Property
writeMoveBetweenRead Gen a
gen = HasCallStack => PropertyT IO () -> Property
property forall a b. (a -> b) -> a -> b
$ do
  a
a      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  a
b      <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen a
gen
  Int
ix     <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genNonNegative
  Int
dix    <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  Int
excess <- forall (m :: * -> *) a.
(Monad m, Show a, HasCallStack) =>
Gen a -> PropertyT m a
forAll Gen Int
genPositive
  (forall (m :: * -> *) a.
(MonadTest m, Eq a, Show a, HasCallStack) =>
a -> a -> m ()
=== (a
a, a
b)) forall a b. (a -> b) -> a -> b
$ forall a. (forall s. ST s a) -> a
runST forall a b. (a -> b) -> a -> b
$ do
    MVector s a
src <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MU.new (Int
ix forall a. Num a => a -> a -> a
+ Int
dix forall a. Num a => a -> a -> a
+ Int
excess)
    MVector s a
dst <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MU.new (Int
ix forall a. Num a => a -> a -> a
+ Int
dix forall a. Num a => a -> a -> a
+ Int
excess)
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MU.write MVector s a
dst Int
ix a
a
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> a -> m ()
MU.write MVector s a
dst (Int
ix forall a. Num a => a -> a -> a
+ Int
dix) a
b
    forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
MU.move (forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MU.slice (Int
ix forall a. Num a => a -> a -> a
+ Int
1) (Int
dix forall a. Num a => a -> a -> a
- Int
1) MVector s a
dst) (forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MU.slice (Int
ix forall a. Num a => a -> a -> a
+ Int
1) (Int
dix forall a. Num a => a -> a -> a
- Int
1) MVector s a
src)
    (,) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
MU.read MVector s a
dst Int
ix forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
MVector (PrimState m) a -> Int -> m a
MU.read MVector s a
dst (Int
ix forall a. Num a => a -> a -> a
+ Int
dix)

-------------------------------------------------------------------------------
-- Utils

newSlice :: MU.Unbox a => Int -> Int -> Int -> ST s (MU.MVector s a)
newSlice :: forall a s. Unbox a => Int -> Int -> Int -> ST s (MVector s a)
newSlice Int
before Int
after Int
len = do
  MVector s a
arr <- forall (m :: * -> *) a.
(PrimMonad m, Unbox a) =>
Int -> m (MVector (PrimState m) a)
MU.new (Int
before forall a. Num a => a -> a -> a
+ Int
len forall a. Num a => a -> a -> a
+ Int
after)
  forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a s. Unbox a => Int -> Int -> MVector s a -> MVector s a
MU.slice Int
before Int
len MVector s a
arr

#endif