{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE RoleAnnotations #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UnboxedTuples #-}
{-# OPTIONS_GHC -Wno-redundant-constraints #-}
module Data.Prim.Array
(
Size(..)
, BArray(..)
, isSameBArray
, sizeOfBArray
, indexBArray
, copyBArray
, cloneBArray
, thawBArray
, thawCopyBArray
, toListBArray
, fromListBArray
, fromListBArrayN
, fromBaseBArray
, toBaseBArray
, BMArray(..)
, getSizeOfBMArray
, readBMArray
, writeBMArray
, writeLazyBMArray
, writeDeepBMArray
, isSameBMArray
, newBMArray
, newLazyBMArray
, newRawBMArray
, makeBMArray
, moveBMArray
, cloneBMArray
, shrinkBMArray
, resizeBMArray
, resizeRawBMArray
, freezeBMArray
, freezeCopyBMArray
, SBArray(..)
, isSameSBArray
, sizeOfSBArray
, indexSBArray
, copySBArray
, cloneSBArray
, thawSBArray
, thawCopySBArray
, toListSBArray
, fromListSBArray
, fromListSBArrayN
, SBMArray(..)
, isSameSBMArray
, getSizeOfSBMArray
, readSBMArray
, writeSBMArray
, writeLazySBMArray
, writeDeepSBMArray
, newSBMArray
, newLazySBMArray
, newRawSBMArray
, makeSBMArray
, moveSBMArray
, cloneSBMArray
, shrinkSBMArray
, resizeSBMArray
, resizeRawSBMArray
, freezeSBMArray
, freezeCopySBMArray
, UArray(..)
, isSameUArray
, isPinnedUArray
, sizeOfUArray
, indexUArray
, copyUArray
, thawUArray
, toListUArray
, fromListUArray
, fromListUArrayN
, fromBaseUArray
, toBaseUArray
, UMArray(..)
, isSameUMArray
, isPinnedUMArray
, getSizeOfUMArray
, readUMArray
, writeUMArray
, newUMArray
, newRawUMArray
, makeUMArray
, newPinnedUMArray
, newRawPinnedUMArray
, makePinnedUMArray
, newAlignedPinnedUMArray
, newRawAlignedPinnedUMArray
, makeAlignedPinnedUMArray
, moveUMArray
, setUMArray
, shrinkUMArray
, resizeUMArray
, freezeUMArray
, uninitialized
, makeMutWith
, fromListMutWith
, foldrWithFB
, eqWith
, compareWith
, appendWith
, concatWith
) where
import Control.DeepSeq
import Control.Prim.Exception
import qualified Data.Foldable as F
import Data.Functor.Classes
import qualified Data.List.NonEmpty as NE (toList)
import Data.Prim
import Data.Prim.Class
import Foreign.Prim
import qualified Data.Array.Base as A
import qualified GHC.Arr as A
newtype Size = Size { Size -> Int
unSize :: Int }
deriving (Int -> Size -> ShowS
[Size] -> ShowS
Size -> String
(Int -> Size -> ShowS)
-> (Size -> String) -> ([Size] -> ShowS) -> Show Size
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Size] -> ShowS
$cshowList :: [Size] -> ShowS
show :: Size -> String
$cshow :: Size -> String
showsPrec :: Int -> Size -> ShowS
$cshowsPrec :: Int -> Size -> ShowS
Show, Size -> Size -> Bool
(Size -> Size -> Bool) -> (Size -> Size -> Bool) -> Eq Size
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Size -> Size -> Bool
$c/= :: Size -> Size -> Bool
== :: Size -> Size -> Bool
$c== :: Size -> Size -> Bool
Eq, Eq Size
Eq Size
-> (Size -> Size -> Ordering)
-> (Size -> Size -> Bool)
-> (Size -> Size -> Bool)
-> (Size -> Size -> Bool)
-> (Size -> Size -> Bool)
-> (Size -> Size -> Size)
-> (Size -> Size -> Size)
-> Ord Size
Size -> Size -> Bool
Size -> Size -> Ordering
Size -> Size -> Size
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Size -> Size -> Size
$cmin :: Size -> Size -> Size
max :: Size -> Size -> Size
$cmax :: Size -> Size -> Size
>= :: Size -> Size -> Bool
$c>= :: Size -> Size -> Bool
> :: Size -> Size -> Bool
$c> :: Size -> Size -> Bool
<= :: Size -> Size -> Bool
$c<= :: Size -> Size -> Bool
< :: Size -> Size -> Bool
$c< :: Size -> Size -> Bool
compare :: Size -> Size -> Ordering
$ccompare :: Size -> Size -> Ordering
$cp1Ord :: Eq Size
Ord, Integer -> Size
Size -> Size
Size -> Size -> Size
(Size -> Size -> Size)
-> (Size -> Size -> Size)
-> (Size -> Size -> Size)
-> (Size -> Size)
-> (Size -> Size)
-> (Size -> Size)
-> (Integer -> Size)
-> Num Size
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> Size
$cfromInteger :: Integer -> Size
signum :: Size -> Size
$csignum :: Size -> Size
abs :: Size -> Size
$cabs :: Size -> Size
negate :: Size -> Size
$cnegate :: Size -> Size
* :: Size -> Size -> Size
$c* :: Size -> Size -> Size
- :: Size -> Size -> Size
$c- :: Size -> Size -> Size
+ :: Size -> Size -> Size
$c+ :: Size -> Size -> Size
Num, Num Size
Ord Size
Num Size -> Ord Size -> (Size -> Rational) -> Real Size
Size -> Rational
forall a. Num a -> Ord a -> (a -> Rational) -> Real a
toRational :: Size -> Rational
$ctoRational :: Size -> Rational
$cp2Real :: Ord Size
$cp1Real :: Num Size
Real, Enum Size
Real Size
Real Size
-> Enum Size
-> (Size -> Size -> Size)
-> (Size -> Size -> Size)
-> (Size -> Size -> Size)
-> (Size -> Size -> Size)
-> (Size -> Size -> (Size, Size))
-> (Size -> Size -> (Size, Size))
-> (Size -> Integer)
-> Integral Size
Size -> Integer
Size -> Size -> (Size, Size)
Size -> Size -> Size
forall a.
Real a
-> Enum a
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
toInteger :: Size -> Integer
$ctoInteger :: Size -> Integer
divMod :: Size -> Size -> (Size, Size)
$cdivMod :: Size -> Size -> (Size, Size)
quotRem :: Size -> Size -> (Size, Size)
$cquotRem :: Size -> Size -> (Size, Size)
mod :: Size -> Size -> Size
$cmod :: Size -> Size -> Size
div :: Size -> Size -> Size
$cdiv :: Size -> Size -> Size
rem :: Size -> Size -> Size
$crem :: Size -> Size -> Size
quot :: Size -> Size -> Size
$cquot :: Size -> Size -> Size
$cp2Integral :: Enum Size
$cp1Integral :: Real Size
Integral, Size
Size -> Size -> Bounded Size
forall a. a -> a -> Bounded a
maxBound :: Size
$cmaxBound :: Size
minBound :: Size
$cminBound :: Size
Bounded, Int -> Size
Size -> Int
Size -> [Size]
Size -> Size
Size -> Size -> [Size]
Size -> Size -> Size -> [Size]
(Size -> Size)
-> (Size -> Size)
-> (Int -> Size)
-> (Size -> Int)
-> (Size -> [Size])
-> (Size -> Size -> [Size])
-> (Size -> Size -> [Size])
-> (Size -> Size -> Size -> [Size])
-> Enum Size
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: Size -> Size -> Size -> [Size]
$cenumFromThenTo :: Size -> Size -> Size -> [Size]
enumFromTo :: Size -> Size -> [Size]
$cenumFromTo :: Size -> Size -> [Size]
enumFromThen :: Size -> Size -> [Size]
$cenumFromThen :: Size -> Size -> [Size]
enumFrom :: Size -> [Size]
$cenumFrom :: Size -> [Size]
fromEnum :: Size -> Int
$cfromEnum :: Size -> Int
toEnum :: Int -> Size
$ctoEnum :: Int -> Size
pred :: Size -> Size
$cpred :: Size -> Size
succ :: Size -> Size
$csucc :: Size -> Size
Enum)
instance Prim Size where
type PrimBase Size = Int
data BArray e = BArray (Array# e)
instance Functor BArray where
fmap :: (a -> b) -> BArray a -> BArray b
fmap a -> b
f BArray a
a =
(forall s. ST s (BArray b)) -> BArray b
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (BArray b)) -> BArray b)
-> (forall s. ST s (BArray b)) -> BArray b
forall a b. (a -> b) -> a -> b
$
Size -> (Int -> ST s b) -> ST s (BMArray b s)
forall e (m :: * -> *) s.
MonadPrim s m =>
Size -> (Int -> m e) -> m (BMArray e s)
makeBMArray
(BArray a -> Size
forall e. BArray e -> Size
sizeOfBArray BArray a
a)
(b -> ST s b
forall (f :: * -> *) a. Applicative f => a -> f a
pure (b -> ST s b) -> (Int -> b) -> Int -> ST s b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
f (a -> b) -> (Int -> a) -> Int -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BArray a -> Int -> a
forall e. BArray e -> Int -> e
indexBArray BArray a
a) ST s (BMArray b s)
-> (BMArray b s -> ST s (BArray b)) -> ST s (BArray b)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= BMArray b s -> ST s (BArray b)
forall e (m :: * -> *) s.
MonadPrim s m =>
BMArray e s -> m (BArray e)
freezeBMArray
{-# INLINE fmap #-}
<$ :: a -> BArray b -> BArray a
(<$) a
x BArray b
a = (forall s. ST s (BArray a)) -> BArray a
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (BArray a)) -> BArray a)
-> (forall s. ST s (BArray a)) -> BArray a
forall a b. (a -> b) -> a -> b
$ Size -> a -> ST s (BMArray a s)
forall e (m :: * -> *) s.
MonadPrim s m =>
Size -> e -> m (BMArray e s)
newLazyBMArray (BArray b -> Size
forall e. BArray e -> Size
sizeOfBArray BArray b
a) a
x ST s (BMArray a s)
-> (BMArray a s -> ST s (BArray a)) -> ST s (BArray a)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= BMArray a s -> ST s (BArray a)
forall e (m :: * -> *) s.
MonadPrim s m =>
BMArray e s -> m (BArray e)
freezeBMArray
{-# INLINE (<$) #-}
instance Foldable BArray where
null :: BArray a -> Bool
null = (Size -> Size -> Bool
forall a. Eq a => a -> a -> Bool
== Size
0) (Size -> Bool) -> (BArray a -> Size) -> BArray a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BArray a -> Size
forall e. BArray e -> Size
sizeOfBArray
{-# INLINE null #-}
length :: BArray a -> Int
length = Size -> Int
coerce (Size -> Int) -> (BArray a -> Size) -> BArray a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BArray a -> Size
forall e. BArray e -> Size
sizeOfBArray
{-# INLINE length #-}
foldr :: (a -> b -> b) -> b -> BArray a -> b
foldr = (BArray a -> Size)
-> (BArray a -> Int -> a) -> (a -> b -> b) -> b -> BArray a -> b
forall (a :: * -> *) e b.
(a e -> Size)
-> (a e -> Int -> e) -> (e -> b -> b) -> b -> a e -> b
foldrWithFB BArray a -> Size
forall e. BArray e -> Size
sizeOfBArray BArray a -> Int -> a
forall e. BArray e -> Int -> e
indexBArray
{-# INLINE foldr #-}
instance Show1 BArray where
#if MIN_VERSION_transformers(0,5,0)
liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> BArray a -> ShowS
liftShowsPrec Int -> a -> ShowS
_ = String -> ([a] -> ShowS) -> Int -> BArray a -> ShowS
forall (f :: * -> *) e.
Foldable f =>
String -> ([e] -> ShowS) -> Int -> f e -> ShowS
liftShowsPrecArray String
"BArray"
#else
showsPrec1 = liftShowsPrecArray "BArray" showList
#endif
instance Show e => Show (BArray e) where
showsPrec :: Int -> BArray e -> ShowS
showsPrec = Int -> BArray e -> ShowS
forall (f :: * -> *) a. (Show1 f, Show a) => Int -> f a -> ShowS
showsPrec1
instance IsList (BArray e) where
type Item (BArray e) = e
fromList :: [Item (BArray e)] -> BArray e
fromList = [Item (BArray e)] -> BArray e
forall e. [e] -> BArray e
fromListBArray
{-# INLINE fromList #-}
fromListN :: Int -> [Item (BArray e)] -> BArray e
fromListN Int
n = Size -> [e] -> BArray e
forall e. HasCallStack => Size -> [e] -> BArray e
fromListBArrayN (Int -> Size
coerce Int
n)
{-# INLINE fromListN #-}
toList :: BArray e -> [Item (BArray e)]
toList = BArray e -> [Item (BArray e)]
forall a. BArray a -> [a]
toListBArray
{-# INLINE toList #-}
instance e ~ Char => IsString (BArray e) where
fromString :: String -> BArray e
fromString = String -> BArray e
forall e. [e] -> BArray e
fromListBArray
{-# INLINE fromString #-}
instance NFData e => NFData (BArray e) where
rnf :: BArray e -> ()
rnf = (BArray e -> Size)
-> (BArray e -> Int -> e)
-> (e -> () -> ())
-> ()
-> BArray e
-> ()
forall (a :: * -> *) e b.
(a e -> Size)
-> (a e -> Int -> e) -> (e -> b -> b) -> b -> a e -> b
foldrWithFB BArray e -> Size
forall e. BArray e -> Size
sizeOfBArray BArray e -> Int -> e
forall e. BArray e -> Int -> e
indexBArray e -> () -> ()
forall a b. NFData a => a -> b -> b
deepseq ()
{-# INLINE rnf #-}
instance Eq e => Eq (BArray e) where
== :: BArray e -> BArray e -> Bool
(==) = (BArray e -> BArray e -> Bool)
-> (BArray e -> Size)
-> (BArray e -> Int -> e)
-> BArray e
-> BArray e
-> Bool
forall e (a :: * -> *).
Eq e =>
(a e -> a e -> Bool)
-> (a e -> Size) -> (a e -> Int -> e) -> a e -> a e -> Bool
eqWith BArray e -> BArray e -> Bool
forall a. BArray a -> BArray a -> Bool
isSameBArray BArray e -> Size
forall e. BArray e -> Size
sizeOfBArray BArray e -> Int -> e
forall e. BArray e -> Int -> e
indexBArray
{-# INLINE (==) #-}
instance Ord e => Ord (BArray e) where
compare :: BArray e -> BArray e -> Ordering
compare = (BArray e -> BArray e -> Bool)
-> (BArray e -> Size)
-> (BArray e -> Int -> e)
-> BArray e
-> BArray e
-> Ordering
forall e (a :: * -> *).
Ord e =>
(a e -> a e -> Bool)
-> (a e -> Size) -> (a e -> Int -> e) -> a e -> a e -> Ordering
compareWith BArray e -> BArray e -> Bool
forall a. BArray a -> BArray a -> Bool
isSameBArray BArray e -> Size
forall e. BArray e -> Size
sizeOfBArray BArray e -> Int -> e
forall e. BArray e -> Int -> e
indexBArray
{-# INLINE compare #-}
instance Eq1 BArray where
#if MIN_VERSION_transformers(0,5,0)
liftEq :: (a -> b -> Bool) -> BArray a -> BArray b -> Bool
liftEq = (forall e. BArray e -> Size)
-> (forall e. BArray e -> Int -> e)
-> (a -> b -> Bool)
-> BArray a
-> BArray b
-> Bool
forall (a :: * -> *) b c.
(forall e. a e -> Size)
-> (forall e. a e -> Int -> e)
-> (b -> c -> Bool)
-> a b
-> a c
-> Bool
liftEqWith forall e. BArray e -> Size
sizeOfBArray forall e. BArray e -> Int -> e
indexBArray
{-# INLINE liftEq #-}
#else
eq1 = liftEqWith sizeOfBArray indexBArray (==)
{-# INLINE eq1 #-}
#endif
instance Ord1 BArray where
#if MIN_VERSION_transformers(0,5,0)
liftCompare :: (a -> b -> Ordering) -> BArray a -> BArray b -> Ordering
liftCompare = (forall e. BArray e -> Size)
-> (forall e. BArray e -> Int -> e)
-> (a -> b -> Ordering)
-> BArray a
-> BArray b
-> Ordering
forall (a :: * -> *) b c.
(forall e. a e -> Size)
-> (forall e. a e -> Int -> e)
-> (b -> c -> Ordering)
-> a b
-> a c
-> Ordering
liftCompareWith forall e. BArray e -> Size
sizeOfBArray forall e. BArray e -> Int -> e
indexBArray
{-# INLINE liftCompare #-}
#else
compare1 = liftCompareWith sizeOfBArray indexBArray compare
{-# INLINE compare1 #-}
#endif
instance Semigroup (BArray e) where
<> :: BArray e -> BArray e -> BArray e
(<>) = (forall s. Size -> ST s (BMArray e s))
-> (forall s.
BArray e -> Int -> BMArray e s -> Int -> Size -> ST s ())
-> (forall s. BMArray e s -> ST s (BArray e))
-> (BArray e -> Size)
-> BArray e
-> BArray e
-> BArray e
forall (ma :: * -> * -> *) e (a :: * -> *).
(forall s. Size -> ST s (ma e s))
-> (forall s. a e -> Int -> ma e s -> Int -> Size -> ST s ())
-> (forall s. ma e s -> ST s (a e))
-> (a e -> Size)
-> a e
-> a e
-> a e
appendWith forall s. Size -> ST s (BMArray e s)
forall e (m :: * -> *) s.
(HasCallStack, MonadPrim s m) =>
Size -> m (BMArray e s)
newRawBMArray forall s. BArray e -> Int -> BMArray e s -> Int -> Size -> ST s ()
forall e (m :: * -> *) s.
MonadPrim s m =>
BArray e -> Int -> BMArray e s -> Int -> Size -> m ()
copyBArray forall s. BMArray e s -> ST s (BArray e)
forall e (m :: * -> *) s.
MonadPrim s m =>
BMArray e s -> m (BArray e)
freezeBMArray BArray e -> Size
forall e. BArray e -> Size
sizeOfBArray
{-# INLINE (<>) #-}
sconcat :: NonEmpty (BArray e) -> BArray e
sconcat NonEmpty (BArray e)
xs = (forall s. Size -> ST s (BMArray e s))
-> (forall s.
BArray e -> Int -> BMArray e s -> Int -> Size -> ST s ())
-> (forall s. BMArray e s -> ST s (BArray e))
-> (BArray e -> Size)
-> [BArray e]
-> BArray e
forall (ma :: * -> * -> *) e (a :: * -> *).
(forall s. Size -> ST s (ma e s))
-> (forall s. a e -> Int -> ma e s -> Int -> Size -> ST s ())
-> (forall s. ma e s -> ST s (a e))
-> (a e -> Size)
-> [a e]
-> a e
concatWith forall s. Size -> ST s (BMArray e s)
forall e (m :: * -> *) s.
(HasCallStack, MonadPrim s m) =>
Size -> m (BMArray e s)
newRawBMArray forall s. BArray e -> Int -> BMArray e s -> Int -> Size -> ST s ()
forall e (m :: * -> *) s.
MonadPrim s m =>
BArray e -> Int -> BMArray e s -> Int -> Size -> m ()
copyBArray forall s. BMArray e s -> ST s (BArray e)
forall e (m :: * -> *) s.
MonadPrim s m =>
BMArray e s -> m (BArray e)
freezeBMArray BArray e -> Size
forall e. BArray e -> Size
sizeOfBArray (NonEmpty (BArray e) -> [BArray e]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty (BArray e)
xs)
{-# INLINE sconcat #-}
stimes :: b -> BArray e -> BArray e
stimes b
n = (forall s. Size -> ST s (BMArray e s))
-> (forall s.
BArray e -> Int -> BMArray e s -> Int -> Size -> ST s ())
-> (forall s. BMArray e s -> ST s (BArray e))
-> (BArray e -> Size)
-> Int
-> BArray e
-> BArray e
forall (a :: * -> *) e (ma :: * -> * -> *).
Monoid (a e) =>
(forall s. Size -> ST s (ma e s))
-> (forall s. a e -> Int -> ma e s -> Int -> Size -> ST s ())
-> (forall s. ma e s -> ST s (a e))
-> (a e -> Size)
-> Int
-> a e
-> a e
cycleWith forall s. Size -> ST s (BMArray e s)
forall e (m :: * -> *) s.
(HasCallStack, MonadPrim s m) =>
Size -> m (BMArray e s)
newRawBMArray forall s. BArray e -> Int -> BMArray e s -> Int -> Size -> ST s ()
forall e (m :: * -> *) s.
MonadPrim s m =>
BArray e -> Int -> BMArray e s -> Int -> Size -> m ()
copyBArray forall s. BMArray e s -> ST s (BArray e)
forall e (m :: * -> *) s.
MonadPrim s m =>
BMArray e s -> m (BArray e)
freezeBMArray BArray e -> Size
forall e. BArray e -> Size
sizeOfBArray (b -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral b
n)
{-# INLINE stimes #-}
instance Monoid (BArray e) where
mempty :: BArray e
mempty = (forall s. ST s (BArray e)) -> BArray e
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (BArray e)) -> BArray e)
-> (forall s. ST s (BArray e)) -> BArray e
forall a b. (a -> b) -> a -> b
$ Size -> ST s (BMArray e s)
forall e (m :: * -> *) s.
(HasCallStack, MonadPrim s m) =>
Size -> m (BMArray e s)
newRawBMArray Size
0 ST s (BMArray e s)
-> (BMArray e s -> ST s (BArray e)) -> ST s (BArray e)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= BMArray e s -> ST s (BArray e)
forall e (m :: * -> *) s.
MonadPrim s m =>
BMArray e s -> m (BArray e)
freezeBMArray
{-# NOINLINE mempty #-}
mappend :: BArray e -> BArray e -> BArray e
mappend = BArray e -> BArray e -> BArray e
forall a. Semigroup a => a -> a -> a
(<>)
{-# INLINE mappend #-}
mconcat :: [BArray e] -> BArray e
mconcat = (forall s. Size -> ST s (BMArray e s))
-> (forall s.
BArray e -> Int -> BMArray e s -> Int -> Size -> ST s ())
-> (forall s. BMArray e s -> ST s (BArray e))
-> (BArray e -> Size)
-> [BArray e]
-> BArray e
forall (ma :: * -> * -> *) e (a :: * -> *).
(forall s. Size -> ST s (ma e s))
-> (forall s. a e -> Int -> ma e s -> Int -> Size -> ST s ())
-> (forall s. ma e s -> ST s (a e))
-> (a e -> Size)
-> [a e]
-> a e
concatWith forall s. Size -> ST s (BMArray e s)
forall e (m :: * -> *) s.
(HasCallStack, MonadPrim s m) =>
Size -> m (BMArray e s)
newRawBMArray forall s. BArray e -> Int -> BMArray e s -> Int -> Size -> ST s ()
forall e (m :: * -> *) s.
MonadPrim s m =>
BArray e -> Int -> BMArray e s -> Int -> Size -> m ()
copyBArray forall s. BMArray e s -> ST s (BArray e)
forall e (m :: * -> *) s.
MonadPrim s m =>
BMArray e s -> m (BArray e)
freezeBMArray BArray e -> Size
forall e. BArray e -> Size
sizeOfBArray
{-# INLINE mconcat #-}
isSameBArray :: BArray a -> BArray a -> Bool
isSameBArray :: BArray a -> BArray a -> Bool
isSameBArray BArray a
a1 BArray a
a2 = (forall s. ST s Bool) -> Bool
forall a. (forall s. ST s a) -> a
runST (BMArray a s -> BMArray a s -> Bool
forall a s. BMArray a s -> BMArray a s -> Bool
isSameBMArray (BMArray a s -> BMArray a s -> Bool)
-> ST s (BMArray a s) -> ST s (BMArray a s -> Bool)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> BArray a -> ST s (BMArray a s)
forall e (m :: * -> *) s.
MonadPrim s m =>
BArray e -> m (BMArray e s)
thawBArray BArray a
a1 ST s (BMArray a s -> Bool) -> ST s (BMArray a s) -> ST s Bool
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> BArray a -> ST s (BMArray a s)
forall e (m :: * -> *) s.
MonadPrim s m =>
BArray e -> m (BMArray e s)
thawBArray BArray a
a2)
{-# INLINE isSameBArray #-}
sizeOfBArray :: forall e. BArray e -> Size
sizeOfBArray :: BArray e -> Size
sizeOfBArray (BArray Array# e
a#) = Int -> Size
Size (Int# -> Int
I# (Array# e -> Int#
forall a. Array# a -> Int#
sizeofArray# Array# e
a#))
{-# INLINE sizeOfBArray #-}
indexBArray ::
forall e.
BArray e
-> Int
-> e
indexBArray :: BArray e -> Int -> e
indexBArray (BArray Array# e
a#) (I# Int#
i#) =
case Array# e -> Int# -> (# e #)
forall a. Array# a -> Int# -> (# a #)
indexArray# Array# e
a# Int#
i# of
(# e
x #) -> e
x
{-# INLINE indexBArray #-}
cloneBArray ::
forall e.
BArray e
-> Int
-> Size
-> BArray e
cloneBArray :: BArray e -> Int -> Size -> BArray e
cloneBArray (BArray Array# e
a#) (I# Int#
i#) (Size (I# Int#
n#)) = Array# e -> BArray e
forall e. Array# e -> BArray e
BArray (Array# e -> Int# -> Int# -> Array# e
forall a. Array# a -> Int# -> Int# -> Array# a
cloneArray# Array# e
a# Int#
i# Int#
n#)
{-# INLINE cloneBArray #-}
copyBArray ::
forall e m s. MonadPrim s m
=> BArray e
-> Int
-> BMArray e s
-> Int
-> Size
-> m ()
copyBArray :: BArray e -> Int -> BMArray e s -> Int -> Size -> m ()
copyBArray (BArray Array# e
src#) (I# Int#
srcOff#) (BMArray MutableArray# s e
dst#) (I# Int#
dstOff#) (Size (I# Int#
n#)) =
(State# s -> State# s) -> m ()
forall s (m :: * -> *).
MonadPrim s m =>
(State# s -> State# s) -> m ()
prim_ (Array# e
-> Int#
-> MutableArray# s e
-> Int#
-> Int#
-> State# s
-> State# s
forall a d.
Array# a
-> Int#
-> MutableArray# d a
-> Int#
-> Int#
-> State# d
-> State# d
copyArray# Array# e
src# Int#
srcOff# MutableArray# s e
dst# Int#
dstOff# Int#
n#)
{-# INLINE copyBArray #-}
thawBArray ::
forall e m s. MonadPrim s m
=> BArray e
-> m (BMArray e s)
thawBArray :: BArray e -> m (BMArray e s)
thawBArray (BArray Array# e
a#) = (State# s -> (# State# s, BMArray e s #)) -> m (BMArray e s)
forall s (m :: * -> *) a.
MonadPrim s m =>
(State# s -> (# State# s, a #)) -> m a
prim ((State# s -> (# State# s, BMArray e s #)) -> m (BMArray e s))
-> (State# s -> (# State# s, BMArray e s #)) -> m (BMArray e s)
forall a b. (a -> b) -> a -> b
$ \State# s
s ->
case Array# e -> State# s -> (# State# s, MutableArray# s e #)
forall a d.
Array# a -> State# d -> (# State# d, MutableArray# d a #)
unsafeThawArray# Array# e
a# State# s
s of
(# State# s
s', MutableArray# s e
ma# #) -> (# State# s
s', MutableArray# s e -> BMArray e s
forall e s. MutableArray# s e -> BMArray e s
BMArray MutableArray# s e
ma# #)
{-# INLINE thawBArray #-}
thawCopyBArray ::
forall e m s. MonadPrim s m
=> BArray e
-> Int
-> Size
-> m (BMArray e s)
thawCopyBArray :: BArray e -> Int -> Size -> m (BMArray e s)
thawCopyBArray (BArray Array# e
a#) (I# Int#
i#) (Size (I# Int#
n#)) = (State# s -> (# State# s, BMArray e s #)) -> m (BMArray e s)
forall s (m :: * -> *) a.
MonadPrim s m =>
(State# s -> (# State# s, a #)) -> m a
prim ((State# s -> (# State# s, BMArray e s #)) -> m (BMArray e s))
-> (State# s -> (# State# s, BMArray e s #)) -> m (BMArray e s)
forall a b. (a -> b) -> a -> b
$ \State# s
s ->
case Array# e
-> Int# -> Int# -> State# s -> (# State# s, MutableArray# s e #)
forall a d.
Array# a
-> Int# -> Int# -> State# d -> (# State# d, MutableArray# d a #)
thawArray# Array# e
a# Int#
i# Int#
n# State# s
s of
(# State# s
s', MutableArray# s e
ma# #) -> (# State# s
s', MutableArray# s e -> BMArray e s
forall e s. MutableArray# s e -> BMArray e s
BMArray MutableArray# s e
ma# #)
{-# INLINE thawCopyBArray #-}
toListBArray :: forall e. BArray e -> [e]
toListBArray :: BArray e -> [e]
toListBArray BArray e
ba = (forall b. (e -> b -> b) -> b -> b) -> [e]
forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
build (\ e -> b -> b
c b
n -> (BArray e -> Size)
-> (BArray e -> Int -> e) -> (e -> b -> b) -> b -> BArray e -> b
forall (a :: * -> *) e b.
(a e -> Size)
-> (a e -> Int -> e) -> (e -> b -> b) -> b -> a e -> b
foldrWithFB BArray e -> Size
forall e. BArray e -> Size
sizeOfBArray BArray e -> Int -> e
forall e. BArray e -> Int -> e
indexBArray e -> b -> b
c b
n BArray e
ba)
{-# INLINE toListBArray #-}
fromListBArrayN ::
forall e. HasCallStack
=> Size
-> [e]
-> BArray e
fromListBArrayN :: Size -> [e] -> BArray e
fromListBArrayN Size
sz [e]
xs =
(forall s. ST s (BArray e)) -> BArray e
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (BArray e)) -> BArray e)
-> (forall s. ST s (BArray e)) -> BArray e
forall a b. (a -> b) -> a -> b
$ (Size -> ST s (BMArray e s))
-> (BMArray e s -> Int -> e -> ST s ())
-> Size
-> [e]
-> ST s (BMArray e s)
forall (m :: * -> *) b a.
Monad m =>
(Size -> m b) -> (b -> Int -> a -> m ()) -> Size -> [a] -> m b
fromListMutWith Size -> ST s (BMArray e s)
forall e (m :: * -> *) s.
(HasCallStack, MonadPrim s m) =>
Size -> m (BMArray e s)
newRawBMArray BMArray e s -> Int -> e -> ST s ()
forall e (m :: * -> *) s.
MonadPrim s m =>
BMArray e s -> Int -> e -> m ()
writeBMArray Size
sz [e]
xs ST s (BMArray e s)
-> (BMArray e s -> ST s (BArray e)) -> ST s (BArray e)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= BMArray e s -> ST s (BArray e)
forall e (m :: * -> *) s.
MonadPrim s m =>
BMArray e s -> m (BArray e)
freezeBMArray
{-# INLINE fromListBArrayN #-}
fromListBArray :: forall e. [e] -> BArray e
fromListBArray :: [e] -> BArray e
fromListBArray [e]
xs = Size -> [e] -> BArray e
forall e. HasCallStack => Size -> [e] -> BArray e
fromListBArrayN (Int -> Size
coerce ([e] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [e]
xs)) [e]
xs
{-# INLINE fromListBArray #-}
fromBaseBArray :: A.Array ix e -> BArray e
fromBaseBArray :: Array ix e -> BArray e
fromBaseBArray (A.Array ix
_ ix
_ Int
_ Array# e
a#) = Array# e -> BArray e
forall e. Array# e -> BArray e
BArray Array# e
a#
toBaseBArray :: BArray e -> A.Array Int e
toBaseBArray :: BArray e -> Array Int e
toBaseBArray a :: BArray e
a@(BArray Array# e
a#) =
let Size Int
n = BArray e -> Size
forall e. BArray e -> Size
sizeOfBArray BArray e
a
in Int -> Int -> Int -> Array# e -> Array Int e
forall i e. i -> i -> Int -> Array# e -> Array i e
A.Array Int
0 (Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
0 (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)) Int
n Array# e
a#
data BMArray e s = BMArray (MutableArray# s e)
instance Eq (BMArray e s) where
== :: BMArray e s -> BMArray e s -> Bool
(==) = BMArray e s -> BMArray e s -> Bool
forall a s. BMArray a s -> BMArray a s -> Bool
isSameBMArray
{-# INLINE (==) #-}
isSameBMArray :: forall a s. BMArray a s -> BMArray a s -> Bool
isSameBMArray :: BMArray a s -> BMArray a s -> Bool
isSameBMArray (BMArray MutableArray# s a
ma1#) (BMArray MutableArray# s a
ma2#) =
Int# -> Bool
isTrue# (MutableArray# s a -> MutableArray# s a -> Int#
forall d a. MutableArray# d a -> MutableArray# d a -> Int#
sameMutableArray# MutableArray# s a
ma1# MutableArray# s a
ma2#)
{-# INLINE isSameBMArray #-}
getSizeOfBMArray ::
forall e m s. MonadPrim s m
=> BMArray e s
-> m Size
getSizeOfBMArray :: BMArray e s -> m Size
getSizeOfBMArray (BMArray MutableArray# s e
ma#) =
(State# s -> (# State# s, Size #)) -> m Size
forall s (m :: * -> *) a.
MonadPrim s m =>
(State# s -> (# State# s, a #)) -> m a
prim ((State# s -> (# State# s, Size #)) -> m Size)
-> (State# s -> (# State# s, Size #)) -> m Size
forall a b. (a -> b) -> a -> b
$ \State# s
s ->
case MutableArray# s e -> State# s -> (# State# s, Int# #)
forall s a. MutableArray# s a -> State# s -> (# State# s, Int# #)
getSizeofMutableArray# MutableArray# s e
ma# State# s
s of
(# State# s
s', Int#
n# #) -> (# State# s
s', Int -> Size
coerce (Int# -> Int
I# Int#
n#) #)
{-# INLINE getSizeOfBMArray #-}
readBMArray ::
forall e m s. MonadPrim s m
=> BMArray e s
-> Int
-> m e
readBMArray :: BMArray e s -> Int -> m e
readBMArray (BMArray MutableArray# s e
ma#) (I# Int#
i#) = (State# s -> (# State# s, e #)) -> m e
forall s (m :: * -> *) a.
MonadPrim s m =>
(State# s -> (# State# s, a #)) -> m a
prim (MutableArray# s e -> Int# -> State# s -> (# State# s, e #)
forall d a.
MutableArray# d a -> Int# -> State# d -> (# State# d, a #)
readArray# MutableArray# s e
ma# Int#
i#)
{-# INLINE readBMArray #-}
writeBMArray ::
forall e m s. MonadPrim s m
=> BMArray e s
-> Int
-> e
-> m ()
writeBMArray :: BMArray e s -> Int -> e -> m ()
writeBMArray BMArray e s
ma Int
i !e
x = BMArray e s -> Int -> e -> m ()
forall e (m :: * -> *) s.
MonadPrim s m =>
BMArray e s -> Int -> e -> m ()
writeLazyBMArray BMArray e s
ma Int
i e
x
{-# INLINE writeBMArray #-}
writeLazyBMArray ::
forall e m s. MonadPrim s m
=> BMArray e s
-> Int
-> e
-> m ()
writeLazyBMArray :: BMArray e s -> Int -> e -> m ()
writeLazyBMArray (BMArray MutableArray# s e
ma#) (I# Int#
i#) e
a = (State# s -> State# s) -> m ()
forall s (m :: * -> *).
MonadPrim s m =>
(State# s -> State# s) -> m ()
prim_ (MutableArray# s e -> Int# -> e -> State# s -> State# s
forall d a. MutableArray# d a -> Int# -> a -> State# d -> State# d
writeArray# MutableArray# s e
ma# Int#
i# e
a)
{-# INLINE writeLazyBMArray #-}
writeDeepBMArray ::
forall e m s. (MonadPrim s m, NFData e)
=> BMArray e s
-> Int
-> e
-> m ()
writeDeepBMArray :: BMArray e s -> Int -> e -> m ()
writeDeepBMArray BMArray e s
ma Int
i !e
x =
case e -> ()
forall a. NFData a => a -> ()
rnf e
x of
() -> BMArray e s -> Int -> e -> m ()
forall e (m :: * -> *) s.
MonadPrim s m =>
BMArray e s -> Int -> e -> m ()
writeLazyBMArray BMArray e s
ma Int
i e
x
{-# INLINE writeDeepBMArray #-}
newBMArray ::
forall e m s. MonadPrim s m
=> Size
-> e
-> m (BMArray e s)
newBMArray :: Size -> e -> m (BMArray e s)
newBMArray Size
sz e
x = e
x e -> m (BMArray e s) -> m (BMArray e s)
`seq` Size -> e -> m (BMArray e s)
forall e (m :: * -> *) s.
MonadPrim s m =>
Size -> e -> m (BMArray e s)
newLazyBMArray Size
sz e
x
{-# INLINE newBMArray #-}
newLazyBMArray ::
forall e m s. MonadPrim s m
=> Size
-> e
-> m (BMArray e s)
newLazyBMArray :: Size -> e -> m (BMArray e s)
newLazyBMArray (Size (I# Int#
n#)) e
a =
(State# s -> (# State# s, BMArray e s #)) -> m (BMArray e s)
forall s (m :: * -> *) a.
MonadPrim s m =>
(State# s -> (# State# s, a #)) -> m a
prim ((State# s -> (# State# s, BMArray e s #)) -> m (BMArray e s))
-> (State# s -> (# State# s, BMArray e s #)) -> m (BMArray e s)
forall a b. (a -> b) -> a -> b
$ \State# s
s ->
case Int# -> e -> State# s -> (# State# s, MutableArray# s e #)
forall a d.
Int# -> a -> State# d -> (# State# d, MutableArray# d a #)
newArray# Int#
n# e
a State# s
s of
(# State# s
s', MutableArray# s e
ma# #) -> (# State# s
s', MutableArray# s e -> BMArray e s
forall e s. MutableArray# s e -> BMArray e s
BMArray MutableArray# s e
ma# #)
{-# INLINE newLazyBMArray #-}
newRawBMArray ::
forall e m s. (HasCallStack, MonadPrim s m)
=> Size
-> m (BMArray e s)
newRawBMArray :: Size -> m (BMArray e s)
newRawBMArray Size
sz = Size -> e -> m (BMArray e s)
forall e (m :: * -> *) s.
MonadPrim s m =>
Size -> e -> m (BMArray e s)
newLazyBMArray Size
sz (String -> String -> e
forall a. HasCallStack => String -> String -> a
uninitialized String
"Data.Prim.Aray" String
"newRawBMArray")
{-# INLINE newRawBMArray #-}
makeBMArray ::
forall e m s. MonadPrim s m
=> Size
-> (Int -> m e)
-> m (BMArray e s)
makeBMArray :: Size -> (Int -> m e) -> m (BMArray e s)
makeBMArray = (Size -> m (BMArray e s))
-> (BMArray e s -> Int -> e -> m ())
-> Size
-> (Int -> m e)
-> m (BMArray e s)
forall (m :: * -> *) b a.
Monad m =>
(Size -> m b)
-> (b -> Int -> a -> m ()) -> Size -> (Int -> m a) -> m b
makeMutWith Size -> m (BMArray e s)
forall e (m :: * -> *) s.
(HasCallStack, MonadPrim s m) =>
Size -> m (BMArray e s)
newRawBMArray BMArray e s -> Int -> e -> m ()
forall e (m :: * -> *) s.
MonadPrim s m =>
BMArray e s -> Int -> e -> m ()
writeBMArray
{-# INLINE makeBMArray #-}
freezeBMArray ::
forall e m s. MonadPrim s m
=> BMArray e s
-> m (BArray e)
freezeBMArray :: BMArray e s -> m (BArray e)
freezeBMArray (BMArray MutableArray# s e
ma#) = (State# s -> (# State# s, BArray e #)) -> m (BArray e)
forall s (m :: * -> *) a.
MonadPrim s m =>
(State# s -> (# State# s, a #)) -> m a
prim ((State# s -> (# State# s, BArray e #)) -> m (BArray e))
-> (State# s -> (# State# s, BArray e #)) -> m (BArray e)
forall a b. (a -> b) -> a -> b
$ \State# s
s ->
case MutableArray# s e -> State# s -> (# State# s, Array# e #)
forall d a.
MutableArray# d a -> State# d -> (# State# d, Array# a #)
unsafeFreezeArray# MutableArray# s e
ma# State# s
s of
(# State# s
s', Array# e
a# #) -> (# State# s
s', Array# e -> BArray e
forall e. Array# e -> BArray e
BArray Array# e
a# #)
{-# INLINE freezeBMArray #-}
freezeCopyBMArray ::
forall e m s. MonadPrim s m
=> BMArray e s
-> Int
-> Size
-> m (BArray e)
freezeCopyBMArray :: BMArray e s -> Int -> Size -> m (BArray e)
freezeCopyBMArray (BMArray MutableArray# s e
ma#) (I# Int#
i#) (Size (I# Int#
n#)) = (State# s -> (# State# s, BArray e #)) -> m (BArray e)
forall s (m :: * -> *) a.
MonadPrim s m =>
(State# s -> (# State# s, a #)) -> m a
prim ((State# s -> (# State# s, BArray e #)) -> m (BArray e))
-> (State# s -> (# State# s, BArray e #)) -> m (BArray e)
forall a b. (a -> b) -> a -> b
$ \State# s
s ->
case MutableArray# s e
-> Int# -> Int# -> State# s -> (# State# s, Array# e #)
forall d a.
MutableArray# d a
-> Int# -> Int# -> State# d -> (# State# d, Array# a #)
freezeArray# MutableArray# s e
ma# Int#
i# Int#
n# State# s
s of
(# State# s
s', Array# e
a# #) -> (# State# s
s', Array# e -> BArray e
forall e. Array# e -> BArray e
BArray Array# e
a# #)
{-# INLINE freezeCopyBMArray #-}
cloneBMArray ::
forall e m s. MonadPrim s m
=> BMArray e s
-> Int
-> Size
-> m (BMArray e s)
cloneBMArray :: BMArray e s -> Int -> Size -> m (BMArray e s)
cloneBMArray (BMArray MutableArray# s e
ma#) (I# Int#
i#) (Size (I# Int#
n#)) =
(State# s -> (# State# s, BMArray e s #)) -> m (BMArray e s)
forall s (m :: * -> *) a.
MonadPrim s m =>
(State# s -> (# State# s, a #)) -> m a
prim ((State# s -> (# State# s, BMArray e s #)) -> m (BMArray e s))
-> (State# s -> (# State# s, BMArray e s #)) -> m (BMArray e s)
forall a b. (a -> b) -> a -> b
$ \State# s
s ->
case MutableArray# s e
-> Int# -> Int# -> State# s -> (# State# s, MutableArray# s e #)
forall d a.
MutableArray# d a
-> Int# -> Int# -> State# d -> (# State# d, MutableArray# d a #)
cloneMutableArray# MutableArray# s e
ma# Int#
i# Int#
n# State# s
s of
(# State# s
s', MutableArray# s e
ma'# #) -> (# State# s
s', MutableArray# s e -> BMArray e s
forall e s. MutableArray# s e -> BMArray e s
BMArray MutableArray# s e
ma'# #)
{-# INLINE cloneBMArray #-}
shrinkBMArray ::
forall e m s. MonadPrim s m
=> BMArray e s
-> Size
-> m ()
shrinkBMArray :: BMArray e s -> Size -> m ()
shrinkBMArray (BMArray MutableArray# s e
ma#) (Size (I# Int#
sz#)) =
(State# s -> State# s) -> m ()
forall s (m :: * -> *).
MonadPrim s m =>
(State# s -> State# s) -> m ()
prim_ (MutableArray# s e -> Int# -> State# s -> State# s
forall s a. MutableArray# s a -> Int# -> State# s -> State# s
shrinkMutableArray# MutableArray# s e
ma# Int#
sz#)
{-# INLINE shrinkBMArray #-}
resizeBMArray ::
forall e m s. MonadPrim s m
=> BMArray e s
-> Size
-> e
-> m (BMArray e s)
resizeBMArray :: BMArray e s -> Size -> e -> m (BMArray e s)
resizeBMArray (BMArray MutableArray# s e
ma#) (Size (I# Int#
sz#)) e
e =
(State# s -> (# State# s, BMArray e s #)) -> m (BMArray e s)
forall s (m :: * -> *) a.
MonadPrim s m =>
(State# s -> (# State# s, a #)) -> m a
prim ((State# s -> (# State# s, BMArray e s #)) -> m (BMArray e s))
-> (State# s -> (# State# s, BMArray e s #)) -> m (BMArray e s)
forall a b. (a -> b) -> a -> b
$ \State# s
s ->
case MutableArray# s e
-> Int# -> e -> State# s -> (# State# s, MutableArray# s e #)
forall s a.
MutableArray# s a
-> Int# -> a -> State# s -> (# State# s, MutableArray# s a #)
resizeMutableArray# MutableArray# s e
ma# Int#
sz# e
e State# s
s of
(# State# s
s', MutableArray# s e
ma'# #) -> (# State# s
s', MutableArray# s e -> BMArray e s
forall e s. MutableArray# s e -> BMArray e s
BMArray MutableArray# s e
ma'# #)
{-# INLINE resizeBMArray #-}
resizeRawBMArray ::
forall e m s. MonadPrim s m
=> BMArray e s
-> Size
-> m (BMArray e s)
resizeRawBMArray :: BMArray e s -> Size -> m (BMArray e s)
resizeRawBMArray BMArray e s
ma Size
sz = BMArray e s -> Size -> e -> m (BMArray e s)
forall e (m :: * -> *) s.
MonadPrim s m =>
BMArray e s -> Size -> e -> m (BMArray e s)
resizeBMArray BMArray e s
ma Size
sz (String -> String -> e
forall a. HasCallStack => String -> String -> a
uninitialized String
"Data.Prim.Aray" String
"resizeRawBMArray")
{-# INLINE resizeRawBMArray #-}
moveBMArray ::
forall e m s. MonadPrim s m
=> BMArray e s
-> Int
-> BMArray e s
-> Int
-> Size
-> m ()
moveBMArray :: BMArray e s -> Int -> BMArray e s -> Int -> Size -> m ()
moveBMArray (BMArray MutableArray# s e
src#) (I# Int#
srcOff#) (BMArray MutableArray# s e
dst#) (I# Int#
dstOff#) (Size (I# Int#
n#)) =
(State# s -> State# s) -> m ()
forall s (m :: * -> *).
MonadPrim s m =>
(State# s -> State# s) -> m ()
prim_ (MutableArray# s e
-> Int#
-> MutableArray# s e
-> Int#
-> Int#
-> State# s
-> State# s
forall d a.
MutableArray# d a
-> Int#
-> MutableArray# d a
-> Int#
-> Int#
-> State# d
-> State# d
copyMutableArray# MutableArray# s e
src# Int#
srcOff# MutableArray# s e
dst# Int#
dstOff# Int#
n#)
{-# INLINE moveBMArray #-}
data SBArray e = SBArray (SmallArray# e)
instance Functor SBArray where
fmap :: (a -> b) -> SBArray a -> SBArray b
fmap a -> b
f SBArray a
a =
(forall s. ST s (SBArray b)) -> SBArray b
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (SBArray b)) -> SBArray b)
-> (forall s. ST s (SBArray b)) -> SBArray b
forall a b. (a -> b) -> a -> b
$
Size -> (Int -> ST s b) -> ST s (SBMArray b s)
forall e (m :: * -> *) s.
MonadPrim s m =>
Size -> (Int -> m e) -> m (SBMArray e s)
makeSBMArray
(SBArray a -> Size
forall e. SBArray e -> Size
sizeOfSBArray SBArray a
a)
(b -> ST s b
forall (f :: * -> *) a. Applicative f => a -> f a
pure (b -> ST s b) -> (Int -> b) -> Int -> ST s b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
f (a -> b) -> (Int -> a) -> Int -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SBArray a -> Int -> a
forall e. SBArray e -> Int -> e
indexSBArray SBArray a
a) ST s (SBMArray b s)
-> (SBMArray b s -> ST s (SBArray b)) -> ST s (SBArray b)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= SBMArray b s -> ST s (SBArray b)
forall e (m :: * -> *) s.
MonadPrim s m =>
SBMArray e s -> m (SBArray e)
freezeSBMArray
{-# INLINE fmap #-}
<$ :: a -> SBArray b -> SBArray a
(<$) a
x SBArray b
a = (forall s. ST s (SBArray a)) -> SBArray a
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (SBArray a)) -> SBArray a)
-> (forall s. ST s (SBArray a)) -> SBArray a
forall a b. (a -> b) -> a -> b
$ Size -> a -> ST s (SBMArray a s)
forall e (m :: * -> *) s.
MonadPrim s m =>
Size -> e -> m (SBMArray e s)
newLazySBMArray (SBArray b -> Size
forall e. SBArray e -> Size
sizeOfSBArray SBArray b
a) a
x ST s (SBMArray a s)
-> (SBMArray a s -> ST s (SBArray a)) -> ST s (SBArray a)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= SBMArray a s -> ST s (SBArray a)
forall e (m :: * -> *) s.
MonadPrim s m =>
SBMArray e s -> m (SBArray e)
freezeSBMArray
{-# INLINE (<$) #-}
instance Foldable SBArray where
null :: SBArray a -> Bool
null = (Size -> Size -> Bool
forall a. Eq a => a -> a -> Bool
== Size
0) (Size -> Bool) -> (SBArray a -> Size) -> SBArray a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SBArray a -> Size
forall e. SBArray e -> Size
sizeOfSBArray
{-# INLINE null #-}
length :: SBArray a -> Int
length = Size -> Int
coerce (Size -> Int) -> (SBArray a -> Size) -> SBArray a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SBArray a -> Size
forall e. SBArray e -> Size
sizeOfSBArray
{-# INLINE length #-}
foldr :: (a -> b -> b) -> b -> SBArray a -> b
foldr = (SBArray a -> Size)
-> (SBArray a -> Int -> a) -> (a -> b -> b) -> b -> SBArray a -> b
forall (a :: * -> *) e b.
(a e -> Size)
-> (a e -> Int -> e) -> (e -> b -> b) -> b -> a e -> b
foldrWithFB SBArray a -> Size
forall e. SBArray e -> Size
sizeOfSBArray SBArray a -> Int -> a
forall e. SBArray e -> Int -> e
indexSBArray
{-# INLINE foldr #-}
instance Show1 SBArray where
#if MIN_VERSION_transformers(0,5,0)
liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> SBArray a -> ShowS
liftShowsPrec Int -> a -> ShowS
_ = String -> ([a] -> ShowS) -> Int -> SBArray a -> ShowS
forall (f :: * -> *) e.
Foldable f =>
String -> ([e] -> ShowS) -> Int -> f e -> ShowS
liftShowsPrecArray String
"SBArray"
#else
showsPrec1 = liftShowsPrecArray "SBArray" showList
#endif
instance Show e => Show (SBArray e) where
showsPrec :: Int -> SBArray e -> ShowS
showsPrec = Int -> SBArray e -> ShowS
forall (f :: * -> *) a. (Show1 f, Show a) => Int -> f a -> ShowS
showsPrec1
instance IsList (SBArray e) where
type Item (SBArray e) = e
fromList :: [Item (SBArray e)] -> SBArray e
fromList = [Item (SBArray e)] -> SBArray e
forall e. [e] -> SBArray e
fromListSBArray
{-# INLINE fromList #-}
fromListN :: Int -> [Item (SBArray e)] -> SBArray e
fromListN Int
n = Size -> [e] -> SBArray e
forall e. HasCallStack => Size -> [e] -> SBArray e
fromListSBArrayN (Int -> Size
coerce Int
n)
{-# INLINE fromListN #-}
toList :: SBArray e -> [Item (SBArray e)]
toList = SBArray e -> [Item (SBArray e)]
forall a. SBArray a -> [a]
toListSBArray
{-# INLINE toList #-}
instance e ~ Char => IsString (SBArray e) where
fromString :: String -> SBArray e
fromString = String -> SBArray e
forall e. [e] -> SBArray e
fromListSBArray
{-# INLINE fromString #-}
instance NFData e => NFData (SBArray e) where
rnf :: SBArray e -> ()
rnf = (SBArray e -> Size)
-> (SBArray e -> Int -> e)
-> (e -> () -> ())
-> ()
-> SBArray e
-> ()
forall (a :: * -> *) e b.
(a e -> Size)
-> (a e -> Int -> e) -> (e -> b -> b) -> b -> a e -> b
foldrWithFB SBArray e -> Size
forall e. SBArray e -> Size
sizeOfSBArray SBArray e -> Int -> e
forall e. SBArray e -> Int -> e
indexSBArray e -> () -> ()
forall a b. NFData a => a -> b -> b
deepseq ()
{-# INLINE rnf #-}
instance Eq e => Eq (SBArray e) where
== :: SBArray e -> SBArray e -> Bool
(==) = (SBArray e -> SBArray e -> Bool)
-> (SBArray e -> Size)
-> (SBArray e -> Int -> e)
-> SBArray e
-> SBArray e
-> Bool
forall e (a :: * -> *).
Eq e =>
(a e -> a e -> Bool)
-> (a e -> Size) -> (a e -> Int -> e) -> a e -> a e -> Bool
eqWith SBArray e -> SBArray e -> Bool
forall a. SBArray a -> SBArray a -> Bool
isSameSBArray SBArray e -> Size
forall e. SBArray e -> Size
sizeOfSBArray SBArray e -> Int -> e
forall e. SBArray e -> Int -> e
indexSBArray
{-# INLINE (==) #-}
instance Ord e => Ord (SBArray e) where
compare :: SBArray e -> SBArray e -> Ordering
compare = (SBArray e -> SBArray e -> Bool)
-> (SBArray e -> Size)
-> (SBArray e -> Int -> e)
-> SBArray e
-> SBArray e
-> Ordering
forall e (a :: * -> *).
Ord e =>
(a e -> a e -> Bool)
-> (a e -> Size) -> (a e -> Int -> e) -> a e -> a e -> Ordering
compareWith SBArray e -> SBArray e -> Bool
forall a. SBArray a -> SBArray a -> Bool
isSameSBArray SBArray e -> Size
forall e. SBArray e -> Size
sizeOfSBArray SBArray e -> Int -> e
forall e. SBArray e -> Int -> e
indexSBArray
{-# INLINE compare #-}
instance Eq1 SBArray where
#if MIN_VERSION_transformers(0,5,0)
liftEq :: (a -> b -> Bool) -> SBArray a -> SBArray b -> Bool
liftEq = (forall e. SBArray e -> Size)
-> (forall e. SBArray e -> Int -> e)
-> (a -> b -> Bool)
-> SBArray a
-> SBArray b
-> Bool
forall (a :: * -> *) b c.
(forall e. a e -> Size)
-> (forall e. a e -> Int -> e)
-> (b -> c -> Bool)
-> a b
-> a c
-> Bool
liftEqWith forall e. SBArray e -> Size
sizeOfSBArray forall e. SBArray e -> Int -> e
indexSBArray
{-# INLINE liftEq #-}
#else
eq1 = liftEqWith sizeOfSBArray indexSBArray (==)
{-# INLINE eq1 #-}
#endif
instance Ord1 SBArray where
#if MIN_VERSION_transformers(0,5,0)
liftCompare :: (a -> b -> Ordering) -> SBArray a -> SBArray b -> Ordering
liftCompare = (forall e. SBArray e -> Size)
-> (forall e. SBArray e -> Int -> e)
-> (a -> b -> Ordering)
-> SBArray a
-> SBArray b
-> Ordering
forall (a :: * -> *) b c.
(forall e. a e -> Size)
-> (forall e. a e -> Int -> e)
-> (b -> c -> Ordering)
-> a b
-> a c
-> Ordering
liftCompareWith forall e. SBArray e -> Size
sizeOfSBArray forall e. SBArray e -> Int -> e
indexSBArray
{-# INLINE liftCompare #-}
#else
compare1 = liftCompareWith sizeOfSBArray indexSBArray compare
{-# INLINE compare1 #-}
#endif
instance Semigroup (SBArray e) where
<> :: SBArray e -> SBArray e -> SBArray e
(<>) = (forall s. Size -> ST s (SBMArray e s))
-> (forall s.
SBArray e -> Int -> SBMArray e s -> Int -> Size -> ST s ())
-> (forall s. SBMArray e s -> ST s (SBArray e))
-> (SBArray e -> Size)
-> SBArray e
-> SBArray e
-> SBArray e
forall (ma :: * -> * -> *) e (a :: * -> *).
(forall s. Size -> ST s (ma e s))
-> (forall s. a e -> Int -> ma e s -> Int -> Size -> ST s ())
-> (forall s. ma e s -> ST s (a e))
-> (a e -> Size)
-> a e
-> a e
-> a e
appendWith forall s. Size -> ST s (SBMArray e s)
forall e (m :: * -> *) s.
(HasCallStack, MonadPrim s m) =>
Size -> m (SBMArray e s)
newRawSBMArray forall s.
SBArray e -> Int -> SBMArray e s -> Int -> Size -> ST s ()
forall e (m :: * -> *) s.
MonadPrim s m =>
SBArray e -> Int -> SBMArray e s -> Int -> Size -> m ()
copySBArray forall s. SBMArray e s -> ST s (SBArray e)
forall e (m :: * -> *) s.
MonadPrim s m =>
SBMArray e s -> m (SBArray e)
freezeSBMArray SBArray e -> Size
forall e. SBArray e -> Size
sizeOfSBArray
{-# INLINE (<>) #-}
sconcat :: NonEmpty (SBArray e) -> SBArray e
sconcat NonEmpty (SBArray e)
xs = (forall s. Size -> ST s (SBMArray e s))
-> (forall s.
SBArray e -> Int -> SBMArray e s -> Int -> Size -> ST s ())
-> (forall s. SBMArray e s -> ST s (SBArray e))
-> (SBArray e -> Size)
-> [SBArray e]
-> SBArray e
forall (ma :: * -> * -> *) e (a :: * -> *).
(forall s. Size -> ST s (ma e s))
-> (forall s. a e -> Int -> ma e s -> Int -> Size -> ST s ())
-> (forall s. ma e s -> ST s (a e))
-> (a e -> Size)
-> [a e]
-> a e
concatWith forall s. Size -> ST s (SBMArray e s)
forall e (m :: * -> *) s.
(HasCallStack, MonadPrim s m) =>
Size -> m (SBMArray e s)
newRawSBMArray forall s.
SBArray e -> Int -> SBMArray e s -> Int -> Size -> ST s ()
forall e (m :: * -> *) s.
MonadPrim s m =>
SBArray e -> Int -> SBMArray e s -> Int -> Size -> m ()
copySBArray forall s. SBMArray e s -> ST s (SBArray e)
forall e (m :: * -> *) s.
MonadPrim s m =>
SBMArray e s -> m (SBArray e)
freezeSBMArray SBArray e -> Size
forall e. SBArray e -> Size
sizeOfSBArray (NonEmpty (SBArray e) -> [SBArray e]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty (SBArray e)
xs)
{-# INLINE sconcat #-}
stimes :: b -> SBArray e -> SBArray e
stimes b
n = (forall s. Size -> ST s (SBMArray e s))
-> (forall s.
SBArray e -> Int -> SBMArray e s -> Int -> Size -> ST s ())
-> (forall s. SBMArray e s -> ST s (SBArray e))
-> (SBArray e -> Size)
-> Int
-> SBArray e
-> SBArray e
forall (a :: * -> *) e (ma :: * -> * -> *).
Monoid (a e) =>
(forall s. Size -> ST s (ma e s))
-> (forall s. a e -> Int -> ma e s -> Int -> Size -> ST s ())
-> (forall s. ma e s -> ST s (a e))
-> (a e -> Size)
-> Int
-> a e
-> a e
cycleWith forall s. Size -> ST s (SBMArray e s)
forall e (m :: * -> *) s.
(HasCallStack, MonadPrim s m) =>
Size -> m (SBMArray e s)
newRawSBMArray forall s.
SBArray e -> Int -> SBMArray e s -> Int -> Size -> ST s ()
forall e (m :: * -> *) s.
MonadPrim s m =>
SBArray e -> Int -> SBMArray e s -> Int -> Size -> m ()
copySBArray forall s. SBMArray e s -> ST s (SBArray e)
forall e (m :: * -> *) s.
MonadPrim s m =>
SBMArray e s -> m (SBArray e)
freezeSBMArray SBArray e -> Size
forall e. SBArray e -> Size
sizeOfSBArray (b -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral b
n)
{-# INLINE stimes #-}
instance Monoid (SBArray e) where
mempty :: SBArray e
mempty = (forall s. ST s (SBArray e)) -> SBArray e
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (SBArray e)) -> SBArray e)
-> (forall s. ST s (SBArray e)) -> SBArray e
forall a b. (a -> b) -> a -> b
$ Size -> ST s (SBMArray e s)
forall e (m :: * -> *) s.
(HasCallStack, MonadPrim s m) =>
Size -> m (SBMArray e s)
newRawSBMArray Size
0 ST s (SBMArray e s)
-> (SBMArray e s -> ST s (SBArray e)) -> ST s (SBArray e)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= SBMArray e s -> ST s (SBArray e)
forall e (m :: * -> *) s.
MonadPrim s m =>
SBMArray e s -> m (SBArray e)
freezeSBMArray
{-# NOINLINE mempty #-}
mappend :: SBArray e -> SBArray e -> SBArray e
mappend = SBArray e -> SBArray e -> SBArray e
forall a. Semigroup a => a -> a -> a
(<>)
{-# INLINE mappend #-}
mconcat :: [SBArray e] -> SBArray e
mconcat = (forall s. Size -> ST s (SBMArray e s))
-> (forall s.
SBArray e -> Int -> SBMArray e s -> Int -> Size -> ST s ())
-> (forall s. SBMArray e s -> ST s (SBArray e))
-> (SBArray e -> Size)
-> [SBArray e]
-> SBArray e
forall (ma :: * -> * -> *) e (a :: * -> *).
(forall s. Size -> ST s (ma e s))
-> (forall s. a e -> Int -> ma e s -> Int -> Size -> ST s ())
-> (forall s. ma e s -> ST s (a e))
-> (a e -> Size)
-> [a e]
-> a e
concatWith forall s. Size -> ST s (SBMArray e s)
forall e (m :: * -> *) s.
(HasCallStack, MonadPrim s m) =>
Size -> m (SBMArray e s)
newRawSBMArray forall s.
SBArray e -> Int -> SBMArray e s -> Int -> Size -> ST s ()
forall e (m :: * -> *) s.
MonadPrim s m =>
SBArray e -> Int -> SBMArray e s -> Int -> Size -> m ()
copySBArray forall s. SBMArray e s -> ST s (SBArray e)
forall e (m :: * -> *) s.
MonadPrim s m =>
SBMArray e s -> m (SBArray e)
freezeSBMArray SBArray e -> Size
forall e. SBArray e -> Size
sizeOfSBArray
{-# INLINE mconcat #-}
isSameSBArray :: SBArray a -> SBArray a -> Bool
isSameSBArray :: SBArray a -> SBArray a -> Bool
isSameSBArray SBArray a
a1 SBArray a
a2 = (forall s. ST s Bool) -> Bool
forall a. (forall s. ST s a) -> a
runST (SBMArray a s -> SBMArray a s -> Bool
forall a s. SBMArray a s -> SBMArray a s -> Bool
isSameSBMArray (SBMArray a s -> SBMArray a s -> Bool)
-> ST s (SBMArray a s) -> ST s (SBMArray a s -> Bool)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> SBArray a -> ST s (SBMArray a s)
forall e (m :: * -> *) s.
MonadPrim s m =>
SBArray e -> m (SBMArray e s)
thawSBArray SBArray a
a1 ST s (SBMArray a s -> Bool) -> ST s (SBMArray a s) -> ST s Bool
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> SBArray a -> ST s (SBMArray a s)
forall e (m :: * -> *) s.
MonadPrim s m =>
SBArray e -> m (SBMArray e s)
thawSBArray SBArray a
a2)
{-# INLINE isSameSBArray #-}
sizeOfSBArray :: forall e. SBArray e -> Size
sizeOfSBArray :: SBArray e -> Size
sizeOfSBArray (SBArray SmallArray# e
a#) = Int -> Size
Size (Int# -> Int
I# (SmallArray# e -> Int#
forall a. SmallArray# a -> Int#
sizeofSmallArray# SmallArray# e
a#))
{-# INLINE sizeOfSBArray #-}
indexSBArray ::
forall e.
SBArray e
-> Int
-> e
indexSBArray :: SBArray e -> Int -> e
indexSBArray (SBArray SmallArray# e
a#) (I# Int#
i#) =
case SmallArray# e -> Int# -> (# e #)
forall a. SmallArray# a -> Int# -> (# a #)
indexSmallArray# SmallArray# e
a# Int#
i# of
(# e
x #) -> e
x
{-# INLINE indexSBArray #-}
cloneSBArray ::
forall e.
SBArray e
-> Int
-> Size
-> SBArray e
cloneSBArray :: SBArray e -> Int -> Size -> SBArray e
cloneSBArray (SBArray SmallArray# e
a#) (I# Int#
i#) (Size (I# Int#
n#)) = SmallArray# e -> SBArray e
forall e. SmallArray# e -> SBArray e
SBArray (SmallArray# e -> Int# -> Int# -> SmallArray# e
forall a. SmallArray# a -> Int# -> Int# -> SmallArray# a
cloneSmallArray# SmallArray# e
a# Int#
i# Int#
n#)
{-# INLINE cloneSBArray #-}
shrinkSBMArray ::
forall e m s. MonadPrim s m
=> SBMArray e s
-> Size
-> m ()
shrinkSBMArray :: SBMArray e s -> Size -> m ()
shrinkSBMArray (SBMArray SmallMutableArray# s e
ma#) (Size (I# Int#
sz#)) =
(State# s -> State# s) -> m ()
forall s (m :: * -> *).
MonadPrim s m =>
(State# s -> State# s) -> m ()
prim_ (SmallMutableArray# s e -> Int# -> State# s -> State# s
forall d a. SmallMutableArray# d a -> Int# -> State# d -> State# d
shrinkSmallMutableArray# SmallMutableArray# s e
ma# Int#
sz#)
{-# INLINE shrinkSBMArray #-}
resizeSBMArray ::
forall e m s. MonadPrim s m
=> SBMArray e s
-> Size
-> e
-> m (SBMArray e s)
resizeSBMArray :: SBMArray e s -> Size -> e -> m (SBMArray e s)
resizeSBMArray (SBMArray SmallMutableArray# s e
ma#) (Size (I# Int#
sz#)) e
e =
(State# s -> (# State# s, SBMArray e s #)) -> m (SBMArray e s)
forall s (m :: * -> *) a.
MonadPrim s m =>
(State# s -> (# State# s, a #)) -> m a
prim ((State# s -> (# State# s, SBMArray e s #)) -> m (SBMArray e s))
-> (State# s -> (# State# s, SBMArray e s #)) -> m (SBMArray e s)
forall a b. (a -> b) -> a -> b
$ \State# s
s ->
case SmallMutableArray# s e
-> Int# -> e -> State# s -> (# State# s, SmallMutableArray# s e #)
forall s a.
SmallMutableArray# s a
-> Int# -> a -> State# s -> (# State# s, SmallMutableArray# s a #)
resizeSmallMutableArray# SmallMutableArray# s e
ma# Int#
sz# e
e State# s
s of
(# State# s
s', SmallMutableArray# s e
ma'# #) -> (# State# s
s', SmallMutableArray# s e -> SBMArray e s
forall e s. SmallMutableArray# s e -> SBMArray e s
SBMArray SmallMutableArray# s e
ma'# #)
{-# INLINE resizeSBMArray #-}
resizeRawSBMArray ::
forall e m s. MonadPrim s m
=> SBMArray e s
-> Size
-> m (SBMArray e s)
resizeRawSBMArray :: SBMArray e s -> Size -> m (SBMArray e s)
resizeRawSBMArray SBMArray e s
ma Size
sz = SBMArray e s -> Size -> e -> m (SBMArray e s)
forall e (m :: * -> *) s.
MonadPrim s m =>
SBMArray e s -> Size -> e -> m (SBMArray e s)
resizeSBMArray SBMArray e s
ma Size
sz (String -> String -> e
forall a. HasCallStack => String -> String -> a
uninitialized String
"Data.Prim.Aray" String
"resizeRawSBMArray")
{-# INLINE resizeRawSBMArray #-}
copySBArray ::
forall e m s. MonadPrim s m
=> SBArray e
-> Int
-> SBMArray e s
-> Int
-> Size
-> m ()
copySBArray :: SBArray e -> Int -> SBMArray e s -> Int -> Size -> m ()
copySBArray (SBArray SmallArray# e
src#) (I# Int#
srcOff#) (SBMArray SmallMutableArray# s e
dst#) (I# Int#
dstOff#) (Size (I# Int#
n#)) =
(State# s -> State# s) -> m ()
forall s (m :: * -> *).
MonadPrim s m =>
(State# s -> State# s) -> m ()
prim_ (SmallArray# e
-> Int#
-> SmallMutableArray# s e
-> Int#
-> Int#
-> State# s
-> State# s
forall a d.
SmallArray# a
-> Int#
-> SmallMutableArray# d a
-> Int#
-> Int#
-> State# d
-> State# d
copySmallArray# SmallArray# e
src# Int#
srcOff# SmallMutableArray# s e
dst# Int#
dstOff# Int#
n#)
{-# INLINE copySBArray #-}
thawSBArray ::
forall e m s. MonadPrim s m
=> SBArray e
-> m (SBMArray e s)
thawSBArray :: SBArray e -> m (SBMArray e s)
thawSBArray (SBArray SmallArray# e
a#) = (State# s -> (# State# s, SBMArray e s #)) -> m (SBMArray e s)
forall s (m :: * -> *) a.
MonadPrim s m =>
(State# s -> (# State# s, a #)) -> m a
prim ((State# s -> (# State# s, SBMArray e s #)) -> m (SBMArray e s))
-> (State# s -> (# State# s, SBMArray e s #)) -> m (SBMArray e s)
forall a b. (a -> b) -> a -> b
$ \State# s
s ->
case SmallArray# e -> State# s -> (# State# s, SmallMutableArray# s e #)
forall a d.
SmallArray# a -> State# d -> (# State# d, SmallMutableArray# d a #)
unsafeThawSmallArray# SmallArray# e
a# State# s
s of
(# State# s
s', SmallMutableArray# s e
ma# #) -> (# State# s
s', SmallMutableArray# s e -> SBMArray e s
forall e s. SmallMutableArray# s e -> SBMArray e s
SBMArray SmallMutableArray# s e
ma# #)
{-# INLINE thawSBArray #-}
thawCopySBArray ::
forall e m s. MonadPrim s m
=> SBArray e
-> Int
-> Size
-> m (SBMArray e s)
thawCopySBArray :: SBArray e -> Int -> Size -> m (SBMArray e s)
thawCopySBArray (SBArray SmallArray# e
a#) (I# Int#
i#) (Size (I# Int#
n#)) = (State# s -> (# State# s, SBMArray e s #)) -> m (SBMArray e s)
forall s (m :: * -> *) a.
MonadPrim s m =>
(State# s -> (# State# s, a #)) -> m a
prim ((State# s -> (# State# s, SBMArray e s #)) -> m (SBMArray e s))
-> (State# s -> (# State# s, SBMArray e s #)) -> m (SBMArray e s)
forall a b. (a -> b) -> a -> b
$ \State# s
s ->
case SmallArray# e
-> Int#
-> Int#
-> State# s
-> (# State# s, SmallMutableArray# s e #)
forall a d.
SmallArray# a
-> Int#
-> Int#
-> State# d
-> (# State# d, SmallMutableArray# d a #)
thawSmallArray# SmallArray# e
a# Int#
i# Int#
n# State# s
s of
(# State# s
s', SmallMutableArray# s e
ma# #) -> (# State# s
s', SmallMutableArray# s e -> SBMArray e s
forall e s. SmallMutableArray# s e -> SBMArray e s
SBMArray SmallMutableArray# s e
ma# #)
{-# INLINE thawCopySBArray #-}
toListSBArray :: forall e. SBArray e -> [e]
toListSBArray :: SBArray e -> [e]
toListSBArray SBArray e
ba = (forall b. (e -> b -> b) -> b -> b) -> [e]
forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
build (\ e -> b -> b
c b
n -> (SBArray e -> Size)
-> (SBArray e -> Int -> e) -> (e -> b -> b) -> b -> SBArray e -> b
forall (a :: * -> *) e b.
(a e -> Size)
-> (a e -> Int -> e) -> (e -> b -> b) -> b -> a e -> b
foldrWithFB SBArray e -> Size
forall e. SBArray e -> Size
sizeOfSBArray SBArray e -> Int -> e
forall e. SBArray e -> Int -> e
indexSBArray e -> b -> b
c b
n SBArray e
ba)
{-# INLINE toListSBArray #-}
fromListSBArrayN ::
forall e. HasCallStack
=> Size
-> [e]
-> SBArray e
fromListSBArrayN :: Size -> [e] -> SBArray e
fromListSBArrayN Size
sz [e]
xs =
(forall s. ST s (SBArray e)) -> SBArray e
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (SBArray e)) -> SBArray e)
-> (forall s. ST s (SBArray e)) -> SBArray e
forall a b. (a -> b) -> a -> b
$ (Size -> ST s (SBMArray e s))
-> (SBMArray e s -> Int -> e -> ST s ())
-> Size
-> [e]
-> ST s (SBMArray e s)
forall (m :: * -> *) b a.
Monad m =>
(Size -> m b) -> (b -> Int -> a -> m ()) -> Size -> [a] -> m b
fromListMutWith Size -> ST s (SBMArray e s)
forall e (m :: * -> *) s.
(HasCallStack, MonadPrim s m) =>
Size -> m (SBMArray e s)
newRawSBMArray SBMArray e s -> Int -> e -> ST s ()
forall e (m :: * -> *) s.
MonadPrim s m =>
SBMArray e s -> Int -> e -> m ()
writeSBMArray Size
sz [e]
xs ST s (SBMArray e s)
-> (SBMArray e s -> ST s (SBArray e)) -> ST s (SBArray e)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= SBMArray e s -> ST s (SBArray e)
forall e (m :: * -> *) s.
MonadPrim s m =>
SBMArray e s -> m (SBArray e)
freezeSBMArray
{-# INLINE fromListSBArrayN #-}
fromListSBArray :: forall e. [e] -> SBArray e
fromListSBArray :: [e] -> SBArray e
fromListSBArray [e]
xs = Size -> [e] -> SBArray e
forall e. HasCallStack => Size -> [e] -> SBArray e
fromListSBArrayN (Int -> Size
coerce ([e] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [e]
xs)) [e]
xs
{-# INLINE fromListSBArray #-}
data SBMArray e s = SBMArray (SmallMutableArray# s e)
instance Eq (SBMArray e s) where
== :: SBMArray e s -> SBMArray e s -> Bool
(==) = SBMArray e s -> SBMArray e s -> Bool
forall a s. SBMArray a s -> SBMArray a s -> Bool
isSameSBMArray
{-# INLINE (==) #-}
isSameSBMArray :: forall a s. SBMArray a s -> SBMArray a s -> Bool
isSameSBMArray :: SBMArray a s -> SBMArray a s -> Bool
isSameSBMArray (SBMArray SmallMutableArray# s a
ma1#) (SBMArray SmallMutableArray# s a
ma2#) =
Int# -> Bool
isTrue# (SmallMutableArray# s a -> SmallMutableArray# s a -> Int#
forall d a.
SmallMutableArray# d a -> SmallMutableArray# d a -> Int#
sameSmallMutableArray# SmallMutableArray# s a
ma1# SmallMutableArray# s a
ma2#)
{-# INLINE isSameSBMArray #-}
getSizeOfSBMArray :: forall e m s. MonadPrim s m => SBMArray e s -> m Size
getSizeOfSBMArray :: SBMArray e s -> m Size
getSizeOfSBMArray (SBMArray SmallMutableArray# s e
ma#) =
(State# s -> (# State# s, Size #)) -> m Size
forall s (m :: * -> *) a.
MonadPrim s m =>
(State# s -> (# State# s, a #)) -> m a
prim ((State# s -> (# State# s, Size #)) -> m Size)
-> (State# s -> (# State# s, Size #)) -> m Size
forall a b. (a -> b) -> a -> b
$ \State# s
s ->
case SmallMutableArray# s e -> State# s -> (# State# s, Int# #)
forall d a.
SmallMutableArray# d a -> State# d -> (# State# d, Int# #)
getSizeofSmallMutableArray# SmallMutableArray# s e
ma# State# s
s of
(# State# s
s', Int#
i# #) -> (# State# s
s', Int -> Size
coerce (Int# -> Int
I# Int#
i#) #)
{-# INLINE getSizeOfSBMArray #-}
readSBMArray ::
forall e m s. MonadPrim s m
=> SBMArray e s
-> Int
-> m e
readSBMArray :: SBMArray e s -> Int -> m e
readSBMArray (SBMArray SmallMutableArray# s e
ma#) (I# Int#
i#) = (State# s -> (# State# s, e #)) -> m e
forall s (m :: * -> *) a.
MonadPrim s m =>
(State# s -> (# State# s, a #)) -> m a
prim (SmallMutableArray# s e -> Int# -> State# s -> (# State# s, e #)
forall d a.
SmallMutableArray# d a -> Int# -> State# d -> (# State# d, a #)
readSmallArray# SmallMutableArray# s e
ma# Int#
i#)
{-# INLINE readSBMArray #-}
writeSBMArray ::
forall e m s. MonadPrim s m
=> SBMArray e s
-> Int
-> e
-> m ()
writeSBMArray :: SBMArray e s -> Int -> e -> m ()
writeSBMArray SBMArray e s
ma Int
i !e
x = SBMArray e s -> Int -> e -> m ()
forall e (m :: * -> *) s.
MonadPrim s m =>
SBMArray e s -> Int -> e -> m ()
writeLazySBMArray SBMArray e s
ma Int
i e
x
{-# INLINE writeSBMArray #-}
writeLazySBMArray ::
forall e m s. MonadPrim s m
=> SBMArray e s
-> Int
-> e
-> m ()
writeLazySBMArray :: SBMArray e s -> Int -> e -> m ()
writeLazySBMArray (SBMArray SmallMutableArray# s e
ma#) (I# Int#
i#) e
a = (State# s -> State# s) -> m ()
forall s (m :: * -> *).
MonadPrim s m =>
(State# s -> State# s) -> m ()
prim_ (SmallMutableArray# s e -> Int# -> e -> State# s -> State# s
forall d a.
SmallMutableArray# d a -> Int# -> a -> State# d -> State# d
writeSmallArray# SmallMutableArray# s e
ma# Int#
i# e
a)
{-# INLINE writeLazySBMArray #-}
writeDeepSBMArray ::
forall e m s. (MonadPrim s m, NFData e)
=> SBMArray e s
-> Int
-> e
-> m ()
writeDeepSBMArray :: SBMArray e s -> Int -> e -> m ()
writeDeepSBMArray SBMArray e s
ma Int
i !e
x =
case e -> ()
forall a. NFData a => a -> ()
rnf e
x of
() -> SBMArray e s -> Int -> e -> m ()
forall e (m :: * -> *) s.
MonadPrim s m =>
SBMArray e s -> Int -> e -> m ()
writeLazySBMArray SBMArray e s
ma Int
i e
x
{-# INLINE writeDeepSBMArray #-}
newSBMArray ::
forall e m s. MonadPrim s m
=> Size
-> e
-> m (SBMArray e s)
newSBMArray :: Size -> e -> m (SBMArray e s)
newSBMArray Size
sz e
x = e
x e -> m (SBMArray e s) -> m (SBMArray e s)
`seq` Size -> e -> m (SBMArray e s)
forall e (m :: * -> *) s.
MonadPrim s m =>
Size -> e -> m (SBMArray e s)
newLazySBMArray Size
sz e
x
{-# INLINE newSBMArray #-}
newLazySBMArray ::
forall e m s. MonadPrim s m
=> Size
-> e
-> m (SBMArray e s)
newLazySBMArray :: Size -> e -> m (SBMArray e s)
newLazySBMArray (Size (I# Int#
n#)) e
a =
(State# s -> (# State# s, SBMArray e s #)) -> m (SBMArray e s)
forall s (m :: * -> *) a.
MonadPrim s m =>
(State# s -> (# State# s, a #)) -> m a
prim ((State# s -> (# State# s, SBMArray e s #)) -> m (SBMArray e s))
-> (State# s -> (# State# s, SBMArray e s #)) -> m (SBMArray e s)
forall a b. (a -> b) -> a -> b
$ \State# s
s ->
case Int# -> e -> State# s -> (# State# s, SmallMutableArray# s e #)
forall a d.
Int# -> a -> State# d -> (# State# d, SmallMutableArray# d a #)
newSmallArray# Int#
n# e
a State# s
s of
(# State# s
s', SmallMutableArray# s e
ma# #) -> (# State# s
s', SmallMutableArray# s e -> SBMArray e s
forall e s. SmallMutableArray# s e -> SBMArray e s
SBMArray SmallMutableArray# s e
ma# #)
{-# INLINE newLazySBMArray #-}
newRawSBMArray ::
forall e m s. (HasCallStack, MonadPrim s m)
=> Size
-> m (SBMArray e s)
newRawSBMArray :: Size -> m (SBMArray e s)
newRawSBMArray Size
sz = Size -> e -> m (SBMArray e s)
forall e (m :: * -> *) s.
MonadPrim s m =>
Size -> e -> m (SBMArray e s)
newLazySBMArray Size
sz (String -> String -> e
forall a. HasCallStack => String -> String -> a
uninitialized String
"Data.Prim.Aray" String
"newRawSBMArray")
{-# INLINE newRawSBMArray #-}
makeSBMArray ::
forall e m s. MonadPrim s m
=> Size
-> (Int -> m e)
-> m (SBMArray e s)
makeSBMArray :: Size -> (Int -> m e) -> m (SBMArray e s)
makeSBMArray = (Size -> m (SBMArray e s))
-> (SBMArray e s -> Int -> e -> m ())
-> Size
-> (Int -> m e)
-> m (SBMArray e s)
forall (m :: * -> *) b a.
Monad m =>
(Size -> m b)
-> (b -> Int -> a -> m ()) -> Size -> (Int -> m a) -> m b
makeMutWith Size -> m (SBMArray e s)
forall e (m :: * -> *) s.
(HasCallStack, MonadPrim s m) =>
Size -> m (SBMArray e s)
newRawSBMArray SBMArray e s -> Int -> e -> m ()
forall e (m :: * -> *) s.
MonadPrim s m =>
SBMArray e s -> Int -> e -> m ()
writeSBMArray
{-# INLINE makeSBMArray #-}
freezeSBMArray ::
forall e m s. MonadPrim s m
=> SBMArray e s
-> m (SBArray e)
freezeSBMArray :: SBMArray e s -> m (SBArray e)
freezeSBMArray (SBMArray SmallMutableArray# s e
ma#) = (State# s -> (# State# s, SBArray e #)) -> m (SBArray e)
forall s (m :: * -> *) a.
MonadPrim s m =>
(State# s -> (# State# s, a #)) -> m a
prim ((State# s -> (# State# s, SBArray e #)) -> m (SBArray e))
-> (State# s -> (# State# s, SBArray e #)) -> m (SBArray e)
forall a b. (a -> b) -> a -> b
$ \State# s
s ->
case SmallMutableArray# s e -> State# s -> (# State# s, SmallArray# e #)
forall d a.
SmallMutableArray# d a -> State# d -> (# State# d, SmallArray# a #)
unsafeFreezeSmallArray# SmallMutableArray# s e
ma# State# s
s of
(# State# s
s', SmallArray# e
a# #) -> (# State# s
s', SmallArray# e -> SBArray e
forall e. SmallArray# e -> SBArray e
SBArray SmallArray# e
a# #)
{-# INLINE freezeSBMArray #-}
freezeCopySBMArray ::
forall e m s. MonadPrim s m
=> SBMArray e s
-> Int
-> Size
-> m (SBArray e)
freezeCopySBMArray :: SBMArray e s -> Int -> Size -> m (SBArray e)
freezeCopySBMArray (SBMArray SmallMutableArray# s e
ma#) (I# Int#
i#) (Size (I# Int#
n#)) = (State# s -> (# State# s, SBArray e #)) -> m (SBArray e)
forall s (m :: * -> *) a.
MonadPrim s m =>
(State# s -> (# State# s, a #)) -> m a
prim ((State# s -> (# State# s, SBArray e #)) -> m (SBArray e))
-> (State# s -> (# State# s, SBArray e #)) -> m (SBArray e)
forall a b. (a -> b) -> a -> b
$ \State# s
s ->
case SmallMutableArray# s e
-> Int# -> Int# -> State# s -> (# State# s, SmallArray# e #)
forall d a.
SmallMutableArray# d a
-> Int# -> Int# -> State# d -> (# State# d, SmallArray# a #)
freezeSmallArray# SmallMutableArray# s e
ma# Int#
i# Int#
n# State# s
s of
(# State# s
s', SmallArray# e
a# #) -> (# State# s
s', SmallArray# e -> SBArray e
forall e. SmallArray# e -> SBArray e
SBArray SmallArray# e
a# #)
{-# INLINE freezeCopySBMArray #-}
cloneSBMArray ::
forall e m s. MonadPrim s m
=> SBMArray e s
-> Int
-> Size
-> m (SBMArray e s)
cloneSBMArray :: SBMArray e s -> Int -> Size -> m (SBMArray e s)
cloneSBMArray (SBMArray SmallMutableArray# s e
ma#) (I# Int#
i#) (Size (I# Int#
n#)) =
(State# s -> (# State# s, SBMArray e s #)) -> m (SBMArray e s)
forall s (m :: * -> *) a.
MonadPrim s m =>
(State# s -> (# State# s, a #)) -> m a
prim ((State# s -> (# State# s, SBMArray e s #)) -> m (SBMArray e s))
-> (State# s -> (# State# s, SBMArray e s #)) -> m (SBMArray e s)
forall a b. (a -> b) -> a -> b
$ \State# s
s ->
case SmallMutableArray# s e
-> Int#
-> Int#
-> State# s
-> (# State# s, SmallMutableArray# s e #)
forall d a.
SmallMutableArray# d a
-> Int#
-> Int#
-> State# d
-> (# State# d, SmallMutableArray# d a #)
cloneSmallMutableArray# SmallMutableArray# s e
ma# Int#
i# Int#
n# State# s
s of
(# State# s
s', SmallMutableArray# s e
ma'# #) -> (# State# s
s', SmallMutableArray# s e -> SBMArray e s
forall e s. SmallMutableArray# s e -> SBMArray e s
SBMArray SmallMutableArray# s e
ma'# #)
{-# INLINE cloneSBMArray #-}
moveSBMArray ::
forall e m s. MonadPrim s m
=> SBMArray e s
-> Int
-> SBMArray e s
-> Int
-> Size
-> m ()
moveSBMArray :: SBMArray e s -> Int -> SBMArray e s -> Int -> Size -> m ()
moveSBMArray (SBMArray SmallMutableArray# s e
src#) (I# Int#
srcOff#) (SBMArray SmallMutableArray# s e
dst#) (I# Int#
dstOff#) (Size (I# Int#
n#)) =
(State# s -> State# s) -> m ()
forall s (m :: * -> *).
MonadPrim s m =>
(State# s -> State# s) -> m ()
prim_ (SmallMutableArray# s e
-> Int#
-> SmallMutableArray# s e
-> Int#
-> Int#
-> State# s
-> State# s
forall d a.
SmallMutableArray# d a
-> Int#
-> SmallMutableArray# d a
-> Int#
-> Int#
-> State# d
-> State# d
copySmallMutableArray# SmallMutableArray# s e
src# Int#
srcOff# SmallMutableArray# s e
dst# Int#
dstOff# Int#
n#)
{-# INLINE moveSBMArray #-}
data UArray e = UArray ByteArray#
type role UArray nominal
instance (Prim e, Show e) => Show (UArray e) where
showsPrec :: Int -> UArray e -> ShowS
showsPrec Int
n UArray e
arr
| Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
1 = (Char
'(' Char -> ShowS
forall a. a -> [a] -> [a]
:) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS
inner ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char
')' Char -> ShowS
forall a. a -> [a] -> [a]
:)
| Bool
otherwise = ShowS
inner
where
inner :: ShowS
inner = (String
"UArray " String -> ShowS
forall a. [a] -> [a] -> [a]
++) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [e] -> ShowS
forall a. Show a => a -> ShowS
shows (UArray e -> [Item (UArray e)]
forall l. IsList l => l -> [Item l]
toList UArray e
arr)
instance Prim e => IsList (UArray e) where
type Item (UArray e) = e
fromList :: [Item (UArray e)] -> UArray e
fromList = [Item (UArray e)] -> UArray e
forall e. Prim e => [e] -> UArray e
fromListUArray
{-# INLINE fromList #-}
fromListN :: Int -> [Item (UArray e)] -> UArray e
fromListN Int
n = Size -> [e] -> UArray e
forall e. Prim e => Size -> [e] -> UArray e
fromListUArrayN (Int -> Size
coerce Int
n)
{-# INLINE fromListN #-}
toList :: UArray e -> [Item (UArray e)]
toList = UArray e -> [Item (UArray e)]
forall e. Prim e => UArray e -> [e]
toListUArray
{-# INLINE toList #-}
instance e ~ Char => IsString (UArray e) where
fromString :: String -> UArray e
fromString = String -> UArray e
forall e. Prim e => [e] -> UArray e
fromListUArray
{-# INLINE fromString #-}
instance NFData (UArray e) where
rnf :: UArray e -> ()
rnf (UArray ByteArray#
_) = ()
{-# INLINE rnf #-}
instance (Prim e, Eq e) => Eq (UArray e) where
== :: UArray e -> UArray e -> Bool
(==) = (UArray e -> UArray e -> Bool)
-> (UArray e -> Size)
-> (UArray e -> Int -> e)
-> UArray e
-> UArray e
-> Bool
forall e (a :: * -> *).
Eq e =>
(a e -> a e -> Bool)
-> (a e -> Size) -> (a e -> Int -> e) -> a e -> a e -> Bool
eqWith UArray e -> UArray e -> Bool
forall a b. UArray a -> UArray b -> Bool
isSameUArray UArray e -> Size
forall e. Prim e => UArray e -> Size
sizeOfUArray UArray e -> Int -> e
forall e. Prim e => UArray e -> Int -> e
indexUArray
{-# INLINE (==) #-}
instance (Prim e, Ord e) => Ord (UArray e) where
compare :: UArray e -> UArray e -> Ordering
compare = (UArray e -> UArray e -> Bool)
-> (UArray e -> Size)
-> (UArray e -> Int -> e)
-> UArray e
-> UArray e
-> Ordering
forall e (a :: * -> *).
Ord e =>
(a e -> a e -> Bool)
-> (a e -> Size) -> (a e -> Int -> e) -> a e -> a e -> Ordering
compareWith UArray e -> UArray e -> Bool
forall a b. UArray a -> UArray b -> Bool
isSameUArray UArray e -> Size
forall e. Prim e => UArray e -> Size
sizeOfUArray UArray e -> Int -> e
forall e. Prim e => UArray e -> Int -> e
indexUArray
{-# INLINE compare #-}
instance Prim e => Semigroup (UArray e) where
<> :: UArray e -> UArray e -> UArray e
(<>) = (forall s. Size -> ST s (UMArray e s))
-> (forall s.
UArray e -> Int -> UMArray e s -> Int -> Size -> ST s ())
-> (forall s. UMArray e s -> ST s (UArray e))
-> (UArray e -> Size)
-> UArray e
-> UArray e
-> UArray e
forall (ma :: * -> * -> *) e (a :: * -> *).
(forall s. Size -> ST s (ma e s))
-> (forall s. a e -> Int -> ma e s -> Int -> Size -> ST s ())
-> (forall s. ma e s -> ST s (a e))
-> (a e -> Size)
-> a e
-> a e
-> a e
appendWith forall s. Size -> ST s (UMArray e s)
forall e (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
Size -> m (UMArray e s)
newRawUMArray forall s. UArray e -> Int -> UMArray e s -> Int -> Size -> ST s ()
forall e (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
UArray e -> Int -> UMArray e s -> Int -> Size -> m ()
copyUArray forall s. UMArray e s -> ST s (UArray e)
forall e (m :: * -> *) s.
MonadPrim s m =>
UMArray e s -> m (UArray e)
freezeUMArray UArray e -> Size
forall e. Prim e => UArray e -> Size
sizeOfUArray
{-# INLINE (<>) #-}
sconcat :: NonEmpty (UArray e) -> UArray e
sconcat NonEmpty (UArray e)
xs = (forall s. Size -> ST s (UMArray e s))
-> (forall s.
UArray e -> Int -> UMArray e s -> Int -> Size -> ST s ())
-> (forall s. UMArray e s -> ST s (UArray e))
-> (UArray e -> Size)
-> [UArray e]
-> UArray e
forall (ma :: * -> * -> *) e (a :: * -> *).
(forall s. Size -> ST s (ma e s))
-> (forall s. a e -> Int -> ma e s -> Int -> Size -> ST s ())
-> (forall s. ma e s -> ST s (a e))
-> (a e -> Size)
-> [a e]
-> a e
concatWith forall s. Size -> ST s (UMArray e s)
forall e (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
Size -> m (UMArray e s)
newRawUMArray forall s. UArray e -> Int -> UMArray e s -> Int -> Size -> ST s ()
forall e (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
UArray e -> Int -> UMArray e s -> Int -> Size -> m ()
copyUArray forall s. UMArray e s -> ST s (UArray e)
forall e (m :: * -> *) s.
MonadPrim s m =>
UMArray e s -> m (UArray e)
freezeUMArray UArray e -> Size
forall e. Prim e => UArray e -> Size
sizeOfUArray (NonEmpty (UArray e) -> [UArray e]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty (UArray e)
xs)
{-# INLINE sconcat #-}
stimes :: b -> UArray e -> UArray e
stimes b
n = (forall s. Size -> ST s (UMArray e s))
-> (forall s.
UArray e -> Int -> UMArray e s -> Int -> Size -> ST s ())
-> (forall s. UMArray e s -> ST s (UArray e))
-> (UArray e -> Size)
-> Int
-> UArray e
-> UArray e
forall (a :: * -> *) e (ma :: * -> * -> *).
Monoid (a e) =>
(forall s. Size -> ST s (ma e s))
-> (forall s. a e -> Int -> ma e s -> Int -> Size -> ST s ())
-> (forall s. ma e s -> ST s (a e))
-> (a e -> Size)
-> Int
-> a e
-> a e
cycleWith forall s. Size -> ST s (UMArray e s)
forall e (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
Size -> m (UMArray e s)
newRawUMArray forall s. UArray e -> Int -> UMArray e s -> Int -> Size -> ST s ()
forall e (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
UArray e -> Int -> UMArray e s -> Int -> Size -> m ()
copyUArray forall s. UMArray e s -> ST s (UArray e)
forall e (m :: * -> *) s.
MonadPrim s m =>
UMArray e s -> m (UArray e)
freezeUMArray UArray e -> Size
forall e. Prim e => UArray e -> Size
sizeOfUArray (b -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral b
n)
{-# INLINE stimes #-}
instance Prim e => Monoid (UArray e) where
mempty :: UArray e
mempty = (forall s. ST s (UArray e)) -> UArray e
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (UArray e)) -> UArray e)
-> (forall s. ST s (UArray e)) -> UArray e
forall a b. (a -> b) -> a -> b
$ Size -> ST s (UMArray e s)
forall e (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
Size -> m (UMArray e s)
newRawUMArray Size
0 ST s (UMArray e s)
-> (UMArray e s -> ST s (UArray e)) -> ST s (UArray e)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= UMArray e s -> ST s (UArray e)
forall e (m :: * -> *) s.
MonadPrim s m =>
UMArray e s -> m (UArray e)
freezeUMArray
{-# NOINLINE mempty #-}
mappend :: UArray e -> UArray e -> UArray e
mappend = UArray e -> UArray e -> UArray e
forall a. Semigroup a => a -> a -> a
(<>)
{-# INLINE mappend #-}
mconcat :: [UArray e] -> UArray e
mconcat = (forall s. Size -> ST s (UMArray e s))
-> (forall s.
UArray e -> Int -> UMArray e s -> Int -> Size -> ST s ())
-> (forall s. UMArray e s -> ST s (UArray e))
-> (UArray e -> Size)
-> [UArray e]
-> UArray e
forall (ma :: * -> * -> *) e (a :: * -> *).
(forall s. Size -> ST s (ma e s))
-> (forall s. a e -> Int -> ma e s -> Int -> Size -> ST s ())
-> (forall s. ma e s -> ST s (a e))
-> (a e -> Size)
-> [a e]
-> a e
concatWith forall s. Size -> ST s (UMArray e s)
forall e (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
Size -> m (UMArray e s)
newRawUMArray forall s. UArray e -> Int -> UMArray e s -> Int -> Size -> ST s ()
forall e (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
UArray e -> Int -> UMArray e s -> Int -> Size -> m ()
copyUArray forall s. UMArray e s -> ST s (UArray e)
forall e (m :: * -> *) s.
MonadPrim s m =>
UMArray e s -> m (UArray e)
freezeUMArray UArray e -> Size
forall e. Prim e => UArray e -> Size
sizeOfUArray
{-# INLINE mconcat #-}
isSameUArray :: forall a b. UArray a -> UArray b -> Bool
isSameUArray :: UArray a -> UArray b -> Bool
isSameUArray (UArray ByteArray#
ma1#) (UArray ByteArray#
ma2#) = Int# -> Bool
isTrue# (ByteArray# -> ByteArray# -> Int#
isSameByteArray# ByteArray#
ma1# ByteArray#
ma2#)
{-# INLINE isSameUArray #-}
isPinnedUArray :: forall e. UArray e -> Bool
isPinnedUArray :: UArray e -> Bool
isPinnedUArray (UArray ByteArray#
b#) = Int# -> Bool
isTrue# (ByteArray# -> Int#
isByteArrayPinned# ByteArray#
b#)
{-# INLINE isPinnedUArray #-}
sizeOfUArray ::
forall e. Prim e
=> UArray e
-> Size
sizeOfUArray :: UArray e -> Size
sizeOfUArray (UArray ByteArray#
a#) =
Count e -> Size
coerce (Count Word8 -> Count e
forall e. Prim e => Count Word8 -> Count e
fromByteCount (Int -> Count Word8
coerce (Int# -> Int
I# (ByteArray# -> Int#
sizeofByteArray# ByteArray#
a#))) :: Count e)
{-# INLINE sizeOfUArray #-}
indexUArray ::
forall e. Prim e
=> UArray e
-> Int
-> e
indexUArray :: UArray e -> Int -> e
indexUArray (UArray ByteArray#
a#) (I# Int#
i#) = ByteArray# -> Int# -> e
forall a. Prim a => ByteArray# -> Int# -> a
indexByteArray# ByteArray#
a# Int#
i#
{-# INLINE indexUArray #-}
copyUArray ::
forall e m s. (Prim e, MonadPrim s m)
=> UArray e
-> Int
-> UMArray e s
-> Int
-> Size
-> m ()
copyUArray :: UArray e -> Int -> UMArray e s -> Int -> Size -> m ()
copyUArray (UArray ByteArray#
src#) Int
srcOff (UMArray MutableByteArray# s
dst#) Int
dstOff Size
n =
let srcOff# :: Int#
srcOff# = Off e -> Int#
forall e. Prim e => Off e -> Int#
unOffBytes# (Int -> Off e
coerce Int
srcOff :: Off e)
dstOff# :: Int#
dstOff# = Off e -> Int#
forall e. Prim e => Off e -> Int#
unOffBytes# (Int -> Off e
coerce Int
dstOff :: Off e)
n# :: Int#
n# = Count e -> Int#
forall e. Prim e => Count e -> Int#
unCountBytes# (Size -> Count e
coerce Size
n :: Count e)
in (State# s -> State# s) -> m ()
forall s (m :: * -> *).
MonadPrim s m =>
(State# s -> State# s) -> m ()
prim_ (ByteArray#
-> Int#
-> MutableByteArray# s
-> Int#
-> Int#
-> State# s
-> State# s
forall d.
ByteArray#
-> Int#
-> MutableByteArray# d
-> Int#
-> Int#
-> State# d
-> State# d
copyByteArray# ByteArray#
src# Int#
srcOff# MutableByteArray# s
dst# Int#
dstOff# Int#
n#)
{-# INLINE copyUArray #-}
thawUArray :: forall e m s. MonadPrim s m => UArray e -> m (UMArray e s)
thawUArray :: UArray e -> m (UMArray e s)
thawUArray (UArray ByteArray#
a#) =
(State# s -> (# State# s, UMArray e s #)) -> m (UMArray e s)
forall s (m :: * -> *) a.
MonadPrim s m =>
(State# s -> (# State# s, a #)) -> m a
prim ((State# s -> (# State# s, UMArray e s #)) -> m (UMArray e s))
-> (State# s -> (# State# s, UMArray e s #)) -> m (UMArray e s)
forall a b. (a -> b) -> a -> b
$ \State# s
s ->
case ByteArray# -> State# s -> (# State# s, MutableByteArray# s #)
forall s.
ByteArray# -> State# s -> (# State# s, MutableByteArray# s #)
unsafeThawByteArray# ByteArray#
a# State# s
s of
(# State# s
s', MutableByteArray# s
ma# #) -> (# State# s
s', MutableByteArray# s -> UMArray e s
forall e s. MutableByteArray# s -> UMArray e s
UMArray MutableByteArray# s
ma# #)
{-# INLINE thawUArray #-}
toListUArray ::
forall e. Prim e
=> UArray e
-> [e]
toListUArray :: UArray e -> [e]
toListUArray UArray e
ba = (forall b. (e -> b -> b) -> b -> b) -> [e]
forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
build (\ e -> b -> b
c b
n -> (UArray e -> Size)
-> (UArray e -> Int -> e) -> (e -> b -> b) -> b -> UArray e -> b
forall (a :: * -> *) e b.
(a e -> Size)
-> (a e -> Int -> e) -> (e -> b -> b) -> b -> a e -> b
foldrWithFB UArray e -> Size
forall e. Prim e => UArray e -> Size
sizeOfUArray UArray e -> Int -> e
forall e. Prim e => UArray e -> Int -> e
indexUArray e -> b -> b
c b
n UArray e
ba)
{-# INLINE toListUArray #-}
fromListUArrayN ::
forall e. Prim e
=> Size
-> [e]
-> UArray e
fromListUArrayN :: Size -> [e] -> UArray e
fromListUArrayN Size
sz [e]
xs =
(forall s. ST s (UArray e)) -> UArray e
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (UArray e)) -> UArray e)
-> (forall s. ST s (UArray e)) -> UArray e
forall a b. (a -> b) -> a -> b
$ (Size -> ST s (UMArray e s))
-> (UMArray e s -> Int -> e -> ST s ())
-> Size
-> [e]
-> ST s (UMArray e s)
forall (m :: * -> *) b a.
Monad m =>
(Size -> m b) -> (b -> Int -> a -> m ()) -> Size -> [a] -> m b
fromListMutWith Size -> ST s (UMArray e s)
forall e (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
Size -> m (UMArray e s)
newRawUMArray UMArray e s -> Int -> e -> ST s ()
forall e (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
UMArray e s -> Int -> e -> m ()
writeUMArray Size
sz [e]
xs ST s (UMArray e s)
-> (UMArray e s -> ST s (UArray e)) -> ST s (UArray e)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= UMArray e s -> ST s (UArray e)
forall e (m :: * -> *) s.
MonadPrim s m =>
UMArray e s -> m (UArray e)
freezeUMArray
{-# INLINE fromListUArrayN #-}
fromListUArray ::
forall e. Prim e
=> [e]
-> UArray e
fromListUArray :: [e] -> UArray e
fromListUArray [e]
xs = Size -> [e] -> UArray e
forall e. Prim e => Size -> [e] -> UArray e
fromListUArrayN (Int -> Size
coerce ([e] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [e]
xs)) [e]
xs
{-# INLINE fromListUArray #-}
fromBaseUArray :: (Prim e, A.IArray A.UArray e) => A.UArray ix e -> UArray e
fromBaseUArray :: UArray ix e -> UArray e
fromBaseUArray (A.UArray ix
_ ix
_ Int
_ ByteArray#
ba#) = ByteArray# -> UArray e
forall e. ByteArray# -> UArray e
UArray ByteArray#
ba#
toBaseUArray :: (Prim e, A.IArray A.UArray e) => UArray e -> A.UArray Int e
toBaseUArray :: UArray e -> UArray Int e
toBaseUArray a :: UArray e
a@(UArray ByteArray#
ba#) =
let Size Int
n = UArray e -> Size
forall e. Prim e => UArray e -> Size
sizeOfUArray UArray e
a
in Int -> Int -> Int -> ByteArray# -> UArray Int e
forall i e. i -> i -> Int -> ByteArray# -> UArray i e
A.UArray Int
0 (Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
0 (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)) Int
n ByteArray#
ba#
data UMArray e s = UMArray (MutableByteArray# s)
type role UMArray nominal nominal
instance Eq (UMArray e s) where
== :: UMArray e s -> UMArray e s -> Bool
(==) = UMArray e s -> UMArray e s -> Bool
forall a b s. UMArray a s -> UMArray b s -> Bool
isSameUMArray
{-# INLINE (==) #-}
instance NFData (UMArray e s) where
rnf :: UMArray e s -> ()
rnf (UMArray MutableByteArray# s
_) = ()
{-# INLINE rnf #-}
isSameUMArray :: forall a b s. UMArray a s -> UMArray b s -> Bool
isSameUMArray :: UMArray a s -> UMArray b s -> Bool
isSameUMArray (UMArray MutableByteArray# s
ma1#) (UMArray MutableByteArray# s
ma2#) = Int# -> Bool
isTrue# (MutableByteArray# s -> MutableByteArray# s -> Int#
forall d. MutableByteArray# d -> MutableByteArray# d -> Int#
sameMutableByteArray# MutableByteArray# s
ma1# MutableByteArray# s
ma2#)
{-# INLINE isSameUMArray #-}
isPinnedUMArray :: forall e s. UMArray e s -> Bool
isPinnedUMArray :: UMArray e s -> Bool
isPinnedUMArray (UMArray MutableByteArray# s
mb#) = Int# -> Bool
isTrue# (MutableByteArray# s -> Int#
forall d. MutableByteArray# d -> Int#
isMutableByteArrayPinned# MutableByteArray# s
mb#)
{-# INLINE isPinnedUMArray #-}
getSizeOfUMArray ::
forall e m s. (Prim e, MonadPrim s m)
=> UMArray e s
-> m Size
getSizeOfUMArray :: UMArray e s -> m Size
getSizeOfUMArray (UMArray MutableByteArray# s
ma#) =
(State# s -> (# State# s, Size #)) -> m Size
forall s (m :: * -> *) a.
MonadPrim s m =>
(State# s -> (# State# s, a #)) -> m a
prim ((State# s -> (# State# s, Size #)) -> m Size)
-> (State# s -> (# State# s, Size #)) -> m Size
forall a b. (a -> b) -> a -> b
$ \State# s
s ->
case MutableByteArray# s -> State# s -> (# State# s, Int# #)
forall d. MutableByteArray# d -> State# d -> (# State# d, Int# #)
getSizeofMutableByteArray# MutableByteArray# s
ma# State# s
s of
(# State# s
s', Int#
n# #) -> (# State# s
s', Count e -> Size
coerce (Count Word8 -> Count e
forall e. Prim e => Count Word8 -> Count e
fromByteCount (Int -> Count Word8
forall e. Int -> Count e
Count (Int# -> Int
I# Int#
n#)) :: Count e) #)
{-# INLINE getSizeOfUMArray #-}
readUMArray ::
forall e m s. (Prim e, MonadPrim s m)
=> UMArray e s
-> Int
-> m e
readUMArray :: UMArray e s -> Int -> m e
readUMArray (UMArray MutableByteArray# s
ma#) (I# Int#
i#) = (State# s -> (# State# s, e #)) -> m e
forall s (m :: * -> *) a.
MonadPrim s m =>
(State# s -> (# State# s, a #)) -> m a
prim (MutableByteArray# s -> Int# -> State# s -> (# State# s, e #)
forall a s.
Prim a =>
MutableByteArray# s -> Int# -> State# s -> (# State# s, a #)
readMutableByteArray# MutableByteArray# s
ma# Int#
i#)
{-# INLINE readUMArray #-}
writeUMArray ::
forall e m s. (Prim e, MonadPrim s m)
=> UMArray e s
-> Int
-> e
-> m ()
writeUMArray :: UMArray e s -> Int -> e -> m ()
writeUMArray (UMArray MutableByteArray# s
ma#) (I# Int#
i#) e
a = (State# s -> State# s) -> m ()
forall s (m :: * -> *).
MonadPrim s m =>
(State# s -> State# s) -> m ()
prim_ (MutableByteArray# s -> Int# -> e -> State# s -> State# s
forall a s.
Prim a =>
MutableByteArray# s -> Int# -> a -> State# s -> State# s
writeMutableByteArray# MutableByteArray# s
ma# Int#
i# e
a)
{-# INLINE writeUMArray #-}
newUMArray ::
forall e m s. (Prim e, MonadPrim s m)
=> Size
-> e
-> m (UMArray e s)
newUMArray :: Size -> e -> m (UMArray e s)
newUMArray Size
n e
e = Size -> m (UMArray e s)
forall e (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
Size -> m (UMArray e s)
newRawUMArray Size
n m (UMArray e s)
-> (UMArray e s -> m (UMArray e s)) -> m (UMArray e s)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \UMArray e s
ma -> UMArray e s
ma UMArray e s -> m () -> m (UMArray e s)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ UMArray e s -> Int -> Size -> e -> m ()
forall e (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
UMArray e s -> Int -> Size -> e -> m ()
setUMArray UMArray e s
ma Int
0 Size
n e
e
{-# INLINE newUMArray #-}
newPinnedUMArray ::
forall e m s. (Prim e, MonadPrim s m)
=> Size
-> e
-> m (UMArray e s)
newPinnedUMArray :: Size -> e -> m (UMArray e s)
newPinnedUMArray Size
n e
e = Size -> m (UMArray e s)
forall e (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
Size -> m (UMArray e s)
newRawPinnedUMArray Size
n m (UMArray e s)
-> (UMArray e s -> m (UMArray e s)) -> m (UMArray e s)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \UMArray e s
ma -> UMArray e s
ma UMArray e s -> m () -> m (UMArray e s)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ UMArray e s -> Int -> Size -> e -> m ()
forall e (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
UMArray e s -> Int -> Size -> e -> m ()
setUMArray UMArray e s
ma Int
0 Size
n e
e
{-# INLINE newPinnedUMArray #-}
newAlignedPinnedUMArray ::
forall e m s. (Prim e, MonadPrim s m)
=> Size
-> e
-> m (UMArray e s)
newAlignedPinnedUMArray :: Size -> e -> m (UMArray e s)
newAlignedPinnedUMArray Size
n e
e = Size -> m (UMArray e s)
forall e (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
Size -> m (UMArray e s)
newRawAlignedPinnedUMArray Size
n m (UMArray e s)
-> (UMArray e s -> m (UMArray e s)) -> m (UMArray e s)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \UMArray e s
ma -> UMArray e s
ma UMArray e s -> m () -> m (UMArray e s)
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ UMArray e s -> Int -> Size -> e -> m ()
forall e (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
UMArray e s -> Int -> Size -> e -> m ()
setUMArray UMArray e s
ma Int
0 Size
n e
e
{-# INLINE newAlignedPinnedUMArray #-}
makeUMArray ::
forall e m s. (Prim e, MonadPrim s m)
=> Size
-> (Int -> m e)
-> m (UMArray e s)
makeUMArray :: Size -> (Int -> m e) -> m (UMArray e s)
makeUMArray = (Size -> m (UMArray e s))
-> (UMArray e s -> Int -> e -> m ())
-> Size
-> (Int -> m e)
-> m (UMArray e s)
forall (m :: * -> *) b a.
Monad m =>
(Size -> m b)
-> (b -> Int -> a -> m ()) -> Size -> (Int -> m a) -> m b
makeMutWith Size -> m (UMArray e s)
forall e (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
Size -> m (UMArray e s)
newRawUMArray UMArray e s -> Int -> e -> m ()
forall e (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
UMArray e s -> Int -> e -> m ()
writeUMArray
{-# INLINE makeUMArray #-}
makePinnedUMArray ::
forall e m s. (Prim e, MonadPrim s m)
=> Size
-> (Int -> m e)
-> m (UMArray e s)
makePinnedUMArray :: Size -> (Int -> m e) -> m (UMArray e s)
makePinnedUMArray = (Size -> m (UMArray e s))
-> (UMArray e s -> Int -> e -> m ())
-> Size
-> (Int -> m e)
-> m (UMArray e s)
forall (m :: * -> *) b a.
Monad m =>
(Size -> m b)
-> (b -> Int -> a -> m ()) -> Size -> (Int -> m a) -> m b
makeMutWith Size -> m (UMArray e s)
forall e (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
Size -> m (UMArray e s)
newRawPinnedUMArray UMArray e s -> Int -> e -> m ()
forall e (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
UMArray e s -> Int -> e -> m ()
writeUMArray
{-# INLINE makePinnedUMArray #-}
makeAlignedPinnedUMArray ::
forall e m s. (Prim e, MonadPrim s m)
=> Size
-> (Int -> m e)
-> m (UMArray e s)
makeAlignedPinnedUMArray :: Size -> (Int -> m e) -> m (UMArray e s)
makeAlignedPinnedUMArray = (Size -> m (UMArray e s))
-> (UMArray e s -> Int -> e -> m ())
-> Size
-> (Int -> m e)
-> m (UMArray e s)
forall (m :: * -> *) b a.
Monad m =>
(Size -> m b)
-> (b -> Int -> a -> m ()) -> Size -> (Int -> m a) -> m b
makeMutWith Size -> m (UMArray e s)
forall e (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
Size -> m (UMArray e s)
newRawAlignedPinnedUMArray UMArray e s -> Int -> e -> m ()
forall e (m :: * -> *) s.
(Prim e, MonadPrim s m) =>
UMArray e s -> Int -> e -> m ()
writeUMArray
{-# INLINE makeAlignedPinnedUMArray #-}
newRawUMArray ::
forall e m s. (Prim e, MonadPrim s m)
=> Size
-> m (UMArray e s)
newRawUMArray :: Size -> m (UMArray e s)
newRawUMArray Size
n =
(State# s -> (# State# s, UMArray e s #)) -> m (UMArray e s)
forall s (m :: * -> *) a.
MonadPrim s m =>
(State# s -> (# State# s, a #)) -> m a
prim ((State# s -> (# State# s, UMArray e s #)) -> m (UMArray e s))
-> (State# s -> (# State# s, UMArray e s #)) -> m (UMArray e s)
forall a b. (a -> b) -> a -> b
$ \State# s
s ->
case Int# -> State# s -> (# State# s, MutableByteArray# s #)
forall d. Int# -> State# d -> (# State# d, MutableByteArray# d #)
newByteArray# (Count e -> Int#
forall e. Prim e => Count e -> Int#
unCountBytes# (Size -> Count e
coerce Size
n :: Count e)) State# s
s of
(# State# s
s', MutableByteArray# s
ma# #) -> (# State# s
s', MutableByteArray# s -> UMArray e s
forall e s. MutableByteArray# s -> UMArray e s
UMArray MutableByteArray# s
ma# #)
{-# INLINE newRawUMArray #-}
newRawPinnedUMArray ::
forall e m s. (Prim e, MonadPrim s m)
=> Size
-> m (UMArray e s)
newRawPinnedUMArray :: Size -> m (UMArray e s)
newRawPinnedUMArray Size
n =
(State# s -> (# State# s, UMArray e s #)) -> m (UMArray e s)
forall s (m :: * -> *) a.
MonadPrim s m =>
(State# s -> (# State# s, a #)) -> m a
prim ((State# s -> (# State# s, UMArray e s #)) -> m (UMArray e s))
-> (State# s -> (# State# s, UMArray e s #)) -> m (UMArray e s)
forall a b. (a -> b) -> a -> b
$ \State# s
s ->
case Int# -> State# s -> (# State# s, MutableByteArray# s #)
forall d. Int# -> State# d -> (# State# d, MutableByteArray# d #)
newPinnedByteArray# (Count e -> Int#
forall e. Prim e => Count e -> Int#
unCountBytes# (Size -> Count e
coerce Size
n :: Count e)) State# s
s of
(# State# s
s', MutableByteArray# s
ma# #) -> (# State# s
s', MutableByteArray# s -> UMArray e s
forall e s. MutableByteArray# s -> UMArray e s
UMArray MutableByteArray# s
ma# #)
{-# INLINE newRawPinnedUMArray #-}
newRawAlignedPinnedUMArray ::
forall e m s. (Prim e, MonadPrim s m)
=> Size
-> m (UMArray e s)
newRawAlignedPinnedUMArray :: Size -> m (UMArray e s)
newRawAlignedPinnedUMArray Size
n =
(State# s -> (# State# s, UMArray e s #)) -> m (UMArray e s)
forall s (m :: * -> *) a.
MonadPrim s m =>
(State# s -> (# State# s, a #)) -> m a
prim ((State# s -> (# State# s, UMArray e s #)) -> m (UMArray e s))
-> (State# s -> (# State# s, UMArray e s #)) -> m (UMArray e s)
forall a b. (a -> b) -> a -> b
$ \State# s
s ->
let c# :: Int#
c# = Count e -> Int#
forall e. Prim e => Count e -> Int#
unCountBytes# (Size -> Count e
coerce Size
n :: Count e)
a# :: Int#
a# = Proxy# e -> Int#
forall a. Prim a => Proxy# a -> Int#
alignment# (Proxy# e
forall k (a :: k). Proxy# a
proxy# :: Proxy# e)
in case Int# -> Int# -> State# s -> (# State# s, MutableByteArray# s #)
forall d.
Int# -> Int# -> State# d -> (# State# d, MutableByteArray# d #)
newAlignedPinnedByteArray# Int#
c# Int#
a# State# s
s of
(# State# s
s', MutableByteArray# s
ma# #) -> (# State# s
s', MutableByteArray# s -> UMArray e s
forall e s. MutableByteArray# s -> UMArray e s
UMArray MutableByteArray# s
ma# #)
{-# INLINE newRawAlignedPinnedUMArray #-}
moveUMArray ::
forall e m s. (Prim e, MonadPrim s m)
=> UMArray e s
-> Int
-> UMArray e s
-> Int
-> Size
-> m ()
moveUMArray :: UMArray e s -> Int -> UMArray e s -> Int -> Size -> m ()
moveUMArray (UMArray MutableByteArray# s
src#) Int
srcOff (UMArray MutableByteArray# s
dst#) Int
dstOff Size
n =
let srcOff# :: Int#
srcOff# = Off e -> Int#
forall e. Prim e => Off e -> Int#
unOffBytes# (Int -> Off e
coerce Int
srcOff :: Off e)
dstOff# :: Int#
dstOff# = Off e -> Int#
forall e. Prim e => Off e -> Int#
unOffBytes# (Int -> Off e
coerce Int
dstOff :: Off e)
n# :: Int#
n# = Count e -> Int#
forall e. Prim e => Count e -> Int#
unCountBytes# (Size -> Count e
coerce Size
n :: Count e)
in (State# s -> State# s) -> m ()
forall s (m :: * -> *).
MonadPrim s m =>
(State# s -> State# s) -> m ()
prim_ (MutableByteArray# s
-> Int#
-> MutableByteArray# s
-> Int#
-> Int#
-> State# s
-> State# s
forall d.
MutableByteArray# d
-> Int#
-> MutableByteArray# d
-> Int#
-> Int#
-> State# d
-> State# d
copyMutableByteArray# MutableByteArray# s
src# Int#
srcOff# MutableByteArray# s
dst# Int#
dstOff# Int#
n#)
{-# INLINE moveUMArray #-}
setUMArray ::
forall e m s. (Prim e, MonadPrim s m)
=> UMArray e s
-> Int
-> Size
-> e
-> m ()
setUMArray :: UMArray e s -> Int -> Size -> e -> m ()
setUMArray (UMArray MutableByteArray# s
ma#) (I# Int#
o#) (Size (I# Int#
n#)) e
a =
(State# s -> State# s) -> m ()
forall s (m :: * -> *).
MonadPrim s m =>
(State# s -> State# s) -> m ()
prim_ (MutableByteArray# s -> Int# -> Int# -> e -> State# s -> State# s
forall a s.
Prim a =>
MutableByteArray# s -> Int# -> Int# -> a -> State# s -> State# s
setMutableByteArray# MutableByteArray# s
ma# Int#
o# Int#
n# e
a)
{-# INLINE setUMArray #-}
shrinkUMArray ::
forall e m s. (MonadPrim s m, Prim e)
=> UMArray e s
-> Size
-> m ()
shrinkUMArray :: UMArray e s -> Size -> m ()
shrinkUMArray (UMArray MutableByteArray# s
mb#) Size
sz =
(State# s -> State# s) -> m ()
forall s (m :: * -> *).
MonadPrim s m =>
(State# s -> State# s) -> m ()
prim_ (MutableByteArray# s -> Int# -> State# s -> State# s
forall d. MutableByteArray# d -> Int# -> State# d -> State# d
shrinkMutableByteArray# MutableByteArray# s
mb# (Count e -> Int#
forall e. Prim e => Count e -> Int#
unCountBytes# (Size -> Count e
coerce Size
sz :: Count e)))
{-# INLINE shrinkUMArray #-}
resizeUMArray ::
forall e m s. (MonadPrim s m, Prim e)
=> UMArray e s
-> Size
-> m (UMArray e s)
resizeUMArray :: UMArray e s -> Size -> m (UMArray e s)
resizeUMArray (UMArray MutableByteArray# s
mb#) Size
sz =
(State# s -> (# State# s, UMArray e s #)) -> m (UMArray e s)
forall s (m :: * -> *) a.
MonadPrim s m =>
(State# s -> (# State# s, a #)) -> m a
prim ((State# s -> (# State# s, UMArray e s #)) -> m (UMArray e s))
-> (State# s -> (# State# s, UMArray e s #)) -> m (UMArray e s)
forall a b. (a -> b) -> a -> b
$ \State# s
s ->
case MutableByteArray# s
-> Int# -> State# s -> (# State# s, MutableByteArray# s #)
forall d.
MutableByteArray# d
-> Int# -> State# d -> (# State# d, MutableByteArray# d #)
resizeMutableByteArray# MutableByteArray# s
mb# (Count e -> Int#
forall e. Prim e => Count e -> Int#
unCountBytes# (Size -> Count e
coerce Size
sz :: Count e)) State# s
s of
(# State# s
s', MutableByteArray# s
mb'# #) -> (# State# s
s', MutableByteArray# s -> UMArray e s
forall e s. MutableByteArray# s -> UMArray e s
UMArray MutableByteArray# s
mb'# #)
{-# INLINE resizeUMArray #-}
freezeUMArray ::
forall e m s. MonadPrim s m
=> UMArray e s
-> m (UArray e)
freezeUMArray :: UMArray e s -> m (UArray e)
freezeUMArray (UMArray MutableByteArray# s
ma#) = (State# s -> (# State# s, UArray e #)) -> m (UArray e)
forall s (m :: * -> *) a.
MonadPrim s m =>
(State# s -> (# State# s, a #)) -> m a
prim ((State# s -> (# State# s, UArray e #)) -> m (UArray e))
-> (State# s -> (# State# s, UArray e #)) -> m (UArray e)
forall a b. (a -> b) -> a -> b
$ \State# s
s ->
case MutableByteArray# s -> State# s -> (# State# s, ByteArray# #)
forall d.
MutableByteArray# d -> State# d -> (# State# d, ByteArray# #)
unsafeFreezeByteArray# MutableByteArray# s
ma# State# s
s of
(# State# s
s', ByteArray#
a# #) -> (# State# s
s', ByteArray# -> UArray e
forall e. ByteArray# -> UArray e
UArray ByteArray#
a# #)
{-# INLINE freezeUMArray #-}
uninitialized ::
HasCallStack
=> String
-> String
-> a
uninitialized :: String -> String -> a
uninitialized String
mname String
fname =
ArrayException -> a
forall e a. Exception e => e -> a
impureThrow (ArrayException -> a) -> ArrayException -> a
forall a b. (a -> b) -> a -> b
$
String -> ArrayException
UndefinedElement (String -> ArrayException) -> String -> ArrayException
forall a b. (a -> b) -> a -> b
$ String
mname String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"." String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
fname String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"\n" String -> ShowS
forall a. [a] -> [a] -> [a]
++ CallStack -> String
prettyCallStack CallStack
HasCallStack => CallStack
callStack
{-# NOINLINE uninitialized #-}
fromListMutWith ::
Monad m
=> (Size -> m b)
-> (b -> Int -> a -> m ())
-> Size
-> [a]
-> m b
fromListMutWith :: (Size -> m b) -> (b -> Int -> a -> m ()) -> Size -> [a] -> m b
fromListMutWith Size -> m b
new b -> Int -> a -> m ()
write sz :: Size
sz@(Size Int
n) [a]
ls = do
b
ma <- Size -> m b
new Size
sz
let go :: Int -> [a] -> m ()
go Int
i =
\case
a
x:[a]
xs
| Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
n -> b -> Int -> a -> m ()
write b
ma Int
i a
x m () -> m () -> m ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> [a] -> m ()
go (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) [a]
xs
[a]
_ -> () -> m ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
b
ma b -> m () -> m b
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Int -> [a] -> m ()
go Int
0 [a]
ls
{-# INLINE fromListMutWith #-}
makeMutWith ::
Monad m
=> (Size -> m b)
-> (b -> Int -> a -> m ())
-> Size
-> (Int -> m a)
-> m b
makeMutWith :: (Size -> m b)
-> (b -> Int -> a -> m ()) -> Size -> (Int -> m a) -> m b
makeMutWith Size -> m b
new b -> Int -> a -> m ()
write sz :: Size
sz@(Size Int
n) Int -> m a
f = do
b
ma <- Size -> m b
new Size
sz
let go :: Int -> m ()
go Int
i = Bool -> m () -> m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
n) (m () -> m ()) -> m () -> m ()
forall a b. (a -> b) -> a -> b
$ Int -> m a
f Int
i m a -> (a -> m ()) -> m ()
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= b -> Int -> a -> m ()
write b
ma Int
i m () -> m () -> m ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> m ()
go (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
b
ma b -> m () -> m b
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Int -> m ()
go Int
0
{-# INLINE makeMutWith #-}
foldrWithFB ::
(a e -> Size)
-> (a e -> Int -> e)
-> (e -> b -> b)
-> b
-> a e
-> b
foldrWithFB :: (a e -> Size)
-> (a e -> Int -> e) -> (e -> b -> b) -> b -> a e -> b
foldrWithFB a e -> Size
size a e -> Int -> e
index e -> b -> b
c b
nil a e
a = Int -> b
go Int
0
where
k :: Int
k = Size -> Int
coerce (a e -> Size
size a e
a)
go :: Int -> b
go Int
i
| Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
k = b
nil
| Bool
otherwise =
let v :: e
v = a e -> Int -> e
index a e
a Int
i
in e
v e -> b -> b
`seq` (e
v e -> b -> b
`c` Int -> b
go (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1))
{-# INLINE[0] foldrWithFB #-}
eqWith ::
Eq e
=> (a e -> a e -> Bool)
-> (a e -> Size)
-> (a e -> Int -> e)
-> a e
-> a e
-> Bool
eqWith :: (a e -> a e -> Bool)
-> (a e -> Size) -> (a e -> Int -> e) -> a e -> a e -> Bool
eqWith a e -> a e -> Bool
isSame a e -> Size
sizeOf a e -> Int -> e
index a e
a1 a e
a2 = a e -> a e -> Bool
isSame a e
a1 a e
a2 Bool -> Bool -> Bool
|| (Size
sz1 Size -> Size -> Bool
forall a. Eq a => a -> a -> Bool
== a e -> Size
sizeOf a e
a2 Bool -> Bool -> Bool
&& Int -> Bool
loop Int
0)
where
sz1 :: Size
sz1@(Size Int
n) = a e -> Size
sizeOf a e
a1
loop :: Int -> Bool
loop Int
i
| Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
n = a e -> Int -> e
index a e
a1 Int
i e -> e -> Bool
forall a. Eq a => a -> a -> Bool
== a e -> Int -> e
index a e
a2 Int
i Bool -> Bool -> Bool
&& Int -> Bool
loop (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
| Bool
otherwise = Bool
True
{-# INLINE eqWith #-}
liftEqWith ::
(forall e. a e -> Size)
-> (forall e. a e -> Int -> e)
-> (b -> c -> Bool)
-> a b
-> a c
-> Bool
liftEqWith :: (forall e. a e -> Size)
-> (forall e. a e -> Int -> e)
-> (b -> c -> Bool)
-> a b
-> a c
-> Bool
liftEqWith forall e. a e -> Size
sizeOf forall e. a e -> Int -> e
index b -> c -> Bool
eq a b
a1 a c
a2 = Size
sz1 Size -> Size -> Bool
forall a. Eq a => a -> a -> Bool
== a c -> Size
forall e. a e -> Size
sizeOf a c
a2 Bool -> Bool -> Bool
&& Int -> Bool
loop Int
0
where
sz1 :: Size
sz1@(Size Int
n) = a b -> Size
forall e. a e -> Size
sizeOf a b
a1
loop :: Int -> Bool
loop Int
i
| Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
n = (a b -> Int -> b
forall e. a e -> Int -> e
index a b
a1 Int
i b -> c -> Bool
`eq` a c -> Int -> c
forall e. a e -> Int -> e
index a c
a2 Int
i) Bool -> Bool -> Bool
&& Int -> Bool
loop (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
| Bool
otherwise = Bool
True
{-# INLINE liftEqWith #-}
liftShowsPrecArray :: Foldable f => String -> ([e] -> ShowS) -> Int -> f e -> ShowS
liftShowsPrecArray :: String -> ([e] -> ShowS) -> Int -> f e -> ShowS
liftShowsPrecArray String
tyName [e] -> ShowS
listShows Int
n f e
arr
| Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
1 = (Char
'(' Char -> ShowS
forall a. a -> [a] -> [a]
:) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS
inner ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char
')' Char -> ShowS
forall a. a -> [a] -> [a]
:)
| Bool
otherwise = ShowS
inner
where
inner :: ShowS
inner = (String
tyName String -> ShowS
forall a. [a] -> [a] -> [a]
++) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char
' ' Char -> ShowS
forall a. a -> [a] -> [a]
:) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [e] -> ShowS
listShows (f e -> [e]
forall (t :: * -> *) a. Foldable t => t a -> [a]
F.toList f e
arr)
compareWith ::
Ord e
=> (a e -> a e -> Bool)
-> (a e -> Size)
-> (a e -> Int -> e)
-> a e
-> a e
-> Ordering
compareWith :: (a e -> a e -> Bool)
-> (a e -> Size) -> (a e -> Int -> e) -> a e -> a e -> Ordering
compareWith a e -> a e -> Bool
isSame a e -> Size
sizeOf a e -> Int -> e
index a e
a1 a e
a2
| a e -> a e -> Bool
isSame a e
a1 a e
a2 = Ordering
EQ
| Bool
otherwise = Int -> Ordering
loop Int
0
where
Size Int
n = Size -> Size -> Size
forall a. Ord a => a -> a -> a
min (a e -> Size
sizeOf a e
a1) (a e -> Size
sizeOf a e
a2)
loop :: Int -> Ordering
loop Int
i
| Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
n = e -> e -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (a e -> Int -> e
index a e
a1 Int
i) (a e -> Int -> e
index a e
a2 Int
i) Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> Int -> Ordering
loop (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
| Bool
otherwise = Size -> Size -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (a e -> Size
sizeOf a e
a1) (a e -> Size
sizeOf a e
a2)
{-# INLINE compareWith #-}
liftCompareWith ::
(forall e. a e -> Size)
-> (forall e. a e -> Int -> e)
-> (b -> c -> Ordering)
-> a b
-> a c
-> Ordering
liftCompareWith :: (forall e. a e -> Size)
-> (forall e. a e -> Int -> e)
-> (b -> c -> Ordering)
-> a b
-> a c
-> Ordering
liftCompareWith forall e. a e -> Size
sizeOf forall e. a e -> Int -> e
index b -> c -> Ordering
comp a b
a1 a c
a2 = Int -> Ordering
loop Int
0
where
Size Int
n = Size -> Size -> Size
forall a. Ord a => a -> a -> a
min (a b -> Size
forall e. a e -> Size
sizeOf a b
a1) (a c -> Size
forall e. a e -> Size
sizeOf a c
a2)
loop :: Int -> Ordering
loop Int
i
| Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
n = b -> c -> Ordering
comp (a b -> Int -> b
forall e. a e -> Int -> e
index a b
a1 Int
i) (a c -> Int -> c
forall e. a e -> Int -> e
index a c
a2 Int
i) Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> Int -> Ordering
loop (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
| Bool
otherwise = Size -> Size -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (a b -> Size
forall e. a e -> Size
sizeOf a b
a1) (a c -> Size
forall e. a e -> Size
sizeOf a c
a2)
{-# INLINE liftCompareWith #-}
appendWith ::
(forall s. Size -> ST s (ma e s))
-> (forall s. a e -> Int -> ma e s -> Int -> Size -> ST s ())
-> (forall s. ma e s -> ST s (a e))
-> (a e -> Size)
-> a e
-> a e
-> a e
appendWith :: (forall s. Size -> ST s (ma e s))
-> (forall s. a e -> Int -> ma e s -> Int -> Size -> ST s ())
-> (forall s. ma e s -> ST s (a e))
-> (a e -> Size)
-> a e
-> a e
-> a e
appendWith forall s. Size -> ST s (ma e s)
newRaw forall s. a e -> Int -> ma e s -> Int -> Size -> ST s ()
copy forall s. ma e s -> ST s (a e)
freeze a e -> Size
sizeOf a e
a1 a e
a2 =
(forall s. ST s (a e)) -> a e
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (a e)) -> a e) -> (forall s. ST s (a e)) -> a e
forall a b. (a -> b) -> a -> b
$ do
let n1 :: Size
n1 = a e -> Size
sizeOf a e
a1
n2 :: Size
n2 = a e -> Size
sizeOf a e
a2
ma e s
ma <- Size -> ST s (ma e s)
forall s. Size -> ST s (ma e s)
newRaw (Size
n1 Size -> Size -> Size
forall a. Num a => a -> a -> a
+ Size
n2)
a e -> Int -> ma e s -> Int -> Size -> ST s ()
forall s. a e -> Int -> ma e s -> Int -> Size -> ST s ()
copy a e
a1 Int
0 ma e s
ma Int
0 Size
n1
a e -> Int -> ma e s -> Int -> Size -> ST s ()
forall s. a e -> Int -> ma e s -> Int -> Size -> ST s ()
copy a e
a2 Int
0 ma e s
ma (Size -> Int
coerce Size
n1) Size
n2
ma e s -> ST s (a e)
forall s. ma e s -> ST s (a e)
freeze ma e s
ma
{-# INLINE appendWith #-}
concatWith ::
(forall s. Size -> ST s (ma e s))
-> (forall s. a e -> Int -> ma e s -> Int -> Size -> ST s ())
-> (forall s. ma e s -> ST s (a e))
-> (a e -> Size)
-> [a e]
-> a e
concatWith :: (forall s. Size -> ST s (ma e s))
-> (forall s. a e -> Int -> ma e s -> Int -> Size -> ST s ())
-> (forall s. ma e s -> ST s (a e))
-> (a e -> Size)
-> [a e]
-> a e
concatWith forall s. Size -> ST s (ma e s)
newRaw forall s. a e -> Int -> ma e s -> Int -> Size -> ST s ()
copy forall s. ma e s -> ST s (a e)
freeze a e -> Size
sizeOf [a e]
xs =
(forall s. ST s (a e)) -> a e
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (a e)) -> a e) -> (forall s. ST s (a e)) -> a e
forall a b. (a -> b) -> a -> b
$ do
let as :: [(Size, a e)]
as = [(a e -> Size
sizeOf a e
a, a e
a) | a e
a <- [a e]
xs]
!n :: Size
n = Sum Size -> Size
forall a. Sum a -> a
getSum (Sum Size -> Size) -> Sum Size -> Size
forall a b. (a -> b) -> a -> b
$ ((Size, a e) -> Sum Size) -> [(Size, a e)] -> Sum Size
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (Size -> Sum Size
forall a. a -> Sum a
Sum (Size -> Sum Size)
-> ((Size, a e) -> Size) -> (Size, a e) -> Sum Size
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Size, a e) -> Size
forall a b. (a, b) -> a
fst) [(Size, a e)]
as
ma e s
ma <- Size -> ST s (ma e s)
forall s. Size -> ST s (ma e s)
newRaw Size
n
let load :: Int -> (Size, a e) -> ST s Int
load Int
i (Size
sz, a e
a) = (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Size -> Int
coerce Size
sz) Int -> ST s () -> ST s Int
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ a e -> Int -> ma e s -> Int -> Size -> ST s ()
forall s. a e -> Int -> ma e s -> Int -> Size -> ST s ()
copy a e
a Int
0 ma e s
ma Int
i Size
sz
(Int -> (Size, a e) -> ST s Int) -> Int -> [(Size, a e)] -> ST s ()
forall (t :: * -> *) (m :: * -> *) b a.
(Foldable t, Monad m) =>
(b -> a -> m b) -> b -> t a -> m ()
foldM_ Int -> (Size, a e) -> ST s Int
load Int
0 [(Size, a e)]
as
ma e s -> ST s (a e)
forall s. ma e s -> ST s (a e)
freeze ma e s
ma
{-# INLINE concatWith #-}
cycleWith ::
Monoid (a e)
=> (forall s. Size -> ST s (ma e s))
-> (forall s. a e -> Int -> ma e s -> Int -> Size -> ST s ())
-> (forall s. ma e s -> ST s (a e))
-> (a e -> Size)
-> Int
-> a e
-> a e
cycleWith :: (forall s. Size -> ST s (ma e s))
-> (forall s. a e -> Int -> ma e s -> Int -> Size -> ST s ())
-> (forall s. ma e s -> ST s (a e))
-> (a e -> Size)
-> Int
-> a e
-> a e
cycleWith forall s. Size -> ST s (ma e s)
newRaw forall s. a e -> Int -> ma e s -> Int -> Size -> ST s ()
copy forall s. ma e s -> ST s (a e)
freeze a e -> Size
sizeOf Int
k a e
a
| Int
k Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0 = a e
forall a. Monoid a => a
mempty
| Bool
otherwise =
(forall s. ST s (a e)) -> a e
forall a. (forall s. ST s a) -> a
runST ((forall s. ST s (a e)) -> a e) -> (forall s. ST s (a e)) -> a e
forall a b. (a -> b) -> a -> b
$ do
let sz :: Size
sz@(Size Int
n) = a e -> Size
sizeOf a e
a
ma e s
ma <- Size -> ST s (ma e s)
forall s. Size -> ST s (ma e s)
newRaw (Int -> Size
Size Int
k Size -> Size -> Size
forall a. Num a => a -> a -> a
* Size
sz)
let load :: Int -> ST s ()
load Int
i = 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
k) (ST s () -> ST s ()) -> ST s () -> ST s ()
forall a b. (a -> b) -> a -> b
$ a e -> Int -> ma e s -> Int -> Size -> ST s ()
forall s. a e -> Int -> ma e s -> Int -> Size -> ST s ()
copy a e
a Int
0 ma e s
ma (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
n) Size
sz ST s () -> ST s () -> ST s ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> ST s ()
load (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
Int -> ST s ()
load Int
0
ma e s -> ST s (a e)
forall s. ma e s -> ST s (a e)
freeze ma e s
ma
{-# INLINE cycleWith #-}