{-# 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 a i e
arr [(Int, e)]
ies = forall a. (forall s. ST s a) -> a
runST (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 forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall i (a :: * -> * -> *) e (m :: * -> *) (b :: * -> * -> *).
(Ix i, MArray a e m, IArray b e) =>
a i e -> m (b i e)
unsafeFreeze)
    unsafeAccum e -> e' -> e
f a i e
arr [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall i (a :: * -> * -> *) e (m :: * -> *) (b :: * -> * -> *).
(Ix i, MArray a e m, IArray b e) =>
a i e -> m (b i e)
unsafeFreeze)
    unsafeAccumArray e -> e' -> e
f e
e (i, i)
lu [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= 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 :: forall i. Ix i => (i, i) -> Int
safeRangeSize (i
l,i
u) = let r :: Int
r = forall i. Ix i => (i, i) -> Int
rangeSize (i
l, i
u)
                      in if Int
r forall a. Ord a => a -> a -> Bool
< Int
0 then forall a. HasCallStack => [Char] -> a
error [Char]
"Negative range size"
                                  else Int
r

{-# INLINE safeIndex #-}
safeIndex :: Ix i => (i, i) -> Int -> i -> Int
safeIndex :: forall i. Ix i => (i, i) -> Int -> i -> Int
safeIndex (i
l,i
u) Int
n i
i = let i' :: Int
i' = forall a. Ix a => (a, a) -> a -> Int
index (i
l,i
u) i
i
                      in if (Int
0 forall a. Ord a => a -> a -> Bool
<= Int
i') Bool -> Bool -> Bool
&& (Int
i' forall a. Ord a => a -> a -> Bool
< Int
n)
                         then Int
i'
                         else forall a. HasCallStack => [Char] -> a
error ([Char]
"Error in array index; " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show Int
i' forall a. [a] -> [a] -> [a]
++
                                     [Char]
" not in range [0.." forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show Int
n forall a. [a] -> [a] -> [a]
++ [Char]
")")

{-# INLINE unsafeReplaceST #-}
unsafeReplaceST :: (IArray a e, Ix i) => a i e -> [(Int, e)] -> ST s (STArray s i e)
unsafeReplaceST :: 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 = do
    STArray s i e
marr <- 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
    forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_ [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 | (Int
i, e
e) <- [(Int, e)]
ies]
    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 :: 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 = do
    STArray s i e
marr <- 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
    forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_ [do e
old <- 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
                  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)
              | (Int
i, e'
new) <- [(Int, e')]
ies]
    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 :: 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
l,i
u) [(Int, e')]
ies = do
    STArray s i e
marr <- 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
    forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_ [do e
old <- 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
                  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)
              | (Int
i, e'
new) <- [(Int, e')]
ies]
    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 :: forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
(i, i) -> [(i, e)] -> a i e
array (i
l,i
u) [(i, e)]
ies
    = let n :: Int
n = forall i. Ix i => (i, i) -> Int
safeRangeSize (i
l,i
u)
      in forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
(i, i) -> [(Int, e)] -> a i e
unsafeArray (i
l,i
u)
                     [(forall i. Ix i => (i, i) -> Int -> i -> Int
safeIndex (i
l,i
u) Int
n i
i, e
e) | (i
i, e
e) <- [(i, e)]
ies]








{-# INLINE [1] listArray #-}




listArray :: (IArray a e, Ix i) => (i,i) -> [e] -> a i e
listArray :: forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
(i, i) -> [e] -> a i e
listArray (i
l,i
u) [e]
es =
    let n :: Int
n = forall i. Ix i => (i, i) -> Int
safeRangeSize (i
l,i
u)
    in forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
(i, i) -> [(Int, e)] -> a i e
unsafeArray (i
l,i
u) (forall a b. [a] -> [b] -> [(a, b)]
zip [Int
0 .. Int
n forall a. Num a => a -> a -> a
- Int
1] [e]
es)

{-# INLINE listArrayST #-}
listArrayST :: Ix i => (i,i) -> [e] -> ST s (STArray s i e)
listArrayST :: forall i e s. Ix i => (i, i) -> [e] -> ST s (STArray s i e)
listArrayST (i
l,i
u) [e]
es = do
    STArray s i e
marr <- 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 = forall i. Ix i => (i, i) -> Int
safeRangeSize (i
l,i
u)
    let fillFromList :: Int -> [e] -> m ()
fillFromList Int
i [e]
xs | Int
i forall a. Eq a => a -> a -> Bool
== Int
n    = forall (m :: * -> *) a. Monad m => a -> m a
return ()
                          | Bool
otherwise = case [e]
xs of
            []   -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
            e
y:[e]
ys -> 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 forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> [e] -> m ()
fillFromList (Int
iforall a. Num a => a -> a -> a
+Int
1) [e]
ys
    forall {m :: * -> *}. MArray (STArray s) e m => Int -> [e] -> m ()
fillFromList Int
0 [e]
es
    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 :: forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
(i, i) -> [e] -> ST s (STUArray s i e)
listUArrayST (i
l,i
u) [e]
es = do
    STUArray s i e
marr <- 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 = forall i. Ix i => (i, i) -> Int
safeRangeSize (i
l,i
u)
    let fillFromList :: Int -> [e] -> m ()
fillFromList Int
i [e]
xs | Int
i forall a. Eq a => a -> a -> Bool
== Int
n    = forall (m :: * -> *) a. Monad m => a -> m a
return ()
                          | Bool
otherwise = case [e]
xs of
            []   -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
            e
y:[e]
ys -> 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 forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> [e] -> m ()
fillFromList (Int
iforall a. Num a => a -> a -> a
+Int
1) [e]
ys
    forall {m :: * -> *}. MArray (STUArray s) e m => Int -> [e] -> m ()
fillFromList Int
0 [e]
es
    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
! :: forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> i -> e
(!) a i e
arr i
i = case forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> (i, i)
bounds a i e
arr of
              (i
l,i
u) -> forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> Int -> e
unsafeAt a i e
arr forall a b. (a -> b) -> a -> b
$ forall i. Ix i => (i, i) -> Int -> i -> Int
safeIndex (i
l,i
u) (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 :: forall (a :: * -> * -> *) e i. (IArray a e, Ix i) => a i e -> [i]
indices a i e
arr = case forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> (i, i)
bounds a i e
arr of (i
l,i
u) -> 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 :: forall (a :: * -> * -> *) e i. (IArray a e, Ix i) => a i e -> [e]
elems a i e
arr = [forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> Int -> e
unsafeAt a i e
arr Int
i | Int
i <- [Int
0 .. forall (a :: * -> * -> *) e i. (IArray a e, Ix i) => a i e -> Int
numElements a i e
arr forall a. Num a => a -> a -> a
- Int
1]]

{-# INLINE assocs #-}

assocs :: (IArray a e, Ix i) => a i e -> [(i, e)]
assocs :: forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> [(i, e)]
assocs a i e
arr = case forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> (i, i)
bounds a i e
arr of
    (i
l,i
u) -> [(i
i, a i e
arr forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> i -> e
! 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 :: forall (a :: * -> * -> *) e i e'.
(IArray a e, Ix i) =>
(e -> e' -> e) -> e -> (i, i) -> [(i, e')] -> a i e
accumArray e -> e' -> e
f e
initialValue (i
l,i
u) [(i, e')]
ies =
    let n :: Int
n = forall i. Ix i => (i, i) -> Int
safeRangeSize (i
l, i
u)
    in 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)
                        [(forall i. Ix i => (i, i) -> Int -> i -> Int
safeIndex (i
l,i
u) Int
n i
i, e'
e) | (i
i, e'
e) <- [(i, e')]
ies]

{-# INLINE (//) #-}

(//) :: (IArray a e, Ix i) => a i e -> [(i, e)] -> a i e
a i e
arr // :: forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> [(i, e)] -> a i e
// [(i, e)]
ies = case forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> (i, i)
bounds a i e
arr of
    (i
l,i
u) -> forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> [(Int, e)] -> a i e
unsafeReplace a i e
arr [ (forall i. Ix i => (i, i) -> Int -> i -> Int
safeIndex (i
l,i
u) (forall (a :: * -> * -> *) e i. (IArray a e, Ix i) => a i e -> Int
numElements a i e
arr) i
i, e
e)
                               | (i
i, 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 :: forall (a :: * -> * -> *) e i e'.
(IArray a e, Ix i) =>
(e -> e' -> e) -> a i e -> [(i, e')] -> a i e
accum e -> e' -> e
f a i e
arr [(i, e')]
ies = case forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> (i, i)
bounds a i e
arr of
    (i
l,i
u) -> let n :: Int
n = forall (a :: * -> * -> *) e i. (IArray a e, Ix i) => a i e -> Int
numElements a i e
arr
             in 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 [(forall i. Ix i => (i, i) -> Int -> i -> Int
safeIndex (i
l,i
u) Int
n i
i, e'
e) | (i
i, 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 :: forall (a :: * -> * -> *) e' e i.
(IArray a e', IArray a e, Ix i) =>
(e' -> e) -> a i e' -> a i e
amap e' -> e
f a i e'
arr = case forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> (i, i)
bounds a i e'
arr of
    (i
l,i
u) -> let n :: Int
n = forall (a :: * -> * -> *) e i. (IArray a e, Ix i) => a i e -> Int
numElements a i e'
arr
             in 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 (forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> Int -> e
unsafeAt a i e'
arr Int
i))
                                  | Int
i <- [Int
0 .. Int
n forall a. Num a => a -> a -> a
- Int
1]]

{-# INLINE ixmap #-}


ixmap :: (IArray a e, Ix i, Ix j) => (i,i) -> (i -> j) -> a j e -> a i e
ixmap :: forall (a :: * -> * -> *) e i j.
(IArray a e, Ix i, Ix j) =>
(i, i) -> (i -> j) -> a j e -> a i e
ixmap (i
l,i
u) i -> j
f a j e
arr =
    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 forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> i -> e
! i -> j
f 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 :: forall i. Ix i => Array i e -> (i, i)
bounds = forall i e. Array i e -> (i, i)
Arr.bounds
    {-# INLINE numElements #-}
    numElements :: forall i. Ix i => Array i e -> Int
numElements      = forall i e. Array i e -> Int
Arr.numElements
    {-# INLINE unsafeArray #-}
    unsafeArray :: forall i. Ix i => (i, i) -> [(Int, e)] -> Array i e
unsafeArray      = forall i e. Ix i => (i, i) -> [(Int, e)] -> Array i e
Arr.unsafeArray
    {-# INLINE unsafeAt #-}
    unsafeAt :: forall i. Ix i => Array i e -> Int -> e
unsafeAt         = forall i e. Array i e -> Int -> e
Arr.unsafeAt
    {-# INLINE unsafeReplace #-}
    unsafeReplace :: forall i. Ix i => Array i e -> [(Int, e)] -> Array i e
unsafeReplace    = forall i e. Array i e -> [(Int, e)] -> Array i e
Arr.unsafeReplace
    {-# INLINE unsafeAccum #-}
    unsafeAccum :: forall i e'.
Ix i =>
(e -> e' -> e) -> Array i e -> [(Int, e')] -> Array i e
unsafeAccum      = forall e a i. (e -> a -> e) -> Array i e -> [(Int, a)] -> Array i e
Arr.unsafeAccum
    {-# INLINE unsafeAccumArray #-}
    unsafeAccumArray :: forall i e'.
Ix i =>
(e -> e' -> e) -> e -> (i, i) -> [(Int, e')] -> Array i e
unsafeAccumArray = 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 :: forall s e i.
(MArray (STUArray s) e (ST s), Ix i) =>
(i, i) -> [(Int, e)] -> e -> ST s (UArray i e)
unsafeArrayUArray (i
l,i
u) [(Int, e)]
ies e
default_elem = do
    STUArray s i e
marr <- 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
    forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_ [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 | (Int
i, e
e) <- [(Int, e)]
ies]
    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 :: forall s i e. STUArray s i e -> ST s (UArray i e)
unsafeFreezeSTUArray (STUArray i
l i
u Int
n MutableByteArray# s
marr#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
    case forall d.
MutableByteArray# d -> State# d -> (# State# d, ByteArray# #)
unsafeFreezeByteArray# MutableByteArray# s
marr# State# s
s1# of { (# State# s
s2#, ByteArray#
arr# #) ->
    (# State# s
s2#, 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 :: 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 e
arr [(Int, e)]
ies = do
    STUArray s i e
marr <- forall i e s. UArray i e -> ST s (STUArray s i e)
thawSTUArray UArray i e
arr
    forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_ [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 | (Int
i, e
e) <- [(Int, e)]
ies]
    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 :: 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 e -> e' -> e
f UArray i e
arr [(Int, e')]
ies = do
    STUArray s i e
marr <- forall i e s. UArray i e -> ST s (STUArray s i e)
thawSTUArray UArray i e
arr
    forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_ [do e
old <- 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
                  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)
              | (Int
i, e'
new) <- [(Int, e')]
ies]
    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 :: 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 e -> e' -> e
f e
initialValue (i
l,i
u) [(Int, e')]
ies = do
    STUArray s i e
marr <- 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
    forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_ [do e
old <- 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
                  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)
              | (Int
i, e'
new) <- [(Int, e')]
ies]
    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 :: forall e i.
(IArray UArray e, Ix i, Eq e) =>
UArray i e -> UArray i e -> Bool
eqUArray arr1 :: UArray i e
arr1@(UArray i
l1 i
u1 Int
n1 ByteArray#
_) arr2 :: UArray i e
arr2@(UArray i
l2 i
u2 Int
n2 ByteArray#
_) =
    if Int
n1 forall a. Eq a => a -> a -> Bool
== Int
0 then Int
n2 forall a. Eq a => a -> a -> Bool
== Int
0 else
    i
l1 forall a. Eq a => a -> a -> Bool
== i
l2 Bool -> Bool -> Bool
&& i
u1 forall a. Eq a => a -> a -> Bool
== i
u2 Bool -> Bool -> Bool
&&
    forall (t :: * -> *). Foldable t => t Bool -> Bool
and [forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> Int -> e
unsafeAt UArray i e
arr1 Int
i forall a. Eq a => a -> a -> Bool
== forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> Int -> e
unsafeAt UArray i e
arr2 Int
i | Int
i <- [Int
0 .. Int
n1 forall a. Num a => a -> a -> a
- Int
1]]

{-# INLINE [1] cmpUArray #-}
cmpUArray :: (IArray UArray e, Ix i, Ord e) => UArray i e -> UArray i e -> Ordering
cmpUArray :: forall e i.
(IArray UArray e, Ix i, Ord e) =>
UArray i e -> UArray i e -> Ordering
cmpUArray UArray i e
arr1 UArray i e
arr2 = forall a. Ord a => a -> a -> Ordering
compare (forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> [(i, e)]
assocs UArray i e
arr1) (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 :: forall e.
(IArray UArray e, Ord e) =>
UArray Int e -> UArray Int e -> Ordering
cmpIntUArray arr1 :: UArray Int e
arr1@(UArray Int
l1 Int
u1 Int
n1 ByteArray#
_) arr2 :: UArray Int e
arr2@(UArray Int
l2 Int
u2 Int
n2 ByteArray#
_) =
    if Int
n1 forall a. Eq a => a -> a -> Bool
== Int
0 then if Int
n2 forall a. Eq a => a -> a -> Bool
== Int
0 then Ordering
EQ else Ordering
LT else
    if Int
n2 forall a. Eq a => a -> a -> Bool
== Int
0 then Ordering
GT else
    case forall a. Ord a => a -> a -> Ordering
compare Int
l1 Int
l2 of
        Ordering
EQ    -> forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Int -> Ordering -> Ordering
cmp (forall a. Ord a => a -> a -> Ordering
compare Int
u1 Int
u2) [Int
0 .. (Int
n1 forall a. Ord a => a -> a -> a
`min` Int
n2) forall a. Num a => a -> a -> a
- Int
1]
        Ordering
other -> Ordering
other
    where
    cmp :: Int -> Ordering -> Ordering
cmp Int
i Ordering
rest = case forall a. Ord a => a -> a -> Ordering
compare (forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> Int -> e
unsafeAt UArray Int e
arr1 Int
i) (forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> Int -> e
unsafeAt UArray Int e
arr2 Int
i) of
        Ordering
EQ    -> Ordering
rest
        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 :: forall (a :: * -> * -> *) e i.
(IArray a e, Ix i, Show i, Show e) =>
Int -> a i e -> ShowS
showsIArray Int
p a i e
a =
    Bool -> ShowS -> ShowS
showParen (Int
p forall a. Ord a => a -> a -> Bool
> Int
appPrec) forall a b. (a -> b) -> a -> b
$
    [Char] -> ShowS
showString [Char]
"array " forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    forall a. Show a => a -> ShowS
shows (forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> (i, i)
bounds a i e
a) forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    Char -> ShowS
showChar Char
' ' forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    forall a. Show a => a -> ShowS
shows (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 :: forall (a :: * -> * -> *) e i.
(IArray a e, Ix i, Read i, Read e) =>
ReadPrec (a i e)
readIArray = forall a. ReadPrec a -> ReadPrec a
parens forall a b. (a -> b) -> a -> b
$ forall a. Int -> ReadPrec a -> ReadPrec a
prec Int
appPrec forall a b. (a -> b) -> a -> b
$
               do Lexeme -> ReadPrec ()
expectP ([Char] -> Lexeme
Ident [Char]
"array")
                  (i, i)
theBounds <- forall a. ReadPrec a -> ReadPrec a
step forall a. Read a => ReadPrec a
readPrec
                  [(i, e)]
vals   <- forall a. ReadPrec a -> ReadPrec a
step forall a. Read a => ReadPrec a
readPrec
                  forall (m :: * -> *) a. Monad m => a -> m a
return (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 :: forall i. Ix i => UArray i Bool -> (i, i)
bounds (UArray i
l i
u Int
_ ByteArray#
_) = (i
l,i
u)
    {-# INLINE numElements #-}
    numElements :: forall i. Ix i => UArray i Bool -> Int
numElements (UArray i
_ i
_ Int
n ByteArray#
_) = Int
n
    {-# INLINE unsafeArray #-}
    unsafeArray :: forall i. Ix i => (i, i) -> [(Int, Bool)] -> UArray i Bool
unsafeArray (i, i)
lu [(Int, Bool)]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i. Ix i => UArray i Bool -> Int -> Bool
unsafeAt (UArray i
_ i
_ Int
_ ByteArray#
arr#) (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# Int#
0#)

    {-# INLINE unsafeReplace #-}
    unsafeReplace :: forall i. Ix i => UArray i Bool -> [(Int, Bool)] -> UArray i Bool
unsafeReplace UArray i Bool
arr [(Int, Bool)]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Bool -> e' -> Bool)
-> UArray i Bool -> [(Int, e')] -> UArray i Bool
unsafeAccum Bool -> e' -> Bool
f UArray i Bool
arr [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Bool -> e' -> Bool)
-> Bool -> (i, i) -> [(Int, e')] -> UArray i Bool
unsafeAccumArray Bool -> e' -> Bool
f Bool
initialValue (i, i)
lu [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i. Ix i => UArray i Char -> (i, i)
bounds (UArray i
l i
u Int
_ ByteArray#
_) = (i
l,i
u)
    {-# INLINE numElements #-}
    numElements :: forall i. Ix i => UArray i Char -> Int
numElements (UArray i
_ i
_ Int
n ByteArray#
_) = Int
n
    {-# INLINE unsafeArray #-}
    unsafeArray :: forall i. Ix i => (i, i) -> [(Int, Char)] -> UArray i Char
unsafeArray (i, i)
lu [(Int, Char)]
ies = forall a. (forall s. ST s a) -> a
runST (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 Char
'\0')
    {-# INLINE unsafeAt #-}
    unsafeAt :: forall i. Ix i => UArray i Char -> Int -> Char
unsafeAt (UArray i
_ i
_ Int
_ ByteArray#
arr#) (I# Int#
i#) = Char# -> Char
C# (ByteArray# -> Int# -> Char#
indexWideCharArray# ByteArray#
arr# Int#
i#)
    {-# INLINE unsafeReplace #-}
    unsafeReplace :: forall i. Ix i => UArray i Char -> [(Int, Char)] -> UArray i Char
unsafeReplace UArray i Char
arr [(Int, Char)]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Char -> e' -> Char)
-> UArray i Char -> [(Int, e')] -> UArray i Char
unsafeAccum Char -> e' -> Char
f UArray i Char
arr [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Char -> e' -> Char)
-> Char -> (i, i) -> [(Int, e')] -> UArray i Char
unsafeAccumArray Char -> e' -> Char
f Char
initialValue (i, i)
lu [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i. Ix i => UArray i Int -> (i, i)
bounds (UArray i
l i
u Int
_ ByteArray#
_) = (i
l,i
u)
    {-# INLINE numElements #-}
    numElements :: forall i. Ix i => UArray i Int -> Int
numElements (UArray i
_ i
_ Int
n ByteArray#
_) = Int
n
    {-# INLINE unsafeArray #-}
    unsafeArray :: forall i. Ix i => (i, i) -> [(Int, Int)] -> UArray i Int
unsafeArray (i, i)
lu [(Int, Int)]
ies = forall a. (forall s. ST s a) -> a
runST (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 Int
0)
    {-# INLINE unsafeAt #-}
    unsafeAt :: forall i. Ix i => UArray i Int -> Int -> Int
unsafeAt (UArray i
_ i
_ Int
_ ByteArray#
arr#) (I# Int#
i#) = Int# -> Int
I# (ByteArray# -> Int# -> Int#
indexIntArray# ByteArray#
arr# Int#
i#)
    {-# INLINE unsafeReplace #-}
    unsafeReplace :: forall i. Ix i => UArray i Int -> [(Int, Int)] -> UArray i Int
unsafeReplace UArray i Int
arr [(Int, Int)]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Int -> e' -> Int) -> UArray i Int -> [(Int, e')] -> UArray i Int
unsafeAccum Int -> e' -> Int
f UArray i Int
arr [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Int -> e' -> Int) -> Int -> (i, i) -> [(Int, e')] -> UArray i Int
unsafeAccumArray Int -> e' -> Int
f Int
initialValue (i, i)
lu [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i. Ix i => UArray i Word -> (i, i)
bounds (UArray i
l i
u Int
_ ByteArray#
_) = (i
l,i
u)
    {-# INLINE numElements #-}
    numElements :: forall i. Ix i => UArray i Word -> Int
numElements (UArray i
_ i
_ Int
n ByteArray#
_) = Int
n
    {-# INLINE unsafeArray #-}
    unsafeArray :: forall i. Ix i => (i, i) -> [(Int, Word)] -> UArray i Word
unsafeArray (i, i)
lu [(Int, Word)]
ies = forall a. (forall s. ST s a) -> a
runST (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 Word
0)
    {-# INLINE unsafeAt #-}
    unsafeAt :: forall i. Ix i => UArray i Word -> Int -> Word
unsafeAt (UArray i
_ i
_ Int
_ ByteArray#
arr#) (I# Int#
i#) = Word# -> Word
W# (ByteArray# -> Int# -> Word#
indexWordArray# ByteArray#
arr# Int#
i#)
    {-# INLINE unsafeReplace #-}
    unsafeReplace :: forall i. Ix i => UArray i Word -> [(Int, Word)] -> UArray i Word
unsafeReplace UArray i Word
arr [(Int, Word)]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Word -> e' -> Word)
-> UArray i Word -> [(Int, e')] -> UArray i Word
unsafeAccum Word -> e' -> Word
f UArray i Word
arr [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Word -> e' -> Word)
-> Word -> (i, i) -> [(Int, e')] -> UArray i Word
unsafeAccumArray Word -> e' -> Word
f Word
initialValue (i, i)
lu [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i. Ix i => UArray i (Ptr a) -> (i, i)
bounds (UArray i
l i
u Int
_ ByteArray#
_) = (i
l,i
u)
    {-# INLINE numElements #-}
    numElements :: forall i. Ix i => UArray i (Ptr a) -> Int
numElements (UArray i
_ i
_ Int
n ByteArray#
_) = Int
n
    {-# INLINE unsafeArray #-}
    unsafeArray :: forall i. Ix i => (i, i) -> [(Int, Ptr a)] -> UArray i (Ptr a)
unsafeArray (i, i)
lu [(Int, Ptr a)]
ies = forall a. (forall s. ST s a) -> a
runST (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 forall a. Ptr a
nullPtr)
    {-# INLINE unsafeAt #-}
    unsafeAt :: forall i. Ix i => UArray i (Ptr a) -> Int -> Ptr a
unsafeAt (UArray i
_ i
_ Int
_ ByteArray#
arr#) (I# Int#
i#) = forall a. Addr# -> Ptr a
Ptr (ByteArray# -> Int# -> Addr#
indexAddrArray# ByteArray#
arr# Int#
i#)
    {-# INLINE unsafeReplace #-}
    unsafeReplace :: forall i.
Ix i =>
UArray i (Ptr a) -> [(Int, Ptr a)] -> UArray i (Ptr a)
unsafeReplace UArray i (Ptr a)
arr [(Int, Ptr a)]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Ptr a -> e' -> Ptr a)
-> UArray i (Ptr a) -> [(Int, e')] -> UArray i (Ptr a)
unsafeAccum Ptr a -> e' -> Ptr a
f UArray i (Ptr a)
arr [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Ptr a -> e' -> Ptr a)
-> Ptr a -> (i, i) -> [(Int, e')] -> UArray i (Ptr a)
unsafeAccumArray Ptr a -> e' -> Ptr a
f Ptr a
initialValue (i, i)
lu [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i. Ix i => UArray i (FunPtr a) -> (i, i)
bounds (UArray i
l i
u Int
_ ByteArray#
_) = (i
l,i
u)
    {-# INLINE numElements #-}
    numElements :: forall i. Ix i => UArray i (FunPtr a) -> Int
numElements (UArray i
_ i
_ Int
n ByteArray#
_) = Int
n
    {-# INLINE unsafeArray #-}
    unsafeArray :: forall i.
Ix i =>
(i, i) -> [(Int, FunPtr a)] -> UArray i (FunPtr a)
unsafeArray (i, i)
lu [(Int, FunPtr a)]
ies = forall a. (forall s. ST s a) -> a
runST (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 forall a. FunPtr a
nullFunPtr)
    {-# INLINE unsafeAt #-}
    unsafeAt :: forall i. Ix i => UArray i (FunPtr a) -> Int -> FunPtr a
unsafeAt (UArray i
_ i
_ Int
_ ByteArray#
arr#) (I# Int#
i#) = forall a. Addr# -> FunPtr a
FunPtr (ByteArray# -> Int# -> Addr#
indexAddrArray# ByteArray#
arr# Int#
i#)
    {-# INLINE unsafeReplace #-}
    unsafeReplace :: forall i.
Ix i =>
UArray i (FunPtr a) -> [(Int, FunPtr a)] -> UArray i (FunPtr a)
unsafeReplace UArray i (FunPtr a)
arr [(Int, FunPtr a)]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(FunPtr a -> e' -> FunPtr a)
-> UArray i (FunPtr a) -> [(Int, e')] -> UArray i (FunPtr a)
unsafeAccum FunPtr a -> e' -> FunPtr a
f UArray i (FunPtr a)
arr [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(FunPtr a -> e' -> FunPtr a)
-> FunPtr a -> (i, i) -> [(Int, e')] -> UArray i (FunPtr a)
unsafeAccumArray FunPtr a -> e' -> FunPtr a
f FunPtr a
initialValue (i, i)
lu [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i. Ix i => UArray i Float -> (i, i)
bounds (UArray i
l i
u Int
_ ByteArray#
_) = (i
l,i
u)
    {-# INLINE numElements #-}
    numElements :: forall i. Ix i => UArray i Float -> Int
numElements (UArray i
_ i
_ Int
n ByteArray#
_) = Int
n
    {-# INLINE unsafeArray #-}
    unsafeArray :: forall i. Ix i => (i, i) -> [(Int, Float)] -> UArray i Float
unsafeArray (i, i)
lu [(Int, Float)]
ies = forall a. (forall s. ST s a) -> a
runST (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 Float
0)
    {-# INLINE unsafeAt #-}
    unsafeAt :: forall i. Ix i => UArray i Float -> Int -> Float
unsafeAt (UArray i
_ i
_ Int
_ ByteArray#
arr#) (I# Int#
i#) = Float# -> Float
F# (ByteArray# -> Int# -> Float#
indexFloatArray# ByteArray#
arr# Int#
i#)
    {-# INLINE unsafeReplace #-}
    unsafeReplace :: forall i.
Ix i =>
UArray i Float -> [(Int, Float)] -> UArray i Float
unsafeReplace UArray i Float
arr [(Int, Float)]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Float -> e' -> Float)
-> UArray i Float -> [(Int, e')] -> UArray i Float
unsafeAccum Float -> e' -> Float
f UArray i Float
arr [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Float -> e' -> Float)
-> Float -> (i, i) -> [(Int, e')] -> UArray i Float
unsafeAccumArray Float -> e' -> Float
f Float
initialValue (i, i)
lu [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i. Ix i => UArray i Double -> (i, i)
bounds (UArray i
l i
u Int
_ ByteArray#
_) = (i
l,i
u)
    {-# INLINE numElements #-}
    numElements :: forall i. Ix i => UArray i Double -> Int
numElements (UArray i
_ i
_ Int
n ByteArray#
_) = Int
n
    {-# INLINE unsafeArray #-}
    unsafeArray :: forall i. Ix i => (i, i) -> [(Int, Double)] -> UArray i Double
unsafeArray (i, i)
lu [(Int, Double)]
ies = forall a. (forall s. ST s a) -> a
runST (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 Double
0)
    {-# INLINE unsafeAt #-}
    unsafeAt :: forall i. Ix i => UArray i Double -> Int -> Double
unsafeAt (UArray i
_ i
_ Int
_ ByteArray#
arr#) (I# Int#
i#) = Double# -> Double
D# (ByteArray# -> Int# -> Double#
indexDoubleArray# ByteArray#
arr# Int#
i#)
    {-# INLINE unsafeReplace #-}
    unsafeReplace :: forall i.
Ix i =>
UArray i Double -> [(Int, Double)] -> UArray i Double
unsafeReplace UArray i Double
arr [(Int, Double)]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Double -> e' -> Double)
-> UArray i Double -> [(Int, e')] -> UArray i Double
unsafeAccum Double -> e' -> Double
f UArray i Double
arr [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Double -> e' -> Double)
-> Double -> (i, i) -> [(Int, e')] -> UArray i Double
unsafeAccumArray Double -> e' -> Double
f Double
initialValue (i, i)
lu [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i. Ix i => UArray i (StablePtr a) -> (i, i)
bounds (UArray i
l i
u Int
_ ByteArray#
_) = (i
l,i
u)
    {-# INLINE numElements #-}
    numElements :: forall i. Ix i => UArray i (StablePtr a) -> Int
numElements (UArray i
_ i
_ Int
n ByteArray#
_) = Int
n
    {-# INLINE unsafeArray #-}
    unsafeArray :: forall i.
Ix i =>
(i, i) -> [(Int, StablePtr a)] -> UArray i (StablePtr a)
unsafeArray (i, i)
lu [(Int, StablePtr a)]
ies = forall a. (forall s. ST s a) -> a
runST (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 forall a. StablePtr a
nullStablePtr)
    {-# INLINE unsafeAt #-}
    unsafeAt :: forall i. Ix i => UArray i (StablePtr a) -> Int -> StablePtr a
unsafeAt (UArray i
_ i
_ Int
_ ByteArray#
arr#) (I# Int#
i#) = forall a. StablePtr# a -> StablePtr a
StablePtr (forall a. ByteArray# -> Int# -> StablePtr# a
indexStablePtrArray# ByteArray#
arr# Int#
i#)
    {-# INLINE unsafeReplace #-}
    unsafeReplace :: forall i.
Ix i =>
UArray i (StablePtr a)
-> [(Int, StablePtr a)] -> UArray i (StablePtr a)
unsafeReplace UArray i (StablePtr a)
arr [(Int, StablePtr a)]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(StablePtr a -> e' -> StablePtr a)
-> UArray i (StablePtr a) -> [(Int, e')] -> UArray i (StablePtr a)
unsafeAccum StablePtr a -> e' -> StablePtr a
f UArray i (StablePtr a)
arr [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(StablePtr a -> e' -> StablePtr a)
-> StablePtr a -> (i, i) -> [(Int, e')] -> UArray i (StablePtr a)
unsafeAccumArray StablePtr a -> e' -> StablePtr a
f StablePtr a
initialValue (i, i)
lu [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall a. StablePtr a
nullStablePtr = forall a. StablePtr# a -> StablePtr a
StablePtr (unsafeCoerce# :: forall a b. a -> b
unsafeCoerce# Addr#
nullAddr#)

instance IArray UArray Int8 where
    {-# INLINE bounds #-}
    bounds :: forall i. Ix i => UArray i Int8 -> (i, i)
bounds (UArray i
l i
u Int
_ ByteArray#
_) = (i
l,i
u)
    {-# INLINE numElements #-}
    numElements :: forall i. Ix i => UArray i Int8 -> Int
numElements (UArray i
_ i
_ Int
n ByteArray#
_) = Int
n
    {-# INLINE unsafeArray #-}
    unsafeArray :: forall i. Ix i => (i, i) -> [(Int, Int8)] -> UArray i Int8
unsafeArray (i, i)
lu [(Int, Int8)]
ies = forall a. (forall s. ST s a) -> a
runST (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 Int8
0)
    {-# INLINE unsafeAt #-}
    unsafeAt :: forall i. Ix i => UArray i Int8 -> Int -> Int8
unsafeAt (UArray i
_ i
_ Int
_ ByteArray#
arr#) (I# Int#
i#) = Int8# -> Int8
I8# (ByteArray# -> Int# -> Int8#
indexInt8Array# ByteArray#
arr# Int#
i#)
    {-# INLINE unsafeReplace #-}
    unsafeReplace :: forall i. Ix i => UArray i Int8 -> [(Int, Int8)] -> UArray i Int8
unsafeReplace UArray i Int8
arr [(Int, Int8)]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Int8 -> e' -> Int8)
-> UArray i Int8 -> [(Int, e')] -> UArray i Int8
unsafeAccum Int8 -> e' -> Int8
f UArray i Int8
arr [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Int8 -> e' -> Int8)
-> Int8 -> (i, i) -> [(Int, e')] -> UArray i Int8
unsafeAccumArray Int8 -> e' -> Int8
f Int8
initialValue (i, i)
lu [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i. Ix i => UArray i Int16 -> (i, i)
bounds (UArray i
l i
u Int
_ ByteArray#
_) = (i
l,i
u)
    {-# INLINE numElements #-}
    numElements :: forall i. Ix i => UArray i Int16 -> Int
numElements (UArray i
_ i
_ Int
n ByteArray#
_) = Int
n
    {-# INLINE unsafeArray #-}
    unsafeArray :: forall i. Ix i => (i, i) -> [(Int, Int16)] -> UArray i Int16
unsafeArray (i, i)
lu [(Int, Int16)]
ies = forall a. (forall s. ST s a) -> a
runST (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 Int16
0)
    {-# INLINE unsafeAt #-}
    unsafeAt :: forall i. Ix i => UArray i Int16 -> Int -> Int16
unsafeAt (UArray i
_ i
_ Int
_ ByteArray#
arr#) (I# Int#
i#) = Int16# -> Int16
I16# (ByteArray# -> Int# -> Int16#
indexInt16Array# ByteArray#
arr# Int#
i#)
    {-# INLINE unsafeReplace #-}
    unsafeReplace :: forall i.
Ix i =>
UArray i Int16 -> [(Int, Int16)] -> UArray i Int16
unsafeReplace UArray i Int16
arr [(Int, Int16)]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Int16 -> e' -> Int16)
-> UArray i Int16 -> [(Int, e')] -> UArray i Int16
unsafeAccum Int16 -> e' -> Int16
f UArray i Int16
arr [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Int16 -> e' -> Int16)
-> Int16 -> (i, i) -> [(Int, e')] -> UArray i Int16
unsafeAccumArray Int16 -> e' -> Int16
f Int16
initialValue (i, i)
lu [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i. Ix i => UArray i Int32 -> (i, i)
bounds (UArray i
l i
u Int
_ ByteArray#
_) = (i
l,i
u)
    {-# INLINE numElements #-}
    numElements :: forall i. Ix i => UArray i Int32 -> Int
numElements (UArray i
_ i
_ Int
n ByteArray#
_) = Int
n
    {-# INLINE unsafeArray #-}
    unsafeArray :: forall i. Ix i => (i, i) -> [(Int, Int32)] -> UArray i Int32
unsafeArray (i, i)
lu [(Int, Int32)]
ies = forall a. (forall s. ST s a) -> a
runST (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 Int32
0)
    {-# INLINE unsafeAt #-}
    unsafeAt :: forall i. Ix i => UArray i Int32 -> Int -> Int32
unsafeAt (UArray i
_ i
_ Int
_ ByteArray#
arr#) (I# Int#
i#) = Int32# -> Int32
I32# (ByteArray# -> Int# -> Int32#
indexInt32Array# ByteArray#
arr# Int#
i#)
    {-# INLINE unsafeReplace #-}
    unsafeReplace :: forall i.
Ix i =>
UArray i Int32 -> [(Int, Int32)] -> UArray i Int32
unsafeReplace UArray i Int32
arr [(Int, Int32)]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Int32 -> e' -> Int32)
-> UArray i Int32 -> [(Int, e')] -> UArray i Int32
unsafeAccum Int32 -> e' -> Int32
f UArray i Int32
arr [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Int32 -> e' -> Int32)
-> Int32 -> (i, i) -> [(Int, e')] -> UArray i Int32
unsafeAccumArray Int32 -> e' -> Int32
f Int32
initialValue (i, i)
lu [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i. Ix i => UArray i Int64 -> (i, i)
bounds (UArray i
l i
u Int
_ ByteArray#
_) = (i
l,i
u)
    {-# INLINE numElements #-}
    numElements :: forall i. Ix i => UArray i Int64 -> Int
numElements (UArray i
_ i
_ Int
n ByteArray#
_) = Int
n
    {-# INLINE unsafeArray #-}
    unsafeArray :: forall i. Ix i => (i, i) -> [(Int, Int64)] -> UArray i Int64
unsafeArray (i, i)
lu [(Int, Int64)]
ies = forall a. (forall s. ST s a) -> a
runST (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 Int64
0)
    {-# INLINE unsafeAt #-}
    unsafeAt :: forall i. Ix i => UArray i Int64 -> Int -> Int64
unsafeAt (UArray i
_ i
_ Int
_ ByteArray#
arr#) (I# Int#
i#) = Int# -> Int64
I64# (ByteArray# -> Int# -> Int#
indexInt64Array# ByteArray#
arr# Int#
i#)
    {-# INLINE unsafeReplace #-}
    unsafeReplace :: forall i.
Ix i =>
UArray i Int64 -> [(Int, Int64)] -> UArray i Int64
unsafeReplace UArray i Int64
arr [(Int, Int64)]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Int64 -> e' -> Int64)
-> UArray i Int64 -> [(Int, e')] -> UArray i Int64
unsafeAccum Int64 -> e' -> Int64
f UArray i Int64
arr [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Int64 -> e' -> Int64)
-> Int64 -> (i, i) -> [(Int, e')] -> UArray i Int64
unsafeAccumArray Int64 -> e' -> Int64
f Int64
initialValue (i, i)
lu [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i. Ix i => UArray i Word8 -> (i, i)
bounds (UArray i
l i
u Int
_ ByteArray#
_) = (i
l,i
u)
    {-# INLINE numElements #-}
    numElements :: forall i. Ix i => UArray i Word8 -> Int
numElements (UArray i
_ i
_ Int
n ByteArray#
_) = Int
n
    {-# INLINE unsafeArray #-}
    unsafeArray :: forall i. Ix i => (i, i) -> [(Int, Word8)] -> UArray i Word8
unsafeArray (i, i)
lu [(Int, Word8)]
ies = forall a. (forall s. ST s a) -> a
runST (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 Word8
0)
    {-# INLINE unsafeAt #-}
    unsafeAt :: forall i. Ix i => UArray i Word8 -> Int -> Word8
unsafeAt (UArray i
_ i
_ Int
_ ByteArray#
arr#) (I# Int#
i#) = Word8# -> Word8
W8# (ByteArray# -> Int# -> Word8#
indexWord8Array# ByteArray#
arr# Int#
i#)
    {-# INLINE unsafeReplace #-}
    unsafeReplace :: forall i.
Ix i =>
UArray i Word8 -> [(Int, Word8)] -> UArray i Word8
unsafeReplace UArray i Word8
arr [(Int, Word8)]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Word8 -> e' -> Word8)
-> UArray i Word8 -> [(Int, e')] -> UArray i Word8
unsafeAccum Word8 -> e' -> Word8
f UArray i Word8
arr [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Word8 -> e' -> Word8)
-> Word8 -> (i, i) -> [(Int, e')] -> UArray i Word8
unsafeAccumArray Word8 -> e' -> Word8
f Word8
initialValue (i, i)
lu [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i. Ix i => UArray i Word16 -> (i, i)
bounds (UArray i
l i
u Int
_ ByteArray#
_) = (i
l,i
u)
    {-# INLINE numElements #-}
    numElements :: forall i. Ix i => UArray i Word16 -> Int
numElements (UArray i
_ i
_ Int
n ByteArray#
_) = Int
n
    {-# INLINE unsafeArray #-}
    unsafeArray :: forall i. Ix i => (i, i) -> [(Int, Word16)] -> UArray i Word16
unsafeArray (i, i)
lu [(Int, Word16)]
ies = forall a. (forall s. ST s a) -> a
runST (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 Word16
0)
    {-# INLINE unsafeAt #-}
    unsafeAt :: forall i. Ix i => UArray i Word16 -> Int -> Word16
unsafeAt (UArray i
_ i
_ Int
_ ByteArray#
arr#) (I# Int#
i#) = Word16# -> Word16
W16# (ByteArray# -> Int# -> Word16#
indexWord16Array# ByteArray#
arr# Int#
i#)
    {-# INLINE unsafeReplace #-}
    unsafeReplace :: forall i.
Ix i =>
UArray i Word16 -> [(Int, Word16)] -> UArray i Word16
unsafeReplace UArray i Word16
arr [(Int, Word16)]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Word16 -> e' -> Word16)
-> UArray i Word16 -> [(Int, e')] -> UArray i Word16
unsafeAccum Word16 -> e' -> Word16
f UArray i Word16
arr [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Word16 -> e' -> Word16)
-> Word16 -> (i, i) -> [(Int, e')] -> UArray i Word16
unsafeAccumArray Word16 -> e' -> Word16
f Word16
initialValue (i, i)
lu [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i. Ix i => UArray i Word32 -> (i, i)
bounds (UArray i
l i
u Int
_ ByteArray#
_) = (i
l,i
u)
    {-# INLINE numElements #-}
    numElements :: forall i. Ix i => UArray i Word32 -> Int
numElements (UArray i
_ i
_ Int
n ByteArray#
_) = Int
n
    {-# INLINE unsafeArray #-}
    unsafeArray :: forall i. Ix i => (i, i) -> [(Int, Word32)] -> UArray i Word32
unsafeArray (i, i)
lu [(Int, Word32)]
ies = forall a. (forall s. ST s a) -> a
runST (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 Word32
0)
    {-# INLINE unsafeAt #-}
    unsafeAt :: forall i. Ix i => UArray i Word32 -> Int -> Word32
unsafeAt (UArray i
_ i
_ Int
_ ByteArray#
arr#) (I# Int#
i#) = Word32# -> Word32
W32# (ByteArray# -> Int# -> Word32#
indexWord32Array# ByteArray#
arr# Int#
i#)
    {-# INLINE unsafeReplace #-}
    unsafeReplace :: forall i.
Ix i =>
UArray i Word32 -> [(Int, Word32)] -> UArray i Word32
unsafeReplace UArray i Word32
arr [(Int, Word32)]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Word32 -> e' -> Word32)
-> UArray i Word32 -> [(Int, e')] -> UArray i Word32
unsafeAccum Word32 -> e' -> Word32
f UArray i Word32
arr [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Word32 -> e' -> Word32)
-> Word32 -> (i, i) -> [(Int, e')] -> UArray i Word32
unsafeAccumArray Word32 -> e' -> Word32
f Word32
initialValue (i, i)
lu [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i. Ix i => UArray i Word64 -> (i, i)
bounds (UArray i
l i
u Int
_ ByteArray#
_) = (i
l,i
u)
    {-# INLINE numElements #-}
    numElements :: forall i. Ix i => UArray i Word64 -> Int
numElements (UArray i
_ i
_ Int
n ByteArray#
_) = Int
n
    {-# INLINE unsafeArray #-}
    unsafeArray :: forall i. Ix i => (i, i) -> [(Int, Word64)] -> UArray i Word64
unsafeArray (i, i)
lu [(Int, Word64)]
ies = forall a. (forall s. ST s a) -> a
runST (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 Word64
0)
    {-# INLINE unsafeAt #-}
    unsafeAt :: forall i. Ix i => UArray i Word64 -> Int -> Word64
unsafeAt (UArray i
_ i
_ Int
_ ByteArray#
arr#) (I# Int#
i#) = Word# -> Word64
W64# (ByteArray# -> Int# -> Word#
indexWord64Array# ByteArray#
arr# Int#
i#)
    {-# INLINE unsafeReplace #-}
    unsafeReplace :: forall i.
Ix i =>
UArray i Word64 -> [(Int, Word64)] -> UArray i Word64
unsafeReplace UArray i Word64
arr [(Int, Word64)]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Word64 -> e' -> Word64)
-> UArray i Word64 -> [(Int, e')] -> UArray i Word64
unsafeAccum Word64 -> e' -> Word64
f UArray i Word64
arr [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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 :: forall i e'.
Ix i =>
(Word64 -> e' -> Word64)
-> Word64 -> (i, i) -> [(Int, e')] -> UArray i Word64
unsafeAccumArray Word64 -> e' -> Word64
f Word64
initialValue (i, i)
lu [(Int, e')]
ies = forall a. (forall s. ST s a) -> a
runST (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
(==) = 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 = 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 -> ShowS
showsPrec = forall (a :: * -> * -> *) e i.
(IArray a e, Ix i, Show i, Show e) =>
Int -> a i e -> ShowS
showsIArray

instance (Ix ix, Read ix, Read e, IArray UArray e) => Read (UArray ix e) where
    readPrec :: ReadPrec (UArray ix e)
readPrec = forall (a :: * -> * -> *) e i.
(IArray a e, Ix i, Read i, Read e) =>
ReadPrec (a i e)
readIArray




{-# NOINLINE arrEleBottom #-}
arrEleBottom :: a
arrEleBottom :: forall a. a
arrEleBottom = forall a. HasCallStack => [Char] -> a
error [Char]
"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 (i
l,i
u) e
initialValue = do
        let n :: Int
n = forall i. Ix i => (i, i) -> Int
safeRangeSize (i
l,i
u)
        a i e
marr <- forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> m (a i e)
unsafeNewArray_ (i
l,i
u)
        forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_ [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 <- [Int
0 .. Int
n forall a. Num a => a -> a -> a
- Int
1]]
        forall (m :: * -> *) a. Monad m => a -> m a
return a i e
marr

    {-# INLINE unsafeNewArray_ #-}
    unsafeNewArray_ (i
l,i
u) = forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i
l,i
u) forall a. a
arrEleBottom

    {-# INLINE newArray_ #-}
    newArray_ (i
l,i
u) = forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i
l,i
u) forall a. a
arrEleBottom

    
    
    
    

    
    
    
    
    

    
    
    

instance MArray IOArray e IO where
    {-# INLINE getBounds #-}
    getBounds :: forall i. Ix i => IOArray i e -> IO (i, i)
getBounds (IOArray STArray RealWorld i e
marr) = forall a. ST RealWorld a -> IO a
stToIO forall a b. (a -> b) -> a -> b
$ 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 :: forall i. Ix i => IOArray i e -> IO Int
getNumElements (IOArray STArray RealWorld i e
marr) = forall a. ST RealWorld a -> IO a
stToIO forall a b. (a -> b) -> a -> b
$ forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m Int
getNumElements STArray RealWorld i e
marr
    newArray :: forall i. Ix i => (i, i) -> e -> IO (IOArray i e)
newArray    = forall i e. Ix i => (i, i) -> e -> IO (IOArray i e)
newIOArray
    unsafeRead :: forall i. Ix i => IOArray i e -> Int -> IO e
unsafeRead  = forall i e. IOArray i e -> Int -> IO e
unsafeReadIOArray
    unsafeWrite :: forall i. Ix i => IOArray i e -> Int -> e -> IO ()
unsafeWrite = 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 :: forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> [e] -> m (a i e)
newListArray (i
l,i
u) [e]
es = do
    a i e
marr <- 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 = forall i. Ix i => (i, i) -> Int
safeRangeSize (i
l,i
u)
    let fillFromList :: Int -> [e] -> m ()
fillFromList Int
i [e]
xs | Int
i forall a. Eq a => a -> a -> Bool
== Int
n    = forall (m :: * -> *) a. Monad m => a -> m a
return ()
                          | Bool
otherwise = case [e]
xs of
            []   -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
            e
y:[e]
ys -> 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 forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> [e] -> m ()
fillFromList (Int
iforall a. Num a => a -> a -> a
+Int
1) [e]
ys
    forall {m :: * -> *}. MArray a e m => Int -> [e] -> m ()
fillFromList Int
0 [e]
es
    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 :: forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> i -> m e
readArray a i e
marr i
i = do
  (i
l,i
u) <- forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m (i, i)
getBounds a i e
marr
  Int
n <- forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m Int
getNumElements a i e
marr
  forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> m e
unsafeRead a i e
marr (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 :: forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> i -> e -> m ()
writeArray a i e
marr i
i e
e = do
  (i
l,i
u) <- forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m (i, i)
getBounds a i e
marr
  Int
n <- forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m Int
getNumElements a i e
marr
  forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> e -> m ()
unsafeWrite a i e
marr (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 :: forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m [e]
getElems a i e
marr = do
  (i
_l, i
_u) <- forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m (i, i)
getBounds a i e
marr
  Int
n <- forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m Int
getNumElements a i e
marr
  forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [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 <- [Int
0 .. Int
n forall a. Num a => a -> a -> a
- Int
1]]

{-# INLINE getAssocs #-}


getAssocs :: (MArray a e m, Ix i) => a i e -> m [(i, e)]
getAssocs :: forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m [(i, e)]
getAssocs a i e
marr = do
  (i
l,i
u) <- forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m (i, i)
getBounds a i e
marr
  Int
n <- forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m Int
getNumElements a i e
marr
  forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [ do e
e <- forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> m e
unsafeRead a i e
marr (forall i. Ix i => (i, i) -> Int -> i -> Int
safeIndex (i
l,i
u) Int
n i
i); forall (m :: * -> *) a. Monad m => a -> m a
return (i
i,e
e)
           | 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 :: forall (a :: * -> * -> *) e' (m :: * -> *) e i.
(MArray a e' m, MArray a e m, Ix i) =>
(e' -> e) -> a i e' -> m (a i e)
mapArray e' -> e
f a i e'
marr = do
  (i
l,i
u) <- forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m (i, i)
getBounds a i e'
marr
  Int
n <- 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' <- forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> m (a i e)
newArray_ (i
l,i
u)
  forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_ [do e'
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
                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 <- [Int
0 .. Int
n forall a. Num a => a -> a -> a
- Int
1]]
  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 :: forall (a :: * -> * -> *) e (m :: * -> *) i j.
(MArray a e m, Ix i, Ix j) =>
(i, i) -> (i -> j) -> a j e -> m (a i e)
mapIndices (i
l',i
u') i -> j
f a j e
marr = do
    a i e
marr' <- forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> m (a i e)
newArray_ (i
l',i
u')
    Int
n' <- forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m Int
getNumElements a i e
marr'
    forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_ [do e
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')
                  forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> e -> m ()
unsafeWrite a i e
marr' (forall i. Ix i => (i, i) -> Int -> i -> Int
safeIndex (i
l',i
u') Int
n' i
i') e
e
              | i
i' <- forall a. Ix a => (a, a) -> [a]
range (i
l',i
u')]
    forall (m :: * -> *) a. Monad m => a -> m a
return a i e
marr'




instance MArray (STArray s) e (ST s) where
    {-# INLINE getBounds #-}
    getBounds :: forall i. Ix i => STArray s i e -> ST s (i, i)
getBounds STArray s i e
arr = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$! forall s i e. STArray s i e -> (i, i)
ArrST.boundsSTArray STArray s i e
arr
    {-# INLINE getNumElements #-}
    getNumElements :: forall i. Ix i => STArray s i e -> ST s Int
getNumElements STArray s i e
arr = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$! forall s i e. STArray s i e -> Int
ArrST.numElementsSTArray STArray s i e
arr
    {-# INLINE newArray #-}
    newArray :: forall i. Ix i => (i, i) -> e -> ST s (STArray s i e)
newArray    = forall i e s. Ix i => (i, i) -> e -> ST s (STArray s i e)
ArrST.newSTArray
    {-# INLINE unsafeRead #-}
    unsafeRead :: forall i. Ix i => STArray s i e -> Int -> ST s e
unsafeRead  = forall s i e. STArray s i e -> Int -> ST s e
ArrST.unsafeReadSTArray
    {-# INLINE unsafeWrite #-}
    unsafeWrite :: forall i. Ix i => STArray s i e -> Int -> e -> ST s ()
unsafeWrite = 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 :: forall i. Ix i => STArray s i e -> ST s (i, i)
getBounds STArray s i e
arr = forall s a. ST s a -> ST s a
strictToLazyST (forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$! forall s i e. STArray s i e -> (i, i)
ArrST.boundsSTArray STArray s i e
arr)
    {-# INLINE getNumElements #-}
    getNumElements :: forall i. Ix i => STArray s i e -> ST s Int
getNumElements STArray s i e
arr = forall s a. ST s a -> ST s a
strictToLazyST (forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$! forall s i e. STArray s i e -> Int
ArrST.numElementsSTArray STArray s i e
arr)
    {-# INLINE newArray #-}
    newArray :: forall i. Ix i => (i, i) -> e -> ST s (STArray s i e)
newArray (i
l,i
u) e
e    = forall s a. ST s a -> ST s a
strictToLazyST (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 :: forall i. Ix i => STArray s i e -> Int -> ST s e
unsafeRead STArray s i e
arr Int
i    = forall s a. ST s a -> ST s a
strictToLazyST (forall s i e. STArray s i e -> Int -> ST s e
ArrST.unsafeReadSTArray STArray s i e
arr Int
i)
    {-# INLINE unsafeWrite #-}
    unsafeWrite :: forall i. Ix i => STArray s i e -> Int -> e -> ST s ()
unsafeWrite STArray s i e
arr Int
i e
e = forall s a. ST s a -> ST s a
strictToLazyST (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 i
_ i
_ Int
_ MutableByteArray# s
arr1# == :: STUArray s i e -> STUArray s i e -> Bool
== STUArray i
_ i
_ Int
_ MutableByteArray# s
arr2# =
        Int# -> Bool
isTrue# (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_ :: forall i s e.
Ix i =>
(i, i) -> (Int# -> Int#) -> ST s (STUArray s i e)
unsafeNewArraySTUArray_ (i
l,i
u) Int# -> Int#
elemsToBytes
 = case forall i. Ix i => (i, i) -> Int
rangeSize (i
l,i
u) of
       n :: Int
n@(I# Int#
n#) ->
           forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
               case forall d. Int# -> State# d -> (# State# d, MutableByteArray# d #)
newByteArray# (Int# -> Int#
elemsToBytes Int#
n#) State# s
s1# of
                   (# State# s
s2#, MutableByteArray# s
marr# #) ->
                       (# State# s
s2#, 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 :: forall i. Ix i => STUArray s i Bool -> ST s (i, i)
getBounds (STUArray i
l i
u Int
_ MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
    {-# INLINE getNumElements #-}
    getNumElements :: forall i. Ix i => STUArray s i Bool -> ST s Int
getNumElements (STUArray i
_ i
_ Int
n MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
    {-# INLINE newArray #-}
    newArray :: forall i. Ix i => (i, i) -> Bool -> ST s (STUArray s i Bool)
newArray (i
l,i
u) Bool
initialValue = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall i. Ix i => (i, i) -> Int
safeRangeSize (i
l,i
u)                   of { n :: Int
n@(I# Int#
n#) ->
        case Int# -> Int#
bOOL_SCALE Int#
n#                         of { Int#
nbytes# ->
        case forall d. Int# -> State# d -> (# State# d, MutableByteArray# d #)
newByteArray# Int#
nbytes# State# s
s1#             of { (# State# s
s2#, MutableByteArray# s
marr# #) ->
        case forall d.
MutableByteArray# d -> Int# -> Int# -> Int# -> State# d -> State# d
setByteArray# MutableByteArray# s
marr# Int#
0# Int#
nbytes# Int#
e# State# s
s2# of { State# s
s3# ->
        (# State# s
s3#, 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# Int#
e#) = if Bool
initialValue then Int
0xff else Int
0x0
    {-# INLINE unsafeNewArray_ #-}
    unsafeNewArray_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i Bool)
unsafeNewArray_ (i
l,i
u) = 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_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i Bool)
newArray_ (i, i)
arrBounds = 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 :: forall i. Ix i => STUArray s i Bool -> Int -> ST s Bool
unsafeRead (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
readWordArray# MutableByteArray# s
marr# (Int# -> Int#
bOOL_INDEX Int#
i#) State# s
s1# of { (# State# s
s2#, 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# Int#
0#) :: Bool #) }
    {-# INLINE unsafeWrite #-}
    unsafeWrite :: forall i. Ix i => STUArray s i Bool -> Int -> Bool -> ST s ()
unsafeWrite (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) Bool
e = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case Int# -> Int#
bOOL_INDEX Int#
i#              of { Int#
j# ->
        case forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
readWordArray# MutableByteArray# s
marr# Int#
j# State# s
s1# of { (# State# s
s2#, 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 { Word#
e# ->
        case forall d.
MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
writeWordArray# MutableByteArray# s
marr# Int#
j# Word#
e# State# s
s2# of { State# s
s3# ->
        (# State# s
s3#, () #) }}}}

instance MArray (STUArray s) Char (ST s) where
    {-# INLINE getBounds #-}
    getBounds :: forall i. Ix i => STUArray s i Char -> ST s (i, i)
getBounds (STUArray i
l i
u Int
_ MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
    {-# INLINE getNumElements #-}
    getNumElements :: forall i. Ix i => STUArray s i Char -> ST s Int
getNumElements (STUArray i
_ i
_ Int
n MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
    {-# INLINE unsafeNewArray_ #-}
    unsafeNewArray_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i Char)
unsafeNewArray_ (i
l,i
u) = 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 Int#
4#)
    {-# INLINE newArray_ #-}
    newArray_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i Char)
newArray_ (i, i)
arrBounds = 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 Int
0)
    {-# INLINE unsafeRead #-}
    unsafeRead :: forall i. Ix i => STUArray s i Char -> Int -> ST s Char
unsafeRead (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Char# #)
readWideCharArray# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# State# s
s2#, Char#
e# #) ->
        (# State# s
s2#, Char# -> Char
C# Char#
e# #) }
    {-# INLINE unsafeWrite #-}
    unsafeWrite :: forall i. Ix i => STUArray s i Char -> Int -> Char -> ST s ()
unsafeWrite (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) (C# Char#
e#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> Char# -> State# d -> State# d
writeWideCharArray# MutableByteArray# s
marr# Int#
i# Char#
e# State# s
s1# of { State# s
s2# ->
        (# State# s
s2#, () #) }

instance MArray (STUArray s) Int (ST s) where
    {-# INLINE getBounds #-}
    getBounds :: forall i. Ix i => STUArray s i Int -> ST s (i, i)
getBounds (STUArray i
l i
u Int
_ MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
    {-# INLINE getNumElements #-}
    getNumElements :: forall i. Ix i => STUArray s i Int -> ST s Int
getNumElements (STUArray i
_ i
_ Int
n MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
    {-# INLINE unsafeNewArray_ #-}
    unsafeNewArray_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i Int)
unsafeNewArray_ (i
l,i
u) = 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_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i Int)
newArray_ (i, i)
arrBounds = forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds Int
0
    {-# INLINE unsafeRead #-}
    unsafeRead :: forall i. Ix i => STUArray s i Int -> Int -> ST s Int
unsafeRead (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
readIntArray# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# State# s
s2#, Int#
e# #) ->
        (# State# s
s2#, Int# -> Int
I# Int#
e# #) }
    {-# INLINE unsafeWrite #-}
    unsafeWrite :: forall i. Ix i => STUArray s i Int -> Int -> Int -> ST s ()
unsafeWrite (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) (I# Int#
e#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
writeIntArray# MutableByteArray# s
marr# Int#
i# Int#
e# State# s
s1# of { State# s
s2# ->
        (# State# s
s2#, () #) }

instance MArray (STUArray s) Word (ST s) where
    {-# INLINE getBounds #-}
    getBounds :: forall i. Ix i => STUArray s i Word -> ST s (i, i)
getBounds (STUArray i
l i
u Int
_ MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
    {-# INLINE getNumElements #-}
    getNumElements :: forall i. Ix i => STUArray s i Word -> ST s Int
getNumElements (STUArray i
_ i
_ Int
n MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
    {-# INLINE unsafeNewArray_ #-}
    unsafeNewArray_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i Word)
unsafeNewArray_ (i
l,i
u) = 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_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i Word)
newArray_ (i, i)
arrBounds = forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds Word
0
    {-# INLINE unsafeRead #-}
    unsafeRead :: forall i. Ix i => STUArray s i Word -> Int -> ST s Word
unsafeRead (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
readWordArray# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# State# s
s2#, Word#
e# #) ->
        (# State# s
s2#, Word# -> Word
W# Word#
e# #) }
    {-# INLINE unsafeWrite #-}
    unsafeWrite :: forall i. Ix i => STUArray s i Word -> Int -> Word -> ST s ()
unsafeWrite (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) (W# Word#
e#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
writeWordArray# MutableByteArray# s
marr# Int#
i# Word#
e# State# s
s1# of { State# s
s2# ->
        (# State# s
s2#, () #) }

instance MArray (STUArray s) (Ptr a) (ST s) where
    {-# INLINE getBounds #-}
    getBounds :: forall i. Ix i => STUArray s i (Ptr a) -> ST s (i, i)
getBounds (STUArray i
l i
u Int
_ MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
    {-# INLINE getNumElements #-}
    getNumElements :: forall i. Ix i => STUArray s i (Ptr a) -> ST s Int
getNumElements (STUArray i
_ i
_ Int
n MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
    {-# INLINE unsafeNewArray_ #-}
    unsafeNewArray_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i (Ptr a))
unsafeNewArray_ (i
l,i
u) = 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_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i (Ptr a))
newArray_ (i, i)
arrBounds = forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds forall a. Ptr a
nullPtr
    {-# INLINE unsafeRead #-}
    unsafeRead :: forall i. Ix i => STUArray s i (Ptr a) -> Int -> ST s (Ptr a)
unsafeRead (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Addr# #)
readAddrArray# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# State# s
s2#, Addr#
e# #) ->
        (# State# s
s2#, forall a. Addr# -> Ptr a
Ptr Addr#
e# #) }
    {-# INLINE unsafeWrite #-}
    unsafeWrite :: forall i. Ix i => STUArray s i (Ptr a) -> Int -> Ptr a -> ST s ()
unsafeWrite (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) (Ptr Addr#
e#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> Addr# -> State# d -> State# d
writeAddrArray# MutableByteArray# s
marr# Int#
i# Addr#
e# State# s
s1# of { State# s
s2# ->
        (# State# s
s2#, () #) }

instance MArray (STUArray s) (FunPtr a) (ST s) where
    {-# INLINE getBounds #-}
    getBounds :: forall i. Ix i => STUArray s i (FunPtr a) -> ST s (i, i)
getBounds (STUArray i
l i
u Int
_ MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
    {-# INLINE getNumElements #-}
    getNumElements :: forall i. Ix i => STUArray s i (FunPtr a) -> ST s Int
getNumElements (STUArray i
_ i
_ Int
n MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
    {-# INLINE unsafeNewArray_ #-}
    unsafeNewArray_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i (FunPtr a))
unsafeNewArray_ (i
l,i
u) = 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_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i (FunPtr a))
newArray_ (i, i)
arrBounds = forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds forall a. FunPtr a
nullFunPtr
    {-# INLINE unsafeRead #-}
    unsafeRead :: forall i. Ix i => STUArray s i (FunPtr a) -> Int -> ST s (FunPtr a)
unsafeRead (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Addr# #)
readAddrArray# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# State# s
s2#, Addr#
e# #) ->
        (# State# s
s2#, forall a. Addr# -> FunPtr a
FunPtr Addr#
e# #) }
    {-# INLINE unsafeWrite #-}
    unsafeWrite :: forall i.
Ix i =>
STUArray s i (FunPtr a) -> Int -> FunPtr a -> ST s ()
unsafeWrite (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) (FunPtr Addr#
e#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> Addr# -> State# d -> State# d
writeAddrArray# MutableByteArray# s
marr# Int#
i# Addr#
e# State# s
s1# of { State# s
s2# ->
        (# State# s
s2#, () #) }

instance MArray (STUArray s) Float (ST s) where
    {-# INLINE getBounds #-}
    getBounds :: forall i. Ix i => STUArray s i Float -> ST s (i, i)
getBounds (STUArray i
l i
u Int
_ MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
    {-# INLINE getNumElements #-}
    getNumElements :: forall i. Ix i => STUArray s i Float -> ST s Int
getNumElements (STUArray i
_ i
_ Int
n MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
    {-# INLINE unsafeNewArray_ #-}
    unsafeNewArray_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i Float)
unsafeNewArray_ (i
l,i
u) = 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_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i Float)
newArray_ (i, i)
arrBounds = forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds Float
0
    {-# INLINE unsafeRead #-}
    unsafeRead :: forall i. Ix i => STUArray s i Float -> Int -> ST s Float
unsafeRead (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Float# #)
readFloatArray# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# State# s
s2#, Float#
e# #) ->
        (# State# s
s2#, Float# -> Float
F# Float#
e# #) }
    {-# INLINE unsafeWrite #-}
    unsafeWrite :: forall i. Ix i => STUArray s i Float -> Int -> Float -> ST s ()
unsafeWrite (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) (F# Float#
e#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> Float# -> State# d -> State# d
writeFloatArray# MutableByteArray# s
marr# Int#
i# Float#
e# State# s
s1# of { State# s
s2# ->
        (# State# s
s2#, () #) }

instance MArray (STUArray s) Double (ST s) where
    {-# INLINE getBounds #-}
    getBounds :: forall i. Ix i => STUArray s i Double -> ST s (i, i)
getBounds (STUArray i
l i
u Int
_ MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
    {-# INLINE getNumElements #-}
    getNumElements :: forall i. Ix i => STUArray s i Double -> ST s Int
getNumElements (STUArray i
_ i
_ Int
n MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
    {-# INLINE unsafeNewArray_ #-}
    unsafeNewArray_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i Double)
unsafeNewArray_ (i
l,i
u) = 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_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i Double)
newArray_ (i, i)
arrBounds = forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds Double
0
    {-# INLINE unsafeRead #-}
    unsafeRead :: forall i. Ix i => STUArray s i Double -> Int -> ST s Double
unsafeRead (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Double# #)
readDoubleArray# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# State# s
s2#, Double#
e# #) ->
        (# State# s
s2#, Double# -> Double
D# Double#
e# #) }
    {-# INLINE unsafeWrite #-}
    unsafeWrite :: forall i. Ix i => STUArray s i Double -> Int -> Double -> ST s ()
unsafeWrite (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) (D# Double#
e#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> Double# -> State# d -> State# d
writeDoubleArray# MutableByteArray# s
marr# Int#
i# Double#
e# State# s
s1# of { State# s
s2# ->
        (# State# s
s2#, () #) }

instance MArray (STUArray s) (StablePtr a) (ST s) where
    {-# INLINE getBounds #-}
    getBounds :: forall i. Ix i => STUArray s i (StablePtr a) -> ST s (i, i)
getBounds (STUArray i
l i
u Int
_ MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
    {-# INLINE getNumElements #-}
    getNumElements :: forall i. Ix i => STUArray s i (StablePtr a) -> ST s Int
getNumElements (STUArray i
_ i
_ Int
n MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
    {-# INLINE unsafeNewArray_ #-}
    unsafeNewArray_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i (StablePtr a))
unsafeNewArray_ (i
l,i
u) = 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_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i (StablePtr a))
newArray_ (i, i)
arrBounds = forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds (forall a. Ptr () -> StablePtr a
castPtrToStablePtr forall a. Ptr a
nullPtr)
    {-# INLINE unsafeRead #-}
    unsafeRead :: forall i.
Ix i =>
STUArray s i (StablePtr a) -> Int -> ST s (StablePtr a)
unsafeRead (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d a.
MutableByteArray# d
-> Int# -> State# d -> (# State# d, StablePtr# a #)
readStablePtrArray# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# State# s
s2#, StablePtr# a
e# #) ->
        (# State# s
s2# , forall a. StablePtr# a -> StablePtr a
StablePtr StablePtr# a
e# #) }
    {-# INLINE unsafeWrite #-}
    unsafeWrite :: forall i.
Ix i =>
STUArray s i (StablePtr a) -> Int -> StablePtr a -> ST s ()
unsafeWrite (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) (StablePtr StablePtr# a
e#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case 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 { State# s
s2# ->
        (# State# s
s2#, () #) }

instance MArray (STUArray s) Int8 (ST s) where
    {-# INLINE getBounds #-}
    getBounds :: forall i. Ix i => STUArray s i Int8 -> ST s (i, i)
getBounds (STUArray i
l i
u Int
_ MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
    {-# INLINE getNumElements #-}
    getNumElements :: forall i. Ix i => STUArray s i Int8 -> ST s Int
getNumElements (STUArray i
_ i
_ Int
n MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
    {-# INLINE unsafeNewArray_ #-}
    unsafeNewArray_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i Int8)
unsafeNewArray_ (i
l,i
u) = forall i s e.
Ix i =>
(i, i) -> (Int# -> Int#) -> ST s (STUArray s i e)
unsafeNewArraySTUArray_ (i
l,i
u) (\Int#
x -> Int#
x)
    {-# INLINE newArray_ #-}
    newArray_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i Int8)
newArray_ (i, i)
arrBounds = forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds Int8
0
    {-# INLINE unsafeRead #-}
    unsafeRead :: forall i. Ix i => STUArray s i Int8 -> Int -> ST s Int8
unsafeRead (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8# #)
readInt8Array# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# State# s
s2#, Int8#
e# #) ->
        (# State# s
s2#, Int8# -> Int8
I8# Int8#
e# #) }
    {-# INLINE unsafeWrite #-}
    unsafeWrite :: forall i. Ix i => STUArray s i Int8 -> Int -> Int8 -> ST s ()
unsafeWrite (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) (I8# Int8#
e#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> Int8# -> State# d -> State# d
writeInt8Array# MutableByteArray# s
marr# Int#
i# Int8#
e# State# s
s1# of { State# s
s2# ->
        (# State# s
s2#, () #) }

instance MArray (STUArray s) Int16 (ST s) where
    {-# INLINE getBounds #-}
    getBounds :: forall i. Ix i => STUArray s i Int16 -> ST s (i, i)
getBounds (STUArray i
l i
u Int
_ MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
    {-# INLINE getNumElements #-}
    getNumElements :: forall i. Ix i => STUArray s i Int16 -> ST s Int
getNumElements (STUArray i
_ i
_ Int
n MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
    {-# INLINE unsafeNewArray_ #-}
    unsafeNewArray_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i Int16)
unsafeNewArray_ (i
l,i
u) = 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 Int#
2#)
    {-# INLINE newArray_ #-}
    newArray_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i Int16)
newArray_ (i, i)
arrBounds = forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds Int16
0
    {-# INLINE unsafeRead #-}
    unsafeRead :: forall i. Ix i => STUArray s i Int16 -> Int -> ST s Int16
unsafeRead (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Int16# #)
readInt16Array# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# State# s
s2#, Int16#
e# #) ->
        (# State# s
s2#, Int16# -> Int16
I16# Int16#
e# #) }
    {-# INLINE unsafeWrite #-}
    unsafeWrite :: forall i. Ix i => STUArray s i Int16 -> Int -> Int16 -> ST s ()
unsafeWrite (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) (I16# Int16#
e#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> Int16# -> State# d -> State# d
writeInt16Array# MutableByteArray# s
marr# Int#
i# Int16#
e# State# s
s1# of { State# s
s2# ->
        (# State# s
s2#, () #) }

instance MArray (STUArray s) Int32 (ST s) where
    {-# INLINE getBounds #-}
    getBounds :: forall i. Ix i => STUArray s i Int32 -> ST s (i, i)
getBounds (STUArray i
l i
u Int
_ MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
    {-# INLINE getNumElements #-}
    getNumElements :: forall i. Ix i => STUArray s i Int32 -> ST s Int
getNumElements (STUArray i
_ i
_ Int
n MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
    {-# INLINE unsafeNewArray_ #-}
    unsafeNewArray_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i Int32)
unsafeNewArray_ (i
l,i
u) = 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 Int#
4#)
    {-# INLINE newArray_ #-}
    newArray_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i Int32)
newArray_ (i, i)
arrBounds = forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds Int32
0
    {-# INLINE unsafeRead #-}
    unsafeRead :: forall i. Ix i => STUArray s i Int32 -> Int -> ST s Int32
unsafeRead (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Int32# #)
readInt32Array# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# State# s
s2#, Int32#
e# #) ->
        (# State# s
s2#, Int32# -> Int32
I32# Int32#
e# #) }
    {-# INLINE unsafeWrite #-}
    unsafeWrite :: forall i. Ix i => STUArray s i Int32 -> Int -> Int32 -> ST s ()
unsafeWrite (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) (I32# Int32#
e#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> Int32# -> State# d -> State# d
writeInt32Array# MutableByteArray# s
marr# Int#
i# Int32#
e# State# s
s1# of { State# s
s2# ->
        (# State# s
s2#, () #) }

instance MArray (STUArray s) Int64 (ST s) where
    {-# INLINE getBounds #-}
    getBounds :: forall i. Ix i => STUArray s i Int64 -> ST s (i, i)
getBounds (STUArray i
l i
u Int
_ MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
    {-# INLINE getNumElements #-}
    getNumElements :: forall i. Ix i => STUArray s i Int64 -> ST s Int
getNumElements (STUArray i
_ i
_ Int
n MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
    {-# INLINE unsafeNewArray_ #-}
    unsafeNewArray_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i Int64)
unsafeNewArray_ (i
l,i
u) = 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 Int#
8#)
    {-# INLINE newArray_ #-}
    newArray_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i Int64)
newArray_ (i, i)
arrBounds = forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds Int64
0
    {-# INLINE unsafeRead #-}
    unsafeRead :: forall i. Ix i => STUArray s i Int64 -> Int -> ST s Int64
unsafeRead (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Int# #)
readInt64Array# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# State# s
s2#, Int#
e# #) ->
        (# State# s
s2#, Int# -> Int64
I64# Int#
e# #) }
    {-# INLINE unsafeWrite #-}
    unsafeWrite :: forall i. Ix i => STUArray s i Int64 -> Int -> Int64 -> ST s ()
unsafeWrite (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) (I64# Int#
e#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> Int# -> State# d -> State# d
writeInt64Array# MutableByteArray# s
marr# Int#
i# Int#
e# State# s
s1# of { State# s
s2# ->
        (# State# s
s2#, () #) }

instance MArray (STUArray s) Word8 (ST s) where
    {-# INLINE getBounds #-}
    getBounds :: forall i. Ix i => STUArray s i Word8 -> ST s (i, i)
getBounds (STUArray i
l i
u Int
_ MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
    {-# INLINE getNumElements #-}
    getNumElements :: forall i. Ix i => STUArray s i Word8 -> ST s Int
getNumElements (STUArray i
_ i
_ Int
n MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
    {-# INLINE unsafeNewArray_ #-}
    unsafeNewArray_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i Word8)
unsafeNewArray_ (i
l,i
u) = forall i s e.
Ix i =>
(i, i) -> (Int# -> Int#) -> ST s (STUArray s i e)
unsafeNewArraySTUArray_ (i
l,i
u) (\Int#
x -> Int#
x)
    {-# INLINE newArray_ #-}
    newArray_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i Word8)
newArray_ (i, i)
arrBounds = forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds Word8
0
    {-# INLINE unsafeRead #-}
    unsafeRead :: forall i. Ix i => STUArray s i Word8 -> Int -> ST s Word8
unsafeRead (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Word8# #)
readWord8Array# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# State# s
s2#, Word8#
e# #) ->
        (# State# s
s2#, Word8# -> Word8
W8# Word8#
e# #) }
    {-# INLINE unsafeWrite #-}
    unsafeWrite :: forall i. Ix i => STUArray s i Word8 -> Int -> Word8 -> ST s ()
unsafeWrite (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) (W8# Word8#
e#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> Word8# -> State# d -> State# d
writeWord8Array# MutableByteArray# s
marr# Int#
i# Word8#
e# State# s
s1# of { State# s
s2# ->
        (# State# s
s2#, () #) }

instance MArray (STUArray s) Word16 (ST s) where
    {-# INLINE getBounds #-}
    getBounds :: forall i. Ix i => STUArray s i Word16 -> ST s (i, i)
getBounds (STUArray i
l i
u Int
_ MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
    {-# INLINE getNumElements #-}
    getNumElements :: forall i. Ix i => STUArray s i Word16 -> ST s Int
getNumElements (STUArray i
_ i
_ Int
n MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
    {-# INLINE unsafeNewArray_ #-}
    unsafeNewArray_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i Word16)
unsafeNewArray_ (i
l,i
u) = 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 Int#
2#)
    {-# INLINE newArray_ #-}
    newArray_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i Word16)
newArray_ (i, i)
arrBounds = forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds Word16
0
    {-# INLINE unsafeRead #-}
    unsafeRead :: forall i. Ix i => STUArray s i Word16 -> Int -> ST s Word16
unsafeRead (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Word16# #)
readWord16Array# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# State# s
s2#, Word16#
e# #) ->
        (# State# s
s2#, Word16# -> Word16
W16# Word16#
e# #) }
    {-# INLINE unsafeWrite #-}
    unsafeWrite :: forall i. Ix i => STUArray s i Word16 -> Int -> Word16 -> ST s ()
unsafeWrite (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) (W16# Word16#
e#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> Word16# -> State# d -> State# d
writeWord16Array# MutableByteArray# s
marr# Int#
i# Word16#
e# State# s
s1# of { State# s
s2# ->
        (# State# s
s2#, () #) }

instance MArray (STUArray s) Word32 (ST s) where
    {-# INLINE getBounds #-}
    getBounds :: forall i. Ix i => STUArray s i Word32 -> ST s (i, i)
getBounds (STUArray i
l i
u Int
_ MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
    {-# INLINE getNumElements #-}
    getNumElements :: forall i. Ix i => STUArray s i Word32 -> ST s Int
getNumElements (STUArray i
_ i
_ Int
n MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
    {-# INLINE unsafeNewArray_ #-}
    unsafeNewArray_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i Word32)
unsafeNewArray_ (i
l,i
u) = 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 Int#
4#)
    {-# INLINE newArray_ #-}
    newArray_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i Word32)
newArray_ (i, i)
arrBounds = forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds Word32
0
    {-# INLINE unsafeRead #-}
    unsafeRead :: forall i. Ix i => STUArray s i Word32 -> Int -> ST s Word32
unsafeRead (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Word32# #)
readWord32Array# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# State# s
s2#, Word32#
e# #) ->
        (# State# s
s2#, Word32# -> Word32
W32# Word32#
e# #) }
    {-# INLINE unsafeWrite #-}
    unsafeWrite :: forall i. Ix i => STUArray s i Word32 -> Int -> Word32 -> ST s ()
unsafeWrite (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) (W32# Word32#
e#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> Word32# -> State# d -> State# d
writeWord32Array# MutableByteArray# s
marr# Int#
i# Word32#
e# State# s
s1# of { State# s
s2# ->
        (# State# s
s2#, () #) }

instance MArray (STUArray s) Word64 (ST s) where
    {-# INLINE getBounds #-}
    getBounds :: forall i. Ix i => STUArray s i Word64 -> ST s (i, i)
getBounds (STUArray i
l i
u Int
_ MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return (i
l,i
u)
    {-# INLINE getNumElements #-}
    getNumElements :: forall i. Ix i => STUArray s i Word64 -> ST s Int
getNumElements (STUArray i
_ i
_ Int
n MutableByteArray# s
_) = forall (m :: * -> *) a. Monad m => a -> m a
return Int
n
    {-# INLINE unsafeNewArray_ #-}
    unsafeNewArray_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i Word64)
unsafeNewArray_ (i
l,i
u) = 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 Int#
8#)
    {-# INLINE newArray_ #-}
    newArray_ :: forall i. Ix i => (i, i) -> ST s (STUArray s i Word64)
newArray_ (i, i)
arrBounds = forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> e -> m (a i e)
newArray (i, i)
arrBounds Word64
0
    {-# INLINE unsafeRead #-}
    unsafeRead :: forall i. Ix i => STUArray s i Word64 -> Int -> ST s Word64
unsafeRead (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Word# #)
readWord64Array# MutableByteArray# s
marr# Int#
i# State# s
s1# of { (# State# s
s2#, Word#
e# #) ->
        (# State# s
s2#, Word# -> Word64
W64# Word#
e# #) }
    {-# INLINE unsafeWrite #-}
    unsafeWrite :: forall i. Ix i => STUArray s i Word64 -> Int -> Word64 -> ST s ()
unsafeWrite (STUArray i
_ i
_ Int
_ MutableByteArray# s
marr#) (I# Int#
i#) (W64# Word#
e#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
        case forall d.
MutableByteArray# d -> Int# -> Word# -> State# d -> State# d
writeWord64Array# MutableByteArray# s
marr# Int#
i# Word#
e# State# s
s1# of { State# s
s2# ->
        (# State# s
s2#, () #) }




bOOL_SCALE, wORD_SCALE, dOUBLE_SCALE, fLOAT_SCALE :: Int# -> Int#
bOOL_SCALE :: Int# -> Int#
bOOL_SCALE Int#
n# =
    
    (Int#
n# Int# -> Int# -> Int#
+# Int#
7#) Int# -> Int# -> Int#
`uncheckedIShiftRA#` Int#
3#
wORD_SCALE :: Int# -> Int#
wORD_SCALE   Int#
n# = Int# -> Int# -> Int#
safe_scale Int#
scale# Int#
n# where !(I# Int#
scale#) = SIZEOF_HSWORD
dOUBLE_SCALE :: Int# -> Int#
dOUBLE_SCALE Int#
n# = Int# -> Int# -> Int#
safe_scale Int#
scale# Int#
n# where !(I# Int#
scale#) = SIZEOF_HSDOUBLE
fLOAT_SCALE :: Int# -> Int#
fLOAT_SCALE  Int#
n# = Int# -> Int# -> Int#
safe_scale Int#
scale# Int#
n# where !(I# Int#
scale#) = SIZEOF_HSFLOAT

safe_scale :: Int# -> Int# -> Int#
safe_scale :: Int# -> Int# -> Int#
safe_scale Int#
scale# Int#
n#
  | Bool -> Bool
not Bool
overflow = Int#
res#
  | Bool
otherwise    = forall a. HasCallStack => [Char] -> a
error forall a b. (a -> b) -> a -> b
$ [Char]
"Data.Array.Base.safe_scale: Overflow; scale: "
    forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show (Int# -> Int
I# Int#
scale#) forall a. [a] -> [a] -> [a]
++ [Char]
", n: " forall a. [a] -> [a] -> [a]
++ 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# Int#
maxN#) = 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 Int#
i# = Int#
i# Int# -> Int# -> Int#
`uncheckedIShiftRA#` Int#
6#
#endif

bOOL_BIT, bOOL_NOT_BIT :: Int# -> Word#
bOOL_BIT :: Int# -> Word#
bOOL_BIT     Int#
n# = Int# -> Word#
int2Word# Int#
1# Word# -> Int# -> Word#
`uncheckedShiftL#` (Word# -> Int#
word2Int# (Int# -> Word#
int2Word# Int#
n# Word# -> Word# -> Word#
`and#` Word#
mask#))
    where !(W# Word#
mask#) = SIZEOF_HSWORD * 8 - 1
bOOL_NOT_BIT :: Int# -> Word#
bOOL_NOT_BIT Int#
n# = Int# -> Word#
bOOL_BIT Int#
n# Word# -> Word# -> Word#
`xor#` Word#
mb#
    where !(W# Word#
mb#) = 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 :: forall i (a :: * -> * -> *) e (m :: * -> *) (b :: * -> * -> *).
(Ix i, MArray a e m, IArray b e) =>
a i e -> m (b i e)
freeze a i e
marr = do
  (i
l,i
u) <- forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m (i, i)
getBounds a i e
marr
  Int
n <- forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m Int
getNumElements a i e
marr
  [e]
es <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> m e
unsafeRead a i e
marr) [Int
0 .. Int
n forall a. Num a => a -> a -> a
- Int
1]
  
  
  forall (m :: * -> *) a. Monad m => a -> m a
return (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 :: forall s i e. STUArray s i e -> ST s (UArray i e)
freezeSTUArray (STUArray i
l i
u Int
n MutableByteArray# s
marr#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
    case forall d. MutableByteArray# d -> Int#
sizeofMutableByteArray# MutableByteArray# s
marr#  of { Int#
n# ->
    case forall d. Int# -> State# d -> (# State# d, MutableByteArray# d #)
newByteArray# Int#
n# State# s
s1#           of { (# State# s
s2#, MutableByteArray# s
marr'# #) ->
    case forall s a.
MutableByteArray# s -> MutableByteArray# s -> CSize -> IO (Ptr a)
memcpy_freeze MutableByteArray# s
marr'# MutableByteArray# s
marr# (forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int# -> Int
I# Int#
n#)) of { IO State# RealWorld -> (# State# RealWorld, Ptr Any #)
m ->
    case unsafeCoerce# :: forall a b. a -> b
unsafeCoerce# State# RealWorld -> (# State# RealWorld, Ptr Any #)
m State# s
s2#            of { (# State# s
s3#, Any
_ #) ->
    case forall d.
MutableByteArray# d -> State# d -> (# State# d, ByteArray# #)
unsafeFreezeByteArray# MutableByteArray# s
marr'# State# s
s3# of { (# State# s
s4#, ByteArray#
arr# #) ->
    (# State# s
s4#, 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 :: forall i (a :: * -> * -> *) e (m :: * -> *) (b :: * -> * -> *).
(Ix i, MArray a e m, IArray b e) =>
a i e -> m (b i e)
unsafeFreeze = 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 :: 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 = case forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> (i, i)
bounds a i e
arr of
  (i
l,i
u) -> do
    b i e
marr <- 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 = forall i. Ix i => (i, i) -> Int
safeRangeSize (i
l,i
u)
    forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
sequence_ [ forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> e -> m ()
unsafeWrite b i e
marr Int
i (forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> Int -> e
unsafeAt a i e
arr Int
i)
              | Int
i <- [Int
0 .. Int
n forall a. Num a => a -> a -> a
- Int
1]]
    forall (m :: * -> *) a. Monad m => a -> m a
return b i e
marr

thawSTUArray :: UArray i e -> ST s (STUArray s i e)
thawSTUArray :: forall i e s. UArray i e -> ST s (STUArray s i e)
thawSTUArray (UArray i
l i
u Int
n ByteArray#
arr#) = forall s a. STRep s a -> ST s a
ST forall a b. (a -> b) -> a -> b
$ \State# s
s1# ->
    case ByteArray# -> Int#
sizeofByteArray# ByteArray#
arr#          of { Int#
n# ->
    case forall d. Int# -> State# d -> (# State# d, MutableByteArray# d #)
newByteArray# Int#
n# State# s
s1#           of { (# State# s
s2#, MutableByteArray# s
marr# #) ->
    case forall s a.
MutableByteArray# s -> ByteArray# -> CSize -> IO (Ptr a)
memcpy_thaw MutableByteArray# s
marr# ByteArray#
arr# (forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int# -> Int
I# Int#
n#)) of { IO State# RealWorld -> (# State# RealWorld, Ptr Any #)
m ->
    case unsafeCoerce# :: forall a b. a -> b
unsafeCoerce# State# RealWorld -> (# State# RealWorld, Ptr Any #)
m State# s
s2#            of { (# State# s
s3#, Any
_ #) ->
    (# State# s
s3#, 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 :: forall i (a :: * -> * -> *) e (b :: * -> * -> *) (m :: * -> *).
(Ix i, IArray a e, MArray b e m) =>
a i e -> m (b i e)
unsafeThaw = 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 :: forall i e s. UArray i e -> ST s (STUArray s i e)
unsafeThawSTUArray (UArray i
l i
u Int
n ByteArray#
marr#) =
    forall (m :: * -> *) a. Monad m => a -> m a
return (forall s i e.
i -> i -> Int -> MutableByteArray# s -> STUArray s i e
STUArray i
l i
u Int
n (unsafeCoerce# :: forall a b. a -> b
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 :: forall ix e. Array ix e -> IO (IOArray ix e)
unsafeThawIOArray Array ix e
arr = forall a. ST RealWorld a -> IO a
stToIO forall a b. (a -> b) -> a -> b
$ do
    STArray RealWorld ix e
marr <- forall i e s. Array i e -> ST s (STArray s i e)
ArrST.unsafeThawSTArray Array ix e
arr
    forall (m :: * -> *) a. Monad m => a -> m a
return (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 :: forall ix e. Array ix e -> IO (IOArray ix e)
thawIOArray Array ix e
arr = forall a. ST RealWorld a -> IO a
stToIO forall a b. (a -> b) -> a -> b
$ do
    STArray RealWorld ix e
marr <- forall i e s. Array i e -> ST s (STArray s i e)
ArrST.thawSTArray Array ix e
arr
    forall (m :: * -> *) a. Monad m => a -> m a
return (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 :: forall ix e. IOArray ix e -> IO (Array ix e)
freezeIOArray (IOArray STArray RealWorld ix e
marr) = forall a. ST RealWorld a -> IO a
stToIO (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 :: forall ix e. IOArray ix e -> IO (Array ix e)
unsafeFreezeIOArray (IOArray STArray RealWorld ix e
marr) = forall a. ST RealWorld a -> IO a
stToIO (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 :: forall s ix a b. STUArray s ix a -> ST s (STUArray s ix b)
castSTUArray (STUArray ix
l ix
u Int
n MutableByteArray# s
marr#) = forall (m :: * -> *) a. Monad m => a -> m a
return (forall s i e.
i -> i -> Int -> MutableByteArray# s -> STUArray s i e
STUArray ix
l ix
u Int
n MutableByteArray# s
marr#)