{-|
Module      : Z.Data.Array
Description : Fast boxed and unboxed arrays
Copyright   : (c) Dong Han, 2017
License     : BSD
Maintainer  : [email protected]
Stability   : experimental
Portability : non-portable

Unified unboxed and boxed array operations using type family.

NONE of the operations are bound checked, if you need checked operations please use "Z.Data.Array.Checked" instead.
It exports the exact same APIs ,so it requires no extra effort to switch between them.

Some mnemonics:

  * 'newArr' and 'newArrWith' return mutable array.
    'readArr' and 'writeArr' perform read and write actions on mutable arrays.
    'setArr' fills the elements with offset and length.
    'indexArr' only works on immutable Array, use 'indexArr'' to avoid thunks building up in the heap.

  * 'freezeArr' and 'thawArr' make a copy thus need slicing params.
    'unsafeFreezeArr' and 'unsafeThawArr' DO NOT COPY, use with care.

  * The order of arguements of 'copyArr', 'copyMutableArr' and 'moveArr' are always target and its offset
    come first, and source and source offset follow, copying length comes last.
-}

module Z.Data.Array.Base (
  -- * Arr typeclass
    Arr(..)
  , singletonArr, doubletonArr
  , modifyIndexArr, insertIndexArr, deleteIndexArr, swapArr, swapMutableArr
  , doubleMutableArr, shuffleMutableArr
  , RealWorld
  -- * Boxed array type
  , Array(..)
  , MutableArray(..)
  , SmallArray(..)
  , SmallMutableArray(..)
  , uninitialized
  -- * Primitive array type
  , PrimArray(..)
  , MutablePrimArray(..)
  , Prim(..)
  -- * Primitive array operations
  , newPinnedPrimArray, newAlignedPinnedPrimArray
  , copyPrimArrayToPtr, copyMutablePrimArrayToPtr, copyPtrToMutablePrimArray
  , primArrayContents, mutablePrimArrayContents, withPrimArrayContents, withMutablePrimArrayContents
  , isPrimArrayPinned, isMutablePrimArrayPinned
  -- * Unlifted array type
  , UnliftedArray(..)
  , MutableUnliftedArray(..)
  , PrimUnlifted(..)
  -- * The 'ArrayException' type
  , ArrayException(..)
  -- * Cast between primitive arrays
  , Cast
  , castArray
  , castMutableArray
  -- * Re-export
  , sizeOf
  ) where

import           Control.Exception          (ArrayException (..), throw)
import           Control.Monad
import           Control.Monad.Primitive
import           Control.Monad.ST
import           Data.Bits                  (unsafeShiftL)
import           Data.Kind                  (Type)
import           Data.Primitive.Array
import           Data.Primitive.ByteArray
#if !MIN_VERSION_primitive(0, 9, 0)
import           Data.Primitive.PrimArray
#else
import           Data.Primitive.PrimArray   hiding
                                            (withMutablePrimArrayContents,
                                             withPrimArrayContents)
#endif
import           Data.Primitive.Ptr         (copyPtrToMutablePrimArray)
import           Data.Primitive.SmallArray
import           Data.Primitive.Types
import           GHC.Exts
import           System.Random.Stateful     (StatefulGen,
                                             UniformRange (uniformRM))
import           Z.Data.Array.Cast
import           Z.Data.Array.UnliftedArray


-- | Bottom value (@throw ('UndefinedElement' 'Data.Array.uninitialized')@)
-- for new boxed array('Array', 'SmallArray'..) initialization.
--
uninitialized :: a
uninitialized :: forall a. a
uninitialized = ArrayException -> a
forall a e. Exception e => e -> a
throw (String -> ArrayException
UndefinedElement String
"Data.Array.uninitialized")


-- | The typeclass that unifies box & unboxed and mutable & immutable array operations.
--
-- Most of these functions simply wrap their primitive counterpart.
-- When there are no primitive ones, we fulfilled the semantic with other operations.
--
-- One exception is 'shrinkMutableArr' which only performs closure resizing on 'PrimArray', because
-- currently, RTS only supports that. 'shrinkMutableArr' won't do anything on other array types.
--
-- It's reasonable to trust GHC to specialize & inline these polymorphic functions.
-- They are used across this package and perform identically to their monomorphic counterpart.
--
class Arr (arr :: Type -> Type) a where


    -- | The mutable version of this array type.
    --
    type MArr arr = (mar :: Type -> Type -> Type) | mar -> arr

    -- | The empty array reference.
    emptyArr :: Arr arr a => arr a

    -- | Make a new array with a given size.
    --
    -- For boxed arrays, all elements are 'uninitialized' , which shall not be accessed.
    -- For primitive arrays, elements are just random garbage.
    newArr :: (PrimMonad m, PrimState m ~ s) => Int -> m (MArr arr s a)


    -- | Make a new array and fill it with an initial value.
    newArrWith :: (PrimMonad m, PrimState m ~ s) => Int -> a -> m (MArr arr s a)


    -- | Read from specified index of mutable array in a primitive monad.
    readArr :: (PrimMonad m, PrimState m ~ s) => MArr arr s a -> Int -> m a


    -- | Write to specified index of mutable array in a primitive monad.
    writeArr :: (PrimMonad m, PrimState m ~ s) => MArr arr s a -> Int -> a -> m ()


    -- | Fill the mutable array with a given value.
    setArr :: (PrimMonad m, PrimState m ~ s) => MArr arr s a -> Int -> Int -> a -> m ()


    -- | Read from the specified index of an immutable array. It's pure and often
    -- results in an indexing thunk for lifted arrays, use 'indexArr\'' or 'indexArrM' to avoid this.
    indexArr :: arr a -> Int -> a


    -- | Read from the specified index of an immutable array. The result is packaged into an unboxed unary tuple; the result itself is not yet evaluated.
    -- Pattern matching on the tuple forces the indexing of the array to happen but does not evaluate the element itself.
    -- Evaluating the thunk prevents additional thunks from building up on the heap.
    -- Avoiding these thunks, in turn, reduces references to the argument array, allowing it to be garbage collected more promptly.
    indexArr' :: arr a -> Int -> (# a #)


    -- | Monadically read a value from the immutable array at the given index.
    -- This allows us to be strict in the array while remaining lazy in the read
    -- element which is very useful for collective operations. Suppose we want to
    -- copy an array. We could do something like this:
    --
    -- > copy marr arr ... = do ...
    -- >                        writeArray marr i (indexArray arr i) ...
    -- >                        ...
    --
    -- But since primitive arrays are lazy, the calls to 'indexArray' will not be
    -- evaluated. Rather, @marr@ will be filled with thunks each of which would
    -- retain a reference to @arr@. This is definitely not what we want!
    --
    -- With 'indexArrayM', we can instead write
    --
    -- > copy marr arr ... = do ...
    -- >                        x <- indexArrayM arr i
    -- >                        writeArray marr i x
    -- >                        ...
    --
    -- Now, indexing is executed immediately although the returned element is
    -- still not evaluated.
    --
    -- /Note:/ this function does not do bounds checking.
    indexArrM :: (Monad m) => arr a -> Int -> m a


    -- | Create an immutable copy of a slice of an array.
    -- This operation makes a copy of the specified section, so it is safe to continue using the mutable array afterward.
    freezeArr :: (PrimMonad m, PrimState m ~ s) => MArr arr s a -> Int -> Int -> m (arr a)


    -- | Create a mutable array from a slice of an immutable array.
    -- This operation makes a copy of the specified slice, so it is safe to use the immutable array afterward.
    thawArr :: (PrimMonad m, PrimState m ~ s) => arr a -> Int -> Int -> m (MArr arr s a)


    -- | Convert a mutable array to an immutable one without copying.
    -- The array should not be modified after the conversion.
    unsafeFreezeArr :: (PrimMonad m, PrimState m ~ s) => MArr arr s a -> m (arr a)



    -- | Convert a mutable array to an immutable one without copying. The
    -- array should not be modified after the conversion.
    unsafeThawArr :: (PrimMonad m, PrimState m ~ s) => arr a -> m (MArr arr s a)


    -- | Copy a slice of an immutable array to a mutable array at given offset.
    copyArr ::  (PrimMonad m, PrimState m ~ s)
            => MArr arr s a -- ^ target
            -> Int          -- ^ offset into target array
            -> arr a        -- ^ source
            -> Int          -- ^ offset into source array
            -> Int          -- ^ number of elements to copy
            -> m ()


    -- | Copy a slice of a mutable array to another mutable array at given offset.
    -- The two mutable arrays must not be the same.
    copyMutableArr :: (PrimMonad m, PrimState m ~ s)
                   => MArr arr s a  -- ^ target
                   -> Int           -- ^ offset into target array
                   -> MArr arr s a  -- ^ source
                   -> Int           -- ^ offset into source array
                   -> Int           -- ^ number of elements to copy
                   -> m ()


    -- | Copy a slice of a mutable array to a mutable array at given offset.
    -- The two mutable arrays can be the same.
    moveArr :: (PrimMonad m, PrimState m ~ s)
            => MArr arr s a  -- ^ target
            -> Int           -- ^ offset into target array
            -> MArr arr s a  -- ^ source
            -> Int           -- ^ offset into source array
            -> Int           -- ^ number of elements to copy
            -> m ()


    -- | Create an immutable copy with the given subrange of the original array.
    cloneArr :: arr a -> Int -> Int -> arr a


    -- | Create a mutable copy the given subrange of the original array.
    cloneMutableArr :: (PrimMonad m, PrimState m ~ s) => MArr arr s a -> Int -> Int -> m (MArr arr s a)


    -- | Resize a mutable array to the given size.
    resizeMutableArr :: (PrimMonad m, PrimState m ~ s) => MArr arr s a -> Int -> m (MArr arr s a)


    -- | Shrink a mutable array to the given size. This operation only works on primitive arrays.
    -- For some array types, this is a no-op, e.g. 'sizeOfMutableArr' will not change.
    shrinkMutableArr :: (PrimMonad m, PrimState m ~ s) => MArr arr s a -> Int -> m ()


    -- | Is two mutable array are reference equal.
    sameMutableArr :: MArr arr s a -> MArr arr s a -> Bool


    -- | Size of the immutable array.
    sizeofArr :: arr a -> Int


    -- | Size of the mutable array.
    sizeofMutableArr :: (PrimMonad m, PrimState m ~ s) => MArr arr s a -> m Int


    -- | Check whether the two immutable arrays refer to the same memory block
    --
    -- Note that the result of 'sameArr' may change depending on compiler's optimizations, for example,
    -- @let arr = runST ... in arr `sameArr` arr@ may return false if compiler decides to
    -- inline it.
    --
    -- See https://ghc.haskell.org/trac/ghc/ticket/13908 for more context.
    --
    sameArr :: arr a -> arr a -> Bool

