{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE PackageImports #-}
{-# LANGUAGE UnboxedTuples #-}

module Data.Primitive.SmallArray
  ( SmallArray(..)
  , SmallMutableArray(..)
  , newSmallArray
  , readSmallArray
  , writeSmallArray
  , copySmallArray
  , copySmallMutableArray
  , indexSmallArray
  , indexSmallArrayM
  , indexSmallArray##
  , cloneSmallArray
  , cloneSmallMutableArray
  , freezeSmallArray
  , unsafeFreezeSmallArray
  , thawSmallArray
  , A.runSmallArray
  , A.unsafeThawSmallArray
  , A.sizeofSmallArray
  , A.sizeofSmallMutableArray
#if MIN_VERSION_base(4,14,0)
  , shrinkSmallMutableArray
#endif
  , A.smallArrayFromList
  , A.smallArrayFromListN
  , A.mapSmallArray'
  , A.traverseSmallArrayP
  ) where

import "primitive" Data.Primitive (sizeOf)
import "primitive" Data.Primitive.SmallArray (SmallArray, SmallMutableArray)

import Control.Exception (throw, ArrayException(..), Exception, toException)
import Control.Monad.Primitive (PrimMonad, PrimState)
import GHC.Exts (raise#)
import GHC.Stack

import qualified "primitive" Data.Primitive.SmallArray as A
import qualified Data.List as L

check :: HasCallStack => String -> Bool -> a -> a
check :: String -> Bool -> a -> a
check String
_      Bool
True  a
x = a
x
check String
errMsg Bool
False a
_ = ArrayException -> a
forall a e. Exception e => e -> a
throw (String -> ArrayException
IndexOutOfBounds (String -> ArrayException) -> String -> ArrayException
forall a b. (a -> b) -> a -> b
$ String
"Data.Primitive.SmallArray." String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
errMsg String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"\n" String -> String -> String
forall a. [a] -> [a] -> [a]
++ CallStack -> String
prettyCallStack CallStack
HasCallStack => CallStack
callStack)

checkUnary :: HasCallStack => String -> Bool -> (# a #) -> (# a #)
checkUnary :: String -> Bool -> (# a #) -> (# a #)
checkUnary String
_      Bool
True  (# a #)
x = (# a #)
x
checkUnary String
errMsg Bool
False (# a #)
_ = ArrayException -> (# a #)
forall e a. Exception e => e -> (# a #)
throwUnary (String -> ArrayException
IndexOutOfBounds (String -> ArrayException) -> String -> ArrayException
forall a b. (a -> b) -> a -> b
$ String
"Data.Primitive.SmallArray." String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
errMsg String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"\n" String -> String -> String
forall a. [a] -> [a] -> [a]
++ CallStack -> String
prettyCallStack CallStack
HasCallStack => CallStack
callStack)

throwUnary :: Exception e => e -> (# a #)
throwUnary :: e -> (# a #)
throwUnary e
e = SomeException -> (# a #)
forall b a. b -> a
raise# (e -> SomeException
forall e. Exception e => e -> SomeException
toException e
e)

newSmallArray :: (HasCallStack, PrimMonad m) => Int -> a -> m (SmallMutableArray (PrimState m) a)
newSmallArray :: Int -> a -> m (SmallMutableArray (PrimState m) a)
newSmallArray Int
n a
x =
    String
-> Bool
-> m (SmallMutableArray (PrimState m) a)
-> m (SmallMutableArray (PrimState m) a)
forall a. HasCallStack => String -> Bool -> a -> a
check String
"newSmallArray: negative size" (Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0)
  (m (SmallMutableArray (PrimState m) a)
 -> m (SmallMutableArray (PrimState m) a))
-> m (SmallMutableArray (PrimState m) a)
-> m (SmallMutableArray (PrimState m) a)
forall a b. (a -> b) -> a -> b
$ String
-> Bool
-> m (SmallMutableArray (PrimState m) a)
-> m (SmallMutableArray (PrimState m) a)
forall a. HasCallStack => String -> Bool -> a -> a
check (String
"newSmallArray: requested " String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
n String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" elements") (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
ptrSz Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
1024Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
1024Int -> Int -> Int
forall a. Num a => a -> a -> a
*Int
1024)
  (m (SmallMutableArray (PrimState m) a)
 -> m (SmallMutableArray (PrimState m) a))
-> m (SmallMutableArray (PrimState m) a)
-> m (SmallMutableArray (PrimState m) a)
forall a b. (a -> b) -> a -> b
$ Int -> a -> m (SmallMutableArray (PrimState m) a)
forall (m :: * -> *) a.
PrimMonad m =>
Int -> a -> m (SmallMutableArray (PrimState m) a)
A.newSmallArray Int
n a
x
  where
  ptrSz :: Int
ptrSz = Int -> Int
forall a. Prim a => a -> Int
sizeOf (Int
forall a. HasCallStack => a
undefined :: Int)

readSmallArray :: (HasCallStack, PrimMonad m) => SmallMutableArray (PrimState m) a -> Int -> m a
readSmallArray :: SmallMutableArray (PrimState m) a -> Int -> m a
readSmallArray SmallMutableArray (PrimState m) a
marr Int
i = do
  let siz :: Int
siz = SmallMutableArray (PrimState m) a -> Int
forall s a. SmallMutableArray s a -> Int
A.sizeofSmallMutableArray SmallMutableArray (PrimState m) a
marr
      explain :: String
explain = [String] -> String
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
L.concat
        [ String
"[size: "
        , Int -> String
forall a. Show a => a -> String
show Int
siz
        , String
", index: "
        , Int -> String
forall a. Show a => a -> String
show Int
i
        , String
"]"
        ]
  String -> Bool -> m a -> m a
forall a. HasCallStack => String -> Bool -> a -> a
check (String
"readSmallArray: index out of bounds " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
explain) (Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
siz) (SmallMutableArray (PrimState m) a -> Int -> m a
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> m a
A.readSmallArray SmallMutableArray (PrimState m) a
marr Int
i)

writeSmallArray :: (HasCallStack, PrimMonad m) => SmallMutableArray (PrimState m) a -> Int -> a -> m ()
writeSmallArray :: SmallMutableArray (PrimState m) a -> Int -> a -> m ()
writeSmallArray SmallMutableArray (PrimState m) a
marr Int
i a
x = do
  let siz :: Int
siz = SmallMutableArray (PrimState m) a -> Int
forall s a. SmallMutableArray s a -> Int
A.sizeofSmallMutableArray SmallMutableArray (PrimState m) a
marr
      explain :: String
explain = [String] -> String
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
L.concat
        [ String
"[size: "
        , Int -> String
forall a. Show a => a -> String
show Int
siz
        , String
", index: "
        , Int -> String
forall a. Show a => a -> String
show Int
i
        , String
"]"
        ]
  String -> Bool -> m () -> m ()
forall a. HasCallStack => String -> Bool -> a -> a
check (String
"writeSmallArray: index out of bounds " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
explain) (Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
siz) (SmallMutableArray (PrimState m) a -> Int -> a -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
A.writeSmallArray SmallMutableArray (PrimState m) a
marr Int
i a
x)

indexSmallArray :: HasCallStack => SmallArray a -> Int -> a
indexSmallArray :: SmallArray a -> Int -> a
indexSmallArray SmallArray a
arr Int
i = String -> Bool -> a -> a
forall a. HasCallStack => String -> Bool -> a -> a
check (String
"indexSmallArray: index out of bounds " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
explain)
  (Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< SmallArray a -> Int
forall a. SmallArray a -> Int
A.sizeofSmallArray SmallArray a
arr)
  (SmallArray a -> Int -> a
forall a. SmallArray a -> Int -> a
A.indexSmallArray SmallArray a
arr Int
i)
  where
  explain :: String
explain = [String] -> String
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
L.concat
    [ String
"[size: "
    , Int -> String
forall a. Show a => a -> String
show (SmallArray a -> Int
forall a. SmallArray a -> Int
A.sizeofSmallArray SmallArray a
arr)
    , String
", index: "
    , Int -> String
forall a. Show a => a -> String
show Int
i
    , String
"]"
    ]

indexSmallArray## :: HasCallStack => SmallArray a -> Int -> (# a #)
indexSmallArray## :: SmallArray a -> Int -> (# a #)
indexSmallArray## SmallArray a
arr Int
i = String -> Bool -> (# a #) -> (# a #)
forall a. HasCallStack => String -> Bool -> (# a #) -> (# a #)
checkUnary String
"indexSmallArray##: index out of bounds"
  (Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< SmallArray a -> Int
forall a. SmallArray a -> Int
A.sizeofSmallArray SmallArray a
arr)
  (SmallArray a -> Int -> (# a #)
forall a. SmallArray a -> Int -> (# a #)
A.indexSmallArray## SmallArray a
arr Int
i)

indexSmallArrayM :: (HasCallStack, Monad m) => SmallArray a -> Int -> m a
indexSmallArrayM :: SmallArray a -> Int -> m a
indexSmallArrayM SmallArray a
arr Int
i = String -> Bool -> m a -> m a
forall a. HasCallStack => String -> Bool -> a -> a
check String
"indexSmallArrayM: index out of bounds"
  (Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< SmallArray a -> Int
forall a. SmallArray a -> Int
A.sizeofSmallArray SmallArray a
arr)
  (SmallArray a -> Int -> m a
forall (m :: * -> *) a. Monad m => SmallArray a -> Int -> m a
A.indexSmallArrayM SmallArray a
arr Int
i)

{-# NOINLINE errorUnsafeFreeze #-}
errorUnsafeFreeze :: a
errorUnsafeFreeze :: a
errorUnsafeFreeze =
  String -> a
forall a. HasCallStack => String -> a
error String
"Data.Primitive.Array.unsafeFreeze:\nAttempted to read from an array after unsafely freezing it."

-- | This installs error thunks in the argument array so that
-- any attempt to use it after an unsafeFreeze will fail.
unsafeFreezeSmallArray :: (HasCallStack, PrimMonad m)
  => SmallMutableArray (PrimState m) a
  -> m (SmallArray a)
unsafeFreezeSmallArray :: SmallMutableArray (PrimState m) a -> m (SmallArray a)
unsafeFreezeSmallArray SmallMutableArray (PrimState m) a
marr = do
  let sz :: Int
sz = SmallMutableArray (PrimState m) a -> Int
forall s a. SmallMutableArray s a -> Int
A.sizeofSmallMutableArray SmallMutableArray (PrimState m) a
marr
  SmallArray a
arr <- SmallMutableArray (PrimState m) a -> Int -> Int -> m (SmallArray a)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> Int -> m (SmallArray a)
A.freezeSmallArray SmallMutableArray (PrimState m) a
marr Int
0 Int
sz
  let go :: Int -> m ()
go !Int
ix = if Int
ix Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
sz
        then SmallMutableArray (PrimState m) a -> Int -> a -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> a -> m ()
A.writeSmallArray SmallMutableArray (PrimState m) a
marr Int
ix a
forall a. a
errorUnsafeFreeze m () -> m () -> m ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> m ()
go (Int
ix Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
        else () -> m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
  Int -> m ()
go Int
0
  SmallArray a -> m (SmallArray a)
forall (m :: * -> *) a. Monad m => a -> m a
return SmallArray a
arr

freezeSmallArray
  :: (HasCallStack, PrimMonad m)
  => SmallMutableArray (PrimState m) a -- ^ source
  -> Int                               -- ^ offset
  -> Int                               -- ^ length
  -> m (SmallArray a)
freezeSmallArray :: SmallMutableArray (PrimState m) a -> Int -> Int -> m (SmallArray a)
freezeSmallArray SmallMutableArray (PrimState m) a
marr Int
s Int
l = String -> Bool -> m (SmallArray a) -> m (SmallArray a)
forall a. HasCallStack => String -> Bool -> a -> a
check String
"freezeSmallArray: index range of out bounds"
  (Int
s Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
s Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= SmallMutableArray (PrimState m) a -> Int
forall s a. SmallMutableArray s a -> Int
A.sizeofSmallMutableArray SmallMutableArray (PrimState m) a
marr)
  (SmallMutableArray (PrimState m) a -> Int -> Int -> m (SmallArray a)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> Int -> m (SmallArray a)
A.freezeSmallArray SmallMutableArray (PrimState m) a
marr Int
s Int
l)

thawSmallArray
  :: (HasCallStack, PrimMonad m)
  => SmallArray a -- ^ source
  -> Int          -- ^ offset
  -> Int          -- ^ length
  -> m (SmallMutableArray (PrimState m) a)
thawSmallArray :: SmallArray a -> Int -> Int -> m (SmallMutableArray (PrimState m) a)
thawSmallArray SmallArray a
arr Int
s Int
l = String
-> Bool
-> m (SmallMutableArray (PrimState m) a)
-> m (SmallMutableArray (PrimState m) a)
forall a. HasCallStack => String -> Bool -> a -> a
check String
"thawSmallArray: index range of out bounds"
  (Int
s Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
s Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= SmallArray a -> Int
forall a. SmallArray a -> Int
A.sizeofSmallArray SmallArray a
arr)
  (SmallArray a -> Int -> Int -> m (SmallMutableArray (PrimState m) a)
forall (m :: * -> *) a.
PrimMonad m =>
SmallArray a -> Int -> Int -> m (SmallMutableArray (PrimState m) a)
A.thawSmallArray SmallArray a
arr Int
s Int
l)

copySmallArray :: (HasCallStack, PrimMonad m)
  => SmallMutableArray (PrimState m) a -- ^ destination array
  -> Int                               -- ^ offset into destination array
  -> SmallArray a                      -- ^ source array
  -> Int                               -- ^ offset into source array
  -> Int                               -- ^ number of elements to copy
  -> m ()
copySmallArray :: SmallMutableArray (PrimState m) a
-> Int -> SmallArray a -> Int -> Int -> m ()
copySmallArray SmallMutableArray (PrimState m) a
marr Int
s1 SmallArray a
arr Int
s2 Int
l = do
  let siz :: Int
siz = SmallMutableArray (PrimState m) a -> Int
forall s a. SmallMutableArray s a -> Int
A.sizeofSmallMutableArray SmallMutableArray (PrimState m) a
marr
  String -> Bool -> m () -> m ()
forall a. HasCallStack => String -> Bool -> a -> a
check String
"copySmallArray: index range of out bounds"
    (Int
s1 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
s2 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
s1 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
siz Bool -> Bool -> Bool
&& Int
s2 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= SmallArray a -> Int
forall a. SmallArray a -> Int
A.sizeofSmallArray SmallArray a
arr)
    (SmallMutableArray (PrimState m) a
-> Int -> SmallArray a -> Int -> Int -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a
-> Int -> SmallArray a -> Int -> Int -> m ()
A.copySmallArray SmallMutableArray (PrimState m) a
marr Int
s1 SmallArray a
arr Int
s2 Int
l)

copySmallMutableArray :: (HasCallStack, PrimMonad m)
  => SmallMutableArray (PrimState m) a -- ^ destination array
  -> Int                               -- ^ offset into destination array
  -> SmallMutableArray (PrimState m) a -- ^ source array
  -> Int                               -- ^ offset into source array
  -> Int                               -- ^ number of elements to copy
  -> m ()
copySmallMutableArray :: SmallMutableArray (PrimState m) a
-> Int -> SmallMutableArray (PrimState m) a -> Int -> Int -> m ()
copySmallMutableArray SmallMutableArray (PrimState m) a
marr1 Int
s1 SmallMutableArray (PrimState m) a
marr2 Int
s2 Int
l = do
  let siz1 :: Int
siz1 = SmallMutableArray (PrimState m) a -> Int
forall s a. SmallMutableArray s a -> Int
A.sizeofSmallMutableArray SmallMutableArray (PrimState m) a
marr1
  let siz2 :: Int
siz2 = SmallMutableArray (PrimState m) a -> Int
forall s a. SmallMutableArray s a -> Int
A.sizeofSmallMutableArray SmallMutableArray (PrimState m) a
marr2
  String -> Bool -> m () -> m ()
forall a. HasCallStack => String -> Bool -> a -> a
check String
"copySmallMutableArray: index range of out bounds"
    (Int
s1 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
s2 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
s1 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
siz1 Bool -> Bool -> Bool
&& Int
s2 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
siz2)
    (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 ()
A.copySmallMutableArray SmallMutableArray (PrimState m) a
marr1 Int
s1 SmallMutableArray (PrimState m) a
marr2 Int
s2 Int
l)

cloneSmallArray :: HasCallStack
  => SmallArray a -- ^ source array
  -> Int          -- ^ offset into source array
  -> Int          -- ^ number of elements to copy
  -> SmallArray a
cloneSmallArray :: SmallArray a -> Int -> Int -> SmallArray a
cloneSmallArray SmallArray a
arr Int
s Int
l = String -> Bool -> SmallArray a -> SmallArray a
forall a. HasCallStack => String -> Bool -> a -> a
check String
"cloneSmallArray: index range of out bounds"
  (Int
s Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
s Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= SmallArray a -> Int
forall a. SmallArray a -> Int
A.sizeofSmallArray SmallArray a
arr)
  (SmallArray a -> Int -> Int -> SmallArray a
forall a. SmallArray a -> Int -> Int -> SmallArray a
A.cloneSmallArray SmallArray a
arr Int
s Int
l)

cloneSmallMutableArray :: (HasCallStack, PrimMonad m)
  => SmallMutableArray (PrimState m) a -- ^ source array
  -> Int                               -- ^ offset into source array
  -> Int                               -- ^ number of elements to copy
  -> m (SmallMutableArray (PrimState m) a)
cloneSmallMutableArray :: SmallMutableArray (PrimState m) a
-> Int -> Int -> m (SmallMutableArray (PrimState m) a)
cloneSmallMutableArray SmallMutableArray (PrimState m) a
marr Int
s Int
l = String
-> Bool
-> m (SmallMutableArray (PrimState m) a)
-> m (SmallMutableArray (PrimState m) a)
forall a. HasCallStack => String -> Bool -> a -> a
check String
"cloneSmallMutableArray: index range of out bounds"
  (Int
s Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
s Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= SmallMutableArray (PrimState m) a -> Int
forall s a. SmallMutableArray s a -> Int
A.sizeofSmallMutableArray SmallMutableArray (PrimState m) a
marr)
  (SmallMutableArray (PrimState m) a
-> Int -> Int -> m (SmallMutableArray (PrimState m) a)
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a
-> Int -> Int -> m (SmallMutableArray (PrimState m) a)
A.cloneSmallMutableArray SmallMutableArray (PrimState m) a
marr Int
s Int
l)

#if MIN_VERSION_base(4,14,0)
shrinkSmallMutableArray :: (HasCallStack, PrimMonad m) => SmallMutableArray (PrimState m) a -> Int -> m ()
shrinkSmallMutableArray :: SmallMutableArray (PrimState m) a -> Int -> m ()
shrinkSmallMutableArray SmallMutableArray (PrimState m) a
marr Int
n = do
    let old :: Int
old = SmallMutableArray (PrimState m) a -> Int
forall s a. SmallMutableArray s a -> Int
A.sizeofSmallMutableArray SmallMutableArray (PrimState m) a
marr
    String -> Bool -> m () -> m ()
forall a. HasCallStack => String -> Bool -> a -> a
check String
"shrinkSmallMutableArray: illegal new size" (Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
0 Bool -> Bool -> Bool
&& Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
old) (SmallMutableArray (PrimState m) a -> Int -> m ()
forall (m :: * -> *) a.
PrimMonad m =>
SmallMutableArray (PrimState m) a -> Int -> m ()
A.shrinkSmallMutableArray SmallMutableArray (PrimState m) a
marr Int
n)
#endif