{-# LANGUAGE
BangPatterns
, CPP
, RankNTypes
, MagicHash
, UnboxedTuples
, MultiParamTypeClasses
, FlexibleInstances
, FlexibleContexts
, UnliftedFFITypes
, RoleAnnotations
#-}
{-# OPTIONS_HADDOCK hide #-}
module Data.Array.Base where
import Control.Monad.ST.Lazy ( strictToLazyST )
import qualified Control.Monad.ST.Lazy as Lazy (ST)
import Data.Ix ( Ix, range, index, rangeSize )
import Foreign.C.Types
import Foreign.StablePtr
import Data.Char
import GHC.Arr ( STArray )
import qualified GHC.Arr as Arr
import qualified GHC.Arr as ArrST
import GHC.ST ( ST(..), runST )
import GHC.Base ( IO(..), divInt# )
import GHC.Exts
import GHC.Ptr ( nullPtr, nullFunPtr )
import GHC.Show ( appPrec )
import GHC.Stable ( StablePtr(..) )
import GHC.Read ( expectP, parens, Read(..) )
import GHC.Int ( Int8(..), Int16(..), Int32(..), Int64(..) )
import GHC.Word ( Word8(..), Word16(..), Word32(..), Word64(..) )
import GHC.IO ( stToIO )
import GHC.IOArray ( IOArray(..),
newIOArray, unsafeReadIOArray, unsafeWriteIOArray )
import Text.Read.Lex ( Lexeme(Ident) )
import Text.ParserCombinators.ReadPrec ( prec, ReadPrec, step )
#include "MachDeps.h"
class IArray a e where
bounds :: Ix i => a i e -> (i,i)
numElements :: Ix i => a i e -> Int
unsafeArray :: Ix i => (i,i) -> [(Int, e)] -> a i e
unsafeAt :: Ix i => a i e -> Int -> e
unsafeReplace :: Ix i => a i e -> [(Int, e)] -> a i e
unsafeAccum :: Ix i => (e -> e' -> e) -> a i e -> [(Int, e')] -> a i e
unsafeAccumArray :: Ix i => (e -> e' -> e) -> e -> (i,i) -> [(Int, e')] -> a i e
unsafeReplace arr :: a i e
arr ies :: [(Int, e)]
ies = (forall s. ST s (a i e)) -> a i e
forall a. (forall s. ST s a) -> a
runST (a i e -> [(Int, e)] -> ST s (STArray s i e)
forall (a :: * -> * -> *) e i s.
(IArray a e, Ix i) =>
a i e -> [(Int, e)] -> ST s (STArray s i e)
unsafeReplaceST a i e
arr [(Int, e)]
ies ST s (STArray s i e)
-> (STArray s i e -> ST s (a i e)) -> ST s (a i e)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= STArray s i e -> ST s (a i e)
forall i (a :: * -> * -> *) e (m :: * -> *) (b :: * -> * -> *).
(Ix i, MArray a e m, IArray b e) =>
a i e -> m (b i e)
unsafeFreeze)
unsafeAccum f :: e -> e' -> e
f arr :: a i e
arr ies :: [(Int, e')]
ies = (forall s. ST s (a i e)) -> a i e
forall a. (forall s. ST s a) -> a
runST ((e -> e' -> e) -> a i e -> [(Int, e')] -> ST s (STArray s i e)
forall (a :: * -> * -> *) e i e' s.
(IArray a e, Ix i) =>
(e -> e' -> e) -> a i e -> [(Int, e')] -> ST s (STArray s i e)
unsafeAccumST e -> e' -> e
f a i e
arr [(Int, e')]
ies ST s (STArray s i e)
-> (STArray s i e -> ST s (a i e)) -> ST s (a i e)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= STArray s i e -> ST s (a i e)
forall i (a :: * -> * -> *) e (m :: * -> *) (b :: * -> * -> *).
(Ix i, MArray a e m, IArray b e) =>
a i e -> m (b i e)
unsafeFreeze)
unsafeAccumArray f :: e -> e' -> e
f e :: e
e lu :: (i, i)
lu ies :: [(Int, e')]
ies = (forall s. ST s (a i e)) -> a i e
forall a. (forall s. ST s a) -> a
runST ((e -> e' -> e)
-> e -> (i, i) -> [(Int, e')] -> ST s (STArray s i e)
forall i e e' s.
Ix i =>
(e -> e' -> e)
-> e -> (i, i) -> [(Int, e')] -> ST s (STArray s i e)
unsafeAccumArrayST e -> e' -> e
f e
e (i, i)
lu [(Int, e')]
ies ST s (STArray s i e)
-> (STArray s i e -> ST s (a i e)) -> ST s (a i e)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= STArray s i e -> ST s (a i e)
forall i (a :: * -> * -> *) e (m :: * -> *) (b :: * -> * -> *).
(Ix i, MArray a e m, IArray b e) =>
a i e -> m (b i e)
unsafeFreeze)
{-# INLINE safeRangeSize #-}
safeRangeSize :: Ix i => (i, i) -> Int
safeRangeSize :: (i, i) -> Int
safeRangeSize (l :: i
l,u :: i
u) = let r :: Int
r = (i, i) -> Int
forall a. Ix a => (a, a) -> Int
rangeSize (i
l, i
u)
in if Int
r Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< 0 then [Char] -> Int
forall a. HasCallStack => [Char] -> a
error "Negative range size"
else Int
r
{-# INLINE safeIndex #-}
safeIndex :: Ix i => (i, i) -> Int -> i -> Int
safeIndex :: (i, i) -> Int -> i -> Int
safeIndex (l :: i
l,u :: i
u) n :: Int
n i :: i
i = let i' :: Int
i' = (i, i) -> i -> Int
forall a. Ix a => (a, a) -> a -> Int
index (i
l,i
u) i
i
in if (0 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
i') Bool -> Bool -> Bool
&& (Int
i' Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
n)
then Int
i'
else [Char] -> Int
forall a. HasCallStack => [Char] -> a
error ("Error in array index; " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
i' [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++
" not in range [0.." [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
n [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ ")")
{-# INLINE unsafeReplaceST #-}
unsafeReplaceST :: (IArray a e, Ix i) => a i e -> [(Int, e)] -> ST s (STArray s i e)
unsafeReplaceST :: a i e -> [(Int, e)] -> ST s (STArray s i e)
unsafeReplaceST arr :: a i e
arr ies :: [(Int, e)]
ies = do
STArray s i e
marr <- a i e -> ST s (STArray s i e)
forall i (a :: * -> * -> *) e (b :: * -> * -> *) (m :: * -> *).
(Ix i, IArray a e, MArray b e m) =>
a i e -> m (b i e)
thaw a i e
arr
[ST s ()] -> ST s ()
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_ [STArray s i e -> Int -> e -> ST s ()
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> e -> m ()
unsafeWrite STArray s i e
marr Int
i e
e | (i :: Int
i, e :: e
e) <- [(Int, e)]
ies]
STArray s i e -> ST s (STArray s i e)
forall (m :: * -> *) a. Monad m => a -> m a
return STArray s i e
marr
{-# INLINE unsafeAccumST #-}
unsafeAccumST :: (IArray a e, Ix i) => (e -> e' -> e) -> a i e -> [(Int, e')] -> ST s (STArray s i e)
unsafeAccumST :: (e -> e' -> e) -> a i e -> [(Int, e')] -> ST s (STArray s i e)
unsafeAccumST f :: e -> e' -> e
f arr :: a i e
arr ies :: [(Int, e')]
ies = do
STArray s i e
marr <- a i e -> ST s (STArray s i e)
forall i (a :: * -> * -> *) e (b :: * -> * -> *) (m :: * -> *).
(Ix i, IArray a e, MArray b e m) =>
a i e -> m (b i e)
thaw a i e
arr
[ST s ()] -> ST s ()
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_ [do e
old <- STArray s i e -> Int -> ST s e
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> m e
unsafeRead STArray s i e
marr Int
i
STArray s i e -> Int -> e -> ST s ()
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> e -> m ()
unsafeWrite STArray s i e
marr Int
i (e -> e' -> e
f e
old e'
new)
| (i :: Int
i, new :: e'
new) <- [(Int, e')]
ies]
STArray s i e -> ST s (STArray s i e)
forall (m :: * -> *) a. Monad m => a -> m a
return STArray s i e
marr
{-# INLINE unsafeAccumArrayST #-}
unsafeAccumArrayST :: Ix i => (e -> e' -> e) -> e -> (i,i) -> [(Int, e')] -> ST s (STArray s i e)
unsafeAccumArrayST :: (e -> e' -> e)
-> e -> (i, i) -> [(Int, e')] -> ST s (STArray s i e)
unsafeAccumArrayST f :: e -> e' -> e
f e :: e
e (l :: i
l,u :: i
u) ies :: [(Int, e')]
ies = do
STArray s i e
marr <- (i, i) -> e -> ST s (STArray s i e)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i
l,i
u) e
e
[ST s ()] -> ST s ()
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_ [do e
old <- STArray s i e -> Int -> ST s e
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> m e
unsafeRead STArray s i e
marr Int
i
STArray s i e -> Int -> e -> ST s ()
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> e -> m ()
unsafeWrite STArray s i e
marr Int
i (e -> e' -> e
f e
old e'
new)
| (i :: Int
i, new :: e'
new) <- [(Int, e')]
ies]
STArray s i e -> ST s (STArray s i e)
forall (m :: * -> *) a. Monad m => a -> m a
return STArray s i e
marr
{-# INLINE array #-}
array :: (IArray a e, Ix i)
=> (i,i)
-> [(i, e)]
-> a i e
array :: (i, i) -> [(i, e)] -> a i e
array (l :: i
l,u :: i
u) ies :: [(i, e)]
ies
= let n :: Int
n = (i, i) -> Int
forall a. Ix a => (a, a) -> Int
safeRangeSize (i
l,i
u)
in (i, i) -> [(Int, e)] -> a i e
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
(i, i) -> [(Int, e)] -> a i e
unsafeArray (i
l,i
u)
[((i, i) -> Int -> i -> Int
forall i. Ix i => (i, i) -> Int -> i -> Int
safeIndex (i
l,i
u) Int
n i
i, e
e) | (i :: i
i, e :: e
e) <- [(i, e)]
ies]
{-# INLINE [1] listArray #-}
listArray :: (IArray a e, Ix i) => (i,i) -> [e] -> a i e
listArray :: (i, i) -> [e] -> a i e
listArray (l :: i
l,u :: i
u) es :: [e]
es =
let n :: Int
n = (i, i) -> Int
forall a. Ix a => (a, a) -> Int
safeRangeSize (i
l,i
u)
in (i, i) -> [(Int, e)] -> a i e
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
(i, i) -> [(Int, e)] -> a i e
unsafeArray (i
l,i
u) ([Int] -> [e] -> [(Int, e)]
forall a b. [a] -> [b] -> [(a, b)]
zip [0 .. Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- 1] [e]
es)
{-# INLINE listArrayST #-}
listArrayST :: Ix i => (i,i) -> [e] -> ST s (STArray s i e)
listArrayST :: (i, i) -> [e] -> ST s (STArray s i e)
listArrayST (l :: i
l,u :: i
u) es :: [e]
es = do
STArray s i e
marr <- (i, i) -> ST s (STArray s i e)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> m (a i e)
newArray_ (i
l,i
u)
let n :: Int
n = (i, i) -> Int
forall a. Ix a => (a, a) -> Int
safeRangeSize (i
l,i
u)
let fillFromList :: Int -> [e] -> m ()
fillFromList i :: Int
i xs :: [e]
xs | Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
n = () -> m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
| Bool
otherwise = case [e]
xs of
[] -> () -> m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
y :: e
y:ys :: [e]
ys -> STArray s i e -> Int -> e -> m ()
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> e -> m ()
unsafeWrite STArray s i e
marr Int
i e
y m () -> m () -> m ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> [e] -> m ()
fillFromList (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+1) [e]
ys
Int -> [e] -> ST s ()
forall (m :: * -> *). MArray (STArray s) e m => Int -> [e] -> m ()
fillFromList 0 [e]
es
STArray s i e -> ST s (STArray s i e)
forall (m :: * -> *) a. Monad m => a -> m a
return STArray s i e
marr
{-# RULES
"listArray/Array" listArray =
\lu es -> runST (listArrayST lu es >>= ArrST.unsafeFreezeSTArray)
#-}
{-# INLINE listUArrayST #-}
listUArrayST :: (MArray (STUArray s) e (ST s), Ix i)
=> (i,i) -> [e] -> ST s (STUArray s i e)
listUArrayST :: (i, i) -> [e] -> ST s (STUArray s i e)
listUArrayST (l :: i
l,u :: i
u) es :: [e]
es = do
STUArray s i e
marr <- (i, i) -> ST s (STUArray s i e)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> m (a i e)
newArray_ (i
l,i
u)
let n :: Int
n = (i, i) -> Int
forall a. Ix a => (a, a) -> Int
safeRangeSize (i
l,i
u)
let fillFromList :: Int -> [e] -> m ()
fillFromList i :: Int
i xs :: [e]
xs | Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
n = () -> m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
| Bool
otherwise = case [e]
xs of
[] -> () -> m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
y :: e
y:ys :: [e]
ys -> STUArray s i e -> Int -> e -> m ()
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> e -> m ()
unsafeWrite STUArray s i e
marr Int
i e
y m () -> m () -> m ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> [e] -> m ()
fillFromList (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+1) [e]
ys
Int -> [e] -> ST s ()
forall (m :: * -> *). MArray (STUArray s) e m => Int -> [e] -> m ()
fillFromList 0 [e]
es
STUArray s i e -> ST s (STUArray s i e)
forall (m :: * -> *) a. Monad m => a -> m a
return STUArray s i e
marr
type ListUArray e = forall i . Ix i => (i,i) -> [e] -> UArray i e
{-# RULES
"listArray/UArray/Bool" listArray
= (\lu es -> runST (listUArrayST lu es >>= unsafeFreezeSTUArray)) :: ListUArray Bool
"listArray/UArray/Char" listArray
= (\lu es -> runST (listUArrayST lu es >>= unsafeFreezeSTUArray)) :: ListUArray Char
"listArray/UArray/Int" listArray
= (\lu es -> runST (listUArrayST lu es >>= unsafeFreezeSTUArray)) :: ListUArray Int
"listArray/UArray/Word" listArray
= (\lu es -> runST (listUArrayST lu es >>= unsafeFreezeSTUArray)) :: ListUArray Word
"listArray/UArray/Ptr" listArray
= (\lu es -> runST (listUArrayST lu es >>= unsafeFreezeSTUArray)) :: ListUArray (Ptr a)
"listArray/UArray/FunPtr" listArray
= (\lu es -> runST (listUArrayST lu es >>= unsafeFreezeSTUArray)) :: ListUArray (FunPtr a)
"listArray/UArray/Float" listArray
= (\lu es -> runST (listUArrayST lu es >>= unsafeFreezeSTUArray)) :: ListUArray Float
"listArray/UArray/Double" listArray
= (\lu es -> runST (listUArrayST lu es >>= unsafeFreezeSTUArray)) :: ListUArray Double
"listArray/UArray/StablePtr" listArray
= (\lu es -> runST (listUArrayST lu es >>= unsafeFreezeSTUArray)) :: ListUArray (StablePtr a)
"listArray/UArray/Int8" listArray
= (\lu es -> runST (listUArrayST lu es >>= unsafeFreezeSTUArray)) :: ListUArray Int8
"listArray/UArray/Int16" listArray
= (\lu es -> runST (listUArrayST lu es >>= unsafeFreezeSTUArray)) :: ListUArray Int16
"listArray/UArray/Int32" listArray
= (\lu es -> runST (listUArrayST lu es >>= unsafeFreezeSTUArray)) :: ListUArray Int32
"listArray/UArray/Int64" listArray
= (\lu es -> runST (listUArrayST lu es >>= unsafeFreezeSTUArray)) :: ListUArray Int64
"listArray/UArray/Word8" listArray
= (\lu es -> runST (listUArrayST lu es >>= unsafeFreezeSTUArray)) :: ListUArray Word8
"listArray/UArray/Word16" listArray
= (\lu es -> runST (listUArrayST lu es >>= unsafeFreezeSTUArray)) :: ListUArray Word16
"listArray/UArray/Word32" listArray
= (\lu es -> runST (listUArrayST lu es >>= unsafeFreezeSTUArray)) :: ListUArray Word32
"listArray/UArray/Word64" listArray
= (\lu es -> runST (listUArrayST lu es >>= unsafeFreezeSTUArray)) :: ListUArray Word64
#-}
{-# INLINE (!) #-}
(!) :: (IArray a e, Ix i) => a i e -> i -> e
(!) arr :: a i e
arr i :: i
i = case a i e -> (i, i)
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> (i, i)
bounds a i e
arr of
(l :: i
l,u :: i
u) -> a i e -> Int -> e
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> Int -> e
unsafeAt a i e
arr (Int -> e) -> Int -> e
forall a b. (a -> b) -> a -> b
$ (i, i) -> Int -> i -> Int
forall i. Ix i => (i, i) -> Int -> i -> Int
safeIndex (i
l,i
u) (a i e -> Int
forall (a :: * -> * -> *) e i. (IArray a e, Ix i) => a i e -> Int
numElements a i e
arr) i
i
{-# INLINE indices #-}
indices :: (IArray a e, Ix i) => a i e -> [i]
indices :: a i e -> [i]
indices arr :: a i e
arr = case a i e -> (i, i)
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> (i, i)
bounds a i e
arr of (l :: i
l,u :: i
u) -> (i, i) -> [i]
forall a. Ix a => (a, a) -> [a]
range (i
l,i
u)
{-# INLINE elems #-}
elems :: (IArray a e, Ix i) => a i e -> [e]
elems :: a i e -> [e]
elems arr :: a i e
arr = [a i e -> Int -> e
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> Int -> e
unsafeAt a i e
arr Int
i | Int
i <- [0 .. a i e -> Int
forall (a :: * -> * -> *) e i. (IArray a e, Ix i) => a i e -> Int
numElements a i e
arr Int -> Int -> Int
forall a. Num a => a -> a -> a
- 1]]
{-# INLINE assocs #-}
assocs :: (IArray a e, Ix i) => a i e -> [(i, e)]
assocs :: a i e -> [(i, e)]
assocs arr :: a i e
arr = case a i e -> (i, i)
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> (i, i)
bounds a i e
arr of
(l :: i
l,u :: i
u) -> [(i
i, a i e
arr a i e -> i -> e
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> i -> e
! i
i) | i
i <- (i, i) -> [i]
forall a. Ix a => (a, a) -> [a]
range (i
l,i
u)]
{-# INLINE accumArray #-}
accumArray :: (IArray a e, Ix i)
=> (e -> e' -> e)
-> e
-> (i,i)
-> [(i, e')]
-> a i e
accumArray :: (e -> e' -> e) -> e -> (i, i) -> [(i, e')] -> a i e
accumArray f :: e -> e' -> e
f initialValue :: e
initialValue (l :: i
l,u :: i
u) ies :: [(i, e')]
ies =
let n :: Int
n = (i, i) -> Int
forall a. Ix a => (a, a) -> Int
safeRangeSize (i
l, i
u)
in (e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> a i e
forall (a :: * -> * -> *) e i e'.
(IArray a e, Ix i) =>
(e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> a i e
unsafeAccumArray e -> e' -> e
f e
initialValue (i
l,i
u)
[((i, i) -> Int -> i -> Int
forall i. Ix i => (i, i) -> Int -> i -> Int
safeIndex (i
l,i
u) Int
n i
i, e'
e) | (i :: i
i, e :: e'
e) <- [(i, e')]
ies]
{-# INLINE (//) #-}
(//) :: (IArray a e, Ix i) => a i e -> [(i, e)] -> a i e
arr :: a i e
arr // :: a i e -> [(i, e)] -> a i e
// ies :: [(i, e)]
ies = case a i e -> (i, i)
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> (i, i)
bounds a i e
arr of
(l :: i
l,u :: i
u) -> a i e -> [(Int, e)] -> a i e
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> [(Int, e)] -> a i e
unsafeReplace a i e
arr [ ((i, i) -> Int -> i -> Int
forall i. Ix i => (i, i) -> Int -> i -> Int
safeIndex (i
l,i
u) (a i e -> Int
forall (a :: * -> * -> *) e i. (IArray a e, Ix i) => a i e -> Int
numElements a i e
arr) i
i, e
e)
| (i :: i
i, e :: e
e) <- [(i, e)]
ies]
{-# INLINE accum #-}
accum :: (IArray a e, Ix i) => (e -> e' -> e) -> a i e -> [(i, e')] -> a i e
accum :: (e -> e' -> e) -> a i e -> [(i, e')] -> a i e
accum f :: e -> e' -> e
f arr :: a i e
arr ies :: [(i, e')]
ies = case a i e -> (i, i)
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> (i, i)
bounds a i e
arr of
(l :: i
l,u :: i
u) -> let n :: Int
n = a i e -> Int
forall (a :: * -> * -> *) e i. (IArray a e, Ix i) => a i e -> Int
numElements a i e
arr
in (e -> e' -> e) -> a i e -> [(Int, e')] -> a i e
forall (a :: * -> * -> *) e i e'.
(IArray a e, Ix i) =>
(e -> e' -> e) -> a i e -> [(Int, e')] -> a i e
unsafeAccum e -> e' -> e
f a i e
arr [((i, i) -> Int -> i -> Int
forall i. Ix i => (i, i) -> Int -> i -> Int
safeIndex (i
l,i
u) Int
n i
i, e'
e) | (i :: i
i, e :: e'
e) <- [(i, e')]
ies]
{-# INLINE amap #-}
amap :: (IArray a e', IArray a e, Ix i) => (e' -> e) -> a i e' -> a i e
amap :: (e' -> e) -> a i e' -> a i e
amap f :: e' -> e
f arr :: a i e'
arr = case a i e' -> (i, i)
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> (i, i)
bounds a i e'
arr of
(l :: i
l,u :: i
u) -> let n :: Int
n = a i e' -> Int
forall (a :: * -> * -> *) e i. (IArray a e, Ix i) => a i e -> Int
numElements a i e'
arr
in (i, i) -> [(Int, e)] -> a i e
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
(i, i) -> [(Int, e)] -> a i e
unsafeArray (i
l,i
u) [ (Int
i, e' -> e
f (a i e' -> Int -> e'
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> Int -> e
unsafeAt a i e'
arr Int
i))
| Int
i <- [0 .. Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- 1]]
{-# INLINE ixmap #-}
ixmap :: (IArray a e, Ix i, Ix j) => (i,i) -> (i -> j) -> a j e -> a i e
ixmap :: (i, i) -> (i -> j) -> a j e -> a i e
ixmap (l :: i
l,u :: i
u) f :: i -> j
f arr :: a j e
arr =
(i, i) -> [(i, e)] -> a i e
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
(i, i) -> [(i, e)] -> a i e
array (i
l,i
u) [(i
i, a j e
arr a j e -> j -> e
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> i -> e
! i -> j
f i
i) | i
i <- (i, i) -> [i]
forall a. Ix a => (a, a) -> [a]
range (i
l,i
u)]
instance IArray Arr.Array e where
{-# INLINE bounds #-}
bounds :: Array i e -> (i, i)
bounds = Array i e -> (i, i)
forall i e. Array i e -> (i, i)
Arr.bounds
{-# INLINE numElements #-}
numElements :: Array i e -> Int
numElements = Array i e -> Int
forall i e. Array i e -> Int
Arr.numElements
{-# INLINE unsafeArray #-}
unsafeArray :: (i, i) -> [(Int, e)] -> Array i e
unsafeArray = (i, i) -> [(Int, e)] -> Array i e
forall i e. Ix i => (i, i) -> [(Int, e)] -> Array i e
Arr.unsafeArray
{-# INLINE unsafeAt #-}
unsafeAt :: Array i e -> Int -> e
unsafeAt = Array i e -> Int -> e
forall i e. Array i e -> Int -> e
Arr.unsafeAt
{-# INLINE unsafeReplace #-}
unsafeReplace :: Array i e -> [(Int, e)] -> Array i e
unsafeReplace = Array i e -> [(Int, e)] -> Array i e
forall i e. Array i e -> [(Int, e)] -> Array i e
Arr.unsafeReplace
{-# INLINE unsafeAccum #-}
unsafeAccum :: (e -> e' -> e) -> Array i e -> [(Int, e')] -> Array i e
unsafeAccum = (e -> e' -> e) -> Array i e -> [(Int, e')] -> Array i e
forall e a i. (e -> a -> e) -> Array i e -> [(Int, a)] -> Array i e
Arr.unsafeAccum
{-# INLINE unsafeAccumArray #-}
unsafeAccumArray :: (e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> Array i e
unsafeAccumArray = (e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> Array i e
forall i e a.
Ix i =>
(e -> a -> e) -> e -> (i, i) -> [(Int, a)] -> Array i e
Arr.unsafeAccumArray
data UArray i e = UArray !i !i !Int ByteArray#
type role UArray nominal nominal
{-# INLINE unsafeArrayUArray #-}
unsafeArrayUArray :: (MArray (STUArray s) e (ST s), Ix i)
=> (i,i) -> [(Int, e)] -> e -> ST s (UArray i e)
unsafeArrayUArray :: (i, i) -> [(Int, e)] -> e -> ST s (UArray i e)
unsafeArrayUArray (l :: i
l,u :: i
u) ies :: [(Int, e)]
ies default_elem :: e
default_elem = do
STUArray s i e
marr <- (i, i) -> e -> ST s (STUArray s i e)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i
l,i
u) e
default_elem
[ST s ()] -> ST s ()
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_ [STUArray s i e -> Int -> e -> ST s ()
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> e -> m ()
unsafeWrite STUArray s i e
marr Int
i e
e | (i :: Int
i, e :: e
e) <- [(Int, e)]
ies]
STUArray s i e -> ST s (UArray i e)
forall s i e. STUArray s i e -> ST s (UArray i e)
unsafeFreezeSTUArray STUArray s i e
marr
{-# INLINE unsafeFreezeSTUArray #-}
unsafeFreezeSTUArray :: STUArray s i e -> ST s (UArray i e)
unsafeFreezeSTUArray :: STUArray s i e -> ST s (UArray i e)
unsafeFreezeSTUArray (STUArray l :: i
l u :: i
u n :: Int
n marr# :: MutableByteArray# s
marr#) = STRep s (UArray i e) -> ST s (UArray i e)
forall s a. STRep s a -> ST s a
ST (STRep s (UArray i e) -> ST s (UArray i e))
-> STRep s (UArray i e) -> ST s (UArray i e)
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> State# s -> (# State# s, ByteArray# #)
forall d.
MutableByteArray# d -> State# d -> (# State# d, ByteArray# #)
unsafeFreezeByteArray# MutableByteArray# s
marr# State# s
s1# of { (# s2# :: State# s
s2#, arr# :: ByteArray#
arr# #) ->
(# State# s
s2#, i -> i -> Int -> ByteArray# -> UArray i e
forall i e. i -> i -> Int -> ByteArray# -> UArray i e
UArray i
l i
u Int
n ByteArray#
arr# #) }
{-# INLINE unsafeReplaceUArray #-}
unsafeReplaceUArray :: (MArray (STUArray s) e (ST s), Ix i)
=> UArray i e -> [(Int, e)] -> ST s (UArray i e)
unsafeReplaceUArray :: UArray i e -> [(Int, e)] -> ST s (UArray i e)
unsafeReplaceUArray arr :: UArray i e
arr ies :: [(Int, e)]
ies = do
STUArray s i e
marr <- UArray i e -> ST s (STUArray s i e)
forall i e s. UArray i e -> ST s (STUArray s i e)
thawSTUArray UArray i e
arr
[ST s ()] -> ST s ()
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_ [STUArray s i e -> Int -> e -> ST s ()
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> e -> m ()
unsafeWrite STUArray s i e
marr Int
i e
e | (i :: Int
i, e :: e
e) <- [(Int, e)]
ies]
STUArray s i e -> ST s (UArray i e)
forall s i e. STUArray s i e -> ST s (UArray i e)
unsafeFreezeSTUArray STUArray s i e
marr
{-# INLINE unsafeAccumUArray #-}
unsafeAccumUArray :: (MArray (STUArray s) e (ST s), Ix i)
=> (e -> e' -> e) -> UArray i e -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumUArray :: (e -> e' -> e) -> UArray i e -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumUArray f :: e -> e' -> e
f arr :: UArray i e
arr ies :: [(Int, e')]
ies = do
STUArray s i e
marr <- UArray i e -> ST s (STUArray s i e)
forall i e s. UArray i e -> ST s (STUArray s i e)
thawSTUArray UArray i e
arr
[ST s ()] -> ST s ()
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_ [do e
old <- STUArray s i e -> Int -> ST s e
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> m e
unsafeRead STUArray s i e
marr Int
i
STUArray s i e -> Int -> e -> ST s ()
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> e -> m ()
unsafeWrite STUArray s i e
marr Int
i (e -> e' -> e
f e
old e'
new)
| (i :: Int
i, new :: e'
new) <- [(Int, e')]
ies]
STUArray s i e -> ST s (UArray i e)
forall s i e. STUArray s i e -> ST s (UArray i e)
unsafeFreezeSTUArray STUArray s i e
marr
{-# INLINE unsafeAccumArrayUArray #-}
unsafeAccumArrayUArray :: (MArray (STUArray s) e (ST s), Ix i)
=> (e -> e' -> e) -> e -> (i,i) -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumArrayUArray :: (e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumArrayUArray f :: e -> e' -> e
f initialValue :: e
initialValue (l :: i
l,u :: i
u) ies :: [(Int, e')]
ies = do
STUArray s i e
marr <- (i, i) -> e -> ST s (STUArray s i e)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i
l,i
u) e
initialValue
[ST s ()] -> ST s ()
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_ [do e
old <- STUArray s i e -> Int -> ST s e
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> m e
unsafeRead STUArray s i e
marr Int
i
STUArray s i e -> Int -> e -> ST s ()
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> e -> m ()
unsafeWrite STUArray s i e
marr Int
i (e -> e' -> e
f e
old e'
new)
| (i :: Int
i, new :: e'
new) <- [(Int, e')]
ies]
STUArray s i e -> ST s (UArray i e)
forall s i e. STUArray s i e -> ST s (UArray i e)
unsafeFreezeSTUArray STUArray s i e
marr
{-# INLINE eqUArray #-}
eqUArray :: (IArray UArray e, Ix i, Eq e) => UArray i e -> UArray i e -> Bool
eqUArray :: UArray i e -> UArray i e -> Bool
eqUArray arr1 :: UArray i e
arr1@(UArray l1 :: i
l1 u1 :: i
u1 n1 :: Int
n1 _) arr2 :: UArray i e
arr2@(UArray l2 :: i
l2 u2 :: i
u2 n2 :: Int
n2 _) =
if Int
n1 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== 0 then Int
n2 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== 0 else
i
l1 i -> i -> Bool
forall a. Eq a => a -> a -> Bool
== i
l2 Bool -> Bool -> Bool
&& i
u1 i -> i -> Bool
forall a. Eq a => a -> a -> Bool
== i
u2 Bool -> Bool -> Bool
&&
[Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
and [UArray i e -> Int -> e
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> Int -> e
unsafeAt UArray i e
arr1 Int
i e -> e -> Bool
forall a. Eq a => a -> a -> Bool
== UArray i e -> Int -> e
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> Int -> e
unsafeAt UArray i e
arr2 Int
i | Int
i <- [0 .. Int
n1 Int -> Int -> Int
forall a. Num a => a -> a -> a
- 1]]
{-# INLINE [1] cmpUArray #-}
cmpUArray :: (IArray UArray e, Ix i, Ord e) => UArray i e -> UArray i e -> Ordering
cmpUArray :: UArray i e -> UArray i e -> Ordering
cmpUArray arr1 :: UArray i e
arr1 arr2 :: UArray i e
arr2 = [(i, e)] -> [(i, e)] -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (UArray i e -> [(i, e)]
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> [(i, e)]
assocs UArray i e
arr1) (UArray i e -> [(i, e)]
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> [(i, e)]
assocs UArray i e
arr2)
{-# INLINE cmpIntUArray #-}
cmpIntUArray :: (IArray UArray e, Ord e) => UArray Int e -> UArray Int e -> Ordering
cmpIntUArray :: UArray Int e -> UArray Int e -> Ordering
cmpIntUArray arr1 :: UArray Int e
arr1@(UArray l1 :: Int
l1 u1 :: Int
u1 n1 :: Int
n1 _) arr2 :: UArray Int e
arr2@(UArray l2 :: Int
l2 u2 :: Int
u2 n2 :: Int
n2 _) =
if Int
n1 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== 0 then if Int
n2 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== 0 then Ordering
EQ else Ordering
LT else
if Int
n2 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== 0 then Ordering
GT else
case Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Int
l1 Int
l2 of
EQ -> (Int -> Ordering -> Ordering) -> Ordering -> [Int] -> Ordering
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Int -> Ordering -> Ordering
cmp (Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Int
u1 Int
u2) [0 .. (Int
n1 Int -> Int -> Int
forall a. Ord a => a -> a -> a
`min` Int
n2) Int -> Int -> Int
forall a. Num a => a -> a -> a
- 1]
other :: Ordering
other -> Ordering
other
where
cmp :: Int -> Ordering -> Ordering
cmp i :: Int
i rest :: Ordering
rest = case e -> e -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (UArray Int e -> Int -> e
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> Int -> e
unsafeAt UArray Int e
arr1 Int
i) (UArray Int e -> Int -> e
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> Int -> e
unsafeAt UArray Int e
arr2 Int
i) of
EQ -> Ordering
rest
other :: Ordering
other -> Ordering
other
{-# RULES "cmpUArray/Int" cmpUArray = cmpIntUArray #-}
{-# SPECIALISE
showsIArray :: (IArray UArray e, Ix i, Show i, Show e) =>
Int -> UArray i e -> ShowS
#-}
showsIArray :: (IArray a e, Ix i, Show i, Show e) => Int -> a i e -> ShowS
showsIArray :: Int -> a i e -> [Char] -> [Char]
showsIArray p :: Int
p a :: a i e
a =
Bool -> ([Char] -> [Char]) -> [Char] -> [Char]
showParen (Int
p Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
appPrec) (([Char] -> [Char]) -> [Char] -> [Char])
-> ([Char] -> [Char]) -> [Char] -> [Char]
forall a b. (a -> b) -> a -> b
$
[Char] -> [Char] -> [Char]
showString "array " ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
(i, i) -> [Char] -> [Char]
forall a. Show a => a -> [Char] -> [Char]
shows (a i e -> (i, i)
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> (i, i)
bounds a i e
a) ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
Char -> [Char] -> [Char]
showChar ' ' ([Char] -> [Char]) -> ([Char] -> [Char]) -> [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
[(i, e)] -> [Char] -> [Char]
forall a. Show a => a -> [Char] -> [Char]
shows (a i e -> [(i, e)]
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> [(i, e)]
assocs a i e
a)
{-# SPECIALISE
readIArray :: (IArray UArray e, Ix i, Read i, Read e) =>
ReadPrec (UArray i e)
#-}
readIArray :: (IArray a e, Ix i, Read i, Read e) => ReadPrec (a i e)
readIArray :: ReadPrec (a i e)
readIArray = ReadPrec (a i e) -> ReadPrec (a i e)
forall a. ReadPrec a -> ReadPrec a
parens (ReadPrec (a i e) -> ReadPrec (a i e))
-> ReadPrec (a i e) -> ReadPrec (a i e)
forall a b. (a -> b) -> a -> b
$ Int -> ReadPrec (a i e) -> ReadPrec (a i e)
forall a. Int -> ReadPrec a -> ReadPrec a
prec Int
appPrec (ReadPrec (a i e) -> ReadPrec (a i e))
-> ReadPrec (a i e) -> ReadPrec (a i e)
forall a b. (a -> b) -> a -> b
$
do Lexeme -> ReadPrec ()
expectP ([Char] -> Lexeme
Ident "array")
(i, i)
theBounds <- ReadPrec (i, i) -> ReadPrec (i, i)
forall a. ReadPrec a -> ReadPrec a
step ReadPrec (i, i)
forall a. Read a => ReadPrec a
readPrec
[(i, e)]
vals <- ReadPrec [(i, e)] -> ReadPrec [(i, e)]
forall a. ReadPrec a -> ReadPrec a
step ReadPrec [(i, e)]
forall a. Read a => ReadPrec a
readPrec
a i e -> ReadPrec (a i e)
forall (m :: * -> *) a. Monad m => a -> m a
return ((i, i) -> [(i, e)] -> a i e
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
(i, i) -> [(i, e)] -> a i e
array (i, i)
theBounds [(i, e)]
vals)
instance IArray UArray Bool where
{-# INLINE bounds #-}
bounds :: UArray i Bool -> (i, i)
bounds (UArray l :: i
l u :: i
u _ _) = (i
l,i
u)
{-# INLINE numElements #-}
numElements :: UArray i Bool -> Int
numElements (UArray _ _ n :: Int
n _) = Int
n
{-# INLINE unsafeArray #-}
unsafeArray :: (i, i) -> [(Int, Bool)] -> UArray i Bool
unsafeArray lu :: (i, i)
lu ies :: [(Int, Bool)]
ies = (forall s. ST s (UArray i Bool)) -> UArray i Bool
forall a. (forall s. ST s a) -> a
runST ((i, i) -> [(Int, Bool)] -> Bool -> ST s (UArray i Bool)
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
(i, i) -> [(Int, e)] -> e -> ST s (UArray i e)
unsafeArrayUArray (i, i)
lu [(Int, Bool)]
ies Bool
False)
{-# INLINE unsafeAt #-}
unsafeAt :: UArray i Bool -> Int -> Bool
unsafeAt (UArray _ _ _ arr# :: ByteArray#
arr#) (I# i# :: Int#
i#) = Int# -> Bool
isTrue#
((ByteArray# -> Int# -> Word#
indexWordArray# ByteArray#
arr# (Int# -> Int#
bOOL_INDEX Int#
i#) Word# -> Word# -> Word#
`and#` Int# -> Word#
bOOL_BIT Int#
i#)
Word# -> Word# -> Int#
`neWord#` Int# -> Word#
int2Word# 0#)
{-# INLINE unsafeReplace #-}
unsafeReplace :: UArray i Bool -> [(Int, Bool)] -> UArray i Bool
unsafeReplace arr :: UArray i Bool
arr ies :: [(Int, Bool)]
ies = (forall s. ST s (UArray i Bool)) -> UArray i Bool
forall a. (forall s. ST s a) -> a
runST (UArray i Bool -> [(Int, Bool)] -> ST s (UArray i Bool)
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
UArray i e -> [(Int, e)] -> ST s (UArray i e)
unsafeReplaceUArray UArray i Bool
arr [(Int, Bool)]
ies)
{-# INLINE unsafeAccum #-}
unsafeAccum :: (Bool -> e' -> Bool)
-> UArray i Bool -> [(Int, e')] -> UArray i Bool
unsafeAccum f :: Bool -> e' -> Bool
f arr :: UArray i Bool
arr ies :: [(Int, e')]
ies = (forall s. ST s (UArray i Bool)) -> UArray i Bool
forall a. (forall s. ST s a) -> a
runST ((Bool -> e' -> Bool)
-> UArray i Bool -> [(Int, e')] -> ST s (UArray i Bool)
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> UArray i e -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumUArray Bool -> e' -> Bool
f UArray i Bool
arr [(Int, e')]
ies)
{-# INLINE unsafeAccumArray #-}
unsafeAccumArray :: (Bool -> e' -> Bool)
-> Bool -> (i, i) -> [(Int, e')] -> UArray i Bool
unsafeAccumArray f :: Bool -> e' -> Bool
f initialValue :: Bool
initialValue lu :: (i, i)
lu ies :: [(Int, e')]
ies = (forall s. ST s (UArray i Bool)) -> UArray i Bool
forall a. (forall s. ST s a) -> a
runST ((Bool -> e' -> Bool)
-> Bool -> (i, i) -> [(Int, e')] -> ST s (UArray i Bool)
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumArrayUArray Bool -> e' -> Bool
f Bool
initialValue (i, i)
lu [(Int, e')]
ies)
instance IArray UArray Char where
{-# INLINE bounds #-}
bounds :: UArray i Char -> (i, i)
bounds (UArray l :: i
l u :: i
u _ _) = (i
l,i
u)
{-# INLINE numElements #-}
numElements :: UArray i Char -> Int
numElements (UArray _ _ n :: Int
n _) = Int
n
{-# INLINE unsafeArray #-}
unsafeArray :: (i, i) -> [(Int, Char)] -> UArray i Char
unsafeArray lu :: (i, i)
lu ies :: [(Int, Char)]
ies = (forall s. ST s (UArray i Char)) -> UArray i Char
forall a. (forall s. ST s a) -> a
runST ((i, i) -> [(Int, Char)] -> Char -> ST s (UArray i Char)
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
(i, i) -> [(Int, e)] -> e -> ST s (UArray i e)
unsafeArrayUArray (i, i)
lu [(Int, Char)]
ies '\0')
{-# INLINE unsafeAt #-}
unsafeAt :: UArray i Char -> Int -> Char
unsafeAt (UArray _ _ _ arr# :: ByteArray#
arr#) (I# i# :: Int#
i#) = Char# -> Char
C# (ByteArray# -> Int# -> Char#
indexWideCharArray# ByteArray#
arr# Int#
i#)
{-# INLINE unsafeReplace #-}
unsafeReplace :: UArray i Char -> [(Int, Char)] -> UArray i Char
unsafeReplace arr :: UArray i Char
arr ies :: [(Int, Char)]
ies = (forall s. ST s (UArray i Char)) -> UArray i Char
forall a. (forall s. ST s a) -> a
runST (UArray i Char -> [(Int, Char)] -> ST s (UArray i Char)
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
UArray i e -> [(Int, e)] -> ST s (UArray i e)
unsafeReplaceUArray UArray i Char
arr [(Int, Char)]
ies)
{-# INLINE unsafeAccum #-}
unsafeAccum :: (Char -> e' -> Char)
-> UArray i Char -> [(Int, e')] -> UArray i Char
unsafeAccum f :: Char -> e' -> Char
f arr :: UArray i Char
arr ies :: [(Int, e')]
ies = (forall s. ST s (UArray i Char)) -> UArray i Char
forall a. (forall s. ST s a) -> a
runST ((Char -> e' -> Char)
-> UArray i Char -> [(Int, e')] -> ST s (UArray i Char)
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> UArray i e -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumUArray Char -> e' -> Char
f UArray i Char
arr [(Int, e')]
ies)
{-# INLINE unsafeAccumArray #-}
unsafeAccumArray :: (Char -> e' -> Char)
-> Char -> (i, i) -> [(Int, e')] -> UArray i Char
unsafeAccumArray f :: Char -> e' -> Char
f initialValue :: Char
initialValue lu :: (i, i)
lu ies :: [(Int, e')]
ies = (forall s. ST s (UArray i Char)) -> UArray i Char
forall a. (forall s. ST s a) -> a
runST ((Char -> e' -> Char)
-> Char -> (i, i) -> [(Int, e')] -> ST s (UArray i Char)
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumArrayUArray Char -> e' -> Char
f Char
initialValue (i, i)
lu [(Int, e')]
ies)
instance IArray UArray Int where
{-# INLINE bounds #-}
bounds :: UArray i Int -> (i, i)
bounds (UArray l :: i
l u :: i
u _ _) = (i
l,i
u)
{-# INLINE numElements #-}
numElements :: UArray i Int -> Int
numElements (UArray _ _ n :: Int
n _) = Int
n
{-# INLINE unsafeArray #-}
unsafeArray :: (i, i) -> [(Int, Int)] -> UArray i Int
unsafeArray lu :: (i, i)
lu ies :: [(Int, Int)]
ies = (forall s. ST s (UArray i Int)) -> UArray i Int
forall a. (forall s. ST s a) -> a
runST ((i, i) -> [(Int, Int)] -> Int -> ST s (UArray i Int)
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
(i, i) -> [(Int, e)] -> e -> ST s (UArray i e)
unsafeArrayUArray (i, i)
lu [(Int, Int)]
ies 0)
{-# INLINE unsafeAt #-}
unsafeAt :: UArray i Int -> Int -> Int
unsafeAt (UArray _ _ _ arr# :: ByteArray#
arr#) (I# i# :: Int#
i#) = Int# -> Int
I# (ByteArray# -> Int# -> Int#
indexIntArray# ByteArray#
arr# Int#
i#)
{-# INLINE unsafeReplace #-}
unsafeReplace :: UArray i Int -> [(Int, Int)] -> UArray i Int
unsafeReplace arr :: UArray i Int
arr ies :: [(Int, Int)]
ies = (forall s. ST s (UArray i Int)) -> UArray i Int
forall a. (forall s. ST s a) -> a
runST (UArray i Int -> [(Int, Int)] -> ST s (UArray i Int)
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
UArray i e -> [(Int, e)] -> ST s (UArray i e)
unsafeReplaceUArray UArray i Int
arr [(Int, Int)]
ies)
{-# INLINE unsafeAccum #-}
unsafeAccum :: (Int -> e' -> Int) -> UArray i Int -> [(Int, e')] -> UArray i Int
unsafeAccum f :: Int -> e' -> Int
f arr :: UArray i Int
arr ies :: [(Int, e')]
ies = (forall s. ST s (UArray i Int)) -> UArray i Int
forall a. (forall s. ST s a) -> a
runST ((Int -> e' -> Int)
-> UArray i Int -> [(Int, e')] -> ST s (UArray i Int)
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> UArray i e -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumUArray Int -> e' -> Int
f UArray i Int
arr [(Int, e')]
ies)
{-# INLINE unsafeAccumArray #-}
unsafeAccumArray :: (Int -> e' -> Int) -> Int -> (i, i) -> [(Int, e')] -> UArray i Int
unsafeAccumArray f :: Int -> e' -> Int
f initialValue :: Int
initialValue lu :: (i, i)
lu ies :: [(Int, e')]
ies = (forall s. ST s (UArray i Int)) -> UArray i Int
forall a. (forall s. ST s a) -> a
runST ((Int -> e' -> Int)
-> Int -> (i, i) -> [(Int, e')] -> ST s (UArray i Int)
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumArrayUArray Int -> e' -> Int
f Int
initialValue (i, i)
lu [(Int, e')]
ies)
instance IArray UArray Word where
{-# INLINE bounds #-}
bounds :: UArray i Word -> (i, i)
bounds (UArray l :: i
l u :: i
u _ _) = (i
l,i
u)
{-# INLINE numElements #-}
numElements :: UArray i Word -> Int
numElements (UArray _ _ n :: Int
n _) = Int
n
{-# INLINE unsafeArray #-}
unsafeArray :: (i, i) -> [(Int, Word)] -> UArray i Word
unsafeArray lu :: (i, i)
lu ies :: [(Int, Word)]
ies = (forall s. ST s (UArray i Word)) -> UArray i Word
forall a. (forall s. ST s a) -> a
runST ((i, i) -> [(Int, Word)] -> Word -> ST s (UArray i Word)
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
(i, i) -> [(Int, e)] -> e -> ST s (UArray i e)
unsafeArrayUArray (i, i)
lu [(Int, Word)]
ies 0)
{-# INLINE unsafeAt #-}
unsafeAt :: UArray i Word -> Int -> Word
unsafeAt (UArray _ _ _ arr# :: ByteArray#
arr#) (I# i# :: Int#
i#) = Word# -> Word
W# (ByteArray# -> Int# -> Word#
indexWordArray# ByteArray#
arr# Int#
i#)
{-# INLINE unsafeReplace #-}
unsafeReplace :: UArray i Word -> [(Int, Word)] -> UArray i Word
unsafeReplace arr :: UArray i Word
arr ies :: [(Int, Word)]
ies = (forall s. ST s (UArray i Word)) -> UArray i Word
forall a. (forall s. ST s a) -> a
runST (UArray i Word -> [(Int, Word)] -> ST s (UArray i Word)
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
UArray i e -> [(Int, e)] -> ST s (UArray i e)
unsafeReplaceUArray UArray i Word
arr [(Int, Word)]
ies)
{-# INLINE unsafeAccum #-}
unsafeAccum :: (Word -> e' -> Word)
-> UArray i Word -> [(Int, e')] -> UArray i Word
unsafeAccum f :: Word -> e' -> Word
f arr :: UArray i Word
arr ies :: [(Int, e')]
ies = (forall s. ST s (UArray i Word)) -> UArray i Word
forall a. (forall s. ST s a) -> a
runST ((Word -> e' -> Word)
-> UArray i Word -> [(Int, e')] -> ST s (UArray i Word)
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> UArray i e -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumUArray Word -> e' -> Word
f UArray i Word
arr [(Int, e')]
ies)
{-# INLINE unsafeAccumArray #-}
unsafeAccumArray :: (Word -> e' -> Word)
-> Word -> (i, i) -> [(Int, e')] -> UArray i Word
unsafeAccumArray f :: Word -> e' -> Word
f initialValue :: Word
initialValue lu :: (i, i)
lu ies :: [(Int, e')]
ies = (forall s. ST s (UArray i Word)) -> UArray i Word
forall a. (forall s. ST s a) -> a
runST ((Word -> e' -> Word)
-> Word -> (i, i) -> [(Int, e')] -> ST s (UArray i Word)
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumArrayUArray Word -> e' -> Word
f Word
initialValue (i, i)
lu [(Int, e')]
ies)
instance IArray UArray (Ptr a) where
{-# INLINE bounds #-}
bounds :: UArray i (Ptr a) -> (i, i)
bounds (UArray l :: i
l u :: i
u _ _) = (i
l,i
u)
{-# INLINE numElements #-}
numElements :: UArray i (Ptr a) -> Int
numElements (UArray _ _ n :: Int
n _) = Int
n
{-# INLINE unsafeArray #-}
unsafeArray :: (i, i) -> [(Int, Ptr a)] -> UArray i (Ptr a)
unsafeArray lu :: (i, i)
lu ies :: [(Int, Ptr a)]
ies = (forall s. ST s (UArray i (Ptr a))) -> UArray i (Ptr a)
forall a. (forall s. ST s a) -> a
runST ((i, i) -> [(Int, Ptr a)] -> Ptr a -> ST s (UArray i (Ptr a))
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
(i, i) -> [(Int, e)] -> e -> ST s (UArray i e)
unsafeArrayUArray (i, i)
lu [(Int, Ptr a)]
ies Ptr a
forall a. Ptr a
nullPtr)
{-# INLINE unsafeAt #-}
unsafeAt :: UArray i (Ptr a) -> Int -> Ptr a
unsafeAt (UArray _ _ _ arr# :: ByteArray#
arr#) (I# i# :: Int#
i#) = Addr# -> Ptr a
forall a. Addr# -> Ptr a
Ptr (ByteArray# -> Int# -> Addr#
indexAddrArray# ByteArray#
arr# Int#
i#)
{-# INLINE unsafeReplace #-}
unsafeReplace :: UArray i (Ptr a) -> [(Int, Ptr a)] -> UArray i (Ptr a)
unsafeReplace arr :: UArray i (Ptr a)
arr ies :: [(Int, Ptr a)]
ies = (forall s. ST s (UArray i (Ptr a))) -> UArray i (Ptr a)
forall a. (forall s. ST s a) -> a
runST (UArray i (Ptr a) -> [(Int, Ptr a)] -> ST s (UArray i (Ptr a))
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
UArray i e -> [(Int, e)] -> ST s (UArray i e)
unsafeReplaceUArray UArray i (Ptr a)
arr [(Int, Ptr a)]
ies)
{-# INLINE unsafeAccum #-}
unsafeAccum :: (Ptr a -> e' -> Ptr a)
-> UArray i (Ptr a) -> [(Int, e')] -> UArray i (Ptr a)
unsafeAccum f :: Ptr a -> e' -> Ptr a
f arr :: UArray i (Ptr a)
arr ies :: [(Int, e')]
ies = (forall s. ST s (UArray i (Ptr a))) -> UArray i (Ptr a)
forall a. (forall s. ST s a) -> a
runST ((Ptr a -> e' -> Ptr a)
-> UArray i (Ptr a) -> [(Int, e')] -> ST s (UArray i (Ptr a))
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> UArray i e -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumUArray Ptr a -> e' -> Ptr a
f UArray i (Ptr a)
arr [(Int, e')]
ies)
{-# INLINE unsafeAccumArray #-}
unsafeAccumArray :: (Ptr a -> e' -> Ptr a)
-> Ptr a -> (i, i) -> [(Int, e')] -> UArray i (Ptr a)
unsafeAccumArray f :: Ptr a -> e' -> Ptr a
f initialValue :: Ptr a
initialValue lu :: (i, i)
lu ies :: [(Int, e')]
ies = (forall s. ST s (UArray i (Ptr a))) -> UArray i (Ptr a)
forall a. (forall s. ST s a) -> a
runST ((Ptr a -> e' -> Ptr a)
-> Ptr a -> (i, i) -> [(Int, e')] -> ST s (UArray i (Ptr a))
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumArrayUArray Ptr a -> e' -> Ptr a
f Ptr a
initialValue (i, i)
lu [(Int, e')]
ies)
instance IArray UArray (FunPtr a) where
{-# INLINE bounds #-}
bounds :: UArray i (FunPtr a) -> (i, i)
bounds (UArray l :: i
l u :: i
u _ _) = (i
l,i
u)
{-# INLINE numElements #-}
numElements :: UArray i (FunPtr a) -> Int
numElements (UArray _ _ n :: Int
n _) = Int
n
{-# INLINE unsafeArray #-}
unsafeArray :: (i, i) -> [(Int, FunPtr a)] -> UArray i (FunPtr a)
unsafeArray lu :: (i, i)
lu ies :: [(Int, FunPtr a)]
ies = (forall s. ST s (UArray i (FunPtr a))) -> UArray i (FunPtr a)
forall a. (forall s. ST s a) -> a
runST ((i, i)
-> [(Int, FunPtr a)] -> FunPtr a -> ST s (UArray i (FunPtr a))
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
(i, i) -> [(Int, e)] -> e -> ST s (UArray i e)
unsafeArrayUArray (i, i)
lu [(Int, FunPtr a)]
ies FunPtr a
forall a. FunPtr a
nullFunPtr)
{-# INLINE unsafeAt #-}
unsafeAt :: UArray i (FunPtr a) -> Int -> FunPtr a
unsafeAt (UArray _ _ _ arr# :: ByteArray#
arr#) (I# i# :: Int#
i#) = Addr# -> FunPtr a
forall a. Addr# -> FunPtr a
FunPtr (ByteArray# -> Int# -> Addr#
indexAddrArray# ByteArray#
arr# Int#
i#)
{-# INLINE unsafeReplace #-}
unsafeReplace :: UArray i (FunPtr a) -> [(Int, FunPtr a)] -> UArray i (FunPtr a)
unsafeReplace arr :: UArray i (FunPtr a)
arr ies :: [(Int, FunPtr a)]
ies = (forall s. ST s (UArray i (FunPtr a))) -> UArray i (FunPtr a)
forall a. (forall s. ST s a) -> a
runST (UArray i (FunPtr a)
-> [(Int, FunPtr a)] -> ST s (UArray i (FunPtr a))
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
UArray i e -> [(Int, e)] -> ST s (UArray i e)
unsafeReplaceUArray UArray i (FunPtr a)
arr [(Int, FunPtr a)]
ies)
{-# INLINE unsafeAccum #-}
unsafeAccum :: (FunPtr a -> e' -> FunPtr a)
-> UArray i (FunPtr a) -> [(Int, e')] -> UArray i (FunPtr a)
unsafeAccum f :: FunPtr a -> e' -> FunPtr a
f arr :: UArray i (FunPtr a)
arr ies :: [(Int, e')]
ies = (forall s. ST s (UArray i (FunPtr a))) -> UArray i (FunPtr a)
forall a. (forall s. ST s a) -> a
runST ((FunPtr a -> e' -> FunPtr a)
-> UArray i (FunPtr a) -> [(Int, e')] -> ST s (UArray i (FunPtr a))
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> UArray i e -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumUArray FunPtr a -> e' -> FunPtr a
f UArray i (FunPtr a)
arr [(Int, e')]
ies)
{-# INLINE unsafeAccumArray #-}
unsafeAccumArray :: (FunPtr a -> e' -> FunPtr a)
-> FunPtr a -> (i, i) -> [(Int, e')] -> UArray i (FunPtr a)
unsafeAccumArray f :: FunPtr a -> e' -> FunPtr a
f initialValue :: FunPtr a
initialValue lu :: (i, i)
lu ies :: [(Int, e')]
ies = (forall s. ST s (UArray i (FunPtr a))) -> UArray i (FunPtr a)
forall a. (forall s. ST s a) -> a
runST ((FunPtr a -> e' -> FunPtr a)
-> FunPtr a -> (i, i) -> [(Int, e')] -> ST s (UArray i (FunPtr a))
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumArrayUArray FunPtr a -> e' -> FunPtr a
f FunPtr a
initialValue (i, i)
lu [(Int, e')]
ies)
instance IArray UArray Float where
{-# INLINE bounds #-}
bounds :: UArray i Float -> (i, i)
bounds (UArray l :: i
l u :: i
u _ _) = (i
l,i
u)
{-# INLINE numElements #-}
numElements :: UArray i Float -> Int
numElements (UArray _ _ n :: Int
n _) = Int
n
{-# INLINE unsafeArray #-}
unsafeArray :: (i, i) -> [(Int, Float)] -> UArray i Float
unsafeArray lu :: (i, i)
lu ies :: [(Int, Float)]
ies = (forall s. ST s (UArray i Float)) -> UArray i Float
forall a. (forall s. ST s a) -> a
runST ((i, i) -> [(Int, Float)] -> Float -> ST s (UArray i Float)
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
(i, i) -> [(Int, e)] -> e -> ST s (UArray i e)
unsafeArrayUArray (i, i)
lu [(Int, Float)]
ies 0)
{-# INLINE unsafeAt #-}
unsafeAt :: UArray i Float -> Int -> Float
unsafeAt (UArray _ _ _ arr# :: ByteArray#
arr#) (I# i# :: Int#
i#) = Float# -> Float
F# (ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
arr# Int#
i#)
{-# INLINE unsafeReplace #-}
unsafeReplace :: UArray i Float -> [(Int, Float)] -> UArray i Float
unsafeReplace arr :: UArray i Float
arr ies :: [(Int, Float)]
ies = (forall s. ST s (UArray i Float)) -> UArray i Float
forall a. (forall s. ST s a) -> a
runST (UArray i Float -> [(Int, Float)] -> ST s (UArray i Float)
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
UArray i e -> [(Int, e)] -> ST s (UArray i e)
unsafeReplaceUArray UArray i Float
arr [(Int, Float)]
ies)
{-# INLINE unsafeAccum #-}
unsafeAccum :: (Float -> e' -> Float)
-> UArray i Float -> [(Int, e')] -> UArray i Float
unsafeAccum f :: Float -> e' -> Float
f arr :: UArray i Float
arr ies :: [(Int, e')]
ies = (forall s. ST s (UArray i Float)) -> UArray i Float
forall a. (forall s. ST s a) -> a
runST ((Float -> e' -> Float)
-> UArray i Float -> [(Int, e')] -> ST s (UArray i Float)
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> UArray i e -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumUArray Float -> e' -> Float
f UArray i Float
arr [(Int, e')]
ies)
{-# INLINE unsafeAccumArray #-}
unsafeAccumArray :: (Float -> e' -> Float)
-> Float -> (i, i) -> [(Int, e')] -> UArray i Float
unsafeAccumArray f :: Float -> e' -> Float
f initialValue :: Float
initialValue lu :: (i, i)
lu ies :: [(Int, e')]
ies = (forall s. ST s (UArray i Float)) -> UArray i Float
forall a. (forall s. ST s a) -> a
runST ((Float -> e' -> Float)
-> Float -> (i, i) -> [(Int, e')] -> ST s (UArray i Float)
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumArrayUArray Float -> e' -> Float
f Float
initialValue (i, i)
lu [(Int, e')]
ies)
instance IArray UArray Double where
{-# INLINE bounds #-}
bounds :: UArray i Double -> (i, i)
bounds (UArray l :: i
l u :: i
u _ _) = (i
l,i
u)
{-# INLINE numElements #-}
numElements :: UArray i Double -> Int
numElements (UArray _ _ n :: Int
n _) = Int
n
{-# INLINE unsafeArray #-}
unsafeArray :: (i, i) -> [(Int, Double)] -> UArray i Double
unsafeArray lu :: (i, i)
lu ies :: [(Int, Double)]
ies = (forall s. ST s (UArray i Double)) -> UArray i Double
forall a. (forall s. ST s a) -> a
runST ((i, i) -> [(Int, Double)] -> Double -> ST s (UArray i Double)
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
(i, i) -> [(Int, e)] -> e -> ST s (UArray i e)
unsafeArrayUArray (i, i)
lu [(Int, Double)]
ies 0)
{-# INLINE unsafeAt #-}
unsafeAt :: UArray i Double -> Int -> Double
unsafeAt (UArray _ _ _ arr# :: ByteArray#
arr#) (I# i# :: Int#
i#) = Double# -> Double
D# (ByteArray# -> Int# -> Double#
indexDoubleArray# ByteArray#
arr# Int#
i#)
{-# INLINE unsafeReplace #-}
unsafeReplace :: UArray i Double -> [(Int, Double)] -> UArray i Double
unsafeReplace arr :: UArray i Double
arr ies :: [(Int, Double)]
ies = (forall s. ST s (UArray i Double)) -> UArray i Double
forall a. (forall s. ST s a) -> a
runST (UArray i Double -> [(Int, Double)] -> ST s (UArray i Double)
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
UArray i e -> [(Int, e)] -> ST s (UArray i e)
unsafeReplaceUArray UArray i Double
arr [(Int, Double)]
ies)
{-# INLINE unsafeAccum #-}
unsafeAccum :: (Double -> e' -> Double)
-> UArray i Double -> [(Int, e')] -> UArray i Double
unsafeAccum f :: Double -> e' -> Double
f arr :: UArray i Double
arr ies :: [(Int, e')]
ies = (forall s. ST s (UArray i Double)) -> UArray i Double
forall a. (forall s. ST s a) -> a
runST ((Double -> e' -> Double)
-> UArray i Double -> [(Int, e')] -> ST s (UArray i Double)
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> UArray i e -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumUArray Double -> e' -> Double
f UArray i Double
arr [(Int, e')]
ies)
{-# INLINE unsafeAccumArray #-}
unsafeAccumArray :: (Double -> e' -> Double)
-> Double -> (i, i) -> [(Int, e')] -> UArray i Double
unsafeAccumArray f :: Double -> e' -> Double
f initialValue :: Double
initialValue lu :: (i, i)
lu ies :: [(Int, e')]
ies = (forall s. ST s (UArray i Double)) -> UArray i Double
forall a. (forall s. ST s a) -> a
runST ((Double -> e' -> Double)
-> Double -> (i, i) -> [(Int, e')] -> ST s (UArray i Double)
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumArrayUArray Double -> e' -> Double
f Double
initialValue (i, i)
lu [(Int, e')]
ies)
instance IArray UArray (StablePtr a) where
{-# INLINE bounds #-}
bounds :: UArray i (StablePtr a) -> (i, i)
bounds (UArray l :: i
l u :: i
u _ _) = (i
l,i
u)
{-# INLINE numElements #-}
numElements :: UArray i (StablePtr a) -> Int
numElements (UArray _ _ n :: Int
n _) = Int
n
{-# INLINE unsafeArray #-}
unsafeArray :: (i, i) -> [(Int, StablePtr a)] -> UArray i (StablePtr a)
unsafeArray lu :: (i, i)
lu ies :: [(Int, StablePtr a)]
ies = (forall s. ST s (UArray i (StablePtr a))) -> UArray i (StablePtr a)
forall a. (forall s. ST s a) -> a
runST ((i, i)
-> [(Int, StablePtr a)]
-> StablePtr a
-> ST s (UArray i (StablePtr a))
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
(i, i) -> [(Int, e)] -> e -> ST s (UArray i e)
unsafeArrayUArray (i, i)
lu [(Int, StablePtr a)]
ies StablePtr a
forall a. StablePtr a
nullStablePtr)
{-# INLINE unsafeAt #-}
unsafeAt :: UArray i (StablePtr a) -> Int -> StablePtr a
unsafeAt (UArray _ _ _ arr# :: ByteArray#
arr#) (I# i# :: Int#
i#) = StablePtr# a -> StablePtr a
forall a. StablePtr# a -> StablePtr a
StablePtr (ByteArray# -> Int# -> StablePtr# a
forall a. ByteArray# -> Int# -> StablePtr# a
indexStablePtrArray# ByteArray#
arr# Int#
i#)
{-# INLINE unsafeReplace #-}
unsafeReplace :: UArray i (StablePtr a)
-> [(Int, StablePtr a)] -> UArray i (StablePtr a)
unsafeReplace arr :: UArray i (StablePtr a)
arr ies :: [(Int, StablePtr a)]
ies = (forall s. ST s (UArray i (StablePtr a))) -> UArray i (StablePtr a)
forall a. (forall s. ST s a) -> a
runST (UArray i (StablePtr a)
-> [(Int, StablePtr a)] -> ST s (UArray i (StablePtr a))
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
UArray i e -> [(Int, e)] -> ST s (UArray i e)
unsafeReplaceUArray UArray i (StablePtr a)
arr [(Int, StablePtr a)]
ies)
{-# INLINE unsafeAccum #-}
unsafeAccum :: (StablePtr a -> e' -> StablePtr a)
-> UArray i (StablePtr a) -> [(Int, e')] -> UArray i (StablePtr a)
unsafeAccum f :: StablePtr a -> e' -> StablePtr a
f arr :: UArray i (StablePtr a)
arr ies :: [(Int, e')]
ies = (forall s. ST s (UArray i (StablePtr a))) -> UArray i (StablePtr a)
forall a. (forall s. ST s a) -> a
runST ((StablePtr a -> e' -> StablePtr a)
-> UArray i (StablePtr a)
-> [(Int, e')]
-> ST s (UArray i (StablePtr a))
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> UArray i e -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumUArray StablePtr a -> e' -> StablePtr a
f UArray i (StablePtr a)
arr [(Int, e')]
ies)
{-# INLINE unsafeAccumArray #-}
unsafeAccumArray :: (StablePtr a -> e' -> StablePtr a)
-> StablePtr a -> (i, i) -> [(Int, e')] -> UArray i (StablePtr a)
unsafeAccumArray f :: StablePtr a -> e' -> StablePtr a
f initialValue :: StablePtr a
initialValue lu :: (i, i)
lu ies :: [(Int, e')]
ies = (forall s. ST s (UArray i (StablePtr a))) -> UArray i (StablePtr a)
forall a. (forall s. ST s a) -> a
runST ((StablePtr a -> e' -> StablePtr a)
-> StablePtr a
-> (i, i)
-> [(Int, e')]
-> ST s (UArray i (StablePtr a))
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumArrayUArray StablePtr a -> e' -> StablePtr a
f StablePtr a
initialValue (i, i)
lu [(Int, e')]
ies)
nullStablePtr :: StablePtr a
nullStablePtr :: StablePtr a
nullStablePtr = StablePtr# a -> StablePtr a
forall a. StablePtr# a -> StablePtr a
StablePtr (Int# -> StablePtr# a
unsafeCoerce# 0#)
instance IArray UArray Int8 where
{-# INLINE bounds #-}
bounds :: UArray i Int8 -> (i, i)
bounds (UArray l :: i
l u :: i
u _ _) = (i
l,i
u)
{-# INLINE numElements #-}
numElements :: UArray i Int8 -> Int
numElements (UArray _ _ n :: Int
n _) = Int
n
{-# INLINE unsafeArray #-}
unsafeArray :: (i, i) -> [(Int, Int8)] -> UArray i Int8
unsafeArray lu :: (i, i)
lu ies :: [(Int, Int8)]
ies = (forall s. ST s (UArray i Int8)) -> UArray i Int8
forall a. (forall s. ST s a) -> a
runST ((i, i) -> [(Int, Int8)] -> Int8 -> ST s (UArray i Int8)
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
(i, i) -> [(Int, e)] -> e -> ST s (UArray i e)
unsafeArrayUArray (i, i)
lu [(Int, Int8)]
ies 0)
{-# INLINE unsafeAt #-}
unsafeAt :: UArray i Int8 -> Int -> Int8
unsafeAt (UArray _ _ _ arr# :: ByteArray#
arr#) (I# i# :: Int#
i#) = Int# -> Int8
I8# (ByteArray# -> Int# -> Int#
indexInt8Array# ByteArray#
arr# Int#
i#)
{-# INLINE unsafeReplace #-}
unsafeReplace :: UArray i Int8 -> [(Int, Int8)] -> UArray i Int8
unsafeReplace arr :: UArray i Int8
arr ies :: [(Int, Int8)]
ies = (forall s. ST s (UArray i Int8)) -> UArray i Int8
forall a. (forall s. ST s a) -> a
runST (UArray i Int8 -> [(Int, Int8)] -> ST s (UArray i Int8)
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
UArray i e -> [(Int, e)] -> ST s (UArray i e)
unsafeReplaceUArray UArray i Int8
arr [(Int, Int8)]
ies)
{-# INLINE unsafeAccum #-}
unsafeAccum :: (Int8 -> e' -> Int8)
-> UArray i Int8 -> [(Int, e')] -> UArray i Int8
unsafeAccum f :: Int8 -> e' -> Int8
f arr :: UArray i Int8
arr ies :: [(Int, e')]
ies = (forall s. ST s (UArray i Int8)) -> UArray i Int8
forall a. (forall s. ST s a) -> a
runST ((Int8 -> e' -> Int8)
-> UArray i Int8 -> [(Int, e')] -> ST s (UArray i Int8)
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> UArray i e -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumUArray Int8 -> e' -> Int8
f UArray i Int8
arr [(Int, e')]
ies)
{-# INLINE unsafeAccumArray #-}
unsafeAccumArray :: (Int8 -> e' -> Int8)
-> Int8 -> (i, i) -> [(Int, e')] -> UArray i Int8
unsafeAccumArray f :: Int8 -> e' -> Int8
f initialValue :: Int8
initialValue lu :: (i, i)
lu ies :: [(Int, e')]
ies = (forall s. ST s (UArray i Int8)) -> UArray i Int8
forall a. (forall s. ST s a) -> a
runST ((Int8 -> e' -> Int8)
-> Int8 -> (i, i) -> [(Int, e')] -> ST s (UArray i Int8)
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumArrayUArray Int8 -> e' -> Int8
f Int8
initialValue (i, i)
lu [(Int, e')]
ies)
instance IArray UArray Int16 where
{-# INLINE bounds #-}
bounds :: UArray i Int16 -> (i, i)
bounds (UArray l :: i
l u :: i
u _ _) = (i
l,i
u)
{-# INLINE numElements #-}
numElements :: UArray i Int16 -> Int
numElements (UArray _ _ n :: Int
n _) = Int
n
{-# INLINE unsafeArray #-}
unsafeArray :: (i, i) -> [(Int, Int16)] -> UArray i Int16
unsafeArray lu :: (i, i)
lu ies :: [(Int, Int16)]
ies = (forall s. ST s (UArray i Int16)) -> UArray i Int16
forall a. (forall s. ST s a) -> a
runST ((i, i) -> [(Int, Int16)] -> Int16 -> ST s (UArray i Int16)
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
(i, i) -> [(Int, e)] -> e -> ST s (UArray i e)
unsafeArrayUArray (i, i)
lu [(Int, Int16)]
ies 0)
{-# INLINE unsafeAt #-}
unsafeAt :: UArray i Int16 -> Int -> Int16
unsafeAt (UArray _ _ _ arr# :: ByteArray#
arr#) (I# i# :: Int#
i#) = Int# -> Int16
I16# (ByteArray# -> Int# -> Int#
indexInt16Array# ByteArray#
arr# Int#
i#)
{-# INLINE unsafeReplace #-}
unsafeReplace :: UArray i Int16 -> [(Int, Int16)] -> UArray i Int16
unsafeReplace arr :: UArray i Int16
arr ies :: [(Int, Int16)]
ies = (forall s. ST s (UArray i Int16)) -> UArray i Int16
forall a. (forall s. ST s a) -> a
runST (UArray i Int16 -> [(Int, Int16)] -> ST s (UArray i Int16)
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
UArray i e -> [(Int, e)] -> ST s (UArray i e)
unsafeReplaceUArray UArray i Int16
arr [(Int, Int16)]
ies)
{-# INLINE unsafeAccum #-}
unsafeAccum :: (Int16 -> e' -> Int16)
-> UArray i Int16 -> [(Int, e')] -> UArray i Int16
unsafeAccum f :: Int16 -> e' -> Int16
f arr :: UArray i Int16
arr ies :: [(Int, e')]
ies = (forall s. ST s (UArray i Int16)) -> UArray i Int16
forall a. (forall s. ST s a) -> a
runST ((Int16 -> e' -> Int16)
-> UArray i Int16 -> [(Int, e')] -> ST s (UArray i Int16)
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> UArray i e -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumUArray Int16 -> e' -> Int16
f UArray i Int16
arr [(Int, e')]
ies)
{-# INLINE unsafeAccumArray #-}
unsafeAccumArray :: (Int16 -> e' -> Int16)
-> Int16 -> (i, i) -> [(Int, e')] -> UArray i Int16
unsafeAccumArray f :: Int16 -> e' -> Int16
f initialValue :: Int16
initialValue lu :: (i, i)
lu ies :: [(Int, e')]
ies = (forall s. ST s (UArray i Int16)) -> UArray i Int16
forall a. (forall s. ST s a) -> a
runST ((Int16 -> e' -> Int16)
-> Int16 -> (i, i) -> [(Int, e')] -> ST s (UArray i Int16)
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumArrayUArray Int16 -> e' -> Int16
f Int16
initialValue (i, i)
lu [(Int, e')]
ies)
instance IArray UArray Int32 where
{-# INLINE bounds #-}
bounds :: UArray i Int32 -> (i, i)
bounds (UArray l :: i
l u :: i
u _ _) = (i
l,i
u)
{-# INLINE numElements #-}
numElements :: UArray i Int32 -> Int
numElements (UArray _ _ n :: Int
n _) = Int
n
{-# INLINE unsafeArray #-}
unsafeArray :: (i, i) -> [(Int, Int32)] -> UArray i Int32
unsafeArray lu :: (i, i)
lu ies :: [(Int, Int32)]
ies = (forall s. ST s (UArray i Int32)) -> UArray i Int32
forall a. (forall s. ST s a) -> a
runST ((i, i) -> [(Int, Int32)] -> Int32 -> ST s (UArray i Int32)
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
(i, i) -> [(Int, e)] -> e -> ST s (UArray i e)
unsafeArrayUArray (i, i)
lu [(Int, Int32)]
ies 0)
{-# INLINE unsafeAt #-}
unsafeAt :: UArray i Int32 -> Int -> Int32
unsafeAt (UArray _ _ _ arr# :: ByteArray#
arr#) (I# i# :: Int#
i#) = Int# -> Int32
I32# (ByteArray# -> Int# -> Int#
indexInt32Array# ByteArray#
arr# Int#
i#)
{-# INLINE unsafeReplace #-}
unsafeReplace :: UArray i Int32 -> [(Int, Int32)] -> UArray i Int32
unsafeReplace arr :: UArray i Int32
arr ies :: [(Int, Int32)]
ies = (forall s. ST s (UArray i Int32)) -> UArray i Int32
forall a. (forall s. ST s a) -> a
runST (UArray i Int32 -> [(Int, Int32)] -> ST s (UArray i Int32)
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
UArray i e -> [(Int, e)] -> ST s (UArray i e)
unsafeReplaceUArray UArray i Int32
arr [(Int, Int32)]
ies)
{-# INLINE unsafeAccum #-}
unsafeAccum :: (Int32 -> e' -> Int32)
-> UArray i Int32 -> [(Int, e')] -> UArray i Int32
unsafeAccum f :: Int32 -> e' -> Int32
f arr :: UArray i Int32
arr ies :: [(Int, e')]
ies = (forall s. ST s (UArray i Int32)) -> UArray i Int32
forall a. (forall s. ST s a) -> a
runST ((Int32 -> e' -> Int32)
-> UArray i Int32 -> [(Int, e')] -> ST s (UArray i Int32)
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> UArray i e -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumUArray Int32 -> e' -> Int32
f UArray i Int32
arr [(Int, e')]
ies)
{-# INLINE unsafeAccumArray #-}
unsafeAccumArray :: (Int32 -> e' -> Int32)
-> Int32 -> (i, i) -> [(Int, e')] -> UArray i Int32
unsafeAccumArray f :: Int32 -> e' -> Int32
f initialValue :: Int32
initialValue lu :: (i, i)
lu ies :: [(Int, e')]
ies = (forall s. ST s (UArray i Int32)) -> UArray i Int32
forall a. (forall s. ST s a) -> a
runST ((Int32 -> e' -> Int32)
-> Int32 -> (i, i) -> [(Int, e')] -> ST s (UArray i Int32)
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumArrayUArray Int32 -> e' -> Int32
f Int32
initialValue (i, i)
lu [(Int, e')]
ies)
instance IArray UArray Int64 where
{-# INLINE bounds #-}
bounds :: UArray i Int64 -> (i, i)
bounds (UArray l :: i
l u :: i
u _ _) = (i
l,i
u)
{-# INLINE numElements #-}
numElements :: UArray i Int64 -> Int
numElements (UArray _ _ n :: Int
n _) = Int
n
{-# INLINE unsafeArray #-}
unsafeArray :: (i, i) -> [(Int, Int64)] -> UArray i Int64
unsafeArray lu :: (i, i)
lu ies :: [(Int, Int64)]
ies = (forall s. ST s (UArray i Int64)) -> UArray i Int64
forall a. (forall s. ST s a) -> a
runST ((i, i) -> [(Int, Int64)] -> Int64 -> ST s (UArray i Int64)
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
(i, i) -> [(Int, e)] -> e -> ST s (UArray i e)
unsafeArrayUArray (i, i)
lu [(Int, Int64)]
ies 0)
{-# INLINE unsafeAt #-}
unsafeAt :: UArray i Int64 -> Int -> Int64
unsafeAt (UArray _ _ _ arr# :: ByteArray#
arr#) (I# i# :: Int#
i#) = Int# -> Int64
I64# (ByteArray# -> Int# -> Int#
indexInt64Array# ByteArray#
arr# Int#
i#)
{-# INLINE unsafeReplace #-}
unsafeReplace :: UArray i Int64 -> [(Int, Int64)] -> UArray i Int64
unsafeReplace arr :: UArray i Int64
arr ies :: [(Int, Int64)]
ies = (forall s. ST s (UArray i Int64)) -> UArray i Int64
forall a. (forall s. ST s a) -> a
runST (UArray i Int64 -> [(Int, Int64)] -> ST s (UArray i Int64)
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
UArray i e -> [(Int, e)] -> ST s (UArray i e)
unsafeReplaceUArray UArray i Int64
arr [(Int, Int64)]
ies)
{-# INLINE unsafeAccum #-}
unsafeAccum :: (Int64 -> e' -> Int64)
-> UArray i Int64 -> [(Int, e')] -> UArray i Int64
unsafeAccum f :: Int64 -> e' -> Int64
f arr :: UArray i Int64
arr ies :: [(Int, e')]
ies = (forall s. ST s (UArray i Int64)) -> UArray i Int64
forall a. (forall s. ST s a) -> a
runST ((Int64 -> e' -> Int64)
-> UArray i Int64 -> [(Int, e')] -> ST s (UArray i Int64)
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> UArray i e -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumUArray Int64 -> e' -> Int64
f UArray i Int64
arr [(Int, e')]
ies)
{-# INLINE unsafeAccumArray #-}
unsafeAccumArray :: (Int64 -> e' -> Int64)
-> Int64 -> (i, i) -> [(Int, e')] -> UArray i Int64
unsafeAccumArray f :: Int64 -> e' -> Int64
f initialValue :: Int64
initialValue lu :: (i, i)
lu ies :: [(Int, e')]
ies = (forall s. ST s (UArray i Int64)) -> UArray i Int64
forall a. (forall s. ST s a) -> a
runST ((Int64 -> e' -> Int64)
-> Int64 -> (i, i) -> [(Int, e')] -> ST s (UArray i Int64)
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumArrayUArray Int64 -> e' -> Int64
f Int64
initialValue (i, i)
lu [(Int, e')]
ies)
instance IArray UArray Word8 where
{-# INLINE bounds #-}
bounds :: UArray i Word8 -> (i, i)
bounds (UArray l :: i
l u :: i
u _ _) = (i
l,i
u)
{-# INLINE numElements #-}
numElements :: UArray i Word8 -> Int
numElements (UArray _ _ n :: Int
n _) = Int
n
{-# INLINE unsafeArray #-}
unsafeArray :: (i, i) -> [(Int, Word8)] -> UArray i Word8
unsafeArray lu :: (i, i)
lu ies :: [(Int, Word8)]
ies = (forall s. ST s (UArray i Word8)) -> UArray i Word8
forall a. (forall s. ST s a) -> a
runST ((i, i) -> [(Int, Word8)] -> Word8 -> ST s (UArray i Word8)
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
(i, i) -> [(Int, e)] -> e -> ST s (UArray i e)
unsafeArrayUArray (i, i)
lu [(Int, Word8)]
ies 0)
{-# INLINE unsafeAt #-}
unsafeAt :: UArray i Word8 -> Int -> Word8
unsafeAt (UArray _ _ _ arr# :: ByteArray#
arr#) (I# i# :: Int#
i#) = Word# -> Word8
W8# (ByteArray# -> Int# -> Word#
indexWord8Array# ByteArray#
arr# Int#
i#)
{-# INLINE unsafeReplace #-}
unsafeReplace :: UArray i Word8 -> [(Int, Word8)] -> UArray i Word8
unsafeReplace arr :: UArray i Word8
arr ies :: [(Int, Word8)]
ies = (forall s. ST s (UArray i Word8)) -> UArray i Word8
forall a. (forall s. ST s a) -> a
runST (UArray i Word8 -> [(Int, Word8)] -> ST s (UArray i Word8)
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
UArray i e -> [(Int, e)] -> ST s (UArray i e)
unsafeReplaceUArray UArray i Word8
arr [(Int, Word8)]
ies)
{-# INLINE unsafeAccum #-}
unsafeAccum :: (Word8 -> e' -> Word8)
-> UArray i Word8 -> [(Int, e')] -> UArray i Word8
unsafeAccum f :: Word8 -> e' -> Word8
f arr :: UArray i Word8
arr ies :: [(Int, e')]
ies = (forall s. ST s (UArray i Word8)) -> UArray i Word8
forall a. (forall s. ST s a) -> a
runST ((Word8 -> e' -> Word8)
-> UArray i Word8 -> [(Int, e')] -> ST s (UArray i Word8)
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> UArray i e -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumUArray Word8 -> e' -> Word8
f UArray i Word8
arr [(Int, e')]
ies)
{-# INLINE unsafeAccumArray #-}
unsafeAccumArray :: (Word8 -> e' -> Word8)
-> Word8 -> (i, i) -> [(Int, e')] -> UArray i Word8
unsafeAccumArray f :: Word8 -> e' -> Word8
f initialValue :: Word8
initialValue lu :: (i, i)
lu ies :: [(Int, e')]
ies = (forall s. ST s (UArray i Word8)) -> UArray i Word8
forall a. (forall s. ST s a) -> a
runST ((Word8 -> e' -> Word8)
-> Word8 -> (i, i) -> [(Int, e')] -> ST s (UArray i Word8)
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumArrayUArray Word8 -> e' -> Word8
f Word8
initialValue (i, i)
lu [(Int, e')]
ies)
instance IArray UArray Word16 where
{-# INLINE bounds #-}
bounds :: UArray i Word16 -> (i, i)
bounds (UArray l :: i
l u :: i
u _ _) = (i
l,i
u)
{-# INLINE numElements #-}
numElements :: UArray i Word16 -> Int
numElements (UArray _ _ n :: Int
n _) = Int
n
{-# INLINE unsafeArray #-}
unsafeArray :: (i, i) -> [(Int, Word16)] -> UArray i Word16
unsafeArray lu :: (i, i)
lu ies :: [(Int, Word16)]
ies = (forall s. ST s (UArray i Word16)) -> UArray i Word16
forall a. (forall s. ST s a) -> a
runST ((i, i) -> [(Int, Word16)] -> Word16 -> ST s (UArray i Word16)
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
(i, i) -> [(Int, e)] -> e -> ST s (UArray i e)
unsafeArrayUArray (i, i)
lu [(Int, Word16)]
ies 0)
{-# INLINE unsafeAt #-}
unsafeAt :: UArray i Word16 -> Int -> Word16
unsafeAt (UArray _ _ _ arr# :: ByteArray#
arr#) (I# i# :: Int#
i#) = Word# -> Word16
W16# (ByteArray# -> Int# -> Word#
indexWord16Array# ByteArray#
arr# Int#
i#)
{-# INLINE unsafeReplace #-}
unsafeReplace :: UArray i Word16 -> [(Int, Word16)] -> UArray i Word16
unsafeReplace arr :: UArray i Word16
arr ies :: [(Int, Word16)]
ies = (forall s. ST s (UArray i Word16)) -> UArray i Word16
forall a. (forall s. ST s a) -> a
runST (UArray i Word16 -> [(Int, Word16)] -> ST s (UArray i Word16)
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
UArray i e -> [(Int, e)] -> ST s (UArray i e)
unsafeReplaceUArray UArray i Word16
arr [(Int, Word16)]
ies)
{-# INLINE unsafeAccum #-}
unsafeAccum :: (Word16 -> e' -> Word16)
-> UArray i Word16 -> [(Int, e')] -> UArray i Word16
unsafeAccum f :: Word16 -> e' -> Word16
f arr :: UArray i Word16
arr ies :: [(Int, e')]
ies = (forall s. ST s (UArray i Word16)) -> UArray i Word16
forall a. (forall s. ST s a) -> a
runST ((Word16 -> e' -> Word16)
-> UArray i Word16 -> [(Int, e')] -> ST s (UArray i Word16)
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> UArray i e -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumUArray Word16 -> e' -> Word16
f UArray i Word16
arr [(Int, e')]
ies)
{-# INLINE unsafeAccumArray #-}
unsafeAccumArray :: (Word16 -> e' -> Word16)
-> Word16 -> (i, i) -> [(Int, e')] -> UArray i Word16
unsafeAccumArray f :: Word16 -> e' -> Word16
f initialValue :: Word16
initialValue lu :: (i, i)
lu ies :: [(Int, e')]
ies = (forall s. ST s (UArray i Word16)) -> UArray i Word16
forall a. (forall s. ST s a) -> a
runST ((Word16 -> e' -> Word16)
-> Word16 -> (i, i) -> [(Int, e')] -> ST s (UArray i Word16)
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumArrayUArray Word16 -> e' -> Word16
f Word16
initialValue (i, i)
lu [(Int, e')]
ies)
instance IArray UArray Word32 where
{-# INLINE bounds #-}
bounds :: UArray i Word32 -> (i, i)
bounds (UArray l :: i
l u :: i
u _ _) = (i
l,i
u)
{-# INLINE numElements #-}
numElements :: UArray i Word32 -> Int
numElements (UArray _ _ n :: Int
n _) = Int
n
{-# INLINE unsafeArray #-}
unsafeArray :: (i, i) -> [(Int, Word32)] -> UArray i Word32
unsafeArray lu :: (i, i)
lu ies :: [(Int, Word32)]
ies = (forall s. ST s (UArray i Word32)) -> UArray i Word32
forall a. (forall s. ST s a) -> a
runST ((i, i) -> [(Int, Word32)] -> Word32 -> ST s (UArray i Word32)
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
(i, i) -> [(Int, e)] -> e -> ST s (UArray i e)
unsafeArrayUArray (i, i)
lu [(Int, Word32)]
ies 0)
{-# INLINE unsafeAt #-}
unsafeAt :: UArray i Word32 -> Int -> Word32
unsafeAt (UArray _ _ _ arr# :: ByteArray#
arr#) (I# i# :: Int#
i#) = Word# -> Word32
W32# (ByteArray# -> Int# -> Word#
indexWord32Array# ByteArray#
arr# Int#
i#)
{-# INLINE unsafeReplace #-}
unsafeReplace :: UArray i Word32 -> [(Int, Word32)] -> UArray i Word32
unsafeReplace arr :: UArray i Word32
arr ies :: [(Int, Word32)]
ies = (forall s. ST s (UArray i Word32)) -> UArray i Word32
forall a. (forall s. ST s a) -> a
runST (UArray i Word32 -> [(Int, Word32)] -> ST s (UArray i Word32)
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
UArray i e -> [(Int, e)] -> ST s (UArray i e)
unsafeReplaceUArray UArray i Word32
arr [(Int, Word32)]
ies)
{-# INLINE unsafeAccum #-}
unsafeAccum :: (Word32 -> e' -> Word32)
-> UArray i Word32 -> [(Int, e')] -> UArray i Word32
unsafeAccum f :: Word32 -> e' -> Word32
f arr :: UArray i Word32
arr ies :: [(Int, e')]
ies = (forall s. ST s (UArray i Word32)) -> UArray i Word32
forall a. (forall s. ST s a) -> a
runST ((Word32 -> e' -> Word32)
-> UArray i Word32 -> [(Int, e')] -> ST s (UArray i Word32)
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> UArray i e -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumUArray Word32 -> e' -> Word32
f UArray i Word32
arr [(Int, e')]
ies)
{-# INLINE unsafeAccumArray #-}
unsafeAccumArray :: (Word32 -> e' -> Word32)
-> Word32 -> (i, i) -> [(Int, e')] -> UArray i Word32
unsafeAccumArray f :: Word32 -> e' -> Word32
f initialValue :: Word32
initialValue lu :: (i, i)
lu ies :: [(Int, e')]
ies = (forall s. ST s (UArray i Word32)) -> UArray i Word32
forall a. (forall s. ST s a) -> a
runST ((Word32 -> e' -> Word32)
-> Word32 -> (i, i) -> [(Int, e')] -> ST s (UArray i Word32)
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumArrayUArray Word32 -> e' -> Word32
f Word32
initialValue (i, i)
lu [(Int, e')]
ies)
instance IArray UArray Word64 where
{-# INLINE bounds #-}
bounds :: UArray i Word64 -> (i, i)
bounds (UArray l :: i
l u :: i
u _ _) = (i
l,i
u)
{-# INLINE numElements #-}
numElements :: UArray i Word64 -> Int
numElements (UArray _ _ n :: Int
n _) = Int
n
{-# INLINE unsafeArray #-}
unsafeArray :: (i, i) -> [(Int, Word64)] -> UArray i Word64
unsafeArray lu :: (i, i)
lu ies :: [(Int, Word64)]
ies = (forall s. ST s (UArray i Word64)) -> UArray i Word64
forall a. (forall s. ST s a) -> a
runST ((i, i) -> [(Int, Word64)] -> Word64 -> ST s (UArray i Word64)
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
(i, i) -> [(Int, e)] -> e -> ST s (UArray i e)
unsafeArrayUArray (i, i)
lu [(Int, Word64)]
ies 0)
{-# INLINE unsafeAt #-}
unsafeAt :: UArray i Word64 -> Int -> Word64
unsafeAt (UArray _ _ _ arr# :: ByteArray#
arr#) (I# i# :: Int#
i#) = Word# -> Word64
W64# (ByteArray# -> Int# -> Word#
indexWord64Array# ByteArray#
arr# Int#
i#)
{-# INLINE unsafeReplace #-}
unsafeReplace :: UArray i Word64 -> [(Int, Word64)] -> UArray i Word64
unsafeReplace arr :: UArray i Word64
arr ies :: [(Int, Word64)]
ies = (forall s. ST s (UArray i Word64)) -> UArray i Word64
forall a. (forall s. ST s a) -> a
runST (UArray i Word64 -> [(Int, Word64)] -> ST s (UArray i Word64)
forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
UArray i e -> [(Int, e)] -> ST s (UArray i e)
unsafeReplaceUArray UArray i Word64
arr [(Int, Word64)]
ies)
{-# INLINE unsafeAccum #-}
unsafeAccum :: (Word64 -> e' -> Word64)
-> UArray i Word64 -> [(Int, e')] -> UArray i Word64
unsafeAccum f :: Word64 -> e' -> Word64
f arr :: UArray i Word64
arr ies :: [(Int, e')]
ies = (forall s. ST s (UArray i Word64)) -> UArray i Word64
forall a. (forall s. ST s a) -> a
runST ((Word64 -> e' -> Word64)
-> UArray i Word64 -> [(Int, e')] -> ST s (UArray i Word64)
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> UArray i e -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumUArray Word64 -> e' -> Word64
f UArray i Word64
arr [(Int, e')]
ies)
{-# INLINE unsafeAccumArray #-}
unsafeAccumArray :: (Word64 -> e' -> Word64)
-> Word64 -> (i, i) -> [(Int, e')] -> UArray i Word64
unsafeAccumArray f :: Word64 -> e' -> Word64
f initialValue :: Word64
initialValue lu :: (i, i)
lu ies :: [(Int, e')]
ies = (forall s. ST s (UArray i Word64)) -> UArray i Word64
forall a. (forall s. ST s a) -> a
runST ((Word64 -> e' -> Word64)
-> Word64 -> (i, i) -> [(Int, e')] -> ST s (UArray i Word64)
forall s e i e'.
(MArray (STUArray s) e (ST s), Ix i) =>
(e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> ST s (UArray i e)
unsafeAccumArrayUArray Word64 -> e' -> Word64
f Word64
initialValue (i, i)
lu [(Int, e')]
ies)
instance (Ix ix, Eq e, IArray UArray e) => Eq (UArray ix e) where
== :: UArray ix e -> UArray ix e -> Bool
(==) = UArray ix e -> UArray ix e -> Bool
forall e i.
(IArray UArray e, Ix i, Eq e) =>
UArray i e -> UArray i e -> Bool
eqUArray
instance (Ix ix, Ord e, IArray UArray e) => Ord (UArray ix e) where
compare :: UArray ix e -> UArray ix e -> Ordering
compare = UArray ix e -> UArray ix e -> Ordering
forall e i.
(IArray UArray e, Ix i, Ord e) =>
UArray i e -> UArray i e -> Ordering
cmpUArray
instance (Ix ix, Show ix, Show e, IArray UArray e) => Show (UArray ix e) where
showsPrec :: Int -> UArray ix e -> [Char] -> [Char]
showsPrec = Int -> UArray ix e -> [Char] -> [Char]
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i, Show i, Show e) =>
Int -> a i e -> [Char] -> [Char]
showsIArray
instance (Ix ix, Read ix, Read e, IArray UArray e) => Read (UArray ix e) where
readPrec :: ReadPrec (UArray ix e)
readPrec = ReadPrec (UArray ix e)
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i, Read i, Read e) =>
ReadPrec (a i e)
readIArray
{-# NOINLINE arrEleBottom #-}
arrEleBottom :: a
arrEleBottom :: a
arrEleBottom = [Char] -> a
forall a. HasCallStack => [Char] -> a
error "MArray: undefined array element"
class (Monad m) => MArray a e m where
getBounds :: Ix i => a i e -> m (i,i)
getNumElements :: Ix i => a i e -> m Int
newArray :: Ix i => (i,i) -> e -> m (a i e)
newArray_ :: Ix i => (i,i) -> m (a i e)
unsafeNewArray_ :: Ix i => (i,i) -> m (a i e)
unsafeRead :: Ix i => a i e -> Int -> m e
unsafeWrite :: Ix i => a i e -> Int -> e -> m ()
{-# INLINE newArray #-}
newArray (l :: i
l,u :: i
u) initialValue :: e
initialValue = do
let n :: Int
n = (i, i) -> Int
forall a. Ix a => (a, a) -> Int
safeRangeSize (i
l,i
u)
a i e
marr <- (i, i) -> m (a i e)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> m (a i e)
unsafeNewArray_ (i
l,i
u)
[m ()] -> m ()
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_ [a i e -> Int -> e -> m ()
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> e -> m ()
unsafeWrite a i e
marr Int
i e
initialValue | Int
i <- [0 .. Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- 1]]
a i e -> m (a i e)
forall (m :: * -> *) a. Monad m => a -> m a
return a i e
marr
{-# INLINE unsafeNewArray_ #-}
unsafeNewArray_ (l :: i
l,u :: i
u) = (i, i) -> e -> m (a i e)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i
l,i
u) e
forall a. a
arrEleBottom
{-# INLINE newArray_ #-}
newArray_ (l :: i
l,u :: i
u) = (i, i) -> e -> m (a i e)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i
l,i
u) e
forall a. a
arrEleBottom
instance MArray IOArray e IO where
{-# INLINE getBounds #-}
getBounds :: IOArray i e -> IO (i, i)
getBounds (IOArray marr :: STArray RealWorld i e
marr) = ST RealWorld (i, i) -> IO (i, i)
forall a. ST RealWorld a -> IO a
stToIO (ST RealWorld (i, i) -> IO (i, i))
-> ST RealWorld (i, i) -> IO (i, i)
forall a b. (a -> b) -> a -> b
$ STArray RealWorld i e -> ST RealWorld (i, i)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m (i, i)
getBounds STArray RealWorld i e
marr
{-# INLINE getNumElements #-}
getNumElements :: IOArray i e -> IO Int
getNumElements (IOArray marr :: STArray RealWorld i e
marr) = ST RealWorld Int -> IO Int
forall a. ST RealWorld a -> IO a
stToIO (ST RealWorld Int -> IO Int) -> ST RealWorld Int -> IO Int
forall a b. (a -> b) -> a -> b
$ STArray RealWorld i e -> ST RealWorld Int
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m Int
getNumElements STArray RealWorld i e
marr
newArray :: (i, i) -> e -> IO (IOArray i e)
newArray = (i, i) -> e -> IO (IOArray i e)
forall i e. Ix i => (i, i) -> e -> IO (IOArray i e)
newIOArray
unsafeRead :: IOArray i e -> Int -> IO e
unsafeRead = IOArray i e -> Int -> IO e
forall i e. IOArray i e -> Int -> IO e
unsafeReadIOArray
unsafeWrite :: IOArray i e -> Int -> e -> IO ()
unsafeWrite = IOArray i e -> Int -> e -> IO ()
forall i e. IOArray i e -> Int -> e -> IO ()
unsafeWriteIOArray
{-# INLINE newListArray #-}
newListArray :: (MArray a e m, Ix i) => (i,i) -> [e] -> m (a i e)
newListArray :: (i, i) -> [e] -> m (a i e)
newListArray (l :: i
l,u :: i
u) es :: [e]
es = do
a i e
marr <- (i, i) -> m (a i e)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> m (a i e)
newArray_ (i
l,i
u)
let n :: Int
n = (i, i) -> Int
forall a. Ix a => (a, a) -> Int
safeRangeSize (i
l,i
u)
let fillFromList :: Int -> [e] -> m ()
fillFromList i :: Int
i xs :: [e]
xs | Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
n = () -> m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
| Bool
otherwise = case [e]
xs of
[] -> () -> m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
y :: e
y:ys :: [e]
ys -> a i e -> Int -> e -> m ()
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> e -> m ()
unsafeWrite a i e
marr Int
i e
y m () -> m () -> m ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> [e] -> m ()
fillFromList (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+1) [e]
ys
Int -> [e] -> m ()
forall (m :: * -> *). MArray a e m => Int -> [e] -> m ()
fillFromList 0 [e]
es
a i e -> m (a i e)
forall (m :: * -> *) a. Monad m => a -> m a
return a i e
marr
{-# INLINE readArray #-}
readArray :: (MArray a e m, Ix i) => a i e -> i -> m e
readArray :: a i e -> i -> m e
readArray marr :: a i e
marr i :: i
i = do
(l :: i
l,u :: i
u) <- a i e -> m (i, i)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m (i, i)
getBounds a i e
marr
Int
n <- a i e -> m Int
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m Int
getNumElements a i e
marr
a i e -> Int -> m e
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> m e
unsafeRead a i e
marr ((i, i) -> Int -> i -> Int
forall i. Ix i => (i, i) -> Int -> i -> Int
safeIndex (i
l,i
u) Int
n i
i)
{-# INLINE writeArray #-}
writeArray :: (MArray a e m, Ix i) => a i e -> i -> e -> m ()
writeArray :: a i e -> i -> e -> m ()
writeArray marr :: a i e
marr i :: i
i e :: e
e = do
(l :: i
l,u :: i
u) <- a i e -> m (i, i)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m (i, i)
getBounds a i e
marr
Int
n <- a i e -> m Int
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m Int
getNumElements a i e
marr
a i e -> Int -> e -> m ()
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> e -> m ()
unsafeWrite a i e
marr ((i, i) -> Int -> i -> Int
forall i. Ix i => (i, i) -> Int -> i -> Int
safeIndex (i
l,i
u) Int
n i
i) e
e
{-# INLINE getElems #-}
getElems :: (MArray a e m, Ix i) => a i e -> m [e]
getElems :: a i e -> m [e]
getElems marr :: a i e
marr = do
(_l :: i
_l, _u :: i
_u) <- a i e -> m (i, i)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m (i, i)
getBounds a i e
marr
Int
n <- a i e -> m Int
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m Int
getNumElements a i e
marr
[m e] -> m [e]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [a i e -> Int -> m e
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> m e
unsafeRead a i e
marr Int
i | Int
i <- [0 .. Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- 1]]
{-# INLINE getAssocs #-}
getAssocs :: (MArray a e m, Ix i) => a i e -> m [(i, e)]
getAssocs :: a i e -> m [(i, e)]
getAssocs marr :: a i e
marr = do
(l :: i
l,u :: i
u) <- a i e -> m (i, i)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m (i, i)
getBounds a i e
marr
Int
n <- a i e -> m Int
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m Int
getNumElements a i e
marr
[m (i, e)] -> m [(i, e)]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [ do e
e <- a i e -> Int -> m e
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> m e
unsafeRead a i e
marr ((i, i) -> Int -> i -> Int
forall i. Ix i => (i, i) -> Int -> i -> Int
safeIndex (i
l,i
u) Int
n i
i); (i, e) -> m (i, e)
forall (m :: * -> *) a. Monad m => a -> m a
return (i
i,e
e)
| i
i <- (i, i) -> [i]
forall a. Ix a => (a, a) -> [a]
range (i
l,i
u)]
{-# INLINE mapArray #-}
mapArray :: (MArray a e' m, MArray a e m, Ix i) => (e' -> e) -> a i e' -> m (a i e)
mapArray :: (e' -> e) -> a i e' -> m (a i e)
mapArray f :: e' -> e
f marr :: a i e'
marr = do
(l :: i
l,u :: i
u) <- a i e' -> m (i, i)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m (i, i)
getBounds a i e'
marr
Int
n <- a i e' -> m Int
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m Int
getNumElements a i e'
marr
a i e
marr' <- (i, i) -> m (a i e)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> m (a i e)
newArray_ (i
l,i
u)
[m ()] -> m ()
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_ [do e'
e <- a i e' -> Int -> m e'
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> m e
unsafeRead a i e'
marr Int
i
a i e -> Int -> e -> m ()
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> e -> m ()
unsafeWrite a i e
marr' Int
i (e' -> e
f e'
e)
| Int
i <- [0 .. Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- 1]]
a i e -> m (a i e)
forall (m :: * -> *) a. Monad m => a -> m a
return a i e
marr'
{-# INLINE mapIndices #-}
mapIndices :: (MArray a e m, Ix i, Ix j) => (i,i) -> (i -> j) -> a j e -> m (a i e)
mapIndices :: (i, i) -> (i -> j) -> a j e -> m (a i e)
mapIndices (l' :: i
l',u' :: i
u') f :: i -> j
f marr :: a j e
marr = do
a i e
marr' <- (i, i) -> m (a i e)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> m (a i e)
newArray_ (i
l',i
u')
Int
n' <- a i e -> m Int
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m Int
getNumElements a i e
marr'
[m ()] -> m ()
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_ [do e
e <- a j e -> j -> m e
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> i -> m e
readArray a j e
marr (i -> j
f i
i')
a i e -> Int -> e -> m ()
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> e -> m ()
unsafeWrite a i e
marr' ((i, i) -> Int -> i -> Int
forall i. Ix i => (i, i) -> Int -> i -> Int
safeIndex (i
l',i
u') Int
n' i
i') e
e
| i
i' <- (i, i) -> [i]
forall a. Ix a => (a, a) -> [a]
range (i
l',i
u')]
a i e -> m (a i e)
forall (m :: * -> *) a. Monad m => a -> m a
return a i e
marr'
instance MArray (STArray s) e (ST s) where
{-# INLINE getBounds #-}
getBounds :: STArray s i e -> ST s (i, i)
getBounds arr :: STArray s i e
arr = (i, i) -> ST s (i, i)
forall (m :: * -> *) a. Monad m => a -> m a
return ((i, i) -> ST s (i, i)) -> (i, i) -> ST s (i, i)
forall a b. (a -> b) -> a -> b
$! STArray s i e -> (i, i)
forall s i e. STArray s i e -> (i, i)
ArrST.boundsSTArray STArray s i e
arr
{-# INLINE getNumElements #-}
getNumElements :: STArray s i e -> ST s Int
getNumElements arr :: STArray s i e
arr = Int -> ST s Int
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> ST s Int) -> Int -> ST s Int
forall a b. (a -> b) -> a -> b
$! STArray s i e -> Int
forall s i e. STArray s i e -> Int
ArrST.numElementsSTArray STArray s i e
arr
{-# INLINE newArray #-}
newArray :: (i, i) -> e -> ST s (STArray s i e)
newArray = (i, i) -> e -> ST s (STArray s i e)
forall i e s. Ix i => (i, i) -> e -> ST s (STArray s i e)
ArrST.newSTArray
{-# INLINE unsafeRead #-}
unsafeRead :: STArray s i e -> Int -> ST s e
unsafeRead = STArray s i e -> Int -> ST s e
forall s i e. STArray s i e -> Int -> ST s e
ArrST.unsafeReadSTArray
{-# INLINE unsafeWrite #-}
unsafeWrite :: STArray s i e -> Int -> e -> ST s ()
unsafeWrite = STArray s i e -> Int -> e -> ST s ()
forall s i e. STArray s i e -> Int -> e -> ST s ()
ArrST.unsafeWriteSTArray
instance MArray (STArray s) e (Lazy.ST s) where
{-# INLINE getBounds #-}
getBounds :: STArray s i e -> ST s (i, i)
getBounds arr :: STArray s i e
arr = ST s (i, i) -> ST s (i, i)
forall s a. ST s a -> ST s a
strictToLazyST ((i, i) -> ST s (i, i)
forall (m :: * -> *) a. Monad m => a -> m a
return ((i, i) -> ST s (i, i)) -> (i, i) -> ST s (i, i)
forall a b. (a -> b) -> a -> b
$! STArray s i e -> (i, i)
forall s i e. STArray s i e -> (i, i)
ArrST.boundsSTArray STArray s i e
arr)
{-# INLINE getNumElements #-}
getNumElements :: STArray s i e -> ST s Int
getNumElements arr :: STArray s i e
arr = ST s Int -> ST s Int
forall s a. ST s a -> ST s a
strictToLazyST (Int -> ST s Int
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> ST s Int) -> Int -> ST s Int
forall a b. (a -> b) -> a -> b
$! STArray s i e -> Int
forall s i e. STArray s i e -> Int
ArrST.numElementsSTArray STArray s i e
arr)
{-# INLINE newArray #-}
newArray :: (i, i) -> e -> ST s (STArray s i e)
newArray (l :: i
l,u :: i
u) e :: e
e = ST s (STArray s i e) -> ST s (STArray s i e)
forall s a. ST s a -> ST s a
strictToLazyST ((i, i) -> e -> ST s (STArray s i e)
forall i e s. Ix i => (i, i) -> e -> ST s (STArray s i e)
ArrST.newSTArray (i
l,i
u) e
e)
{-# INLINE unsafeRead #-}
unsafeRead :: STArray s i e -> Int -> ST s e
unsafeRead arr :: STArray s i e
arr i :: Int
i = ST s e -> ST s e
forall s a. ST s a -> ST s a
strictToLazyST (STArray s i e -> Int -> ST s e
forall s i e. STArray s i e -> Int -> ST s e
ArrST.unsafeReadSTArray STArray s i e
arr Int
i)
{-# INLINE unsafeWrite #-}
unsafeWrite :: STArray s i e -> Int -> e -> ST s ()
unsafeWrite arr :: STArray s i e
arr i :: Int
i e :: e
e = ST s () -> ST s ()
forall s a. ST s a -> ST s a
strictToLazyST (STArray s i e -> Int -> e -> ST s ()
forall s i e. STArray s i e -> Int -> e -> ST s ()
ArrST.unsafeWriteSTArray STArray s i e
arr Int
i e
e)
data STUArray s i e = STUArray !i !i !Int (MutableByteArray# s)
type role STUArray nominal nominal nominal
instance Eq (STUArray s i e) where
STUArray _ _ _ arr1# :: MutableByteArray# s
arr1# == :: STUArray s i e -> STUArray s i e -> Bool
== STUArray _ _ _ arr2# :: MutableByteArray# s
arr2# =
Int# -> Bool
isTrue# (MutableByteArray# s -> MutableByteArray# s -> Int#
forall d. MutableByteArray# d -> MutableByteArray# d -> Int#
sameMutableByteArray# MutableByteArray# s
arr1# MutableByteArray# s
arr2#)
{-# INLINE unsafeNewArraySTUArray_ #-}
unsafeNewArraySTUArray_ :: Ix i
=> (i,i) -> (Int# -> Int#) -> ST s (STUArray s i e)
unsafeNewArraySTUArray_ :: (i, i) -> (Int# -> Int#) -> ST s (STUArray s i e)
unsafeNewArraySTUArray_ (l :: i
l,u :: i
u) elemsToBytes :: Int# -> Int#
elemsToBytes
= case (i, i) -> Int
forall a. Ix a => (a, a) -> Int
rangeSize (i
l,i
u) of
n :: Int
n@(I# n# :: Int#
n#) ->
STRep s (STUArray s i e) -> ST s (STUArray s i e)
forall s a. STRep s a -> ST s a
ST (STRep s (STUArray s i e) -> ST s (STUArray s i e))
-> STRep s (STUArray s i e) -> ST s (STUArray s i e)
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case Int# -> State# s -> (# State# s, MutableByteArray# s #)
forall d. Int# -> State# d -> (# State# d, MutableByteArray# d #)
newByteArray# (Int# -> Int#
elemsToBytes Int#
n#) State# s
s1# of
(# s2# :: State# s
s2#, marr# :: MutableByteArray# s
marr# #) ->
(# State# s
s2#, i -> i -> Int -> MutableByteArray# s -> STUArray s i e
forall s i e.
i -> i -> Int -> MutableByteArray# s -> STUArray s i e
STUArray i
l i
u Int
n MutableByteArray# s
marr# #)
instance MArray (STUArray s) Bool (ST s) where
{-# INLINE getBounds #-}
getBounds :: STUArray s i Bool -> ST s (i, i)
getBounds (STUArray l :: i
l u :: i
u _ _) = (i, i) -> ST s (i, i)
forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
{-# INLINE getNumElements #-}
getNumElements :: STUArray s i Bool -> ST s Int
getNumElements (STUArray _ _ n :: Int
n _) = Int -> ST s Int
forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
{-# INLINE newArray #-}
newArray :: (i, i) -> Bool -> ST s (STUArray s i Bool)
newArray (l :: i
l,u :: i
u) initialValue :: Bool
initialValue = STRep s (STUArray s i Bool) -> ST s (STUArray s i Bool)
forall s a. STRep s a -> ST s a
ST (STRep s (STUArray s i Bool) -> ST s (STUArray s i Bool))
-> STRep s (STUArray s i Bool) -> ST s (STUArray s i Bool)
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case (i, i) -> Int
forall a. Ix a => (a, a) -> Int
safeRangeSize (i
l,i
u) of { n :: Int
n@(I# n# :: Int#
n#) ->
case Int# -> Int#
bOOL_SCALE Int#
n# of { nbytes# :: Int#
nbytes# ->
case Int# -> State# s -> (# State# s, MutableByteArray# s #)
forall d. Int# -> State# d -> (# State# d, MutableByteArray# d #)
newByteArray# Int#
nbytes# State# s
s1# of { (# s2# :: State# s
s2#, marr# :: MutableByteArray# s
marr# #) ->
case MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> State# s
forall d.
MutableByteArray# d -> Int# -> Int# -> Int# -> State# d -> State# d
setByteArray# MutableByteArray# s
marr# 0# Int#
nbytes# Int#
e# State# s
s2# of { s3# :: State# s
s3# ->
(# State# s
s3#, i -> i -> Int -> MutableByteArray# s -> STUArray s i Bool
forall s i e.
i -> i -> Int -> MutableByteArray# s -> STUArray s i e
STUArray i
l i
u Int
n MutableByteArray# s
marr# #) }}}}
where
!(I# e# :: Int#
e#) = if Bool
initialValue then 0xff else 0x0
{-# INLINE unsafeNewArray_ #-}
unsafeNewArray_ :: (i, i) -> ST s (STUArray s i Bool)
unsafeNewArray_ (l :: i
l,u :: i
u) = (i, i) -> (Int# -> Int#) -> ST s (STUArray s i Bool)
forall i s e.
Ix i =>
(i, i) -> (Int# -> Int#) -> ST s (STUArray s i e)
unsafeNewArraySTUArray_ (i
l,i
u) Int# -> Int#
bOOL_SCALE
{-# INLINE newArray_ #-}
newArray_ :: (i, i) -> ST s (STUArray s i Bool)
newArray_ arrBounds :: (i, i)
arrBounds = (i, i) -> Bool -> ST s (STUArray s i Bool)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds Bool
False
{-# INLINE unsafeRead #-}
unsafeRead :: STUArray s i Bool -> Int -> ST s Bool
unsafeRead (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) = STRep s Bool -> ST s Bool
forall s a. STRep s a -> ST s a
ST (STRep s Bool -> ST s Bool) -> STRep s Bool -> ST s Bool
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> State# s -> (# State# s, Word# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
readWordArray# MutableByteArray# s
marr# (Int# -> Int#
bOOL_INDEX Int#
i#) State# s
s1# of { (# s2# :: State# s
s2#, e# :: Word#
e# #) ->
(# State# s
s2#, Int# -> Bool
isTrue# ((Word#
e# Word# -> Word# -> Word#
`and#` Int# -> Word#
bOOL_BIT Int#
i#) Word# -> Word# -> Int#
`neWord#` Int# -> Word#
int2Word# 0#) :: Bool #) }
{-# INLINE unsafeWrite #-}
unsafeWrite :: STUArray s i Bool -> Int -> Bool -> ST s ()
unsafeWrite (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) e :: Bool
e = STRep s () -> ST s ()
forall s a. STRep s a -> ST s a
ST (STRep s () -> ST s ()) -> STRep s () -> ST s ()
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case Int# -> Int#
bOOL_INDEX Int#
i# of { j# :: Int#
j# ->
case MutableByteArray# s -> Int# -> State# s -> (# State# s, Word# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
readWordArray# MutableByteArray# s
marr# Int#
j# State# s
s1# of { (# s2# :: State# s
s2#, old# :: Word#
old# #) ->
case if Bool
e then Word#
old# Word# -> Word# -> Word#
`or#` Int# -> Word#
bOOL_BIT Int#
i#
else Word#
old# Word# -> Word# -> Word#
`and#` Int# -> Word#
bOOL_NOT_BIT Int#
i# of { e# :: Word#
e# ->
case MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
forall d.
MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
writeWordArray# MutableByteArray# s
marr# Int#
j# Word#
e# State# s
s2# of { s3# :: State# s
s3# ->
(# State# s
s3#, () #) }}}}
instance MArray (STUArray s) Char (ST s) where
{-# INLINE getBounds #-}
getBounds :: STUArray s i Char -> ST s (i, i)
getBounds (STUArray l :: i
l u :: i
u _ _) = (i, i) -> ST s (i, i)
forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
{-# INLINE getNumElements #-}
getNumElements :: STUArray s i Char -> ST s Int
getNumElements (STUArray _ _ n :: Int
n _) = Int -> ST s Int
forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
{-# INLINE unsafeNewArray_ #-}
unsafeNewArray_ :: (i, i) -> ST s (STUArray s i Char)
unsafeNewArray_ (l :: i
l,u :: i
u) = (i, i) -> (Int# -> Int#) -> ST s (STUArray s i Char)
forall i s e.
Ix i =>
(i, i) -> (Int# -> Int#) -> ST s (STUArray s i e)
unsafeNewArraySTUArray_ (i
l,i
u) (Int# -> Int# -> Int#
safe_scale 4#)
{-# INLINE newArray_ #-}
newArray_ :: (i, i) -> ST s (STUArray s i Char)
newArray_ arrBounds :: (i, i)
arrBounds = (i, i) -> Char -> ST s (STUArray s i Char)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds (Int -> Char
chr 0)
{-# INLINE unsafeRead #-}
unsafeRead :: STUArray s i Char -> Int -> ST s Char
unsafeRead (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) = STRep s Char -> ST s Char
forall s a. STRep s a -> ST s a
ST (STRep s Char -> ST s Char) -> STRep s Char -> ST s Char
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> State# s -> (# State# s, Char# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
readWideCharArray# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# s2# :: State# s
s2#, e# :: Char#
e# #) ->
(# State# s
s2#, Char# -> Char
C# Char#
e# #) }
{-# INLINE unsafeWrite #-}
unsafeWrite :: STUArray s i Char -> Int -> Char -> ST s ()
unsafeWrite (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) (C# e# :: Char#
e#) = STRep s () -> ST s ()
forall s a. STRep s a -> ST s a
ST (STRep s () -> ST s ()) -> STRep s () -> ST s ()
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> Char# -> State# s -> State# s
forall d.
MutableByteArray# d -> Int# -> Char# -> State# d -> State# d
writeWideCharArray# MutableByteArray# s
marr# Int#
i# Char#
e# State# s
s1# of { s2# :: State# s
s2# ->
(# State# s
s2#, () #) }
instance MArray (STUArray s) Int (ST s) where
{-# INLINE getBounds #-}
getBounds :: STUArray s i Int -> ST s (i, i)
getBounds (STUArray l :: i
l u :: i
u _ _) = (i, i) -> ST s (i, i)
forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
{-# INLINE getNumElements #-}
getNumElements :: STUArray s i Int -> ST s Int
getNumElements (STUArray _ _ n :: Int
n _) = Int -> ST s Int
forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
{-# INLINE unsafeNewArray_ #-}
unsafeNewArray_ :: (i, i) -> ST s (STUArray s i Int)
unsafeNewArray_ (l :: i
l,u :: i
u) = (i, i) -> (Int# -> Int#) -> ST s (STUArray s i Int)
forall i s e.
Ix i =>
(i, i) -> (Int# -> Int#) -> ST s (STUArray s i e)
unsafeNewArraySTUArray_ (i
l,i
u) Int# -> Int#
wORD_SCALE
{-# INLINE newArray_ #-}
newArray_ :: (i, i) -> ST s (STUArray s i Int)
newArray_ arrBounds :: (i, i)
arrBounds = (i, i) -> Int -> ST s (STUArray s i Int)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds 0
{-# INLINE unsafeRead #-}
unsafeRead :: STUArray s i Int -> Int -> ST s Int
unsafeRead (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) = STRep s Int -> ST s Int
forall s a. STRep s a -> ST s a
ST (STRep s Int -> ST s Int) -> STRep s Int -> ST s Int
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> State# s -> (# State# s, Int# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
readIntArray# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# s2# :: State# s
s2#, e# :: Int#
e# #) ->
(# State# s
s2#, Int# -> Int
I# Int#
e# #) }
{-# INLINE unsafeWrite #-}
unsafeWrite :: STUArray s i Int -> Int -> Int -> ST s ()
unsafeWrite (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) (I# e# :: Int#
e#) = STRep s () -> ST s ()
forall s a. STRep s a -> ST s a
ST (STRep s () -> ST s ()) -> STRep s () -> ST s ()
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
forall d.
MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
writeIntArray# MutableByteArray# s
marr# Int#
i# Int#
e# State# s
s1# of { s2# :: State# s
s2# ->
(# State# s
s2#, () #) }
instance MArray (STUArray s) Word (ST s) where
{-# INLINE getBounds #-}
getBounds :: STUArray s i Word -> ST s (i, i)
getBounds (STUArray l :: i
l u :: i
u _ _) = (i, i) -> ST s (i, i)
forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
{-# INLINE getNumElements #-}
getNumElements :: STUArray s i Word -> ST s Int
getNumElements (STUArray _ _ n :: Int
n _) = Int -> ST s Int
forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
{-# INLINE unsafeNewArray_ #-}
unsafeNewArray_ :: (i, i) -> ST s (STUArray s i Word)
unsafeNewArray_ (l :: i
l,u :: i
u) = (i, i) -> (Int# -> Int#) -> ST s (STUArray s i Word)
forall i s e.
Ix i =>
(i, i) -> (Int# -> Int#) -> ST s (STUArray s i e)
unsafeNewArraySTUArray_ (i
l,i
u) Int# -> Int#
wORD_SCALE
{-# INLINE newArray_ #-}
newArray_ :: (i, i) -> ST s (STUArray s i Word)
newArray_ arrBounds :: (i, i)
arrBounds = (i, i) -> Word -> ST s (STUArray s i Word)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds 0
{-# INLINE unsafeRead #-}
unsafeRead :: STUArray s i Word -> Int -> ST s Word
unsafeRead (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) = STRep s Word -> ST s Word
forall s a. STRep s a -> ST s a
ST (STRep s Word -> ST s Word) -> STRep s Word -> ST s Word
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> State# s -> (# State# s, Word# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
readWordArray# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# s2# :: State# s
s2#, e# :: Word#
e# #) ->
(# State# s
s2#, Word# -> Word
W# Word#
e# #) }
{-# INLINE unsafeWrite #-}
unsafeWrite :: STUArray s i Word -> Int -> Word -> ST s ()
unsafeWrite (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) (W# e# :: Word#
e#) = STRep s () -> ST s ()
forall s a. STRep s a -> ST s a
ST (STRep s () -> ST s ()) -> STRep s () -> ST s ()
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
forall d.
MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
writeWordArray# MutableByteArray# s
marr# Int#
i# Word#
e# State# s
s1# of { s2# :: State# s
s2# ->
(# State# s
s2#, () #) }
instance MArray (STUArray s) (Ptr a) (ST s) where
{-# INLINE getBounds #-}
getBounds :: STUArray s i (Ptr a) -> ST s (i, i)
getBounds (STUArray l :: i
l u :: i
u _ _) = (i, i) -> ST s (i, i)
forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
{-# INLINE getNumElements #-}
getNumElements :: STUArray s i (Ptr a) -> ST s Int
getNumElements (STUArray _ _ n :: Int
n _) = Int -> ST s Int
forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
{-# INLINE unsafeNewArray_ #-}
unsafeNewArray_ :: (i, i) -> ST s (STUArray s i (Ptr a))
unsafeNewArray_ (l :: i
l,u :: i
u) = (i, i) -> (Int# -> Int#) -> ST s (STUArray s i (Ptr a))
forall i s e.
Ix i =>
(i, i) -> (Int# -> Int#) -> ST s (STUArray s i e)
unsafeNewArraySTUArray_ (i
l,i
u) Int# -> Int#
wORD_SCALE
{-# INLINE newArray_ #-}
newArray_ :: (i, i) -> ST s (STUArray s i (Ptr a))
newArray_ arrBounds :: (i, i)
arrBounds = (i, i) -> Ptr a -> ST s (STUArray s i (Ptr a))
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds Ptr a
forall a. Ptr a
nullPtr
{-# INLINE unsafeRead #-}
unsafeRead :: STUArray s i (Ptr a) -> Int -> ST s (Ptr a)
unsafeRead (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) = STRep s (Ptr a) -> ST s (Ptr a)
forall s a. STRep s a -> ST s a
ST (STRep s (Ptr a) -> ST s (Ptr a))
-> STRep s (Ptr a) -> ST s (Ptr a)
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> State# s -> (# State# s, Addr# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Addr# #)
readAddrArray# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# s2# :: State# s
s2#, e# :: Addr#
e# #) ->
(# State# s
s2#, Addr# -> Ptr a
forall a. Addr# -> Ptr a
Ptr Addr#
e# #) }
{-# INLINE unsafeWrite #-}
unsafeWrite :: STUArray s i (Ptr a) -> Int -> Ptr a -> ST s ()
unsafeWrite (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) (Ptr e# :: Addr#
e#) = STRep s () -> ST s ()
forall s a. STRep s a -> ST s a
ST (STRep s () -> ST s ()) -> STRep s () -> ST s ()
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> Addr# -> State# s -> State# s
forall d.
MutableByteArray# d -> Int# -> Addr# -> State# d -> State# d
writeAddrArray# MutableByteArray# s
marr# Int#
i# Addr#
e# State# s
s1# of { s2# :: State# s
s2# ->
(# State# s
s2#, () #) }
instance MArray (STUArray s) (FunPtr a) (ST s) where
{-# INLINE getBounds #-}
getBounds :: STUArray s i (FunPtr a) -> ST s (i, i)
getBounds (STUArray l :: i
l u :: i
u _ _) = (i, i) -> ST s (i, i)
forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
{-# INLINE getNumElements #-}
getNumElements :: STUArray s i (FunPtr a) -> ST s Int
getNumElements (STUArray _ _ n :: Int
n _) = Int -> ST s Int
forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
{-# INLINE unsafeNewArray_ #-}
unsafeNewArray_ :: (i, i) -> ST s (STUArray s i (FunPtr a))
unsafeNewArray_ (l :: i
l,u :: i
u) = (i, i) -> (Int# -> Int#) -> ST s (STUArray s i (FunPtr a))
forall i s e.
Ix i =>
(i, i) -> (Int# -> Int#) -> ST s (STUArray s i e)
unsafeNewArraySTUArray_ (i
l,i
u) Int# -> Int#
wORD_SCALE
{-# INLINE newArray_ #-}
newArray_ :: (i, i) -> ST s (STUArray s i (FunPtr a))
newArray_ arrBounds :: (i, i)
arrBounds = (i, i) -> FunPtr a -> ST s (STUArray s i (FunPtr a))
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds FunPtr a
forall a. FunPtr a
nullFunPtr
{-# INLINE unsafeRead #-}
unsafeRead :: STUArray s i (FunPtr a) -> Int -> ST s (FunPtr a)
unsafeRead (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) = STRep s (FunPtr a) -> ST s (FunPtr a)
forall s a. STRep s a -> ST s a
ST (STRep s (FunPtr a) -> ST s (FunPtr a))
-> STRep s (FunPtr a) -> ST s (FunPtr a)
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> State# s -> (# State# s, Addr# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Addr# #)
readAddrArray# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# s2# :: State# s
s2#, e# :: Addr#
e# #) ->
(# State# s
s2#, Addr# -> FunPtr a
forall a. Addr# -> FunPtr a
FunPtr Addr#
e# #) }
{-# INLINE unsafeWrite #-}
unsafeWrite :: STUArray s i (FunPtr a) -> Int -> FunPtr a -> ST s ()
unsafeWrite (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) (FunPtr e# :: Addr#
e#) = STRep s () -> ST s ()
forall s a. STRep s a -> ST s a
ST (STRep s () -> ST s ()) -> STRep s () -> ST s ()
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> Addr# -> State# s -> State# s
forall d.
MutableByteArray# d -> Int# -> Addr# -> State# d -> State# d
writeAddrArray# MutableByteArray# s
marr# Int#
i# Addr#
e# State# s
s1# of { s2# :: State# s
s2# ->
(# State# s
s2#, () #) }
instance MArray (STUArray s) Float (ST s) where
{-# INLINE getBounds #-}
getBounds :: STUArray s i Float -> ST s (i, i)
getBounds (STUArray l :: i
l u :: i
u _ _) = (i, i) -> ST s (i, i)
forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
{-# INLINE getNumElements #-}
getNumElements :: STUArray s i Float -> ST s Int
getNumElements (STUArray _ _ n :: Int
n _) = Int -> ST s Int
forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
{-# INLINE unsafeNewArray_ #-}
unsafeNewArray_ :: (i, i) -> ST s (STUArray s i Float)
unsafeNewArray_ (l :: i
l,u :: i
u) = (i, i) -> (Int# -> Int#) -> ST s (STUArray s i Float)
forall i s e.
Ix i =>
(i, i) -> (Int# -> Int#) -> ST s (STUArray s i e)
unsafeNewArraySTUArray_ (i
l,i
u) Int# -> Int#
fLOAT_SCALE
{-# INLINE newArray_ #-}
newArray_ :: (i, i) -> ST s (STUArray s i Float)
newArray_ arrBounds :: (i, i)
arrBounds = (i, i) -> Float -> ST s (STUArray s i Float)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds 0
{-# INLINE unsafeRead #-}
unsafeRead :: STUArray s i Float -> Int -> ST s Float
unsafeRead (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) = STRep s Float -> ST s Float
forall s a. STRep s a -> ST s a
ST (STRep s Float -> ST s Float) -> STRep s Float -> ST s Float
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> State# s -> (# State# s, Float# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Float# #)
readFloatArray# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# s2# :: State# s
s2#, e# :: Float#
e# #) ->
(# State# s
s2#, Float# -> Float
F# Float#
e# #) }
{-# INLINE unsafeWrite #-}
unsafeWrite :: STUArray s i Float -> Int -> Float -> ST s ()
unsafeWrite (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) (F# e# :: Float#
e#) = STRep s () -> ST s ()
forall s a. STRep s a -> ST s a
ST (STRep s () -> ST s ()) -> STRep s () -> ST s ()
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> Float# -> State# s -> State# s
forall d.
MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeFloatArray# MutableByteArray# s
marr# Int#
i# Float#
e# State# s
s1# of { s2# :: State# s
s2# ->
(# State# s
s2#, () #) }
instance MArray (STUArray s) Double (ST s) where
{-# INLINE getBounds #-}
getBounds :: STUArray s i Double -> ST s (i, i)
getBounds (STUArray l :: i
l u :: i
u _ _) = (i, i) -> ST s (i, i)
forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
{-# INLINE getNumElements #-}
getNumElements :: STUArray s i Double -> ST s Int
getNumElements (STUArray _ _ n :: Int
n _) = Int -> ST s Int
forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
{-# INLINE unsafeNewArray_ #-}
unsafeNewArray_ :: (i, i) -> ST s (STUArray s i Double)
unsafeNewArray_ (l :: i
l,u :: i
u) = (i, i) -> (Int# -> Int#) -> ST s (STUArray s i Double)
forall i s e.
Ix i =>
(i, i) -> (Int# -> Int#) -> ST s (STUArray s i e)
unsafeNewArraySTUArray_ (i
l,i
u) Int# -> Int#
dOUBLE_SCALE
{-# INLINE newArray_ #-}
newArray_ :: (i, i) -> ST s (STUArray s i Double)
newArray_ arrBounds :: (i, i)
arrBounds = (i, i) -> Double -> ST s (STUArray s i Double)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds 0
{-# INLINE unsafeRead #-}
unsafeRead :: STUArray s i Double -> Int -> ST s Double
unsafeRead (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) = STRep s Double -> ST s Double
forall s a. STRep s a -> ST s a
ST (STRep s Double -> ST s Double) -> STRep s Double -> ST s Double
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> State# s -> (# State# s, Double# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
readDoubleArray# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# s2# :: State# s
s2#, e# :: Double#
e# #) ->
(# State# s
s2#, Double# -> Double
D# Double#
e# #) }
{-# INLINE unsafeWrite #-}
unsafeWrite :: STUArray s i Double -> Int -> Double -> ST s ()
unsafeWrite (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) (D# e# :: Double#
e#) = STRep s () -> ST s ()
forall s a. STRep s a -> ST s a
ST (STRep s () -> ST s ()) -> STRep s () -> ST s ()
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> Double# -> State# s -> State# s
forall d.
MutableByteArray# d -> Int# -> Double# -> State# d -> State# d
writeDoubleArray# MutableByteArray# s
marr# Int#
i# Double#
e# State# s
s1# of { s2# :: State# s
s2# ->
(# State# s
s2#, () #) }
instance MArray (STUArray s) (StablePtr a) (ST s) where
{-# INLINE getBounds #-}
getBounds :: STUArray s i (StablePtr a) -> ST s (i, i)
getBounds (STUArray l :: i
l u :: i
u _ _) = (i, i) -> ST s (i, i)
forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
{-# INLINE getNumElements #-}
getNumElements :: STUArray s i (StablePtr a) -> ST s Int
getNumElements (STUArray _ _ n :: Int
n _) = Int -> ST s Int
forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
{-# INLINE unsafeNewArray_ #-}
unsafeNewArray_ :: (i, i) -> ST s (STUArray s i (StablePtr a))
unsafeNewArray_ (l :: i
l,u :: i
u) = (i, i) -> (Int# -> Int#) -> ST s (STUArray s i (StablePtr a))
forall i s e.
Ix i =>
(i, i) -> (Int# -> Int#) -> ST s (STUArray s i e)
unsafeNewArraySTUArray_ (i
l,i
u) Int# -> Int#
wORD_SCALE
{-# INLINE newArray_ #-}
newArray_ :: (i, i) -> ST s (STUArray s i (StablePtr a))
newArray_ arrBounds :: (i, i)
arrBounds = (i, i) -> StablePtr a -> ST s (STUArray s i (StablePtr a))
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds (Ptr () -> StablePtr a
forall a. Ptr () -> StablePtr a
castPtrToStablePtr Ptr ()
forall a. Ptr a
nullPtr)
{-# INLINE unsafeRead #-}
unsafeRead :: STUArray s i (StablePtr a) -> Int -> ST s (StablePtr a)
unsafeRead (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) = STRep s (StablePtr a) -> ST s (StablePtr a)
forall s a. STRep s a -> ST s a
ST (STRep s (StablePtr a) -> ST s (StablePtr a))
-> STRep s (StablePtr a) -> ST s (StablePtr a)
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s
-> Int# -> State# s -> (# State# s, StablePtr# a #)
forall d a.
MutableByteArray# d
-> Int# -> State# d -> (# State# d, StablePtr# a #)
readStablePtrArray# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# s2# :: State# s
s2#, e# :: StablePtr# a
e# #) ->
(# State# s
s2# , StablePtr# a -> StablePtr a
forall a. StablePtr# a -> StablePtr a
StablePtr StablePtr# a
e# #) }
{-# INLINE unsafeWrite #-}
unsafeWrite :: STUArray s i (StablePtr a) -> Int -> StablePtr a -> ST s ()
unsafeWrite (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) (StablePtr e# :: StablePtr# a
e#) = STRep s () -> ST s ()
forall s a. STRep s a -> ST s a
ST (STRep s () -> ST s ()) -> STRep s () -> ST s ()
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> StablePtr# a -> State# s -> State# s
forall d a.
MutableByteArray# d -> Int# -> StablePtr# a -> State# d -> State# d
writeStablePtrArray# MutableByteArray# s
marr# Int#
i# StablePtr# a
e# State# s
s1# of { s2# :: State# s
s2# ->
(# State# s
s2#, () #) }
instance MArray (STUArray s) Int8 (ST s) where
{-# INLINE getBounds #-}
getBounds :: STUArray s i Int8 -> ST s (i, i)
getBounds (STUArray l :: i
l u :: i
u _ _) = (i, i) -> ST s (i, i)
forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
{-# INLINE getNumElements #-}
getNumElements :: STUArray s i Int8 -> ST s Int
getNumElements (STUArray _ _ n :: Int
n _) = Int -> ST s Int
forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
{-# INLINE unsafeNewArray_ #-}
unsafeNewArray_ :: (i, i) -> ST s (STUArray s i Int8)
unsafeNewArray_ (l :: i
l,u :: i
u) = (i, i) -> (Int# -> Int#) -> ST s (STUArray s i Int8)
forall i s e.
Ix i =>
(i, i) -> (Int# -> Int#) -> ST s (STUArray s i e)
unsafeNewArraySTUArray_ (i
l,i
u) (\x :: Int#
x -> Int#
x)
{-# INLINE newArray_ #-}
newArray_ :: (i, i) -> ST s (STUArray s i Int8)
newArray_ arrBounds :: (i, i)
arrBounds = (i, i) -> Int8 -> ST s (STUArray s i Int8)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds 0
{-# INLINE unsafeRead #-}
unsafeRead :: STUArray s i Int8 -> Int -> ST s Int8
unsafeRead (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) = STRep s Int8 -> ST s Int8
forall s a. STRep s a -> ST s a
ST (STRep s Int8 -> ST s Int8) -> STRep s Int8 -> ST s Int8
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> State# s -> (# State# s, Int# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
readInt8Array# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# s2# :: State# s
s2#, e# :: Int#
e# #) ->
(# State# s
s2#, Int# -> Int8
I8# Int#
e# #) }
{-# INLINE unsafeWrite #-}
unsafeWrite :: STUArray s i Int8 -> Int -> Int8 -> ST s ()
unsafeWrite (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) (I8# e# :: Int#
e#) = STRep s () -> ST s ()
forall s a. STRep s a -> ST s a
ST (STRep s () -> ST s ()) -> STRep s () -> ST s ()
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
forall d.
MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
writeInt8Array# MutableByteArray# s
marr# Int#
i# Int#
e# State# s
s1# of { s2# :: State# s
s2# ->
(# State# s
s2#, () #) }
instance MArray (STUArray s) Int16 (ST s) where
{-# INLINE getBounds #-}
getBounds :: STUArray s i Int16 -> ST s (i, i)
getBounds (STUArray l :: i
l u :: i
u _ _) = (i, i) -> ST s (i, i)
forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
{-# INLINE getNumElements #-}
getNumElements :: STUArray s i Int16 -> ST s Int
getNumElements (STUArray _ _ n :: Int
n _) = Int -> ST s Int
forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
{-# INLINE unsafeNewArray_ #-}
unsafeNewArray_ :: (i, i) -> ST s (STUArray s i Int16)
unsafeNewArray_ (l :: i
l,u :: i
u) = (i, i) -> (Int# -> Int#) -> ST s (STUArray s i Int16)
forall i s e.
Ix i =>
(i, i) -> (Int# -> Int#) -> ST s (STUArray s i e)
unsafeNewArraySTUArray_ (i
l,i
u) (Int# -> Int# -> Int#
safe_scale 2#)
{-# INLINE newArray_ #-}
newArray_ :: (i, i) -> ST s (STUArray s i Int16)
newArray_ arrBounds :: (i, i)
arrBounds = (i, i) -> Int16 -> ST s (STUArray s i Int16)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds 0
{-# INLINE unsafeRead #-}
unsafeRead :: STUArray s i Int16 -> Int -> ST s Int16
unsafeRead (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) = STRep s Int16 -> ST s Int16
forall s a. STRep s a -> ST s a
ST (STRep s Int16 -> ST s Int16) -> STRep s Int16 -> ST s Int16
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> State# s -> (# State# s, Int# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
readInt16Array# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# s2# :: State# s
s2#, e# :: Int#
e# #) ->
(# State# s
s2#, Int# -> Int16
I16# Int#
e# #) }
{-# INLINE unsafeWrite #-}
unsafeWrite :: STUArray s i Int16 -> Int -> Int16 -> ST s ()
unsafeWrite (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) (I16# e# :: Int#
e#) = STRep s () -> ST s ()
forall s a. STRep s a -> ST s a
ST (STRep s () -> ST s ()) -> STRep s () -> ST s ()
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
forall d.
MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
writeInt16Array# MutableByteArray# s
marr# Int#
i# Int#
e# State# s
s1# of { s2# :: State# s
s2# ->
(# State# s
s2#, () #) }
instance MArray (STUArray s) Int32 (ST s) where
{-# INLINE getBounds #-}
getBounds :: STUArray s i Int32 -> ST s (i, i)
getBounds (STUArray l :: i
l u :: i
u _ _) = (i, i) -> ST s (i, i)
forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
{-# INLINE getNumElements #-}
getNumElements :: STUArray s i Int32 -> ST s Int
getNumElements (STUArray _ _ n :: Int
n _) = Int -> ST s Int
forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
{-# INLINE unsafeNewArray_ #-}
unsafeNewArray_ :: (i, i) -> ST s (STUArray s i Int32)
unsafeNewArray_ (l :: i
l,u :: i
u) = (i, i) -> (Int# -> Int#) -> ST s (STUArray s i Int32)
forall i s e.
Ix i =>
(i, i) -> (Int# -> Int#) -> ST s (STUArray s i e)
unsafeNewArraySTUArray_ (i
l,i
u) (Int# -> Int# -> Int#
safe_scale 4#)
{-# INLINE newArray_ #-}
newArray_ :: (i, i) -> ST s (STUArray s i Int32)
newArray_ arrBounds :: (i, i)
arrBounds = (i, i) -> Int32 -> ST s (STUArray s i Int32)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds 0
{-# INLINE unsafeRead #-}
unsafeRead :: STUArray s i Int32 -> Int -> ST s Int32
unsafeRead (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) = STRep s Int32 -> ST s Int32
forall s a. STRep s a -> ST s a
ST (STRep s Int32 -> ST s Int32) -> STRep s Int32 -> ST s Int32
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> State# s -> (# State# s, Int# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
readInt32Array# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# s2# :: State# s
s2#, e# :: Int#
e# #) ->
(# State# s
s2#, Int# -> Int32
I32# Int#
e# #) }
{-# INLINE unsafeWrite #-}
unsafeWrite :: STUArray s i Int32 -> Int -> Int32 -> ST s ()
unsafeWrite (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) (I32# e# :: Int#
e#) = STRep s () -> ST s ()
forall s a. STRep s a -> ST s a
ST (STRep s () -> ST s ()) -> STRep s () -> ST s ()
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
forall d.
MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
writeInt32Array# MutableByteArray# s
marr# Int#
i# Int#
e# State# s
s1# of { s2# :: State# s
s2# ->
(# State# s
s2#, () #) }
instance MArray (STUArray s) Int64 (ST s) where
{-# INLINE getBounds #-}
getBounds :: STUArray s i Int64 -> ST s (i, i)
getBounds (STUArray l :: i
l u :: i
u _ _) = (i, i) -> ST s (i, i)
forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
{-# INLINE getNumElements #-}
getNumElements :: STUArray s i Int64 -> ST s Int
getNumElements (STUArray _ _ n :: Int
n _) = Int -> ST s Int
forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
{-# INLINE unsafeNewArray_ #-}
unsafeNewArray_ :: (i, i) -> ST s (STUArray s i Int64)
unsafeNewArray_ (l :: i
l,u :: i
u) = (i, i) -> (Int# -> Int#) -> ST s (STUArray s i Int64)
forall i s e.
Ix i =>
(i, i) -> (Int# -> Int#) -> ST s (STUArray s i e)
unsafeNewArraySTUArray_ (i
l,i
u) (Int# -> Int# -> Int#
safe_scale 8#)
{-# INLINE newArray_ #-}
newArray_ :: (i, i) -> ST s (STUArray s i Int64)
newArray_ arrBounds :: (i, i)
arrBounds = (i, i) -> Int64 -> ST s (STUArray s i Int64)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds 0
{-# INLINE unsafeRead #-}
unsafeRead :: STUArray s i Int64 -> Int -> ST s Int64
unsafeRead (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) = STRep s Int64 -> ST s Int64
forall s a. STRep s a -> ST s a
ST (STRep s Int64 -> ST s Int64) -> STRep s Int64 -> ST s Int64
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> State# s -> (# State# s, Int# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
readInt64Array# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# s2# :: State# s
s2#, e# :: Int#
e# #) ->
(# State# s
s2#, Int# -> Int64
I64# Int#
e# #) }
{-# INLINE unsafeWrite #-}
unsafeWrite :: STUArray s i Int64 -> Int -> Int64 -> ST s ()
unsafeWrite (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) (I64# e# :: Int#
e#) = STRep s () -> ST s ()
forall s a. STRep s a -> ST s a
ST (STRep s () -> ST s ()) -> STRep s () -> ST s ()
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> Int# -> State# s -> State# s
forall d.
MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
writeInt64Array# MutableByteArray# s
marr# Int#
i# Int#
e# State# s
s1# of { s2# :: State# s
s2# ->
(# State# s
s2#, () #) }
instance MArray (STUArray s) Word8 (ST s) where
{-# INLINE getBounds #-}
getBounds :: STUArray s i Word8 -> ST s (i, i)
getBounds (STUArray l :: i
l u :: i
u _ _) = (i, i) -> ST s (i, i)
forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
{-# INLINE getNumElements #-}
getNumElements :: STUArray s i Word8 -> ST s Int
getNumElements (STUArray _ _ n :: Int
n _) = Int -> ST s Int
forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
{-# INLINE unsafeNewArray_ #-}
unsafeNewArray_ :: (i, i) -> ST s (STUArray s i Word8)
unsafeNewArray_ (l :: i
l,u :: i
u) = (i, i) -> (Int# -> Int#) -> ST s (STUArray s i Word8)
forall i s e.
Ix i =>
(i, i) -> (Int# -> Int#) -> ST s (STUArray s i e)
unsafeNewArraySTUArray_ (i
l,i
u) (\x :: Int#
x -> Int#
x)
{-# INLINE newArray_ #-}
newArray_ :: (i, i) -> ST s (STUArray s i Word8)
newArray_ arrBounds :: (i, i)
arrBounds = (i, i) -> Word8 -> ST s (STUArray s i Word8)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds 0
{-# INLINE unsafeRead #-}
unsafeRead :: STUArray s i Word8 -> Int -> ST s Word8
unsafeRead (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) = STRep s Word8 -> ST s Word8
forall s a. STRep s a -> ST s a
ST (STRep s Word8 -> ST s Word8) -> STRep s Word8 -> ST s Word8
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> State# s -> (# State# s, Word# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
readWord8Array# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# s2# :: State# s
s2#, e# :: Word#
e# #) ->
(# State# s
s2#, Word# -> Word8
W8# Word#
e# #) }
{-# INLINE unsafeWrite #-}
unsafeWrite :: STUArray s i Word8 -> Int -> Word8 -> ST s ()
unsafeWrite (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) (W8# e# :: Word#
e#) = STRep s () -> ST s ()
forall s a. STRep s a -> ST s a
ST (STRep s () -> ST s ()) -> STRep s () -> ST s ()
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
forall d.
MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
writeWord8Array# MutableByteArray# s
marr# Int#
i# Word#
e# State# s
s1# of { s2# :: State# s
s2# ->
(# State# s
s2#, () #) }
instance MArray (STUArray s) Word16 (ST s) where
{-# INLINE getBounds #-}
getBounds :: STUArray s i Word16 -> ST s (i, i)
getBounds (STUArray l :: i
l u :: i
u _ _) = (i, i) -> ST s (i, i)
forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
{-# INLINE getNumElements #-}
getNumElements :: STUArray s i Word16 -> ST s Int
getNumElements (STUArray _ _ n :: Int
n _) = Int -> ST s Int
forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
{-# INLINE unsafeNewArray_ #-}
unsafeNewArray_ :: (i, i) -> ST s (STUArray s i Word16)
unsafeNewArray_ (l :: i
l,u :: i
u) = (i, i) -> (Int# -> Int#) -> ST s (STUArray s i Word16)
forall i s e.
Ix i =>
(i, i) -> (Int# -> Int#) -> ST s (STUArray s i e)
unsafeNewArraySTUArray_ (i
l,i
u) (Int# -> Int# -> Int#
safe_scale 2#)
{-# INLINE newArray_ #-}
newArray_ :: (i, i) -> ST s (STUArray s i Word16)
newArray_ arrBounds :: (i, i)
arrBounds = (i, i) -> Word16 -> ST s (STUArray s i Word16)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds 0
{-# INLINE unsafeRead #-}
unsafeRead :: STUArray s i Word16 -> Int -> ST s Word16
unsafeRead (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) = STRep s Word16 -> ST s Word16
forall s a. STRep s a -> ST s a
ST (STRep s Word16 -> ST s Word16) -> STRep s Word16 -> ST s Word16
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> State# s -> (# State# s, Word# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
readWord16Array# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# s2# :: State# s
s2#, e# :: Word#
e# #) ->
(# State# s
s2#, Word# -> Word16
W16# Word#
e# #) }
{-# INLINE unsafeWrite #-}
unsafeWrite :: STUArray s i Word16 -> Int -> Word16 -> ST s ()
unsafeWrite (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) (W16# e# :: Word#
e#) = STRep s () -> ST s ()
forall s a. STRep s a -> ST s a
ST (STRep s () -> ST s ()) -> STRep s () -> ST s ()
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
forall d.
MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
writeWord16Array# MutableByteArray# s
marr# Int#
i# Word#
e# State# s
s1# of { s2# :: State# s
s2# ->
(# State# s
s2#, () #) }
instance MArray (STUArray s) Word32 (ST s) where
{-# INLINE getBounds #-}
getBounds :: STUArray s i Word32 -> ST s (i, i)
getBounds (STUArray l :: i
l u :: i
u _ _) = (i, i) -> ST s (i, i)
forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
{-# INLINE getNumElements #-}
getNumElements :: STUArray s i Word32 -> ST s Int
getNumElements (STUArray _ _ n :: Int
n _) = Int -> ST s Int
forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
{-# INLINE unsafeNewArray_ #-}
unsafeNewArray_ :: (i, i) -> ST s (STUArray s i Word32)
unsafeNewArray_ (l :: i
l,u :: i
u) = (i, i) -> (Int# -> Int#) -> ST s (STUArray s i Word32)
forall i s e.
Ix i =>
(i, i) -> (Int# -> Int#) -> ST s (STUArray s i e)
unsafeNewArraySTUArray_ (i
l,i
u) (Int# -> Int# -> Int#
safe_scale 4#)
{-# INLINE newArray_ #-}
newArray_ :: (i, i) -> ST s (STUArray s i Word32)
newArray_ arrBounds :: (i, i)
arrBounds = (i, i) -> Word32 -> ST s (STUArray s i Word32)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds 0
{-# INLINE unsafeRead #-}
unsafeRead :: STUArray s i Word32 -> Int -> ST s Word32
unsafeRead (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) = STRep s Word32 -> ST s Word32
forall s a. STRep s a -> ST s a
ST (STRep s Word32 -> ST s Word32) -> STRep s Word32 -> ST s Word32
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> State# s -> (# State# s, Word# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
readWord32Array# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# s2# :: State# s
s2#, e# :: Word#
e# #) ->
(# State# s
s2#, Word# -> Word32
W32# Word#
e# #) }
{-# INLINE unsafeWrite #-}
unsafeWrite :: STUArray s i Word32 -> Int -> Word32 -> ST s ()
unsafeWrite (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) (W32# e# :: Word#
e#) = STRep s () -> ST s ()
forall s a. STRep s a -> ST s a
ST (STRep s () -> ST s ()) -> STRep s () -> ST s ()
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
forall d.
MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
writeWord32Array# MutableByteArray# s
marr# Int#
i# Word#
e# State# s
s1# of { s2# :: State# s
s2# ->
(# State# s
s2#, () #) }
instance MArray (STUArray s) Word64 (ST s) where
{-# INLINE getBounds #-}
getBounds :: STUArray s i Word64 -> ST s (i, i)
getBounds (STUArray l :: i
l u :: i
u _ _) = (i, i) -> ST s (i, i)
forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
{-# INLINE getNumElements #-}
getNumElements :: STUArray s i Word64 -> ST s Int
getNumElements (STUArray _ _ n :: Int
n _) = Int -> ST s Int
forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
{-# INLINE unsafeNewArray_ #-}
unsafeNewArray_ :: (i, i) -> ST s (STUArray s i Word64)
unsafeNewArray_ (l :: i
l,u :: i
u) = (i, i) -> (Int# -> Int#) -> ST s (STUArray s i Word64)
forall i s e.
Ix i =>
(i, i) -> (Int# -> Int#) -> ST s (STUArray s i e)
unsafeNewArraySTUArray_ (i
l,i
u) (Int# -> Int# -> Int#
safe_scale 8#)
{-# INLINE newArray_ #-}
newArray_ :: (i, i) -> ST s (STUArray s i Word64)
newArray_ arrBounds :: (i, i)
arrBounds = (i, i) -> Word64 -> ST s (STUArray s i Word64)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds 0
{-# INLINE unsafeRead #-}
unsafeRead :: STUArray s i Word64 -> Int -> ST s Word64
unsafeRead (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) = STRep s Word64 -> ST s Word64
forall s a. STRep s a -> ST s a
ST (STRep s Word64 -> ST s Word64) -> STRep s Word64 -> ST s Word64
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> State# s -> (# State# s, Word# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
readWord64Array# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# s2# :: State# s
s2#, e# :: Word#
e# #) ->
(# State# s
s2#, Word# -> Word64
W64# Word#
e# #) }
{-# INLINE unsafeWrite #-}
unsafeWrite :: STUArray s i Word64 -> Int -> Word64 -> ST s ()
unsafeWrite (STUArray _ _ _ marr# :: MutableByteArray# s
marr#) (I# i# :: Int#
i#) (W64# e# :: Word#
e#) = STRep s () -> ST s ()
forall s a. STRep s a -> ST s a
ST (STRep s () -> ST s ()) -> STRep s () -> ST s ()
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int# -> Word# -> State# s -> State# s
forall d.
MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
writeWord64Array# MutableByteArray# s
marr# Int#
i# Word#
e# State# s
s1# of { s2# :: State# s
s2# ->
(# State# s
s2#, () #) }
bOOL_SCALE, wORD_SCALE, dOUBLE_SCALE, fLOAT_SCALE :: Int# -> Int#
bOOL_SCALE :: Int# -> Int#
bOOL_SCALE n# :: Int#
n# =
(Int#
n# Int# -> Int# -> Int#
+# 7#) Int# -> Int# -> Int#
`uncheckedIShiftRA#` 3#
wORD_SCALE :: Int# -> Int#
wORD_SCALE n# :: Int#
n# = Int# -> Int# -> Int#
safe_scale Int#
scale# Int#
n# where !(I# scale# :: Int#
scale#) = SIZEOF_HSWORD
dOUBLE_SCALE :: Int# -> Int#
dOUBLE_SCALE n# :: Int#
n# = Int# -> Int# -> Int#
safe_scale Int#
scale# Int#
n# where !(I# scale# :: Int#
scale#) = SIZEOF_HSDOUBLE
fLOAT_SCALE :: Int# -> Int#
fLOAT_SCALE n# :: Int#
n# = Int# -> Int# -> Int#
safe_scale Int#
scale# Int#
n# where !(I# scale# :: Int#
scale#) = SIZEOF_HSFLOAT
safe_scale :: Int# -> Int# -> Int#
safe_scale :: Int# -> Int# -> Int#
safe_scale scale# :: Int#
scale# n# :: Int#
n#
| Bool -> Bool
not Bool
overflow = Int#
res#
| Bool
otherwise = [Char] -> Int#
forall a. HasCallStack => [Char] -> a
error ([Char] -> Int#) -> [Char] -> Int#
forall a b. (a -> b) -> a -> b
$ "Data.Array.Base.safe_scale: Overflow; scale: "
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show (Int# -> Int
I# Int#
scale#) [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ ", n: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show (Int# -> Int
I# Int#
n#)
where
!res# :: Int#
res# = Int#
scale# Int# -> Int# -> Int#
*# Int#
n#
!overflow :: Bool
overflow = Int# -> Bool
isTrue# (Int#
maxN# Int# -> Int# -> Int#
`divInt#` Int#
scale# Int# -> Int# -> Int#
<# Int#
n#)
!(I# maxN# :: Int#
maxN#) = Int
forall a. Bounded a => a
maxBound
{-# INLINE safe_scale #-}
bOOL_INDEX :: Int# -> Int#
#if SIZEOF_HSWORD == 4
bOOL_INDEX i# = i# `uncheckedIShiftRA#` 5#
#elif SIZEOF_HSWORD == 8
bOOL_INDEX :: Int# -> Int#
bOOL_INDEX i# :: Int#
i# = Int#
i# Int# -> Int# -> Int#
`uncheckedIShiftRA#` 6#
#endif
bOOL_BIT, bOOL_NOT_BIT :: Int# -> Word#
bOOL_BIT :: Int# -> Word#
bOOL_BIT n# :: Int#
n# = Int# -> Word#
int2Word# 1# Word# -> Int# -> Word#
`uncheckedShiftL#` (Word# -> Int#
word2Int# (Int# -> Word#
int2Word# Int#
n# Word# -> Word# -> Word#
`and#` Word#
mask#))
where !(W# mask# :: Word#
mask#) = SIZEOF_HSWORD * 8 - 1
bOOL_NOT_BIT :: Int# -> Word#
bOOL_NOT_BIT n# :: Int#
n# = Int# -> Word#
bOOL_BIT Int#
n# Word# -> Word# -> Word#
`xor#` Word#
mb#
where !(W# mb# :: Word#
mb#) = Word
forall a. Bounded a => a
maxBound
freeze :: (Ix i, MArray a e m, IArray b e) => a i e -> m (b i e)
{-# NOINLINE [1] freeze #-}
freeze :: a i e -> m (b i e)
freeze marr :: a i e
marr = do
(l :: i
l,u :: i
u) <- a i e -> m (i, i)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m (i, i)
getBounds a i e
marr
Int
n <- a i e -> m Int
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m Int
getNumElements a i e
marr
[e]
es <- (Int -> m e) -> [Int] -> m [e]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (a i e -> Int -> m e
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> m e
unsafeRead a i e
marr) [0 .. Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- 1]
b i e -> m (b i e)
forall (m :: * -> *) a. Monad m => a -> m a
return ((i, i) -> [e] -> b i e
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
(i, i) -> [e] -> a i e
listArray (i
l,i
u) [e]
es)
freezeSTUArray :: STUArray s i e -> ST s (UArray i e)
freezeSTUArray :: STUArray s i e -> ST s (UArray i e)
freezeSTUArray (STUArray l :: i
l u :: i
u n :: Int
n marr# :: MutableByteArray# s
marr#) = STRep s (UArray i e) -> ST s (UArray i e)
forall s a. STRep s a -> ST s a
ST (STRep s (UArray i e) -> ST s (UArray i e))
-> STRep s (UArray i e) -> ST s (UArray i e)
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case MutableByteArray# s -> Int#
forall d. MutableByteArray# d -> Int#
sizeofMutableByteArray# MutableByteArray# s
marr# of { n# :: Int#
n# ->
case Int# -> State# s -> (# State# s, MutableByteArray# s #)
forall d. Int# -> State# d -> (# State# d, MutableByteArray# d #)
newByteArray# Int#
n# State# s
s1# of { (# s2# :: State# s
s2#, marr'# :: MutableByteArray# s
marr'# #) ->
case MutableByteArray# s -> MutableByteArray# s -> CSize -> IO (Ptr Any)
forall s a.
MutableByteArray# s -> MutableByteArray# s -> CSize -> IO (Ptr a)
memcpy_freeze MutableByteArray# s
marr'# MutableByteArray# s
marr# (Int -> CSize
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int# -> Int
I# Int#
n#)) of { IO m :: State# RealWorld -> (# State# RealWorld, Ptr Any #)
m ->
case (State# RealWorld -> (# State# RealWorld, Ptr Any #))
-> State# s -> (# State# s, Any #)
unsafeCoerce# State# RealWorld -> (# State# RealWorld, Ptr Any #)
m State# s
s2# of { (# s3# :: State# s
s3#, _ #) ->
case MutableByteArray# s -> State# s -> (# State# s, ByteArray# #)
forall d.
MutableByteArray# d -> State# d -> (# State# d, ByteArray# #)
unsafeFreezeByteArray# MutableByteArray# s
marr'# State# s
s3# of { (# s4# :: State# s
s4#, arr# :: ByteArray#
arr# #) ->
(# State# s
s4#, i -> i -> Int -> ByteArray# -> UArray i e
forall i e. i -> i -> Int -> ByteArray# -> UArray i e
UArray i
l i
u Int
n ByteArray#
arr# #) }}}}}
foreign import ccall unsafe "memcpy"
memcpy_freeze :: MutableByteArray# s -> MutableByteArray# s -> CSize
-> IO (Ptr a)
{-# RULES
"freeze/STArray" freeze = ArrST.freezeSTArray
"freeze/STUArray" freeze = freezeSTUArray
#-}
{-# INLINE [1] unsafeFreeze #-}
unsafeFreeze :: (Ix i, MArray a e m, IArray b e) => a i e -> m (b i e)
unsafeFreeze :: a i e -> m (b i e)
unsafeFreeze = a i e -> m (b i e)
forall i (a :: * -> * -> *) e (m :: * -> *) (b :: * -> * -> *).
(Ix i, MArray a e m, IArray b e) =>
a i e -> m (b i e)
freeze
{-# RULES
"unsafeFreeze/STArray" unsafeFreeze = ArrST.unsafeFreezeSTArray
"unsafeFreeze/STUArray" unsafeFreeze = unsafeFreezeSTUArray
#-}
thaw :: (Ix i, IArray a e, MArray b e m) => a i e -> m (b i e)
{-# NOINLINE [1] thaw #-}
thaw :: a i e -> m (b i e)
thaw arr :: a i e
arr = case a i e -> (i, i)
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> (i, i)
bounds a i e
arr of
(l :: i
l,u :: i
u) -> do
b i e
marr <- (i, i) -> m (b i e)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> m (a i e)
newArray_ (i
l,i
u)
let n :: Int
n = (i, i) -> Int
forall a. Ix a => (a, a) -> Int
safeRangeSize (i
l,i
u)
[m ()] -> m ()
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_ [ b i e -> Int -> e -> m ()
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> e -> m ()
unsafeWrite b i e
marr Int
i (a i e -> Int -> e
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> Int -> e
unsafeAt a i e
arr Int
i)
| Int
i <- [0 .. Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- 1]]
b i e -> m (b i e)
forall (m :: * -> *) a. Monad m => a -> m a
return b i e
marr
thawSTUArray :: UArray i e -> ST s (STUArray s i e)
thawSTUArray :: UArray i e -> ST s (STUArray s i e)
thawSTUArray (UArray l :: i
l u :: i
u n :: Int
n arr# :: ByteArray#
arr#) = STRep s (STUArray s i e) -> ST s (STUArray s i e)
forall s a. STRep s a -> ST s a
ST (STRep s (STUArray s i e) -> ST s (STUArray s i e))
-> STRep s (STUArray s i e) -> ST s (STUArray s i e)
forall a b. (a -> b) -> a -> b
$ \s1# :: State# s
s1# ->
case ByteArray# -> Int#
sizeofByteArray# ByteArray#
arr# of { n# :: Int#
n# ->
case Int# -> State# s -> (# State# s, MutableByteArray# s #)
forall d. Int# -> State# d -> (# State# d, MutableByteArray# d #)
newByteArray# Int#
n# State# s
s1# of { (# s2# :: State# s
s2#, marr# :: MutableByteArray# s
marr# #) ->
case MutableByteArray# s -> ByteArray# -> CSize -> IO (Ptr Any)
forall s a.
MutableByteArray# s -> ByteArray# -> CSize -> IO (Ptr a)
memcpy_thaw MutableByteArray# s
marr# ByteArray#
arr# (Int -> CSize
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int# -> Int
I# Int#
n#)) of { IO m :: State# RealWorld -> (# State# RealWorld, Ptr Any #)
m ->
case (State# RealWorld -> (# State# RealWorld, Ptr Any #))
-> State# s -> (# State# s, Any #)
unsafeCoerce# State# RealWorld -> (# State# RealWorld, Ptr Any #)
m State# s
s2# of { (# s3# :: State# s
s3#, _ #) ->
(# State# s
s3#, i -> i -> Int -> MutableByteArray# s -> STUArray s i e
forall s i e.
i -> i -> Int -> MutableByteArray# s -> STUArray s i e
STUArray i
l i
u Int
n MutableByteArray# s
marr# #) }}}}
foreign import ccall unsafe "memcpy"
memcpy_thaw :: MutableByteArray# s -> ByteArray# -> CSize
-> IO (Ptr a)
{-# RULES
"thaw/STArray" thaw = ArrST.thawSTArray
"thaw/STUArray" thaw = thawSTUArray
#-}
{-# INLINE [1] unsafeThaw #-}
unsafeThaw :: (Ix i, IArray a e, MArray b e m) => a i e -> m (b i e)
unsafeThaw :: a i e -> m (b i e)
unsafeThaw = a i e -> m (b i e)
forall i (a :: * -> * -> *) e (b :: * -> * -> *) (m :: * -> *).
(Ix i, IArray a e, MArray b e m) =>
a i e -> m (b i e)
thaw
{-# INLINE unsafeThawSTUArray #-}
unsafeThawSTUArray :: UArray i e -> ST s (STUArray s i e)
unsafeThawSTUArray :: UArray i e -> ST s (STUArray s i e)
unsafeThawSTUArray (UArray l :: i
l u :: i
u n :: Int
n marr# :: ByteArray#
marr#) =
STUArray s i e -> ST s (STUArray s i e)
forall (m :: * -> *) a. Monad m => a -> m a
return (i -> i -> Int -> MutableByteArray# s -> STUArray s i e
forall s i e.
i -> i -> Int -> MutableByteArray# s -> STUArray s i e
STUArray i
l i
u Int
n (ByteArray# -> MutableByteArray# s
unsafeCoerce# ByteArray#
marr#))
{-# RULES
"unsafeThaw/STArray" unsafeThaw = ArrST.unsafeThawSTArray
"unsafeThaw/STUArray" unsafeThaw = unsafeThawSTUArray
#-}
{-# INLINE unsafeThawIOArray #-}
unsafeThawIOArray :: Arr.Array ix e -> IO (IOArray ix e)
unsafeThawIOArray :: Array ix e -> IO (IOArray ix e)
unsafeThawIOArray arr :: Array ix e
arr = ST RealWorld (IOArray ix e) -> IO (IOArray ix e)
forall a. ST RealWorld a -> IO a
stToIO (ST RealWorld (IOArray ix e) -> IO (IOArray ix e))
-> ST RealWorld (IOArray ix e) -> IO (IOArray ix e)
forall a b. (a -> b) -> a -> b
$ do
STArray RealWorld ix e
marr <- Array ix e -> ST RealWorld (STArray RealWorld ix e)
forall i e s. Array i e -> ST s (STArray s i e)
ArrST.unsafeThawSTArray Array ix e
arr
IOArray ix e -> ST RealWorld (IOArray ix e)
forall (m :: * -> *) a. Monad m => a -> m a
return (STArray RealWorld ix e -> IOArray ix e
forall i e. STArray RealWorld i e -> IOArray i e
IOArray STArray RealWorld ix e
marr)
{-# RULES
"unsafeThaw/IOArray" unsafeThaw = unsafeThawIOArray
#-}
thawIOArray :: Arr.Array ix e -> IO (IOArray ix e)
thawIOArray :: Array ix e -> IO (IOArray ix e)
thawIOArray arr :: Array ix e
arr = ST RealWorld (IOArray ix e) -> IO (IOArray ix e)
forall a. ST RealWorld a -> IO a
stToIO (ST RealWorld (IOArray ix e) -> IO (IOArray ix e))
-> ST RealWorld (IOArray ix e) -> IO (IOArray ix e)
forall a b. (a -> b) -> a -> b
$ do
STArray RealWorld ix e
marr <- Array ix e -> ST RealWorld (STArray RealWorld ix e)
forall i e s. Array i e -> ST s (STArray s i e)
ArrST.thawSTArray Array ix e
arr
IOArray ix e -> ST RealWorld (IOArray ix e)
forall (m :: * -> *) a. Monad m => a -> m a
return (STArray RealWorld ix e -> IOArray ix e
forall i e. STArray RealWorld i e -> IOArray i e
IOArray STArray RealWorld ix e
marr)
{-# RULES
"thaw/IOArray" thaw = thawIOArray
#-}
freezeIOArray :: IOArray ix e -> IO (Arr.Array ix e)
freezeIOArray :: IOArray ix e -> IO (Array ix e)
freezeIOArray (IOArray marr :: STArray RealWorld ix e
marr) = ST RealWorld (Array ix e) -> IO (Array ix e)
forall a. ST RealWorld a -> IO a
stToIO (STArray RealWorld ix e -> ST RealWorld (Array ix e)
forall s i e. STArray s i e -> ST s (Array i e)
ArrST.freezeSTArray STArray RealWorld ix e
marr)
{-# RULES
"freeze/IOArray" freeze = freezeIOArray
#-}
{-# INLINE unsafeFreezeIOArray #-}
unsafeFreezeIOArray :: IOArray ix e -> IO (Arr.Array ix e)
unsafeFreezeIOArray :: IOArray ix e -> IO (Array ix e)
unsafeFreezeIOArray (IOArray marr :: STArray RealWorld ix e
marr) = ST RealWorld (Array ix e) -> IO (Array ix e)
forall a. ST RealWorld a -> IO a
stToIO (STArray RealWorld ix e -> ST RealWorld (Array ix e)
forall s i e. STArray s i e -> ST s (Array i e)
ArrST.unsafeFreezeSTArray STArray RealWorld ix e
marr)
{-# RULES
"unsafeFreeze/IOArray" unsafeFreeze = unsafeFreezeIOArray
#-}
castSTUArray :: STUArray s ix a -> ST s (STUArray s ix b)
castSTUArray :: STUArray s ix a -> ST s (STUArray s ix b)
castSTUArray (STUArray l :: ix
l u :: ix
u n :: Int
n marr# :: MutableByteArray# s
marr#) = STUArray s ix b -> ST s (STUArray s ix b)
forall (m :: * -> *) a. Monad m => a -> m a
return (ix -> ix -> Int -> MutableByteArray# s -> STUArray s ix b
forall s i e.
i -> i -> Int -> MutableByteArray# s -> STUArray s i e
STUArray ix
l ix
u Int
n MutableByteArray# s
marr#)