instance Arr Array a where
    type MArr Array = MutableArray
    emptyArr :: Arr Array a => Array a
emptyArr = Array a
forall a. Array a
emptyArray
    {-# INLINE emptyArr #-}
    newArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
Int -> m (MArr Array s a)
newArr Int
n = 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
uninitialized
    {-# INLINE newArr #-}
    newArrWith :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
Int -> a -> m (MArr Array s a)
newArrWith = Int -> a -> m (MutableArray (PrimState m) a)
Int -> a -> m (MArr Array s a)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (MutableArray (PrimState m) a)
newArray
    {-# INLINE newArrWith #-}
    readArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr Array s a -> Int -> m a
readArr = MutableArray (PrimState m) a -> Int -> m a
MArr Array s a -> Int -> m a
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> m a
readArray
    {-# INLINE readArr #-}
    writeArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr Array s a -> Int -> a -> m ()
writeArr = MutableArray (PrimState m) a -> Int -> a -> m ()
MArr Array s a -> Int -> a -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
writeArray
    {-# INLINE writeArr #-}
    setArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr Array s a -> Int -> Int -> a -> m ()
setArr MArr Array s a
marr Int
s Int
l a
x = Int -> m ()
go Int
s
      where
        !sl :: Int
sl = Int
s Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
l
        go :: Int -> m ()
go !Int
i | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
sl = () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
              | Bool
otherwise = MutableArray (PrimState m) a -> Int -> a -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
writeArray MutableArray (PrimState m) a
MArr Array s a
marr Int
i a
x m () -> m () -> m ()
forall a b. m a -> m b -> m b
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
+Int
1)
    {-# INLINE setArr #-}
    indexArr :: Array a -> Int -> a
indexArr = Array a -> Int -> a
forall a. Array a -> Int -> a
indexArray
    {-# INLINE indexArr #-}
    indexArr' :: Array a -> Int -> (# a #)
indexArr' (Array Array# a
arr#) (I# Int#
i#) = Array# a -> Int# -> (# a #)
forall a. Array# a -> Int# -> (# a #)
indexArray# Array# a
arr# Int#
i#
    {-# INLINE indexArr' #-}
    indexArrM :: forall (m :: * -> *). Monad m => Array a -> Int -> m a
indexArrM = Array a -> Int -> m a
forall (m :: * -> *) a. Applicative m => Array a -> Int -> m a
indexArrayM
    {-# INLINE indexArrM #-}
    freezeArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr Array s a -> Int -> Int -> m (Array a)
freezeArr = MutableArray (PrimState m) a -> Int -> Int -> m (Array a)
MArr Array s a -> Int -> Int -> m (Array a)
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> Int -> m (Array a)
freezeArray
    {-# INLINE freezeArr #-}
    thawArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
Array a -> Int -> Int -> m (MArr Array s a)
thawArr = Array a -> Int -> Int -> m (MutableArray (PrimState m) a)
Array a -> Int -> Int -> m (MArr Array s a)
forall (m :: * -> *) a.
PrimMonad m =>
Array a -> Int -> Int -> m (MutableArray (PrimState m) a)
thawArray
    {-# INLINE thawArr #-}
    unsafeFreezeArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr Array s a -> m (Array a)
unsafeFreezeArr = MutableArray (PrimState m) a -> m (Array a)
MArr Array s a -> m (Array a)
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> m (Array a)
unsafeFreezeArray
    {-# INLINE unsafeFreezeArr #-}
    unsafeThawArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
Array a -> m (MArr Array s a)
unsafeThawArr = Array a -> m (MutableArray (PrimState m) a)
Array a -> m (MArr Array s a)
forall (m :: * -> *) a.
PrimMonad m =>
Array a -> m (MutableArray (PrimState m) a)
unsafeThawArray
    {-# INLINE unsafeThawArr #-}

    copyArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr Array s a -> Int -> Array a -> Int -> Int -> m ()
copyArr = MutableArray (PrimState m) a
-> Int -> Array a -> Int -> Int -> m ()
MArr Array s a -> Int -> Array a -> Int -> Int -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a
-> Int -> Array a -> Int -> Int -> m ()
copyArray
    {-# INLINE copyArr #-}
    copyMutableArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr Array s a -> Int -> MArr Array s a -> Int -> Int -> m ()
copyMutableArr = MutableArray (PrimState m) a
-> Int -> MutableArray (PrimState m) a -> Int -> Int -> m ()
MArr Array s a -> Int -> MArr Array s a -> Int -> Int -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a
-> Int -> MutableArray (PrimState m) a -> Int -> Int -> m ()
copyMutableArray
    {-# INLINE copyMutableArr #-}

    moveArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr Array s a -> Int -> MArr Array s a -> Int -> Int -> m ()
moveArr MArr Array s a
marr1 Int
s1 MArr Array s a
marr2 Int
s2 Int
l
        | Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0 = () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
        | MutableArray s a -> MutableArray s a -> Bool
forall s a. MutableArray s a -> MutableArray s a -> Bool
sameMutableArray MutableArray s a
MArr Array s a
marr1 MutableArray s a
MArr Array s a
marr2 =
            case Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Int
s1 Int
s2 of
                Ordering
LT ->
                    let !d :: Int
d = Int
s2 Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
s1
                        !s2l :: Int
s2l = Int
s2 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
l
                        go :: Int -> m ()
go !Int
i | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
s2l = () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
                              | Bool
otherwise = 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
MArr Array s a
marr2 Int
i
                                               MutableArray (PrimState m) a -> Int -> a -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
writeArray MutableArray (PrimState m) a
MArr Array s a
marr1 (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
d) a
x
                                               Int -> m ()
go (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1)
                    in Int -> m ()
go Int
s2

                Ordering
EQ -> () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

                Ordering
GT ->
                    let !d :: Int
d = Int
s1 Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
s2
                        go :: Int -> m ()
go !Int
i | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
s2 = () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
                              | Bool
otherwise = 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
MArr Array s a
marr2 Int
i
                                               MutableArray (PrimState m) a -> Int -> a -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a -> Int -> a -> m ()
writeArray MutableArray (PrimState m) a
MArr Array s a
marr1 (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
d) a
x
                                               Int -> m ()
go (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)
                    in Int -> m ()
go (Int
s2Int -> Int -> Int
forall a. Num a => a -> a -> a
+Int
lInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)
        | Bool
otherwise = 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
MArr Array s a
marr1 Int
s1 MutableArray (PrimState m) a
MArr Array s a
marr2 Int
s2 Int
l
    {-# INLINE moveArr #-}

    cloneArr :: Array a -> Int -> Int -> Array a
cloneArr = Array a -> Int -> Int -> Array a
forall a. Array a -> Int -> Int -> Array a
cloneArray
    {-# INLINE cloneArr #-}
    cloneMutableArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr Array s a -> Int -> Int -> m (MArr Array s a)
cloneMutableArr = MutableArray (PrimState m) a
-> Int -> Int -> m (MutableArray (PrimState m) a)
MArr Array s a -> Int -> Int -> m (MArr Array s a)
forall (m :: * -> *) a.
PrimMonad m =>
MutableArray (PrimState m) a
-> Int -> Int -> m (MutableArray (PrimState m) a)
cloneMutableArray
    {-# INLINE cloneMutableArr #-}

    resizeMutableArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr Array s a -> Int -> m (MArr Array s a)
resizeMutableArr MArr Array s a
marr Int
n = do
        MutableArray s a
marr' <- 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
uninitialized
        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 s a
MutableArray (PrimState m) a
marr' Int
0 MutableArray (PrimState m) a
MArr Array s a
marr Int
0 (MutableArray s a -> Int
forall s a. MutableArray s a -> Int
sizeofMutableArray MutableArray s a
MArr Array s a
marr)
        MutableArray s a -> m (MutableArray s a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return MutableArray s a
marr'
    {-# INLINE resizeMutableArr #-}
    shrinkMutableArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr Array s a -> Int -> m ()
shrinkMutableArr MArr Array s a
_ Int
_ = () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
    {-# INLINE shrinkMutableArr #-}

    sameMutableArr :: forall s. MArr Array s a -> MArr Array s a -> Bool
sameMutableArr = MutableArray s a -> MutableArray s a -> Bool
MArr Array s a -> MArr Array s a -> Bool
forall s a. MutableArray s a -> MutableArray s a -> Bool
sameMutableArray
    {-# INLINE sameMutableArr #-}
    sizeofArr :: Array a -> Int
sizeofArr = Array a -> Int
forall a. Array a -> Int
sizeofArray
    {-# INLINE sizeofArr #-}
    sizeofMutableArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr Array s a -> m Int
sizeofMutableArr = Int -> m Int
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> m Int)
-> (MutableArray s a -> Int) -> MutableArray s a -> m Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MutableArray s a -> Int
forall s a. MutableArray s a -> Int
sizeofMutableArray
    {-# INLINE sizeofMutableArr #-}

    sameArr :: Array a -> Array a -> Bool
sameArr (Array Array# a
arr1#) (Array Array# a
arr2#) = Int# -> Bool
isTrue# (
        MutableArray# Any Any -> MutableArray# Any Any -> Int#
forall s a. MutableArray# s a -> MutableArray# s a -> Int#
sameMutableArray# (Array# a -> MutableArray# Any Any
forall a b. a -> b
unsafeCoerce# Array# a
arr1#) (Array# a -> MutableArray# Any Any
forall a b. a -> b
unsafeCoerce# Array# a
arr2#))
    {-# INLINE sameArr #-}

instance Arr SmallArray a where
    type MArr SmallArray = SmallMutableArray
    emptyArr :: Arr SmallArray a => SmallArray a
emptyArr = SmallArray a
forall a. SmallArray a
emptySmallArray
    {-# INLINE emptyArr #-}
    newArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
Int -> m (MArr SmallArray s a)
newArr Int
n = Int -> a -> m (SmallMutableArray (PrimState m) a)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
newSmallArray Int
n a
forall a. a
uninitialized
    {-# INLINE newArr #-}
    newArrWith :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
Int -> a -> m (MArr SmallArray s a)
newArrWith = Int -> a -> m (SmallMutableArray (PrimState m) a)
Int -> a -> m (MArr SmallArray s a)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
newSmallArray
    {-# INLINE newArrWith #-}
    readArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr SmallArray s a -> Int -> m a
readArr = SmallMutableArray (PrimState m) a -> Int -> m a
MArr SmallArray s a -> Int -> m a
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> m a
readSmallArray
    {-# INLINE readArr #-}
    writeArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr SmallArray s a -> Int -> a -> m ()
writeArr = SmallMutableArray (PrimState m) a -> Int -> a -> m ()
MArr SmallArray s a -> Int -> a -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
writeSmallArray
    {-# INLINE writeArr #-}
    setArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr SmallArray s a -> Int -> Int -> a -> m ()
setArr MArr SmallArray s a
marr Int
s Int
l a
x = Int -> m ()
go Int
s
      where
        !sl :: Int
sl = Int
s Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
l
        go :: Int -> m ()
go !Int
i | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
sl = () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
              | Bool
otherwise = SmallMutableArray (PrimState m) a -> Int -> a -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
writeSmallArray SmallMutableArray (PrimState m) a
MArr SmallArray s a
marr Int
i a
x m () -> m () -> m ()
forall a b. m a -> m b -> m b
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
+Int
1)
    {-# INLINE setArr #-}
    indexArr :: SmallArray a -> Int -> a
indexArr = SmallArray a -> Int -> a
forall a. SmallArray a -> Int -> a
indexSmallArray
    {-# INLINE indexArr #-}
    indexArr' :: SmallArray a -> Int -> (# a #)
indexArr' (SmallArray SmallArray# a
arr#) (I# Int#
i#) = SmallArray# a -> Int# -> (# a #)
forall a. SmallArray# a -> Int# -> (# a #)
indexSmallArray# SmallArray# a
arr# Int#
i#
    {-# INLINE indexArr' #-}
    indexArrM :: forall (m :: * -> *). Monad m => SmallArray a -> Int -> m a
indexArrM = SmallArray a -> Int -> m a
forall (m :: * -> *) a. Applicative m => SmallArray a -> Int -> m a
indexSmallArrayM
    {-# INLINE indexArrM #-}
    freezeArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr SmallArray s a -> Int -> Int -> m (SmallArray a)
freezeArr = SmallMutableArray (PrimState m) a -> Int -> Int -> m (SmallArray a)
MArr SmallArray s a -> Int -> Int -> m (SmallArray a)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> Int -> m (SmallArray a)
freezeSmallArray
    {-# INLINE freezeArr #-}
    thawArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
SmallArray a -> Int -> Int -> m (MArr SmallArray s a)
thawArr = SmallArray a -> Int -> Int -> m (SmallMutableArray (PrimState m) a)
SmallArray a -> Int -> Int -> m (MArr SmallArray s a)
forall (m :: * -> *) a.
PrimMonad m =>
SmallArray a -> Int -> Int -> m (SmallMutableArray (PrimState m) a)
thawSmallArray
    {-# INLINE thawArr #-}
    unsafeFreezeArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr SmallArray s a -> m (SmallArray a)
unsafeFreezeArr = SmallMutableArray (PrimState m) a -> m (SmallArray a)
MArr SmallArray s a -> m (SmallArray a)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> m (SmallArray a)
unsafeFreezeSmallArray
    {-# INLINE unsafeFreezeArr #-}
    unsafeThawArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
SmallArray a -> m (MArr SmallArray s a)
unsafeThawArr = SmallArray a -> m (SmallMutableArray (PrimState m) a)
SmallArray a -> m (MArr SmallArray s a)
forall (m :: * -> *) a.
PrimMonad m =>
SmallArray a -> m (SmallMutableArray (PrimState m) a)
unsafeThawSmallArray
    {-# INLINE unsafeThawArr #-}

    copyArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr SmallArray s a -> Int -> SmallArray a -> Int -> Int -> m ()
copyArr = SmallMutableArray (PrimState m) a
-> Int -> SmallArray a -> Int -> Int -> m ()
MArr SmallArray s a -> Int -> SmallArray a -> Int -> Int -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a
-> Int -> SmallArray a -> Int -> Int -> m ()
copySmallArray
    {-# INLINE copyArr #-}
    copyMutableArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr SmallArray s a
-> Int -> MArr SmallArray s a -> Int -> Int -> m ()
copyMutableArr = SmallMutableArray (PrimState m) a
-> Int -> SmallMutableArray (PrimState m) a -> Int -> Int -> m ()
MArr SmallArray s a
-> Int -> MArr SmallArray s a -> Int -> Int -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a
-> Int -> SmallMutableArray (PrimState m) a -> Int -> Int -> m ()
copySmallMutableArray
    {-# INLINE copyMutableArr #-}

    moveArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr SmallArray s a
-> Int -> MArr SmallArray s a -> Int -> Int -> m ()
moveArr MArr SmallArray s a
marr1 Int
s1 MArr SmallArray s a
marr2 Int
s2 Int
l
        | Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0 = () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
        | MArr SmallArray s a -> MArr SmallArray s a -> Bool
forall s. MArr SmallArray s a -> MArr SmallArray s a -> Bool
forall (arr :: * -> *) a s.
Arr arr a =>
MArr arr s a -> MArr arr s a -> Bool
sameMutableArr MArr SmallArray s a
marr1 MArr SmallArray s a
marr2 =
            case Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Int
s1 Int
s2 of
                Ordering
LT ->
                    let !d :: Int
d = Int
s2 Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
s1
                        !s2l :: Int
s2l = Int
s2 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
l
                        go :: Int -> m ()
go !Int
i | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
s2l = () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
                              | Bool
otherwise = do a
x <- SmallMutableArray (PrimState m) a -> Int -> m a
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> m a
readSmallArray SmallMutableArray (PrimState m) a
MArr SmallArray s a
marr2 Int
i
                                               SmallMutableArray (PrimState m) a -> Int -> a -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
writeSmallArray SmallMutableArray (PrimState m) a
MArr SmallArray s a
marr1 (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
d) a
x
                                               Int -> m ()
go (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1)
                    in Int -> m ()
go Int
s2

                Ordering
EQ -> () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

                Ordering
GT ->
                    let !d :: Int
d = Int
s1 Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
s2
                        go :: Int -> m ()
go !Int
i | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
s2 = () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
                              | Bool
otherwise = do a
x <- SmallMutableArray (PrimState m) a -> Int -> m a
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> m a
readSmallArray SmallMutableArray (PrimState m) a
MArr SmallArray s a
marr2 Int
i
                                               SmallMutableArray (PrimState m) a -> Int -> a -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
writeSmallArray SmallMutableArray (PrimState m) a
MArr SmallArray s a
marr1 (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
d) a
x
                                               Int -> m ()
go (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)
                    in Int -> m ()
go (Int
s2Int -> Int -> Int
forall a. Num a => a -> a -> a
+Int
lInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)
        | Bool
otherwise = SmallMutableArray (PrimState m) a
-> Int -> SmallMutableArray (PrimState m) a -> Int -> Int -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a
-> Int -> SmallMutableArray (PrimState m) a -> Int -> Int -> m ()
copySmallMutableArray SmallMutableArray (PrimState m) a
MArr SmallArray s a
marr1 Int
s1 SmallMutableArray (PrimState m) a
MArr SmallArray s a
marr2 Int
s2 Int
l
    {-# INLINE moveArr #-}

    cloneArr :: SmallArray a -> Int -> Int -> SmallArray a
cloneArr = SmallArray a -> Int -> Int -> SmallArray a
forall a. SmallArray a -> Int -> Int -> SmallArray a
cloneSmallArray
    {-# INLINE cloneArr #-}
    cloneMutableArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr SmallArray s a -> Int -> Int -> m (MArr SmallArray s a)
cloneMutableArr = SmallMutableArray (PrimState m) a
-> Int -> Int -> m (SmallMutableArray (PrimState m) a)
MArr SmallArray s a -> Int -> Int -> m (MArr SmallArray s a)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a
-> Int -> Int -> m (SmallMutableArray (PrimState m) a)
cloneSmallMutableArray
    {-# INLINE cloneMutableArr #-}

    resizeMutableArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr SmallArray s a -> Int -> m (MArr SmallArray s a)
resizeMutableArr MArr SmallArray s a
marr Int
n = do
        SmallMutableArray s a
marr' <- Int -> a -> m (SmallMutableArray (PrimState m) a)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
newSmallArray Int
n a
forall a. a
uninitialized
        SmallMutableArray (PrimState m) a
-> Int -> SmallMutableArray (PrimState m) a -> Int -> Int -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a
-> Int -> SmallMutableArray (PrimState m) a -> Int -> Int -> m ()
copySmallMutableArray SmallMutableArray s a
SmallMutableArray (PrimState m) a
marr' Int
0 SmallMutableArray (PrimState m) a
MArr SmallArray s a
marr Int
0 (SmallMutableArray s a -> Int
forall s a. SmallMutableArray s a -> Int
sizeofSmallMutableArray SmallMutableArray s a
MArr SmallArray s a
marr)
        SmallMutableArray s a -> m (SmallMutableArray s a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return SmallMutableArray s a
marr'
    {-# INLINE resizeMutableArr #-}
    shrinkMutableArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr SmallArray s a -> Int -> m ()
shrinkMutableArr = SmallMutableArray (PrimState m) a -> Int -> m ()
MArr SmallArray s a -> Int -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> m ()
shrinkSmallMutableArray
    {-# INLINE shrinkMutableArr #-}

    sameMutableArr :: forall s. MArr SmallArray s a -> MArr SmallArray s a -> Bool
sameMutableArr (SmallMutableArray SmallMutableArray# s a
smarr1#) (SmallMutableArray SmallMutableArray# s a
smarr2#) =
        Int# -> Bool
isTrue# (SmallMutableArray# s a -> SmallMutableArray# s a -> Int#
forall s a.
SmallMutableArray# s a -> SmallMutableArray# s a -> Int#
sameSmallMutableArray# SmallMutableArray# s a
smarr1# SmallMutableArray# s a
smarr2#)
    {-# INLINE sameMutableArr #-}
    sizeofArr :: SmallArray a -> Int
sizeofArr = SmallArray a -> Int
forall a. SmallArray a -> Int
sizeofSmallArray
    {-# INLINE sizeofArr #-}
    sizeofMutableArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr SmallArray s a -> m Int
sizeofMutableArr = Int -> m Int
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> m Int)
-> (SmallMutableArray s a -> Int) -> SmallMutableArray s a -> m Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SmallMutableArray s a -> Int
forall s a. SmallMutableArray s a -> Int
sizeofSmallMutableArray
    {-# INLINE sizeofMutableArr #-}

    sameArr :: SmallArray a -> SmallArray a -> Bool
sameArr (SmallArray SmallArray# a
arr1#) (SmallArray SmallArray# a
arr2#) = Int# -> Bool
isTrue# (
        SmallMutableArray# Any Any -> SmallMutableArray# Any Any -> Int#
forall s a.
SmallMutableArray# s a -> SmallMutableArray# s a -> Int#
sameSmallMutableArray# (SmallArray# a -> SmallMutableArray# Any Any
forall a b. a -> b
unsafeCoerce# SmallArray# a
arr1#) (SmallArray# a -> SmallMutableArray# Any Any
forall a b. a -> b
unsafeCoerce# SmallArray# a
arr2#))
    {-# INLINE sameArr #-}

instance Prim a => Arr PrimArray a where
    type MArr PrimArray = MutablePrimArray
    emptyArr :: Arr PrimArray a => PrimArray a
emptyArr = PrimArray a
forall a. PrimArray a
emptyPrimArray
    {-# INLINE emptyArr #-}
    newArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
Int -> m (MArr PrimArray s a)
newArr = Int -> m (MutablePrimArray (PrimState m) a)
Int -> m (MArr PrimArray s a)
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
Int -> m (MutablePrimArray (PrimState m) a)
newPrimArray
    {-# INLINE newArr #-}
    newArrWith :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
Int -> a -> m (MArr PrimArray s a)
newArrWith Int
n a
x = do
        MutablePrimArray s a
marr <- Int -> m (MutablePrimArray (PrimState m) a)
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
Int -> m (MutablePrimArray (PrimState m) a)
newPrimArray Int
n
        Bool -> m () -> m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0) (MutablePrimArray (PrimState m) a -> Int -> Int -> a -> m ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutablePrimArray (PrimState m) a -> Int -> Int -> a -> m ()
setPrimArray MutablePrimArray s a
MutablePrimArray (PrimState m) a
marr Int
0 Int
n a
x)
        MutablePrimArray s a -> m (MutablePrimArray s a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return MutablePrimArray s a
marr
    {-# INLINE newArrWith #-}
    readArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr PrimArray s a -> Int -> m a
readArr = MutablePrimArray (PrimState m) a -> Int -> m a
MArr PrimArray s a -> Int -> m a
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutablePrimArray (PrimState m) a -> Int -> m a
readPrimArray
    {-# INLINE readArr #-}
    writeArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr PrimArray s a -> Int -> a -> m ()
writeArr = MutablePrimArray (PrimState m) a -> Int -> a -> m ()
MArr PrimArray s a -> Int -> a -> m ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutablePrimArray (PrimState m) a -> Int -> a -> m ()
writePrimArray
    {-# INLINE writeArr #-}
    setArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr PrimArray s a -> Int -> Int -> a -> m ()
setArr = MutablePrimArray (PrimState m) a -> Int -> Int -> a -> m ()
MArr PrimArray s a -> Int -> Int -> a -> m ()
forall a (m :: * -> *).
(Prim a, PrimMonad m) =>
MutablePrimArray (PrimState m) a -> Int -> Int -> a -> m ()
setPrimArray
    {-# INLINE setArr #-}
    indexArr :: PrimArray a -> Int -> a
indexArr = PrimArray a -> Int -> a
forall a. Prim a => PrimArray a -> Int -> a
indexPrimArray
    {-# INLINE indexArr #-}
    indexArr' :: PrimArray a -> Int -> (# a #)
indexArr' PrimArray a
arr Int
i = (# PrimArray a -> Int -> a
forall a. Prim a => PrimArray a -> Int -> a
indexPrimArray PrimArray a
arr Int
i #)
    {-# INLINE indexArr' #-}
    indexArrM :: forall (m :: * -> *). Monad m => PrimArray a -> Int -> m a
indexArrM PrimArray a
arr Int
i = a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (PrimArray a -> Int -> a
forall a. Prim a => PrimArray a -> Int -> a
indexPrimArray PrimArray a
arr Int
i)
    {-# INLINE indexArrM #-}
    freezeArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr PrimArray s a -> Int -> Int -> m (PrimArray a)
freezeArr = MutablePrimArray (PrimState m) a -> Int -> Int -> m (PrimArray a)
MArr PrimArray s a -> Int -> Int -> m (PrimArray a)
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
MutablePrimArray (PrimState m) a -> Int -> Int -> m (PrimArray a)
freezePrimArray
    {-# INLINE freezeArr #-}
    thawArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
PrimArray a -> Int -> Int -> m (MArr PrimArray s a)
thawArr = PrimArray a -> Int -> Int -> m (MutablePrimArray (PrimState m) a)
PrimArray a -> Int -> Int -> m (MArr PrimArray s a)
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
PrimArray a -> Int -> Int -> m (MutablePrimArray (PrimState m) a)
thawPrimArray
    {-# INLINE thawArr #-}
    unsafeFreezeArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr PrimArray s a -> m (PrimArray a)
unsafeFreezeArr = MutablePrimArray (PrimState m) a -> m (PrimArray a)
MArr PrimArray s a -> m (PrimArray a)
forall (m :: * -> *) a.
PrimMonad m =>
MutablePrimArray (PrimState m) a -> m (PrimArray a)
unsafeFreezePrimArray
    {-# INLINE unsafeFreezeArr #-}
    unsafeThawArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
PrimArray a -> m (MArr PrimArray s a)
unsafeThawArr = PrimArray a -> m (MutablePrimArray (PrimState m) a)
PrimArray a -> m (MArr PrimArray s a)
forall (m :: * -> *) a.
PrimMonad m =>
PrimArray a -> m (MutablePrimArray (PrimState m) a)
unsafeThawPrimArray
    {-# INLINE unsafeThawArr #-}

    copyArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr PrimArray s a -> Int -> PrimArray a -> Int -> Int -> m ()
copyArr = MutablePrimArray (PrimState m) a
-> Int -> PrimArray a -> Int -> Int -> m ()
MArr PrimArray s a -> Int -> PrimArray a -> Int -> Int -> m ()
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
MutablePrimArray (PrimState m) a
-> Int -> PrimArray a -> Int -> Int -> m ()
copyPrimArray
    {-# INLINE copyArr #-}
    copyMutableArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr PrimArray s a
-> Int -> MArr PrimArray s a -> Int -> Int -> m ()
copyMutableArr = MutablePrimArray (PrimState m) a
-> Int -> MutablePrimArray (PrimState m) a -> Int -> Int -> m ()
MArr PrimArray s a
-> Int -> MArr PrimArray s a -> Int -> Int -> m ()
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
MutablePrimArray (PrimState m) a
-> Int -> MutablePrimArray (PrimState m) a -> Int -> Int -> m ()
copyMutablePrimArray
    {-# INLINE copyMutableArr #-}

    moveArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr PrimArray s a
-> Int -> MArr PrimArray s a -> Int -> Int -> m ()
moveArr (MutablePrimArray MutableByteArray# s
dst) Int
doff (MutablePrimArray MutableByteArray# s
src) Int
soff Int
n =
        MutableByteArray (PrimState m)
-> Int -> MutableByteArray (PrimState m) -> Int -> Int -> m ()
forall (m :: * -> *).
PrimMonad m =>
MutableByteArray (PrimState m)
-> Int -> MutableByteArray (PrimState m) -> Int -> Int -> m ()
moveByteArray (MutableByteArray# s -> MutableByteArray s
forall s. MutableByteArray# s -> MutableByteArray s
MutableByteArray MutableByteArray# s
dst) (Int
doffInt -> Int -> Int
forall a. Num a => a -> a -> a
*Int
siz) (MutableByteArray# s -> MutableByteArray s
forall s. MutableByteArray# s -> MutableByteArray s
MutableByteArray MutableByteArray# s
src) (Int
soffInt -> Int -> Int
forall a. Num a => a -> a -> a
*Int
siz) (Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
*Int
siz)
      where siz :: Int
siz = a -> Int
forall a. Prim a => a -> Int
sizeOf (a
forall a. HasCallStack => a
undefined :: a)
    {-# INLINE moveArr #-}

    cloneArr :: PrimArray a -> Int -> Int -> PrimArray a
cloneArr = PrimArray a -> Int -> Int -> PrimArray a
forall a. Prim a => PrimArray a -> Int -> Int -> PrimArray a
clonePrimArray
    {-# INLINE cloneArr #-}
    cloneMutableArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr PrimArray s a -> Int -> Int -> m (MArr PrimArray s a)
cloneMutableArr = MutablePrimArray (PrimState m) a
-> Int -> Int -> m (MutablePrimArray (PrimState m) a)
MArr PrimArray s a -> Int -> Int -> m (MArr PrimArray s a)
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
MutablePrimArray (PrimState m) a
-> Int -> Int -> m (MutablePrimArray (PrimState m) a)
cloneMutablePrimArray
    {-# INLINE cloneMutableArr #-}

    resizeMutableArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr PrimArray s a -> Int -> m (MArr PrimArray s a)
resizeMutableArr = MutablePrimArray (PrimState m) a
-> Int -> m (MutablePrimArray (PrimState m) a)
MArr PrimArray s a -> Int -> m (MArr PrimArray s a)
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
MutablePrimArray (PrimState m) a
-> Int -> m (MutablePrimArray (PrimState m) a)
resizeMutablePrimArray
    {-# INLINE resizeMutableArr #-}
    shrinkMutableArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr PrimArray s a -> Int -> m ()
shrinkMutableArr = MutablePrimArray (PrimState m) a -> Int -> m ()
MArr PrimArray s a -> Int -> m ()
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
MutablePrimArray (PrimState m) a -> Int -> m ()
shrinkMutablePrimArray
    {-# INLINE shrinkMutableArr #-}

    sameMutableArr :: forall s. MArr PrimArray s a -> MArr PrimArray s a -> Bool
sameMutableArr = MutablePrimArray s a -> MutablePrimArray s a -> Bool
MArr PrimArray s a -> MArr PrimArray s a -> Bool
forall s a. MutablePrimArray s a -> MutablePrimArray s a -> Bool
sameMutablePrimArray
    {-# INLINE sameMutableArr #-}
    sizeofArr :: PrimArray a -> Int
sizeofArr = PrimArray a -> Int
forall a. Prim a => PrimArray a -> Int
sizeofPrimArray
    {-# INLINE sizeofArr #-}
    sizeofMutableArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr PrimArray s a -> m Int
sizeofMutableArr = MutablePrimArray (PrimState m) a -> m Int
MArr PrimArray s a -> m Int
forall (m :: * -> *) a.
(PrimMonad m, Prim a) =>
MutablePrimArray (PrimState m) a -> m Int
getSizeofMutablePrimArray
    {-# INLINE sizeofMutableArr #-}

    sameArr :: PrimArray a -> PrimArray a -> Bool
sameArr (PrimArray ByteArray#
ba1#) (PrimArray ByteArray#
ba2#) =
        Int# -> Bool
isTrue# (MutableByteArray# Any -> MutableByteArray# Any -> Int#
forall s. MutableByteArray# s -> MutableByteArray# s -> Int#
sameMutableByteArray# (ByteArray# -> MutableByteArray# Any
forall a b. a -> b
unsafeCoerce# ByteArray#
ba1#) (ByteArray# -> MutableByteArray# Any
forall a b. a -> b
unsafeCoerce# ByteArray#
ba2#))
    {-# INLINE sameArr #-}

instance PrimUnlifted a => Arr UnliftedArray a where
    type MArr UnliftedArray = MutableUnliftedArray
    emptyArr :: Arr UnliftedArray a => UnliftedArray a
emptyArr = UnliftedArray a
forall a. PrimUnlifted a => UnliftedArray a
emptyUnliftedArray
    {-# INLINE emptyArr #-}
    newArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
Int -> m (MArr UnliftedArray s a)
newArr = Int -> m (MutableUnliftedArray (PrimState m) a)
Int -> m (MArr UnliftedArray s a)
forall {k} (m :: * -> *) (a :: k).
PrimMonad m =>
Int -> m (MutableUnliftedArray (PrimState m) a)
unsafeNewUnliftedArray
    {-# INLINE newArr #-}
    newArrWith :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
Int -> a -> m (MArr UnliftedArray s a)
newArrWith = Int -> a -> m (MutableUnliftedArray (PrimState m) a)
Int -> a -> m (MArr UnliftedArray s a)
forall (m :: * -> *) a.
(PrimMonad m, PrimUnlifted a) =>
Int -> a -> m (MutableUnliftedArray (PrimState m) a)
newUnliftedArray
    {-# INLINE newArrWith #-}
    readArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr UnliftedArray s a -> Int -> m a
readArr = MutableUnliftedArray (PrimState m) a -> Int -> m a
MArr UnliftedArray s a -> Int -> m a
forall (m :: * -> *) a.
(PrimMonad m, PrimUnlifted a) =>
MutableUnliftedArray (PrimState m) a -> Int -> m a
readUnliftedArray
    {-# INLINE readArr #-}
    writeArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr UnliftedArray s a -> Int -> a -> m ()
writeArr = MutableUnliftedArray (PrimState m) a -> Int -> a -> m ()
MArr UnliftedArray s a -> Int -> a -> m ()
forall (m :: * -> *) a.
(PrimMonad m, PrimUnlifted a) =>
MutableUnliftedArray (PrimState m) a -> Int -> a -> m ()
writeUnliftedArray
    {-# INLINE writeArr #-}
    setArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr UnliftedArray s a -> Int -> Int -> a -> m ()
setArr = MutableUnliftedArray (PrimState m) a -> Int -> Int -> a -> m ()
MArr UnliftedArray s a -> Int -> Int -> a -> m ()
forall (m :: * -> *) a.
(PrimMonad m, PrimUnlifted a) =>
MutableUnliftedArray (PrimState m) a -> Int -> Int -> a -> m ()
setUnliftedArray
    {-# INLINE setArr #-}
    indexArr :: UnliftedArray a -> Int -> a
indexArr = UnliftedArray a -> Int -> a
forall a. PrimUnlifted a => UnliftedArray a -> Int -> a
indexUnliftedArray
    {-# INLINE indexArr #-}
    indexArr' :: UnliftedArray a -> Int -> (# a #)
indexArr' UnliftedArray a
arr Int
i = (# UnliftedArray a -> Int -> a
forall a. PrimUnlifted a => UnliftedArray a -> Int -> a
indexUnliftedArray UnliftedArray a
arr Int
i #)
    {-# INLINE indexArr' #-}
    indexArrM :: forall (m :: * -> *). Monad m => UnliftedArray a -> Int -> m a
indexArrM UnliftedArray a
arr Int
i = a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (UnliftedArray a -> Int -> a
forall a. PrimUnlifted a => UnliftedArray a -> Int -> a
indexUnliftedArray UnliftedArray a
arr Int
i)
    {-# INLINE indexArrM #-}
    freezeArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr UnliftedArray s a -> Int -> Int -> m (UnliftedArray a)
freezeArr = MutableUnliftedArray (PrimState m) a
-> Int -> Int -> m (UnliftedArray a)
MArr UnliftedArray s a -> Int -> Int -> m (UnliftedArray a)
forall {k} (m :: * -> *) (a :: k).
PrimMonad m =>
MutableUnliftedArray (PrimState m) a
-> Int -> Int -> m (UnliftedArray a)
freezeUnliftedArray
    {-# INLINE freezeArr #-}
    thawArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
UnliftedArray a -> Int -> Int -> m (MArr UnliftedArray s a)
thawArr = UnliftedArray a
-> Int -> Int -> m (MutableUnliftedArray (PrimState m) a)
UnliftedArray a -> Int -> Int -> m (MArr UnliftedArray s a)
forall {k} (m :: * -> *) (a :: k).
PrimMonad m =>
UnliftedArray a
-> Int -> Int -> m (MutableUnliftedArray (PrimState m) a)
thawUnliftedArray
    {-# INLINE thawArr #-}
    unsafeFreezeArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr UnliftedArray s a -> m (UnliftedArray a)
unsafeFreezeArr = MutableUnliftedArray (PrimState m) a -> m (UnliftedArray a)
MArr UnliftedArray s a -> m (UnliftedArray a)
forall {k} (m :: * -> *) (a :: k).
PrimMonad m =>
MutableUnliftedArray (PrimState m) a -> m (UnliftedArray a)
unsafeFreezeUnliftedArray
    {-# INLINE unsafeFreezeArr #-}
    unsafeThawArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
UnliftedArray a -> m (MArr UnliftedArray s a)
unsafeThawArr (UnliftedArray ArrayArray#
arr#) = (State# (PrimState m)
 -> (# State# (PrimState m), MutableUnliftedArray s a #))
-> m (MutableUnliftedArray s a)
forall a.
(State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
forall (m :: * -> *) a.
PrimMonad m =>
(State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
primitive ( \ State# (PrimState m)
s0# ->
            let !(# State# s
s1#, MutableArray# s Any
marr# #) = Array# Any -> State# s -> (# State# s, MutableArray# s Any #)
forall a d.
Array# a -> State# d -> (# State# d, MutableArray# d a #)
unsafeThawArray# (ArrayArray# -> Array# Any
forall a b. a -> b
unsafeCoerce# ArrayArray#
arr#) State# s
State# (PrimState m)
s0#
                                                        -- ArrayArray# and Array# use the same representation
            in (# State# s
State# (PrimState m)
s1#, MutableArrayArray# s -> MutableUnliftedArray s a
forall {k} s (a :: k).
MutableArrayArray# s -> MutableUnliftedArray s a
MutableUnliftedArray (MutableArray# s Any -> MutableArrayArray# s
forall a b. a -> b
unsafeCoerce# MutableArray# s Any
marr#) #)    -- so this works
        )
    {-# INLINE unsafeThawArr #-}

    copyArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr UnliftedArray s a
-> Int -> UnliftedArray a -> Int -> Int -> m ()
copyArr = MutableUnliftedArray (PrimState m) a
-> Int -> UnliftedArray a -> Int -> Int -> m ()
MArr UnliftedArray s a
-> Int -> UnliftedArray a -> Int -> Int -> m ()
forall {k} (m :: * -> *) (a :: k).
PrimMonad m =>
MutableUnliftedArray (PrimState m) a
-> Int -> UnliftedArray a -> Int -> Int -> m ()
copyUnliftedArray
    {-# INLINE copyArr #-}
    copyMutableArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr UnliftedArray s a
-> Int -> MArr UnliftedArray s a -> Int -> Int -> m ()
copyMutableArr = MutableUnliftedArray (PrimState m) a
-> Int
-> MutableUnliftedArray (PrimState m) a
-> Int
-> Int
-> m ()
MArr UnliftedArray s a
-> Int -> MArr UnliftedArray s a -> Int -> Int -> m ()
forall {k} (m :: * -> *) (a :: k).
PrimMonad m =>
MutableUnliftedArray (PrimState m) a
-> Int
-> MutableUnliftedArray (PrimState m) a
-> Int
-> Int
-> m ()
copyMutableUnliftedArray
    {-# INLINE copyMutableArr #-}

    moveArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr UnliftedArray s a
-> Int -> MArr UnliftedArray s a -> Int -> Int -> m ()
moveArr MArr UnliftedArray s a
marr1 Int
s1 MArr UnliftedArray s a
marr2 Int
s2 Int
l
        | Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0 = () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
        | MutableUnliftedArray s a -> MutableUnliftedArray s a -> Bool
forall {k} s (a :: k).
MutableUnliftedArray s a -> MutableUnliftedArray s a -> Bool
sameMutableUnliftedArray MutableUnliftedArray s a
MArr UnliftedArray s a
marr1 MutableUnliftedArray s a
MArr UnliftedArray s a
marr2 =
            case Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Int
s1 Int
s2 of
                Ordering
LT ->
                    let !d :: Int
d = Int
s2 Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
s1
                        !s2l :: Int
s2l = Int
s2 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
l
                        go :: Int -> m ()
go !Int
i | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
s2l = () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
                              | Bool
otherwise = do a
x <- MutableUnliftedArray (PrimState m) a -> Int -> m a
forall (m :: * -> *) a.
(PrimMonad m, PrimUnlifted a) =>
MutableUnliftedArray (PrimState m) a -> Int -> m a
readUnliftedArray MutableUnliftedArray (PrimState m) a
MArr UnliftedArray s a
marr2 Int
i
                                               MutableUnliftedArray (PrimState m) a -> Int -> a -> m ()
forall (m :: * -> *) a.
(PrimMonad m, PrimUnlifted a) =>
MutableUnliftedArray (PrimState m) a -> Int -> a -> m ()
writeUnliftedArray MutableUnliftedArray (PrimState m) a
MArr UnliftedArray s a
marr1 (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
d) a
x
                                               Int -> m ()
go (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1)
                    in Int -> m ()
go Int
s2

                Ordering
EQ -> () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

                Ordering
GT ->
                    let !d :: Int
d = Int
s1 Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
s2
                        go :: Int -> m ()
go !Int
i | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
s2 = () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
                              | Bool
otherwise = do a
x <- MutableUnliftedArray (PrimState m) a -> Int -> m a
forall (m :: * -> *) a.
(PrimMonad m, PrimUnlifted a) =>
MutableUnliftedArray (PrimState m) a -> Int -> m a
readUnliftedArray MutableUnliftedArray (PrimState m) a
MArr UnliftedArray s a
marr2 Int
i
                                               MutableUnliftedArray (PrimState m) a -> Int -> a -> m ()
forall (m :: * -> *) a.
(PrimMonad m, PrimUnlifted a) =>
MutableUnliftedArray (PrimState m) a -> Int -> a -> m ()
writeUnliftedArray MutableUnliftedArray (PrimState m) a
MArr UnliftedArray s a
marr1 (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
d) a
x
                                               Int -> m ()
go (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)
                    in Int -> m ()
go (Int
s2Int -> Int -> Int
forall a. Num a => a -> a -> a
+Int
lInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)
        | Bool
otherwise = MutableUnliftedArray (PrimState m) a
-> Int
-> MutableUnliftedArray (PrimState m) a
-> Int
-> Int
-> m ()
forall {k} (m :: * -> *) (a :: k).
PrimMonad m =>
MutableUnliftedArray (PrimState m) a
-> Int
-> MutableUnliftedArray (PrimState m) a
-> Int
-> Int
-> m ()
copyMutableUnliftedArray MutableUnliftedArray (PrimState m) a
MArr UnliftedArray s a
marr1 Int
s1 MutableUnliftedArray (PrimState m) a
MArr UnliftedArray s a
marr2 Int
s2 Int
l
    {-# INLINE moveArr #-}

    cloneArr :: UnliftedArray a -> Int -> Int -> UnliftedArray a
cloneArr = UnliftedArray a -> Int -> Int -> UnliftedArray a
forall {k} (a :: k).
UnliftedArray a -> Int -> Int -> UnliftedArray a
cloneUnliftedArray
    {-# INLINE cloneArr #-}
    cloneMutableArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr UnliftedArray s a -> Int -> Int -> m (MArr UnliftedArray s a)
cloneMutableArr = MutableUnliftedArray (PrimState m) a
-> Int -> Int -> m (MutableUnliftedArray (PrimState m) a)
MArr UnliftedArray s a -> Int -> Int -> m (MArr UnliftedArray s a)
forall {k} (m :: * -> *) (a :: k).
PrimMonad m =>
MutableUnliftedArray (PrimState m) a
-> Int -> Int -> m (MutableUnliftedArray (PrimState m) a)
cloneMutableUnliftedArray
    {-# INLINE cloneMutableArr #-}

    resizeMutableArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr UnliftedArray s a -> Int -> m (MArr UnliftedArray s a)
resizeMutableArr MArr UnliftedArray s a
marr Int
n = do
        MutableUnliftedArray s a
marr' <- Int -> a -> m (MutableUnliftedArray (PrimState m) a)
forall (m :: * -> *) a.
(PrimMonad m, PrimUnlifted a) =>
Int -> a -> m (MutableUnliftedArray (PrimState m) a)
newUnliftedArray Int
n a
forall a. a
uninitialized
        MutableUnliftedArray (PrimState m) a
-> Int
-> MutableUnliftedArray (PrimState m) a
-> Int
-> Int
-> m ()
forall {k} (m :: * -> *) (a :: k).
PrimMonad m =>
MutableUnliftedArray (PrimState m) a
-> Int
-> MutableUnliftedArray (PrimState m) a
-> Int
-> Int
-> m ()
copyMutableUnliftedArray MutableUnliftedArray s a
MutableUnliftedArray (PrimState m) a
marr' Int
0 MutableUnliftedArray (PrimState m) a
MArr UnliftedArray s a
marr Int
0 (MutableUnliftedArray s a -> Int
forall {k} s (e :: k). MutableUnliftedArray s e -> Int
sizeofMutableUnliftedArray MutableUnliftedArray s a
MArr UnliftedArray s a
marr)
        MutableUnliftedArray s a -> m (MutableUnliftedArray s a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return MutableUnliftedArray s a
marr'
    {-# INLINE resizeMutableArr #-}
    shrinkMutableArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr UnliftedArray s a -> Int -> m ()
shrinkMutableArr MArr UnliftedArray s a
_ Int
_ = () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
    {-# INLINE shrinkMutableArr #-}

    sameMutableArr :: forall s. MArr UnliftedArray s a -> MArr UnliftedArray s a -> Bool
sameMutableArr = MutableUnliftedArray s a -> MutableUnliftedArray s a -> Bool
MArr UnliftedArray s a -> MArr UnliftedArray s a -> Bool
forall {k} s (a :: k).
MutableUnliftedArray s a -> MutableUnliftedArray s a -> Bool
sameMutableUnliftedArray
    {-# INLINE sameMutableArr #-}
    sizeofArr :: UnliftedArray a -> Int
sizeofArr = UnliftedArray a -> Int
forall {k} (e :: k). UnliftedArray e -> Int
sizeofUnliftedArray
    {-# INLINE sizeofArr #-}
    sizeofMutableArr :: forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr UnliftedArray s a -> m Int
sizeofMutableArr = Int -> m Int
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> m Int)
-> (MutableUnliftedArray s a -> Int)
-> MutableUnliftedArray s a
-> m Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MutableUnliftedArray s a -> Int
forall {k} s (e :: k). MutableUnliftedArray s e -> Int
sizeofMutableUnliftedArray
    {-# INLINE sizeofMutableArr #-}

    sameArr :: UnliftedArray a -> UnliftedArray a -> Bool
sameArr (UnliftedArray ArrayArray#
arr1#) (UnliftedArray ArrayArray#
arr2#) = Int# -> Bool
isTrue# (
        MutableArrayArray# Any -> MutableArrayArray# Any -> Int#
forall s. MutableArrayArray# s -> MutableArrayArray# s -> Int#
sameMutableArrayArray# (ArrayArray# -> MutableArrayArray# Any
forall a b. a -> b
unsafeCoerce# ArrayArray#
arr1#) (ArrayArray# -> MutableArrayArray# Any
forall a b. a -> b
unsafeCoerce# ArrayArray#
arr2#))
    {-# INLINE sameArr #-}

--------------------------------------------------------------------------------

-- FIXME: directly use Data.Primitive.PrimArray.withPrimArrayContents
-- when primitive>=0.9.0 ?
-- | Obtain the pointer to the content of an array, and the pointer should only be used during the IO action.
--
-- This operation is only safe on /pinned/ primitive arrays (Arrays allocated by 'newPinnedPrimArray' or
-- 'newAlignedPinnedPrimArray').
--
-- Don't pass a forever loop to this function, see <https://ghc.haskell.org/trac/ghc/ticket/14346 #14346>.
withPrimArrayContents :: PrimArray a -> (Ptr a -> IO b) -> IO b
{-# INLINE withPrimArrayContents #-}
withPrimArrayContents :: forall a b. PrimArray a -> (Ptr a -> IO b) -> IO b
withPrimArrayContents (PrimArray ByteArray#
ba#) Ptr a -> IO b
f = do
    let addr# :: Addr#
addr# = ByteArray# -> Addr#
byteArrayContents# ByteArray#
ba#
        ptr :: Ptr a
ptr = Addr# -> Ptr a
forall a. Addr# -> Ptr a
Ptr Addr#
addr#
    b
b <- Ptr a -> IO b
f Ptr a
ptr
    (State# (PrimState IO) -> State# (PrimState IO)) -> IO ()
forall (m :: * -> *).
PrimMonad m =>
(State# (PrimState m) -> State# (PrimState m)) -> m ()
primitive_ (ByteArray# -> State# RealWorld -> State# RealWorld
forall a. a -> State# RealWorld -> State# RealWorld
touch# ByteArray#
ba#)
    b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
b

-- FIXME: directly use Data.Primitive.PrimArray.withMutablePrimArrayContents
-- when primitive>=0.9.0 ?
-- | Obtain the pointer to the content of an mutable array, and the pointer should only be used during the IO action.
--
-- This operation is only safe on /pinned/ primitive arrays (Arrays allocated by 'newPinnedPrimArray' or
-- 'newAlignedPinnedPrimArray').
--
-- Don't pass a forever loop to this function, see <https://ghc.haskell.org/trac/ghc/ticket/14346 #14346>.
withMutablePrimArrayContents :: MutablePrimArray RealWorld a -> (Ptr a -> IO b) -> IO b
{-# INLINE withMutablePrimArrayContents #-}
withMutablePrimArrayContents :: forall a b. MutablePrimArray RealWorld a -> (Ptr a -> IO b) -> IO b
withMutablePrimArrayContents (MutablePrimArray MutableByteArray# RealWorld
mba#) Ptr a -> IO b
f = do
    let addr# :: Addr#
addr# = ByteArray# -> Addr#
byteArrayContents# (MutableByteArray# RealWorld -> ByteArray#
forall a b. a -> b
unsafeCoerce# MutableByteArray# RealWorld
mba#)
        ptr :: Ptr a
ptr = Addr# -> Ptr a
forall a. Addr# -> Ptr a
Ptr Addr#
addr#
    b
b <- Ptr a -> IO b
f Ptr a
ptr
    (State# (PrimState IO) -> State# (PrimState IO)) -> IO ()
forall (m :: * -> *).
PrimMonad m =>
(State# (PrimState m) -> State# (PrimState m)) -> m ()
primitive_ (MutableByteArray# RealWorld -> State# RealWorld -> State# RealWorld
forall a. a -> State# RealWorld -> State# RealWorld
touch# MutableByteArray# RealWorld
mba#)
    b -> IO b
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return b
b

-- | Cast between arrays
castArray :: (Arr arr a, Cast a b) => arr a -> arr b
{-# INLINE castArray #-}
castArray :: forall (arr :: * -> *) a b. (Arr arr a, Cast a b) => arr a -> arr b
castArray = arr a -> arr b
forall a b. a -> b
unsafeCoerce#


-- | Cast between mutable arrays
castMutableArray :: (Arr arr a, Cast a b) => MArr arr s a -> MArr arr s b
{-# INLINE castMutableArray #-}
castMutableArray :: forall (arr :: * -> *) a b s.
(Arr arr a, Cast a b) =>
MArr arr s a -> MArr arr s b
castMutableArray = MArr arr s a -> MArr arr s b
forall a b. a -> b
unsafeCoerce#

--------------------------------------------------------------------------------

singletonArr :: Arr arr a => a -> arr a
{-# INLINE singletonArr #-}
singletonArr :: forall (arr :: * -> *) a. Arr arr a => a -> arr a
singletonArr a
x = (forall s. ST s (arr a)) -> arr a
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (arr a)) -> arr a)
-> (forall s. ST s (arr a)) -> arr a
forall a b. (a -> b) -> a -> b
$ do
    MArr arr s a
marr <- Int -> a -> ST s (MArr arr s a)
forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
Int -> a -> m (MArr arr s a)
forall (arr :: * -> *) a (m :: * -> *) s.
(Arr arr a, PrimMonad m, PrimState m ~ s) =>
Int -> a -> m (MArr arr s a)
newArrWith Int
1 a
x
    MArr arr s a -> ST s (arr a)
forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> m (arr a)
forall (arr :: * -> *) a (m :: * -> *) s.
(Arr arr a, PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> m (arr a)
unsafeFreezeArr MArr arr s a
marr

doubletonArr :: Arr arr a => a -> a -> arr a
{-# INLINE doubletonArr #-}
doubletonArr :: forall (arr :: * -> *) a. Arr arr a => a -> a -> arr a
doubletonArr a
x a
y = (forall s. ST s (arr a)) -> arr a
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (arr a)) -> arr a)
-> (forall s. ST s (arr a)) -> arr a
forall a b. (a -> b) -> a -> b
$ do
    MArr arr s a
marr <- Int -> a -> ST s (MArr arr s a)
forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
Int -> a -> m (MArr arr s a)
forall (arr :: * -> *) a (m :: * -> *) s.
(Arr arr a, PrimMonad m, PrimState m ~ s) =>
Int -> a -> m (MArr arr s a)
newArrWith Int
2 a
x
    MArr arr s a -> Int -> a -> ST s ()
forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> Int -> a -> m ()
forall (arr :: * -> *) a (m :: * -> *) s.
(Arr arr a, PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> Int -> a -> m ()
writeArr MArr arr s a
marr Int
1 a
y
    MArr arr s a -> ST s (arr a)
forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> m (arr a)
forall (arr :: * -> *) a (m :: * -> *) s.
(Arr arr a, PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> m (arr a)
unsafeFreezeArr MArr arr s a
marr

-- | Modify(strictly) an immutable some elements of an array with specified subrange.
-- This function will produce a new array.
modifyIndexArr :: Arr arr a
               => arr a
               -> Int        -- ^ offset
               -> Int        -- ^ length
               -> Int        -- ^ index in new array
               -> (a -> a)   -- ^ modify function
               -> arr a
{-# INLINE modifyIndexArr #-}
modifyIndexArr :: forall (arr :: * -> *) a.
Arr arr a =>
arr a -> Int -> Int -> Int -> (a -> a) -> arr a
modifyIndexArr arr a
arr Int
off Int
len Int
ix a -> a
f = (forall s. ST s (arr a)) -> arr a
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (arr a)) -> arr a)
-> (forall s. ST s (arr a)) -> arr a
forall a b. (a -> b) -> a -> b
$ do
    MArr arr s a
marr <- arr a -> ST s (MArr arr s a)
forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
arr a -> m (MArr arr s a)
forall (arr :: * -> *) a (m :: * -> *) s.
(Arr arr a, PrimMonad m, PrimState m ~ s) =>
arr a -> m (MArr arr s a)
unsafeThawArr (arr a -> Int -> Int -> arr a
forall (arr :: * -> *) a. Arr arr a => arr a -> Int -> Int -> arr a
cloneArr arr a
arr Int
off Int
len)
    !a
v <- a -> a
f (a -> a) -> ST s a -> ST s a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MArr arr s a -> Int -> ST s a
forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> Int -> m a
forall (arr :: * -> *) a (m :: * -> *) s.
(Arr arr a, PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> Int -> m a
readArr MArr arr s a
marr Int
ix
    MArr arr s a -> Int -> a -> ST s ()
forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> Int -> a -> m ()
forall (arr :: * -> *) a (m :: * -> *) s.
(Arr arr a, PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> Int -> a -> m ()
writeArr MArr arr s a
marr Int
ix a
v
    MArr arr s a -> ST s (arr a)
forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> m (arr a)
forall (arr :: * -> *) a (m :: * -> *) s.
(Arr arr a, PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> m (arr a)
unsafeFreezeArr MArr arr s a
marr

-- | Insert a value to an immutable array at given index. This function will produce a new array.
insertIndexArr :: Arr arr a
               => arr a
               -> Int        -- ^ offset
               -> Int        -- ^ length
               -> Int        -- ^ insert index in new array
               -> a          -- ^ value to be inserted
               -> arr a
{-# INLINE insertIndexArr #-}
insertIndexArr :: forall (arr :: * -> *) a.
Arr arr a =>
arr a -> Int -> Int -> Int -> a -> arr a
insertIndexArr arr a
arr Int
s Int
l Int
i a
x = (forall s. ST s (arr a)) -> arr a
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (arr a)) -> arr a)
-> (forall s. ST s (arr a)) -> arr a
forall a b. (a -> b) -> a -> b
$ do
    MArr arr s a
marr <- Int -> a -> ST s (MArr arr s a)
forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
Int -> a -> m (MArr arr s a)
forall (arr :: * -> *) a (m :: * -> *) s.
(Arr arr a, PrimMonad m, PrimState m ~ s) =>
Int -> a -> m (MArr arr s a)
newArrWith (Int
lInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1) a
x
    Bool -> ST s () -> ST s ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
iInt -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>Int
0) (ST s () -> ST s ()) -> ST s () -> ST s ()
forall a b. (a -> b) -> a -> b
$ MArr arr s a -> Int -> arr a -> Int -> Int -> ST s ()
forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> Int -> arr a -> Int -> Int -> m ()
forall (arr :: * -> *) a (m :: * -> *) s.
(Arr arr a, PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> Int -> arr a -> Int -> Int -> m ()
copyArr MArr arr s a
marr Int
0 arr a
arr Int
s Int
i
    Bool -> ST s () -> ST s ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
iInt -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<Int
l) (ST s () -> ST s ()) -> ST s () -> ST s ()
forall a b. (a -> b) -> a -> b
$ MArr arr s a -> Int -> arr a -> Int -> Int -> ST s ()
forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> Int -> arr a -> Int -> Int -> m ()
forall (arr :: * -> *) a (m :: * -> *) s.
(Arr arr a, PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> Int -> arr a -> Int -> Int -> m ()
copyArr MArr arr s a
marr (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1) arr a
arr (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
s) (Int
lInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
i)
    MArr arr s a -> ST s (arr a)
forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> m (arr a)
forall (arr :: * -> *) a (m :: * -> *) s.
(Arr arr a, PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> m (arr a)
unsafeFreezeArr MArr arr s a
marr

-- | Delete an element of the immutable array's at given index. This function will produce a new array.
deleteIndexArr :: Arr arr a
               => arr a
               -> Int        -- ^ offset
               -> Int        -- ^ length
               -> Int        -- ^ the index of the element to delete
               -> arr a
{-# INLINE deleteIndexArr #-}
deleteIndexArr :: forall (arr :: * -> *) a.
Arr arr a =>
arr a -> Int -> Int -> Int -> arr a
deleteIndexArr arr a
arr Int
s Int
l Int
i = (forall s. ST s (arr a)) -> arr a
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (arr a)) -> arr a)
-> (forall s. ST s (arr a)) -> arr a
forall a b. (a -> b) -> a -> b
$ do
    MArr arr s a
marr <- Int -> ST s (MArr arr s a)
forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
Int -> m (MArr arr s a)
forall (arr :: * -> *) a (m :: * -> *) s.
(Arr arr a, PrimMonad m, PrimState m ~ s) =>
Int -> m (MArr arr s a)
newArr (Int
lInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)
    Bool -> ST s () -> ST s ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
iInt -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>Int
0) (ST s () -> ST s ()) -> ST s () -> ST s ()
forall a b. (a -> b) -> a -> b
$ MArr arr s a -> Int -> arr a -> Int -> Int -> ST s ()
forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> Int -> arr a -> Int -> Int -> m ()
forall (arr :: * -> *) a (m :: * -> *) s.
(Arr arr a, PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> Int -> arr a -> Int -> Int -> m ()
copyArr MArr arr s a
marr Int
0 arr a
arr Int
s Int
i
    let i' :: Int
i' = Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1
    Bool -> ST s () -> ST s ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
i'Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<Int
l) (ST s () -> ST s ()) -> ST s () -> ST s ()
forall a b. (a -> b) -> a -> b
$ MArr arr s a -> Int -> arr a -> Int -> Int -> ST s ()
forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> Int -> arr a -> Int -> Int -> m ()
forall (arr :: * -> *) a (m :: * -> *) s.
(Arr arr a, PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> Int -> arr a -> Int -> Int -> m ()
copyArr MArr arr s a
marr Int
i arr a
arr (Int
i'Int -> Int -> Int
forall a. Num a => a -> a -> a
+Int
s) (Int
lInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
i')
    MArr arr s a -> ST s (arr a)
forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> m (arr a)
forall (arr :: * -> *) a (m :: * -> *) s.
(Arr arr a, PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> m (arr a)
unsafeFreezeArr MArr arr s a
marr

-- | Swap two elements under given index and return a new array.
swapArr :: Arr arr a
             => arr a
             -> Int
             -> Int
             -> arr a
{-# INLINE swapArr #-}
swapArr :: forall (arr :: * -> *) a. Arr arr a => arr a -> Int -> Int -> arr a
swapArr arr a
arr Int
i Int
j = (forall s. ST s (arr a)) -> arr a
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (arr a)) -> arr a)
-> (forall s. ST s (arr a)) -> arr a
forall a b. (a -> b) -> a -> b
$ do
    MArr arr s a
marr <- arr a -> Int -> Int -> ST s (MArr arr s a)
forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
arr a -> Int -> Int -> m (MArr arr s a)
forall (arr :: * -> *) a (m :: * -> *) s.
(Arr arr a, PrimMonad m, PrimState m ~ s) =>
arr a -> Int -> Int -> m (MArr arr s a)
thawArr arr a
arr Int
0 (arr a -> Int
forall (arr :: * -> *) a. Arr arr a => arr a -> Int
sizeofArr arr a
arr)
    MArr arr s a -> Int -> Int -> ST s ()
forall (m :: * -> *) s (arr :: * -> *) a.
(PrimMonad m, PrimState m ~ s, Arr arr a) =>
MArr arr s a -> Int -> Int -> m ()
swapMutableArr MArr arr s a
marr Int
i Int
j
    MArr arr s a -> ST s (arr a)
forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> m (arr a)
forall (arr :: * -> *) a (m :: * -> *) s.
(Arr arr a, PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> m (arr a)
unsafeFreezeArr MArr arr s a
marr

-- | Swap two elements under given index, no atomically guarantee is given.
swapMutableArr :: (PrimMonad m, PrimState m ~ s, Arr arr a)
             => MArr arr s a
             -> Int
             -> Int
             -> m ()
{-# INLINE swapMutableArr #-}
swapMutableArr :: forall (m :: * -> *) s (arr :: * -> *) a.
(PrimMonad m, PrimState m ~ s, Arr arr a) =>
MArr arr s a -> Int -> Int -> m ()
swapMutableArr MArr arr s a
marr Int
i Int
j = do
    a
x <- MArr arr s a -> Int -> m a
forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> Int -> m a
forall (arr :: * -> *) a (m :: * -> *) s.
(Arr arr a, PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> Int -> m a
readArr MArr arr s a
marr Int
i
    a
y <- MArr arr s a -> Int -> m a
forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> Int -> m a
forall (arr :: * -> *) a (m :: * -> *) s.
(Arr arr a, PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> Int -> m a
readArr MArr arr s a
marr Int
j
    MArr arr s a -> Int -> a -> m ()
forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> Int -> a -> m ()
forall (arr :: * -> *) a (m :: * -> *) s.
(Arr arr a, PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> Int -> a -> m ()
writeArr MArr arr s a
marr Int
i a
y
    MArr arr s a -> Int -> a -> m ()
forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> Int -> a -> m ()
forall (arr :: * -> *) a (m :: * -> *) s.
(Arr arr a, PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> Int -> a -> m ()
writeArr MArr arr s a
marr Int
j a
x

-- | Resize mutable array to @max (given_size) (2 * original_size)@ if orignal array is smaller than @give_size@.
doubleMutableArr :: (Arr arr a, PrimMonad m, PrimState m ~ s) => MArr arr s a -> Int -> m (MArr arr s a)
{-# INLINE doubleMutableArr #-}
doubleMutableArr :: forall (arr :: * -> *) a (m :: * -> *) s.
(Arr arr a, PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> Int -> m (MArr arr s a)
doubleMutableArr MArr arr s a
marr Int
l = do
    Int
siz <- MArr arr s a -> m Int
forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> m Int
forall (arr :: * -> *) a (m :: * -> *) s.
(Arr arr a, PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> m Int
sizeofMutableArr MArr arr s a
marr
    if (Int
siz Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
l)
    then MArr arr s a -> Int -> m (MArr arr s a)
forall (m :: * -> *) s.
(PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> Int -> m (MArr arr s a)
forall (arr :: * -> *) a (m :: * -> *) s.
(Arr arr a, PrimMonad m, PrimState m ~ s) =>
MArr arr s a -> Int -> m (MArr arr s a)
resizeMutableArr MArr arr s a
marr (Int -> Int -> Int
forall a. Ord a => a -> a -> a
max (Int
siz Int -> Int -> Int
forall a. Bits a => a -> Int -> a
`unsafeShiftL` Int
1) Int
l)
    else MArr arr s a -> m (MArr arr s a)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return MArr arr s a
marr


-- | Shuffle array's elements in slice range.
--
-- This function use <https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle Fisher-Yates> algorithm.
shuffleMutableArr :: (StatefulGen g m, PrimMonad m, PrimState m ~ s, Arr arr a) => g -> MArr arr s a
            -> Int  -- ^ offset
            -> Int  -- ^ length
            -> m ()
{-# INLINE shuffleMutableArr #-}
shuffleMutableArr :: forall g (m :: * -> *) s (arr :: * -> *) a.
(StatefulGen g m, PrimMonad m, PrimState m ~ s, Arr arr a) =>
g -> MArr arr s a -> Int -> Int -> m ()
shuffleMutableArr g
g MArr arr s a
marr Int
off Int
n = Int -> m ()
go (Int
offInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)
  where
    go :: Int -> m ()
go Int
i | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
offInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1 = () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
         | Bool
otherwise = do
            Int
j <- (Int, Int) -> g -> m Int
forall a g (m :: * -> *).
(UniformRange a, StatefulGen g m) =>
(a, a) -> g -> m a
forall g (m :: * -> *). StatefulGen g m => (Int, Int) -> g -> m Int
uniformRM (Int
off, Int
i) g
g
            MArr arr s a -> Int -> Int -> m ()
forall (m :: * -> *) s (arr :: * -> *) a.
(PrimMonad m, PrimState m ~ s, Arr arr a) =>
MArr arr s a -> Int -> Int -> m ()
swapMutableArr MArr arr s a
marr Int
i Int
j
            Int -> m ()
go (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)