array 0.4.0.1 → 0.5.8.0
raw patch · 19 files changed
Files
- Data/Array.hs +0/−12
- Data/Array/Base.hs +360/−455
- Data/Array/IArray.hs +12/−0
- Data/Array/IO.hs +5/−67
- Data/Array/IO/Internals.hs +27/−29
- Data/Array/IO/Safe.hs +3/−3
- Data/Array/MArray.hs +14/−77
- Data/Array/MArray/Safe.hs +11/−1
- Data/Array/ST.hs +3/−27
- Data/Array/ST/Safe.hs +2/−1
- Data/Array/Storable.hs +2/−19
- Data/Array/Storable/Internals.hs +17/−2
- Data/Array/Storable/Safe.hs +1/−0
- Data/Array/Unsafe.hs +1/−0
- LICENSE +1/−0
- Setup.hs +1/−0
- array.cabal +34/−34
- changelog.md +101/−0
- include/Typeable.h +0/−59
Data/Array.hs view
@@ -54,19 +54,7 @@ ) where import Data.Ix-import Data.Typeable ()--#ifdef __GLASGOW_HASKELL__ import GHC.Arr -- Most of the hard work is done here-#endif--#ifdef __HUGS__-import Hugs.Array-#endif--#ifdef __NHC__-import Array -- Haskell'98 arrays-#endif {- $intro Haskell provides indexable /arrays/, which may be thought of as functions
Data/Array/Base.hs view
@@ -1,11 +1,16 @@-{-# OPTIONS_GHC -XBangPatterns -fno-warn-unused-imports #-}-{-# OPTIONS_HADDOCK hide #-}--- XXX With a GHC 6.9 we get a spurious--- Data/Array/Base.hs:26:0:--- Warning: Module `Data.Ix' is imported, but nothing from it is used,--- except perhaps instances visible in `Data.Ix'--- To suppress this warning, use: import Data.Ix()--- The -fno-warn-unused-imports works around that bug+{-# LANGUAGE+ BangPatterns+ , CPP+ , RankNTypes+ , MagicHash+ , UnboxedTuples+ , MultiParamTypeClasses+ , FlexibleInstances+ , FlexibleContexts+ , UnliftedFFITypes+ , RoleAnnotations+ #-}+{-# OPTIONS_HADDOCK not-home #-} ----------------------------------------------------------------------------- -- |@@ -20,61 +25,47 @@ -- Basis for IArray and MArray. Not intended for external consumption; -- use IArray or MArray instead. --+-- = WARNING+--+-- This module is considered __internal__.+--+-- The Package Versioning Policy __does not apply__.+--+-- The contents of this module may change __in any way whatsoever__+-- and __without any warning__ between minor versions of this package.+--+-- Authors importing this module are expected to track development+-- closely. ----------------------------------------------------------------------------- --- #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 Data.Ix ( Ix, range, index, inRange, rangeSize ) import Foreign.C.Types import Foreign.StablePtr -#ifdef __GLASGOW_HASKELL__ import Data.Char import GHC.Arr ( STArray, unsafeIndex ) import qualified GHC.Arr as Arr import qualified GHC.Arr as ArrST import GHC.ST ( ST(..), runST )-import GHC.Base-import GHC.Word ( Word(..) )-import GHC.Ptr ( Ptr(..), FunPtr(..), nullPtr, nullFunPtr )-import GHC.Float ( Float(..), Double(..) )+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(..) )-#if __GLASGOW_HASKELL__ >= 611-import GHC.IO ( IO(..), stToIO )+import GHC.IO ( stToIO ) import GHC.IOArray ( IOArray(..), newIOArray, unsafeReadIOArray, unsafeWriteIOArray )-#else-import GHC.IOBase ( IO(..), IOArray(..), stToIO,- newIOArray, unsafeReadIOArray, unsafeWriteIOArray )-#endif-#else-import Data.Int-import Data.Word-import Foreign.Ptr-#endif--#ifdef __HUGS__-import Data.Bits-import Foreign.Storable-import qualified Hugs.Array as Arr-import qualified Hugs.ST as ArrST-import Hugs.Array ( unsafeIndex )-import Hugs.IOArray-import Hugs.ST ( STArray, ST(..), runST )-import Hugs.ByteArray-#endif--import Data.Typeable-#include "Typeable.h"+import Text.Read.Lex ( Lexeme(Ident) )+import Text.ParserCombinators.ReadPrec ( prec, ReadPrec, step ) -#ifdef __GLASGOW_HASKELL__ #include "MachDeps.h"-#endif ----------------------------------------------------------------------------- -- Class of immutable arrays@@ -203,35 +194,26 @@ let n = safeRangeSize (l,u) in unsafeArray (l,u) (zip [0 .. n - 1] es) -{-# INLINE listArrayST #-}+{-# INLINE genArray #-}+-- | Constructs an immutable array using a generator function.+--+-- @since 0.5.6.0+genArray :: (IArray a e, Ix i) => (i,i) -> (i -> e) -> a i e+genArray (l,u) f = listArray (l,u) $ map f $ range (l,u)++{-# INLINE listArrayST #-} -- See Note [Inlining and fusion] listArrayST :: Ix i => (i,i) -> [e] -> ST s (STArray s i e)-listArrayST (l,u) es = do- marr <- newArray_ (l,u)- let n = safeRangeSize (l,u)- let fillFromList i xs | i == n = return ()- | otherwise = case xs of- [] -> return ()- y:ys -> unsafeWrite marr i y >> fillFromList (i+1) ys- fillFromList 0 es- return marr+listArrayST = newListArray {-# RULES "listArray/Array" listArray = \lu es -> runST (listArrayST lu es >>= ArrST.unsafeFreezeSTArray) #-} -{-# INLINE listUArrayST #-}+{-# INLINE listUArrayST #-} -- See Note [Inlining and fusion] listUArrayST :: (MArray (STUArray s) e (ST s), Ix i) => (i,i) -> [e] -> ST s (STUArray s i e)-listUArrayST (l,u) es = do- marr <- newArray_ (l,u)- let n = safeRangeSize (l,u)- let fillFromList i xs | i == n = return ()- | otherwise = case xs of- [] -> return ()- y:ys -> unsafeWrite marr i y >> fillFromList (i+1) ys- fillFromList 0 es- return marr+listUArrayST = newListArray -- I don't know how to write a single rule for listUArrayST, because -- the type looks like constrained over 's', which runST doesn't@@ -252,7 +234,6 @@ -- calls seem to be floated out, then floated back into the middle -- of listUArrayST, so I was not able to do this. -#ifdef __GLASGOW_HASKELL__ type ListUArray e = forall i . Ix i => (i,i) -> [e] -> UArray i e {-# RULES@@ -291,14 +272,25 @@ "listArray/UArray/Word64" listArray = (\lu es -> runST (listUArrayST lu es >>= unsafeFreezeSTUArray)) :: ListUArray Word64 #-}-#endif {-# INLINE (!) #-}--- | Returns the element of an immutable array at the specified index.+-- | Returns the element of an immutable array at the specified index,+-- or throws an exception if the index is out of bounds. (!) :: (IArray a e, Ix i) => a i e -> i -> e (!) arr i = case bounds arr of (l,u) -> unsafeAt arr $ safeIndex (l,u) (numElements arr) i +{-# INLINE (!?) #-}+-- | Returns 'Just' the element of an immutable array at the specified index,+-- or 'Nothing' if the index is out of bounds.+--+-- @since 0.5.6.0+(!?) :: (IArray a e, Ix i) => a i e -> i -> Maybe e+(!?) arr i = let b = bounds arr in+ if inRange b i+ then Just $ unsafeAt arr $ unsafeIndex b i+ else Nothing+ {-# INLINE indices #-} -- | Returns a list of all the valid indices in an array. indices :: (IArray a e, Ix i) => a i e -> [i]@@ -308,8 +300,7 @@ -- | Returns a list of all the elements of an array, in the same order -- as their indices. elems :: (IArray a e, Ix i) => a i e -> [e]-elems arr = case bounds arr of- (_l, _u) -> [unsafeAt arr i | i <- [0 .. numElements arr - 1]]+elems arr = [unsafeAt arr i | i <- [0 .. numElements arr - 1]] {-# INLINE assocs #-} -- | Returns the contents of an array as a list of associations.@@ -395,6 +386,94 @@ ixmap (l,u) f arr = array (l,u) [(i, arr ! f i) | i <- range (l,u)] +-- | Lazy right-associative fold.+--+-- @since 0.5.8.0+foldrArray :: (IArray a e, Ix i) => (e -> b -> b) -> b -> a i e -> b+foldrArray f z = \a ->+ let !n = numElements a+ go i | i >= n = z+ | otherwise = f (unsafeAt a i) (go (i+1))+ in go 0+{-# INLINE foldrArray #-}++-- | Strict accumulating left-associative fold.+--+-- @since 0.5.8.0+foldlArray' :: (IArray a e, Ix i) => (b -> e -> b) -> b -> a i e -> b+foldlArray' f z0 = \a ->+ let !n = numElements a+ go !z i | i >= n = z+ | otherwise = go (f z (unsafeAt a i)) (i+1)+ in go z0 0+{-# INLINE foldlArray' #-}++-- | Lazy left-associative fold.+--+-- @since 0.5.8.0+foldlArray :: (IArray a e, Ix i) => (b -> e -> b) -> b -> a i e -> b+foldlArray f z = \a ->+ let !n = numElements a+ go i | i < 0 = z+ | otherwise = f (go (i-1)) (unsafeAt a i)+ in go (n-1)+{-# INLINE foldlArray #-}++-- | Strict accumulating right-associative fold.+--+-- @since 0.5.8.0+foldrArray' :: (IArray a e, Ix i) => (e -> b -> b) -> b -> a i e -> b+foldrArray' f z0 = \a ->+ let !n = numElements a+ go i !z | i < 0 = z+ | otherwise = go (i-1) (f (unsafeAt a i) z)+ in go (n-1) z0+{-# INLINE foldrArray' #-}++-- | Map elements to applicative actions, sequence them left-to-right, and+-- discard the results.+--+-- @since 0.5.8.0+traverseArray_+ :: (IArray a e, Ix i, Applicative f) => (e -> f b) -> a i e -> f ()+traverseArray_ f = foldrArray (\x z -> f x *> z) (pure ())+{-# INLINE traverseArray_ #-}++-- | @forArray_@ is 'traverseArray_' with its arguments flipped.+--+-- @since 0.5.8.0+forArray_ :: (IArray a e, Ix i, Applicative f) => a i e -> (e -> f b) -> f ()+forArray_ = flip traverseArray_+{-# INLINE forArray_ #-}++-- | Strict accumulating left-associative monadic fold.+--+-- @since 0.5.8.0+foldlArrayM'+ :: (IArray a e, Ix i, Monad m) => (b -> e -> m b) -> b -> a i e -> m b+foldlArrayM' f z0 = \a ->+ let !n = numElements a+ go !z i | i >= n = pure z+ | otherwise = do+ z' <- f z (unsafeAt a i)+ go z' (i+1)+ in go z0 0+{-# INLINE foldlArrayM' #-}++-- | Strict accumulating right-associative monadic fold.+--+-- @since 0.5.8.0+foldrArrayM'+ :: (IArray a e, Ix i, Monad m) => (e -> b -> m b) -> b -> a i e -> m b+foldrArrayM' f z0 = \a ->+ let !n = numElements a+ go i !z | i < 0 = pure z+ | otherwise = do+ z' <- f (unsafeAt a i) z+ go (i-1) z'+ in go (n-1) z0+{-# INLINE foldrArrayM' #-}+ ----------------------------------------------------------------------------- -- Normal polymorphic arrays @@ -433,14 +512,9 @@ -- get the benefits of unboxed arrays (don\'t forget to import -- "Data.Array.Unboxed" instead of "Data.Array"). ---#ifdef __GLASGOW_HASKELL__ data UArray i e = UArray !i !i !Int ByteArray#-#endif-#ifdef __HUGS__-data UArray i e = UArray !i !i !Int !ByteArray-#endif--INSTANCE_TYPEABLE2(UArray,uArrayTc,"UArray")+-- There are class-based invariants on both parameters. See also #9220.+type role UArray nominal nominal {-# INLINE unsafeArrayUArray #-} unsafeArrayUArray :: (MArray (STUArray s) e (ST s), Ix i)@@ -452,15 +526,9 @@ {-# INLINE unsafeFreezeSTUArray #-} unsafeFreezeSTUArray :: STUArray s i e -> ST s (UArray i e)-#if __GLASGOW_HASKELL__ unsafeFreezeSTUArray (STUArray l u n marr#) = ST $ \s1# -> case unsafeFreezeByteArray# marr# s1# of { (# s2#, arr# #) -> (# s2#, UArray l u n arr# #) }-#elif __HUGS__-unsafeFreezeSTUArray (STUArray l u n marr) = do- arr <- unsafeFreezeMutableByteArray marr- return (UArray l u n arr)-#endif {-# INLINE unsafeReplaceUArray #-} unsafeReplaceUArray :: (MArray (STUArray s) e (ST s), Ix i)@@ -517,7 +585,7 @@ {-# RULES "cmpUArray/Int" cmpUArray = cmpIntUArray #-} -------------------------------------------------------------------------------- Showing IArrays+-- Showing and Reading IArrays {-# SPECIALISE showsIArray :: (IArray UArray e, Ix i, Show i, Show e) =>@@ -526,20 +594,27 @@ showsIArray :: (IArray a e, Ix i, Show i, Show e) => Int -> a i e -> ShowS showsIArray p a =- showParen (p > 9) $+ showParen (p > appPrec) $ showString "array " . shows (bounds a) . showChar ' ' . shows (assocs 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 = parens $ prec appPrec $+ do expectP (Ident "array")+ theBounds <- step readPrec+ vals <- step readPrec+ return (array theBounds vals)+ ----------------------------------------------------------------------------- -- Flat unboxed arrays: instances -#ifdef __HUGS__-unsafeAtBArray :: Storable e => UArray i e -> Int -> e-unsafeAtBArray (UArray _ _ _ arr) = readByteArray arr-#endif- instance IArray UArray Bool where {-# INLINE bounds #-} bounds (UArray l u _ _) = (l,u)@@ -547,16 +622,11 @@ numElements (UArray _ _ n _) = n {-# INLINE unsafeArray #-} unsafeArray lu ies = runST (unsafeArrayUArray lu ies False)-#ifdef __GLASGOW_HASKELL__ {-# INLINE unsafeAt #-}- unsafeAt (UArray _ _ _ arr#) (I# i#) =- (indexWordArray# arr# (bOOL_INDEX i#) `and#` bOOL_BIT i#)- `neWord#` int2Word# 0#-#endif-#ifdef __HUGS__- unsafeAt (UArray _ _ _ arr) i =- testBit (readByteArray arr (bOOL_INDEX i)::BitSet) (bOOL_SUBINDEX i)-#endif+ unsafeAt (UArray _ _ _ arr#) (I# i#) = isTrue#+ ((indexWordArray# arr# (bOOL_INDEX i#) `and#` bOOL_BIT i#)+ `neWord#` int2Word# 0#)+ {-# INLINE unsafeReplace #-} unsafeReplace arr ies = runST (unsafeReplaceUArray arr ies) {-# INLINE unsafeAccum #-}@@ -572,12 +642,7 @@ {-# INLINE unsafeArray #-} unsafeArray lu ies = runST (unsafeArrayUArray lu ies '\0') {-# INLINE unsafeAt #-}-#ifdef __GLASGOW_HASKELL__ unsafeAt (UArray _ _ _ arr#) (I# i#) = C# (indexWideCharArray# arr# i#)-#endif-#ifdef __HUGS__- unsafeAt = unsafeAtBArray-#endif {-# INLINE unsafeReplace #-} unsafeReplace arr ies = runST (unsafeReplaceUArray arr ies) {-# INLINE unsafeAccum #-}@@ -592,13 +657,8 @@ numElements (UArray _ _ n _) = n {-# INLINE unsafeArray #-} unsafeArray lu ies = runST (unsafeArrayUArray lu ies 0)-#ifdef __GLASGOW_HASKELL__ {-# INLINE unsafeAt #-} unsafeAt (UArray _ _ _ arr#) (I# i#) = I# (indexIntArray# arr# i#)-#endif-#ifdef __HUGS__- unsafeAt = unsafeAtBArray-#endif {-# INLINE unsafeReplace #-} unsafeReplace arr ies = runST (unsafeReplaceUArray arr ies) {-# INLINE unsafeAccum #-}@@ -613,13 +673,8 @@ numElements (UArray _ _ n _) = n {-# INLINE unsafeArray #-} unsafeArray lu ies = runST (unsafeArrayUArray lu ies 0)-#ifdef __GLASGOW_HASKELL__ {-# INLINE unsafeAt #-} unsafeAt (UArray _ _ _ arr#) (I# i#) = W# (indexWordArray# arr# i#)-#endif-#ifdef __HUGS__- unsafeAt = unsafeAtBArray-#endif {-# INLINE unsafeReplace #-} unsafeReplace arr ies = runST (unsafeReplaceUArray arr ies) {-# INLINE unsafeAccum #-}@@ -635,12 +690,7 @@ {-# INLINE unsafeArray #-} unsafeArray lu ies = runST (unsafeArrayUArray lu ies nullPtr) {-# INLINE unsafeAt #-}-#ifdef __GLASGOW_HASKELL__ unsafeAt (UArray _ _ _ arr#) (I# i#) = Ptr (indexAddrArray# arr# i#)-#endif-#ifdef __HUGS__- unsafeAt = unsafeAtBArray-#endif {-# INLINE unsafeReplace #-} unsafeReplace arr ies = runST (unsafeReplaceUArray arr ies) {-# INLINE unsafeAccum #-}@@ -655,13 +705,8 @@ numElements (UArray _ _ n _) = n {-# INLINE unsafeArray #-} unsafeArray lu ies = runST (unsafeArrayUArray lu ies nullFunPtr)-#ifdef __GLASGOW_HASKELL__ {-# INLINE unsafeAt #-} unsafeAt (UArray _ _ _ arr#) (I# i#) = FunPtr (indexAddrArray# arr# i#)-#endif-#ifdef __HUGS__- unsafeAt = unsafeAtBArray-#endif {-# INLINE unsafeReplace #-} unsafeReplace arr ies = runST (unsafeReplaceUArray arr ies) {-# INLINE unsafeAccum #-}@@ -676,13 +721,8 @@ numElements (UArray _ _ n _) = n {-# INLINE unsafeArray #-} unsafeArray lu ies = runST (unsafeArrayUArray lu ies 0)-#ifdef __GLASGOW_HASKELL__ {-# INLINE unsafeAt #-} unsafeAt (UArray _ _ _ arr#) (I# i#) = F# (indexFloatArray# arr# i#)-#endif-#ifdef __HUGS__- unsafeAt = unsafeAtBArray-#endif {-# INLINE unsafeReplace #-} unsafeReplace arr ies = runST (unsafeReplaceUArray arr ies) {-# INLINE unsafeAccum #-}@@ -697,13 +737,8 @@ numElements (UArray _ _ n _) = n {-# INLINE unsafeArray #-} unsafeArray lu ies = runST (unsafeArrayUArray lu ies 0)-#ifdef __GLASGOW_HASKELL__ {-# INLINE unsafeAt #-} unsafeAt (UArray _ _ _ arr#) (I# i#) = D# (indexDoubleArray# arr# i#)-#endif-#ifdef __HUGS__- unsafeAt = unsafeAtBArray-#endif {-# INLINE unsafeReplace #-} unsafeReplace arr ies = runST (unsafeReplaceUArray arr ies) {-# INLINE unsafeAccum #-}@@ -718,13 +753,8 @@ numElements (UArray _ _ n _) = n {-# INLINE unsafeArray #-} unsafeArray lu ies = runST (unsafeArrayUArray lu ies nullStablePtr)-#ifdef __GLASGOW_HASKELL__ {-# INLINE unsafeAt #-} unsafeAt (UArray _ _ _ arr#) (I# i#) = StablePtr (indexStablePtrArray# arr# i#)-#endif-#ifdef __HUGS__- unsafeAt = unsafeAtBArray-#endif {-# INLINE unsafeReplace #-} unsafeReplace arr ies = runST (unsafeReplaceUArray arr ies) {-# INLINE unsafeAccum #-}@@ -734,12 +764,7 @@ -- bogus StablePtr value for initialising a UArray of StablePtr. nullStablePtr :: StablePtr a-#ifdef __GLASGOW_HASKELL__-nullStablePtr = StablePtr (unsafeCoerce# 0#)-#endif-#ifdef __HUGS__-nullStablePtr = castPtrToStablePtr nullPtr-#endif+nullStablePtr = StablePtr (unsafeCoerce# nullAddr#) instance IArray UArray Int8 where {-# INLINE bounds #-}@@ -748,13 +773,8 @@ numElements (UArray _ _ n _) = n {-# INLINE unsafeArray #-} unsafeArray lu ies = runST (unsafeArrayUArray lu ies 0)-#ifdef __GLASGOW_HASKELL__ {-# INLINE unsafeAt #-} unsafeAt (UArray _ _ _ arr#) (I# i#) = I8# (indexInt8Array# arr# i#)-#endif-#ifdef __HUGS__- unsafeAt = unsafeAtBArray-#endif {-# INLINE unsafeReplace #-} unsafeReplace arr ies = runST (unsafeReplaceUArray arr ies) {-# INLINE unsafeAccum #-}@@ -769,13 +789,8 @@ numElements (UArray _ _ n _) = n {-# INLINE unsafeArray #-} unsafeArray lu ies = runST (unsafeArrayUArray lu ies 0)-#ifdef __GLASGOW_HASKELL__ {-# INLINE unsafeAt #-} unsafeAt (UArray _ _ _ arr#) (I# i#) = I16# (indexInt16Array# arr# i#)-#endif-#ifdef __HUGS__- unsafeAt = unsafeAtBArray-#endif {-# INLINE unsafeReplace #-} unsafeReplace arr ies = runST (unsafeReplaceUArray arr ies) {-# INLINE unsafeAccum #-}@@ -790,13 +805,8 @@ numElements (UArray _ _ n _) = n {-# INLINE unsafeArray #-} unsafeArray lu ies = runST (unsafeArrayUArray lu ies 0)-#ifdef __GLASGOW_HASKELL__ {-# INLINE unsafeAt #-} unsafeAt (UArray _ _ _ arr#) (I# i#) = I32# (indexInt32Array# arr# i#)-#endif-#ifdef __HUGS__- unsafeAt = unsafeAtBArray-#endif {-# INLINE unsafeReplace #-} unsafeReplace arr ies = runST (unsafeReplaceUArray arr ies) {-# INLINE unsafeAccum #-}@@ -811,13 +821,8 @@ numElements (UArray _ _ n _) = n {-# INLINE unsafeArray #-} unsafeArray lu ies = runST (unsafeArrayUArray lu ies 0)-#ifdef __GLASGOW_HASKELL__ {-# INLINE unsafeAt #-} unsafeAt (UArray _ _ _ arr#) (I# i#) = I64# (indexInt64Array# arr# i#)-#endif-#ifdef __HUGS__- unsafeAt = unsafeAtBArray-#endif {-# INLINE unsafeReplace #-} unsafeReplace arr ies = runST (unsafeReplaceUArray arr ies) {-# INLINE unsafeAccum #-}@@ -832,13 +837,8 @@ numElements (UArray _ _ n _) = n {-# INLINE unsafeArray #-} unsafeArray lu ies = runST (unsafeArrayUArray lu ies 0)-#ifdef __GLASGOW_HASKELL__ {-# INLINE unsafeAt #-} unsafeAt (UArray _ _ _ arr#) (I# i#) = W8# (indexWord8Array# arr# i#)-#endif-#ifdef __HUGS__- unsafeAt = unsafeAtBArray-#endif {-# INLINE unsafeReplace #-} unsafeReplace arr ies = runST (unsafeReplaceUArray arr ies) {-# INLINE unsafeAccum #-}@@ -853,13 +853,8 @@ numElements (UArray _ _ n _) = n {-# INLINE unsafeArray #-} unsafeArray lu ies = runST (unsafeArrayUArray lu ies 0)-#ifdef __GLASGOW_HASKELL__ {-# INLINE unsafeAt #-} unsafeAt (UArray _ _ _ arr#) (I# i#) = W16# (indexWord16Array# arr# i#)-#endif-#ifdef __HUGS__- unsafeAt = unsafeAtBArray-#endif {-# INLINE unsafeReplace #-} unsafeReplace arr ies = runST (unsafeReplaceUArray arr ies) {-# INLINE unsafeAccum #-}@@ -874,13 +869,8 @@ numElements (UArray _ _ n _) = n {-# INLINE unsafeArray #-} unsafeArray lu ies = runST (unsafeArrayUArray lu ies 0)-#ifdef __GLASGOW_HASKELL__ {-# INLINE unsafeAt #-} unsafeAt (UArray _ _ _ arr#) (I# i#) = W32# (indexWord32Array# arr# i#)-#endif-#ifdef __HUGS__- unsafeAt = unsafeAtBArray-#endif {-# INLINE unsafeReplace #-} unsafeReplace arr ies = runST (unsafeReplaceUArray arr ies) {-# INLINE unsafeAccum #-}@@ -895,13 +885,8 @@ numElements (UArray _ _ n _) = n {-# INLINE unsafeArray #-} unsafeArray lu ies = runST (unsafeArrayUArray lu ies 0)-#ifdef __GLASGOW_HASKELL__ {-# INLINE unsafeAt #-} unsafeAt (UArray _ _ _ arr#) (I# i#) = W64# (indexWord64Array# arr# i#)-#endif-#ifdef __HUGS__- unsafeAt = unsafeAtBArray-#endif {-# INLINE unsafeReplace #-} unsafeReplace arr ies = runST (unsafeReplaceUArray arr ies) {-# INLINE unsafeAccum #-}@@ -918,6 +903,9 @@ instance (Ix ix, Show ix, Show e, IArray UArray e) => Show (UArray ix e) where showsPrec = showsIArray +instance (Ix ix, Read ix, Read e, IArray UArray e) => Read (UArray ix e) where+ readPrec = readIArray+ ----------------------------------------------------------------------------- -- Mutable arrays @@ -937,24 +925,27 @@ in which the mutable array will be manipulated. -} class (Monad m) => MArray a e m where-- -- | Returns the bounds of the array+ -- | Returns the bounds of the array (lowest,highest). getBounds :: Ix i => a i e -> m (i,i)- -- | Returns the number of elements in the array+ -- | Returns the number of elements in the array. getNumElements :: Ix i => a i e -> m Int -- | Builds a new array, with every element initialised to the supplied- -- value.+ -- value. The first and second element of the tuple specifies the lowest+ -- and highest index, respectively. newArray :: Ix i => (i,i) -> e -> m (a i e) -- | Builds a new array, with every element initialised to an -- undefined value. In a monadic context in which operations must -- be deterministic (e.g. the ST monad), the array elements are -- initialised to a fixed but undefined value, such as zero.+ -- The first and second element of the tuple specifies the lowest+ -- and highest index, respectively. newArray_ :: Ix i => (i,i) -> m (a i e) -- | Builds a new array, with every element initialised to an undefined- -- value.+ -- value. The first and second element of the tuple specifies the lowest+ -- and highest index, respectively. unsafeNewArray_ :: Ix i => (i,i) -> m (a i e) unsafeRead :: Ix i => a i e -> Int -> m e@@ -991,35 +982,52 @@ -- default initialisation with undefined values if we *do* know the -- initial value and it is constant for all elements. + {-# MINIMAL getBounds, getNumElements, (newArray | unsafeNewArray_), unsafeRead, unsafeWrite #-}+ instance MArray IOArray e IO where-#if defined(__HUGS__)- getBounds = return . boundsIOArray- getNumElements = return . getNumElementsIOArray-#elif defined(__GLASGOW_HASKELL__) {-# INLINE getBounds #-} getBounds (IOArray marr) = stToIO $ getBounds marr {-# INLINE getNumElements #-} getNumElements (IOArray marr) = stToIO $ getNumElements marr-#endif newArray = newIOArray unsafeRead = unsafeReadIOArray unsafeWrite = unsafeWriteIOArray -{-# INLINE newListArray #-}+{-# INLINE newListArray #-} -- See Note [Inlining and fusion] -- | Constructs a mutable array from a list of initial elements. -- The list gives the elements of the array in ascending order--- beginning with the lowest index.+-- beginning with the lowest index. The first and second element+-- of the tuple specifies the lowest and highest index, respectively. newListArray :: (MArray a e m, Ix i) => (i,i) -> [e] -> m (a i e) newListArray (l,u) es = do marr <- newArray_ (l,u) let n = safeRangeSize (l,u)- let fillFromList i xs | i == n = return ()- | otherwise = case xs of- [] -> return ()- y:ys -> unsafeWrite marr i y >> fillFromList (i+1) ys- fillFromList 0 es+ f x k i+ | i == n = return ()+ | otherwise = unsafeWrite marr i x >> k (i+1)+ foldr f (\ !_i -> return ()) es 0+ -- The bang above is important for GHC for unbox the Int. return marr +{-# INLINE newGenArray #-}+-- | Constructs a mutable array using a generator function.+-- It invokes the generator function in ascending order of the indices.+--+-- @since 0.5.6.0+newGenArray :: (MArray a e m, Ix i) => (i,i) -> (i -> m e) -> m (a i e)+newGenArray bnds f = do+ let n = safeRangeSize bnds+ marr <- unsafeNewArray_ bnds+ let g ix k i+ | i == n = return ()+ | otherwise = do+ x <- f ix+ unsafeWrite marr i x+ k (i+1)+ foldr g (\ !_i -> return ()) (range bnds) 0+ -- The bang above is important for GHC for unbox the Int.+ return marr+ {-# INLINE readArray #-} -- | Read an element from a mutable array readArray :: (MArray a e m, Ix i) => a i e -> i -> m e@@ -1036,6 +1044,31 @@ n <- getNumElements marr unsafeWrite marr (safeIndex (l,u) n i) e +{-# INLINE modifyArray #-}+-- | Modify an element in a mutable array+--+-- @since 0.5.6.0+modifyArray :: (MArray a e m, Ix i) => a i e -> i -> (e -> e) -> m ()+modifyArray marr i f = do+ (l,u) <- getBounds marr+ n <- getNumElements marr+ let idx = safeIndex (l,u) n i+ x <- unsafeRead marr idx+ unsafeWrite marr idx (f x)++{-# INLINE modifyArray' #-}+-- | Modify an element in a mutable array. Strict in the written element.+--+-- @since 0.5.6.0+modifyArray' :: (MArray a e m, Ix i) => a i e -> i -> (e -> e) -> m ()+modifyArray' marr i f = do+ (l,u) <- getBounds marr+ n <- getNumElements marr+ let idx = safeIndex (l,u) n i+ x <- unsafeRead marr idx+ let !x' = f x+ unsafeWrite marr idx x'+ {-# INLINE getElems #-} -- | Return a list of all the elements of a mutable array getElems :: (MArray a e m, Ix i) => a i e -> m [e]@@ -1079,6 +1112,70 @@ | i' <- range (l',u')] return marr' +-- | Strict accumulating left-associative fold.+--+-- @since 0.5.8.0+foldlMArray' :: (MArray a e m, Ix i) => (b -> e -> b) -> b -> a i e -> m b+foldlMArray' f = foldlMArrayM' (\z x -> pure (f z x))+{-# INLINE foldlMArray' #-}++-- | Strict accumulating right-associative fold.+--+-- @since 0.5.8.0+foldrMArray' :: (MArray a e m, Ix i) => (e -> b -> b) -> b -> a i e -> m b+foldrMArray' f = foldrMArrayM' (\x z -> pure (f x z))+{-# INLINE foldrMArray' #-}++-- | Strict accumulating left-associative monadic fold.+--+-- @since 0.5.8.0+foldlMArrayM' :: (MArray a e m, Ix i) => (b -> e -> m b) -> b -> a i e -> m b+foldlMArrayM' f z0 = \a -> do+ !n <- getNumElements a+ let go !z i | i >= n = pure z+ | otherwise = do+ x <- unsafeRead a i+ z' <- f z x+ go z' (i+1)+ go z0 0+{-# INLINE foldlMArrayM' #-}++-- | Strict accumulating right-associative monadic fold.+--+-- @since 0.5.8.0+foldrMArrayM' :: (MArray a e m, Ix i) => (e -> b -> m b) -> b -> a i e -> m b+foldrMArrayM' f z0 = \a -> do+ !n <- getNumElements a+ let go i !z | i < 0 = pure z+ | otherwise = do+ x <- unsafeRead a i+ z' <- f x z+ go (i-1) z'+ go (n-1) z0+{-# INLINE foldrMArrayM' #-}++-- | Map elements to monadic actions, sequence them left-to-right, and discard+-- the results.+--+-- @since 0.5.8.0+mapMArrayM_ :: (MArray a e m, Ix i) => (e -> m b) -> a i e -> m ()+mapMArrayM_ f = \a -> do+ !n <- getNumElements a+ let go i | i >= n = pure ()+ | otherwise = do+ x <- unsafeRead a i+ _ <- f x+ go (i+1)+ go 0+{-# INLINE mapMArrayM_ #-}++-- | @forMArrayM_@ is 'mapMArrayM_' with its arguments flipped.+--+-- @since 0.5.8.0+forMArrayM_ :: (MArray a e m, Ix i) => a i e -> (e -> m b) -> m ()+forMArrayM_ = flip mapMArrayM_+{-# INLINE forMArrayM_ #-}+ ----------------------------------------------------------------------------- -- Polymorphic non-strict mutable arrays (ST monad) @@ -1106,10 +1203,6 @@ {-# INLINE unsafeWrite #-} unsafeWrite arr i e = strictToLazyST (ArrST.unsafeWriteSTArray arr i e) -#ifdef __HUGS__-INSTANCE_TYPEABLE3(STArray,sTArrayTc,"STArray")-#endif- ----------------------------------------------------------------------------- -- Flat unboxed mutable arrays (ST monad) @@ -1128,26 +1221,15 @@ -- element type. However, 'STUArray' is strict in its elements - so -- don\'t use 'STUArray' if you require the non-strictness that -- 'STArray' provides.-#ifdef __GLASGOW_HASKELL__ data STUArray s i e = STUArray !i !i !Int (MutableByteArray# s)-#endif-#ifdef __HUGS__-data STUArray s i e = STUArray !i !i !Int !(MutableByteArray s)-#endif--INSTANCE_TYPEABLE3(STUArray,stUArrayTc,"STUArray")+-- The "ST" parameter must be nominal for the safety of the ST trick.+-- The other parameters have class constraints. See also #9220.+type role STUArray nominal nominal nominal -#ifdef __GLASGOW_HASKELL__ instance Eq (STUArray s i e) where STUArray _ _ _ arr1# == STUArray _ _ _ arr2# =- sameMutableByteArray# arr1# arr2#-#endif-#ifdef __HUGS__-instance Eq (STUArray s i e) where- STUArray _ _ _ arr1 == STUArray _ _ _ arr2 = arr1 == arr2-#endif+ isTrue# (sameMutableByteArray# arr1# arr2#) -#ifdef __GLASGOW_HASKELL__ {-# INLINE unsafeNewArraySTUArray_ #-} unsafeNewArraySTUArray_ :: Ix i => (i,i) -> (Int# -> Int#) -> ST s (STUArray s i e)@@ -1166,17 +1248,13 @@ getNumElements (STUArray _ _ n _) = return n {-# INLINE newArray #-} newArray (l,u) initialValue = ST $ \s1# ->- case safeRangeSize (l,u) of { n@(I# n#) ->- case newByteArray# (bOOL_SCALE n#) s1# of { (# s2#, marr# #) ->- case bOOL_WORD_SCALE n# of { n'# ->- let loop i# s3# | i# ==# n'# = s3#- | otherwise =- case writeWordArray# marr# i# e# s3# of { s4# ->- loop (i# +# 1#) s4# } in- case loop 0# s2# of { s3# ->+ case safeRangeSize (l,u) of { n@(I# n#) ->+ case bOOL_SCALE n# of { nbytes# ->+ case newByteArray# nbytes# s1# of { (# s2#, marr# #) ->+ case setByteArray# marr# 0# nbytes# e# s2# of { s3# -> (# s3#, STUArray l u n marr# #) }}}} where- !(W# e#) = if initialValue then maxBound else 0+ !(I# e#) = if initialValue then 0xff else 0x0 {-# INLINE unsafeNewArray_ #-} unsafeNewArray_ (l,u) = unsafeNewArraySTUArray_ (l,u) bOOL_SCALE {-# INLINE newArray_ #-}@@ -1184,7 +1262,7 @@ {-# INLINE unsafeRead #-} unsafeRead (STUArray _ _ _ marr#) (I# i#) = ST $ \s1# -> case readWordArray# marr# (bOOL_INDEX i#) s1# of { (# s2#, e# #) ->- (# s2#, (e# `and#` bOOL_BIT i#) `neWord#` int2Word# 0# #) }+ (# s2#, isTrue# ((e# `and#` bOOL_BIT i#) `neWord#` int2Word# 0#) :: Bool #) } {-# INLINE unsafeWrite #-} unsafeWrite (STUArray _ _ _ marr#) (I# i#) e = ST $ \s1# -> case bOOL_INDEX i# of { j# ->@@ -1200,7 +1278,7 @@ {-# INLINE getNumElements #-} getNumElements (STUArray _ _ n _) = return n {-# INLINE unsafeNewArray_ #-}- unsafeNewArray_ (l,u) = unsafeNewArraySTUArray_ (l,u) (*# 4#)+ unsafeNewArray_ (l,u) = unsafeNewArraySTUArray_ (l,u) (safe_scale 4#) {-# INLINE newArray_ #-} newArray_ arrBounds = newArray arrBounds (chr 0) {-# INLINE unsafeRead #-}@@ -1362,7 +1440,7 @@ {-# INLINE getNumElements #-} getNumElements (STUArray _ _ n _) = return n {-# INLINE unsafeNewArray_ #-}- unsafeNewArray_ (l,u) = unsafeNewArraySTUArray_ (l,u) (*# 2#)+ unsafeNewArray_ (l,u) = unsafeNewArraySTUArray_ (l,u) (safe_scale 2#) {-# INLINE newArray_ #-} newArray_ arrBounds = newArray arrBounds 0 {-# INLINE unsafeRead #-}@@ -1380,7 +1458,7 @@ {-# INLINE getNumElements #-} getNumElements (STUArray _ _ n _) = return n {-# INLINE unsafeNewArray_ #-}- unsafeNewArray_ (l,u) = unsafeNewArraySTUArray_ (l,u) (*# 4#)+ unsafeNewArray_ (l,u) = unsafeNewArraySTUArray_ (l,u) (safe_scale 4#) {-# INLINE newArray_ #-} newArray_ arrBounds = newArray arrBounds 0 {-# INLINE unsafeRead #-}@@ -1398,7 +1476,7 @@ {-# INLINE getNumElements #-} getNumElements (STUArray _ _ n _) = return n {-# INLINE unsafeNewArray_ #-}- unsafeNewArray_ (l,u) = unsafeNewArraySTUArray_ (l,u) (*# 8#)+ unsafeNewArray_ (l,u) = unsafeNewArraySTUArray_ (l,u) (safe_scale 8#) {-# INLINE newArray_ #-} newArray_ arrBounds = newArray arrBounds 0 {-# INLINE unsafeRead #-}@@ -1434,7 +1512,7 @@ {-# INLINE getNumElements #-} getNumElements (STUArray _ _ n _) = return n {-# INLINE unsafeNewArray_ #-}- unsafeNewArray_ (l,u) = unsafeNewArraySTUArray_ (l,u) (*# 2#)+ unsafeNewArray_ (l,u) = unsafeNewArraySTUArray_ (l,u) (safe_scale 2#) {-# INLINE newArray_ #-} newArray_ arrBounds = newArray arrBounds 0 {-# INLINE unsafeRead #-}@@ -1452,7 +1530,7 @@ {-# INLINE getNumElements #-} getNumElements (STUArray _ _ n _) = return n {-# INLINE unsafeNewArray_ #-}- unsafeNewArray_ (l,u) = unsafeNewArraySTUArray_ (l,u) (*# 4#)+ unsafeNewArray_ (l,u) = unsafeNewArraySTUArray_ (l,u) (safe_scale 4#) {-# INLINE newArray_ #-} newArray_ arrBounds = newArray arrBounds 0 {-# INLINE unsafeRead #-}@@ -1470,7 +1548,7 @@ {-# INLINE getNumElements #-} getNumElements (STUArray _ _ n _) = return n {-# INLINE unsafeNewArray_ #-}- unsafeNewArray_ (l,u) = unsafeNewArraySTUArray_ (l,u) (*# 8#)+ unsafeNewArray_ (l,u) = unsafeNewArraySTUArray_ (l,u) (safe_scale 8#) {-# INLINE newArray_ #-} newArray_ arrBounds = newArray arrBounds 0 {-# INLINE unsafeRead #-}@@ -1485,16 +1563,33 @@ ----------------------------------------------------------------------------- -- Translation between elements and bytes -bOOL_SCALE, bOOL_WORD_SCALE,- wORD_SCALE, dOUBLE_SCALE, fLOAT_SCALE :: Int# -> Int#-bOOL_SCALE n# = (n# +# last#) `uncheckedIShiftRA#` 3#- where !(I# last#) = SIZEOF_HSWORD * 8 - 1-bOOL_WORD_SCALE n# = bOOL_INDEX (n# +# last#)- where !(I# last#) = SIZEOF_HSWORD * 8 - 1-wORD_SCALE n# = scale# *# n# where !(I# scale#) = SIZEOF_HSWORD-dOUBLE_SCALE n# = scale# *# n# where !(I# scale#) = SIZEOF_HSDOUBLE-fLOAT_SCALE n# = scale# *# n# where !(I# scale#) = SIZEOF_HSFLOAT+bOOL_SCALE, wORD_SCALE, dOUBLE_SCALE, fLOAT_SCALE :: Int# -> Int#+bOOL_SCALE n# =+ -- Round the number of bits up to the next whole-word-aligned number+ -- of bytes to avoid ghc#23132; the addition can signed-overflow but+ -- that's OK because it will not unsigned-overflow and the logical+ -- right-shift brings us back in-bounds+#if SIZEOF_HSWORD == 4+ ((n# +# 31#) `uncheckedIShiftRL#` 5#) `uncheckedIShiftL#` 2#+#elif SIZEOF_HSWORD == 8+ ((n# +# 63#) `uncheckedIShiftRL#` 6#) `uncheckedIShiftL#` 3#+#endif+wORD_SCALE n# = safe_scale scale# n# where !(I# scale#) = SIZEOF_HSWORD+dOUBLE_SCALE n# = safe_scale scale# n# where !(I# scale#) = SIZEOF_HSDOUBLE+fLOAT_SCALE n# = safe_scale scale# n# where !(I# scale#) = SIZEOF_HSFLOAT +safe_scale :: Int# -> Int# -> Int#+safe_scale scale# n#+ | not overflow = res#+ | otherwise = error $ "Data.Array.Base.safe_scale: Overflow; scale: "+ ++ show (I# scale#) ++ ", n: " ++ show (I# n#)+ where+ !res# = scale# *# n#+ !overflow = isTrue# (maxN# `divInt#` scale# <# n#)+ !(I# maxN#) = maxBound+{-# INLINE safe_scale #-}++-- | The index of the word which the given @Bool@ array elements falls within. bOOL_INDEX :: Int# -> Int# #if SIZEOF_HSWORD == 4 bOOL_INDEX i# = i# `uncheckedIShiftRA#` 5#@@ -1507,192 +1602,7 @@ where !(W# mask#) = SIZEOF_HSWORD * 8 - 1 bOOL_NOT_BIT n# = bOOL_BIT n# `xor#` mb# where !(W# mb#) = maxBound-#endif /* __GLASGOW_HASKELL__ */ -#ifdef __HUGS__-newMBArray_ :: (Ix i, Storable e) => (i,i) -> ST s (STUArray s i e)-newMBArray_ = makeArray undefined- where- makeArray :: (Ix i, Storable e) => e -> (i,i) -> ST s (STUArray s i e)- makeArray dummy (l,u) = do- let n = safeRangeSize (l,u)- marr <- newMutableByteArray (n * sizeOf dummy)- return (STUArray l u n marr)--unsafeReadMBArray :: Storable e => STUArray s i e -> Int -> ST s e-unsafeReadMBArray (STUArray _ _ _ marr) = readMutableByteArray marr--unsafeWriteMBArray :: Storable e => STUArray s i e -> Int -> e -> ST s ()-unsafeWriteMBArray (STUArray _ _ _ marr) = writeMutableByteArray marr--getBoundsMBArray :: Storable e => STUArray s i e -> ST s (i, i)-getBoundsMBArray (STUArray l u _ _) = return (l,u)--getNumElementsMBArray :: Storable e => STUArray s i e -> ST s Int-getNumElementsMBArray (STUArray _ _ n _) = return n--instance MArray (STUArray s) Bool (ST s) where- getBounds = getBoundsMBArray- getNumElements = getNumElementsMBArray- unsafeNewArray_ (l,u) = do- let n = rangeSize (l,u)- marr <- newMutableByteArray (bOOL_SCALE n)- return (STUArray l u n marr)- newArray_ bounds = unsafeNewArray_ bounds- unsafeRead (STUArray _ _ _ marr) i = do- let ix = bOOL_INDEX i- bit = bOOL_SUBINDEX i- w <- readMutableByteArray marr ix- return (testBit (w::BitSet) bit)- unsafeWrite (STUArray _ _ _ marr) i e = do- let ix = bOOL_INDEX i- bit = bOOL_SUBINDEX i- w <- readMutableByteArray marr ix- writeMutableByteArray marr ix- (if e then setBit (w::BitSet) bit else clearBit w bit)--instance MArray (STUArray s) Char (ST s) where- getBounds = getBoundsMBArray- getNumElements = getNumElementsMBArray- unsafeNewArray_ = newMBArray_- newArray_ = unsafeNewArray_- unsafeRead = unsafeReadMBArray- unsafeWrite = unsafeWriteMBArray--instance MArray (STUArray s) Int (ST s) where- getBounds = getBoundsMBArray- getNumElements = getNumElementsMBArray- unsafeNewArray_ = newMBArray_- newArray_ = unsafeNewArray_- unsafeRead = unsafeReadMBArray- unsafeWrite = unsafeWriteMBArray--instance MArray (STUArray s) Word (ST s) where- getBounds = getBoundsMBArray- getNumElements = getNumElementsMBArray- unsafeNewArray_ = newMBArray_- newArray_ = unsafeNewArray_- unsafeRead = unsafeReadMBArray- unsafeWrite = unsafeWriteMBArray--instance MArray (STUArray s) (Ptr a) (ST s) where- getBounds = getBoundsMBArray- getNumElements = getNumElementsMBArray- unsafeNewArray_ = newMBArray_- newArray_ = unsafeNewArray_- unsafeRead = unsafeReadMBArray- unsafeWrite = unsafeWriteMBArray--instance MArray (STUArray s) (FunPtr a) (ST s) where- getBounds = getBoundsMBArray- getNumElements = getNumElementsMBArray- unsafeNewArray_ = newMBArray_- newArray_ = unsafeNewArray_- unsafeRead = unsafeReadMBArray- unsafeWrite = unsafeWriteMBArray--instance MArray (STUArray s) Float (ST s) where- getBounds = getBoundsMBArray- getNumElements = getNumElementsMBArray- unsafeNewArray_ = newMBArray_- newArray_ = unsafeNewArray_- unsafeRead = unsafeReadMBArray- unsafeWrite = unsafeWriteMBArray--instance MArray (STUArray s) Double (ST s) where- getBounds = getBoundsMBArray- getNumElements = getNumElementsMBArray- unsafeNewArray_ = newMBArray_- newArray_ = unsafeNewArray_- unsafeRead = unsafeReadMBArray- unsafeWrite = unsafeWriteMBArray--instance MArray (STUArray s) (StablePtr a) (ST s) where- getBounds = getBoundsMBArray- getNumElements = getNumElementsMBArray- unsafeNewArray_ = newMBArray_- newArray_ = unsafeNewArray_- unsafeRead = unsafeReadMBArray- unsafeWrite = unsafeWriteMBArray--instance MArray (STUArray s) Int8 (ST s) where- getBounds = getBoundsMBArray- getNumElements = getNumElementsMBArray- unsafeNewArray_ = newMBArray_- newArray_ = unsafeNewArray_- unsafeRead = unsafeReadMBArray- unsafeWrite = unsafeWriteMBArray--instance MArray (STUArray s) Int16 (ST s) where- getBounds = getBoundsMBArray- getNumElements = getNumElementsMBArray- unsafeNewArray_ = newMBArray_- newArray_ = unsafeNewArray_- unsafeRead = unsafeReadMBArray- unsafeWrite = unsafeWriteMBArray--instance MArray (STUArray s) Int32 (ST s) where- getBounds = getBoundsMBArray- getNumElements = getNumElementsMBArray- unsafeNewArray_ = newMBArray_- newArray_ = unsafeNewArray_- unsafeRead = unsafeReadMBArray- unsafeWrite = unsafeWriteMBArray--instance MArray (STUArray s) Int64 (ST s) where- getBounds = getBoundsMBArray- getNumElements = getNumElementsMBArray- unsafeNewArray_ = newMBArray_- newArray_ = unsafeNewArray_- unsafeRead = unsafeReadMBArray- unsafeWrite = unsafeWriteMBArray--instance MArray (STUArray s) Word8 (ST s) where- getBounds = getBoundsMBArray- getNumElements = getNumElementsMBArray- unsafeNewArray_ = newMBArray_- newArray_ = unsafeNewArray_- unsafeRead = unsafeReadMBArray- unsafeWrite = unsafeWriteMBArray--instance MArray (STUArray s) Word16 (ST s) where- getBounds = getBoundsMBArray- getNumElements = getNumElementsMBArray- unsafeNewArray_ = newMBArray_- newArray_ = unsafeNewArray_- unsafeRead = unsafeReadMBArray- unsafeWrite = unsafeWriteMBArray--instance MArray (STUArray s) Word32 (ST s) where- getBounds = getBoundsMBArray- getNumElements = getNumElementsMBArray- unsafeNewArray_ = newMBArray_- newArray_ = unsafeNewArray_- unsafeRead = unsafeReadMBArray- unsafeWrite = unsafeWriteMBArray--instance MArray (STUArray s) Word64 (ST s) where- getBounds = getBoundsMBArray- getNumElements = getNumElementsMBArray- unsafeNewArray_ = newMBArray_- newArray_ = unsafeNewArray_- unsafeRead = unsafeReadMBArray- unsafeWrite = unsafeWriteMBArray--type BitSet = Word8--bitSetSize = bitSize (0::BitSet)--bOOL_SCALE :: Int -> Int-bOOL_SCALE n = (n + bitSetSize - 1) `div` bitSetSize--bOOL_INDEX :: Int -> Int-bOOL_INDEX i = i `div` bitSetSize--bOOL_SUBINDEX :: Int -> Int-bOOL_SUBINDEX i = i `mod` bitSetSize-#endif /* __HUGS__ */- ----------------------------------------------------------------------------- -- Freezing @@ -1709,15 +1619,14 @@ -- use the safe array creation function here. return (listArray (l,u) es) -#ifdef __GLASGOW_HASKELL__-freezeSTUArray :: Ix i => STUArray s i e -> ST s (UArray i e)+freezeSTUArray :: STUArray s i e -> ST s (UArray i e) freezeSTUArray (STUArray l u n marr#) = ST $ \s1# ->- case sizeofMutableByteArray# marr# of { n# ->- case newByteArray# n# s1# of { (# s2#, marr'# #) ->+ case getSizeofMutableByteArray# marr# s1# of { (# s2#, n# #) ->+ case newByteArray# n# s2# of { (# s3#, marr'# #) -> case memcpy_freeze marr'# marr# (fromIntegral (I# n#)) of { IO m ->- case unsafeCoerce# m s2# of { (# s3#, _ #) ->- case unsafeFreezeByteArray# marr'# s3# of { (# s4#, arr# #) ->- (# s4#, UArray l u n arr# #) }}}}}+ case unsafeCoerce# m s3# of { (# s4#, _ #) ->+ case unsafeFreezeByteArray# marr'# s4# of { (# s5#, arr# #) ->+ (# s5#, UArray l u n arr# #) }}}}} foreign import ccall unsafe "memcpy" memcpy_freeze :: MutableByteArray# s -> MutableByteArray# s -> CSize@@ -1727,7 +1636,6 @@ "freeze/STArray" freeze = ArrST.freezeSTArray "freeze/STUArray" freeze = freezeSTUArray #-}-#endif /* __GLASGOW_HASKELL__ */ -- In-place conversion of mutable arrays to immutable ones places -- a proof obligation on the user: no other parts of your code can@@ -1786,8 +1694,7 @@ | i <- [0 .. n - 1]] return marr -thawSTUArray :: Ix i => UArray i e -> ST s (STUArray s i e)-#if __GLASGOW_HASKELL__+thawSTUArray :: UArray i e -> ST s (STUArray s i e) thawSTUArray (UArray l u n arr#) = ST $ \s1# -> case sizeofByteArray# arr# of { n# -> case newByteArray# n# s1# of { (# s2#, marr# #) ->@@ -1803,11 +1710,6 @@ "thaw/STArray" thaw = ArrST.thawSTArray "thaw/STUArray" thaw = thawSTUArray #-}-#elif __HUGS__-thawSTUArray (UArray l u n arr) = do- marr <- thawByteArray arr- return (STUArray l u n marr)-#endif -- In-place conversion of immutable arrays to mutable ones places -- a proof obligation on the user: no other parts of your code can@@ -1851,9 +1753,8 @@ unsafeThaw :: (Ix i, IArray a e, MArray b e m) => a i e -> m (b i e) unsafeThaw = thaw -#ifdef __GLASGOW_HASKELL__ {-# INLINE unsafeThawSTUArray #-}-unsafeThawSTUArray :: Ix i => UArray i e -> ST s (STUArray s i e)+unsafeThawSTUArray :: UArray i e -> ST s (STUArray s i e) unsafeThawSTUArray (UArray l u n marr#) = return (STUArray l u n (unsafeCoerce# marr#)) @@ -1863,7 +1764,7 @@ #-} {-# INLINE unsafeThawIOArray #-}-unsafeThawIOArray :: Ix ix => Arr.Array ix e -> IO (IOArray ix e)+unsafeThawIOArray :: Arr.Array ix e -> IO (IOArray ix e) unsafeThawIOArray arr = stToIO $ do marr <- ArrST.unsafeThawSTArray arr return (IOArray marr)@@ -1872,7 +1773,7 @@ "unsafeThaw/IOArray" unsafeThaw = unsafeThawIOArray #-} -thawIOArray :: Ix ix => Arr.Array ix e -> IO (IOArray ix e)+thawIOArray :: Arr.Array ix e -> IO (IOArray ix e) thawIOArray arr = stToIO $ do marr <- ArrST.thawSTArray arr return (IOArray marr)@@ -1881,7 +1782,7 @@ "thaw/IOArray" thaw = thawIOArray #-} -freezeIOArray :: Ix ix => IOArray ix e -> IO (Arr.Array ix e)+freezeIOArray :: IOArray ix e -> IO (Arr.Array ix e) freezeIOArray (IOArray marr) = stToIO (ArrST.freezeSTArray marr) {-# RULES@@ -1889,22 +1790,26 @@ #-} {-# INLINE unsafeFreezeIOArray #-}-unsafeFreezeIOArray :: Ix ix => IOArray ix e -> IO (Arr.Array ix e)+unsafeFreezeIOArray :: IOArray ix e -> IO (Arr.Array ix e) unsafeFreezeIOArray (IOArray marr) = stToIO (ArrST.unsafeFreezeSTArray marr) {-# RULES "unsafeFreeze/IOArray" unsafeFreeze = unsafeFreezeIOArray #-}-#endif /* __GLASGOW_HASKELL__ */ -- | Casts an 'STUArray' with one element type into one with a -- different element type. All the elements of the resulting array -- are undefined (unless you know what you\'re doing...). castSTUArray :: STUArray s ix a -> ST s (STUArray s ix b)-#if __GLASGOW_HASKELL__ castSTUArray (STUArray l u n marr#) = return (STUArray l u n marr#)-#elif __HUGS__-castSTUArray (STUArray l u n marr) = return (STUArray l u n marr)-#endif +--------------------------------------------------------------------------------++-- Note [Inlining and fusion]+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~+-- Many functions in this module are marked INLINE because they consume their+-- input with `foldr`. By inlining them, it is possible that the `foldr` will+-- meet a `build` from the call site, and beneficial fusion will take place.+-- That is, they become "good consumers". See array issue #8 for data showing+-- the perf improvement that comes with fusion.
Data/Array/IArray.hs view
@@ -29,13 +29,25 @@ array, -- :: (IArray a e, Ix i) => (i,i) -> [(i, e)] -> a i e listArray, -- :: (IArray a e, Ix i) => (i,i) -> [e] -> a i e accumArray, -- :: (IArray a e, Ix i) => (e -> e' -> e) -> e -> (i,i) -> [(i, e')] -> a i e+ genArray, -- :: (IArray a e, Ix i) => (i,i) -> (i -> e) -> a i e -- * Accessing arrays (!), -- :: (IArray a e, Ix i) => a i e -> i -> e+ (!?), -- :: (IArray a e, Ix i) => a i e -> i -> Maybe e bounds, -- :: (HasBounds a, Ix i) => a i e -> (i,i) indices, -- :: (HasBounds a, Ix i) => a i e -> [i] elems, -- :: (IArray a e, Ix i) => a i e -> [e] assocs, -- :: (IArray a e, Ix i) => a i e -> [(i, e)]++ -- * Array folds+ foldrArray,+ foldlArray',+ foldlArray,+ foldrArray',+ traverseArray_,+ forArray_,+ foldlArrayM',+ foldrArrayM', -- * Incremental array updates (//), -- :: (IArray a e, Ix i) => a i e -> [(i, e)] -> a i e
Data/Array/IO.hs view
@@ -1,5 +1,5 @@-{-# OPTIONS_GHC -#include "HsBase.h" #-}-{-# OPTIONS_GHC -w #-} --tmp+{-# LANGUAGE MagicHash, Trustworthy, UnliftedFFITypes #-}+ ----------------------------------------------------------------------------- -- | -- Module : Data.Array.IO@@ -20,7 +20,6 @@ -- * @IO@ arrays with unboxed elements IOUArray, -- instance of: Eq, Typeable- castIOUArray, -- :: IOUArray i a -> IO (IOUArray i b) -- * Overloaded mutable array interface module Data.Array.MArray,@@ -31,29 +30,17 @@ ) where import Data.Array.Base-import Data.Array.IO.Internals hiding ( castIOUArray )-import qualified Data.Array.Unsafe as U ( castIOUArray )+import Data.Array.IO.Internals import Data.Array.MArray import System.IO.Error -#ifdef __GLASGOW_HASKELL__ import Foreign import Foreign.C import GHC.Exts (MutableByteArray#, RealWorld)-import GHC.Arr-import GHC.IORef import GHC.IO.Handle-import GHC.IO.Buffer import GHC.IO.Exception -#else-import Data.Char-import Data.Word ( Word8 )-import System.IO-#endif--#ifdef __GLASGOW_HASKELL__ -- --------------------------------------------------------------------------- -- hGetArray @@ -77,7 +64,7 @@ -- allocate a separate area of memory and copy. allocaBytes count $ \p -> do r <- hGetBuf handle p count- memcpy_ba_ptr ptr p (fromIntegral r)+ _ <- memcpy_ba_ptr ptr p (fromIntegral r) return r foreign import ccall unsafe "memcpy"@@ -100,7 +87,7 @@ -- as in hGetArray, we would like to use the array directly, but -- we can't be sure that the MutableByteArray# is pinned. allocaBytes count $ \p -> do- memcpy_ptr_ba p raw (fromIntegral count)+ _ <- memcpy_ptr_ba p raw (fromIntegral count) hPutBuf handle p count foreign import ccall unsafe "memcpy"@@ -114,52 +101,3 @@ ioException (ioeSetErrorString (mkIOError InvalidArgument fn (Just handle) Nothing) ("illegal buffer size " ++ showsPrec 9 (sz::Int) []))--#else /* !__GLASGOW_HASKELL__ */-hGetArray :: Handle -> IOUArray Int Word8 -> Int -> IO Int-hGetArray handle arr count = do- bds <- getBounds arr- if count < 0 || count > rangeSize bds- then illegalBufferSize handle "hGetArray" count- else get 0- where- get i | i == count = return i- | otherwise = do- error_or_c <- try (hGetChar handle)- case error_or_c of- Left ex- | isEOFError ex -> return i- | otherwise -> ioError ex- Right c -> do- unsafeWrite arr i (fromIntegral (ord c))- get (i+1)--hPutArray :: Handle -> IOUArray Int Word8 -> Int -> IO ()-hPutArray handle arr count = do- bds <- getBounds arr- if count < 0 || count > rangeSize bds- then illegalBufferSize handle "hPutArray" count- else put 0- where- put i | i == count = return ()- | otherwise = do- w <- unsafeRead arr i- hPutChar handle (chr (fromIntegral w))- put (i+1)--illegalBufferSize :: Handle -> String -> Int -> IO a-illegalBufferSize _ fn sz = ioError $- userError (fn ++ ": illegal buffer size " ++ showsPrec 9 (sz::Int) [])-#endif /* !__GLASGOW_HASKELL__ */---{-# DEPRECATED castIOUArray- "Please import from Data.Array.Unsafe instead; This will be removed in the next release"- #-}--- | Casts an 'IOUArray' with one element type into one with a--- different element type. All the elements of the resulting array--- are undefined (unless you know what you\'re doing...).-{-# INLINE castIOUArray #-}-castIOUArray :: IOUArray i a -> IO (IOUArray i b)-castIOUArray = U.castIOUArray-
Data/Array/IO/Internals.hs view
@@ -1,9 +1,14 @@-{-# OPTIONS_HADDOCK hide #-}-{-# OPTIONS_GHC -#include "HsBase.h" #-}+{-# LANGUAGE+ FlexibleInstances+ , MultiParamTypeClasses+ , RoleAnnotations+ #-}++{-# OPTIONS_HADDOCK not-home #-} ----------------------------------------------------------------------------- -- | -- Module : Data.Array.IO.Internal--- Copyright : (c) The University of Glasgow 2001+-- Copyright : (c) The University of Glasgow 2001-2012 -- License : BSD-style (see the file libraries/base/LICENSE) -- -- Maintainer : libraries@haskell.org@@ -12,43 +17,39 @@ -- -- Mutable boxed and unboxed arrays in the IO monad. --+-- = WARNING+--+-- This module is considered __internal__.+--+-- The Package Versioning Policy __does not apply__.+--+-- The contents of this module may change __in any way whatsoever__+-- and __without any warning__ between minor versions of this package.+--+-- Authors importing this module are expected to track development+-- closely.+-- ----------------------------------------------------------------------------- --- #hide module Data.Array.IO.Internals ( IOArray(..), -- instance of: Eq, Typeable IOUArray(..), -- instance of: Eq, Typeable castIOUArray, -- :: IOUArray ix a -> IO (IOUArray ix b)-#ifdef __GLASGOW_HASKELL__ unsafeThawIOUArray,-#endif+ unsafeFreezeIOUArray ) where import Data.Int import Data.Word-import Data.Typeable import Control.Monad.ST ( RealWorld, stToIO ) import Foreign.Ptr ( Ptr, FunPtr ) import Foreign.StablePtr ( StablePtr ) -import Data.Ix import Data.Array.Base -#ifdef __HUGS__-import Hugs.IOArray-#endif--#ifdef __GLASGOW_HASKELL__-#if __GLASGOW_HASKELL__ >= 611 import GHC.IOArray (IOArray(..))-#else-import GHC.IOBase (IOArray(..))-#endif-#endif /* __GLASGOW_HASKELL__ */ -#include "Typeable.h"- ----------------------------------------------------------------------------- -- Flat unboxed mutable arrays (IO monad) @@ -61,8 +62,8 @@ -- are supported: see "Data.Array.MArray" for a list of instances. -- newtype IOUArray i e = IOUArray (STUArray RealWorld i e)--INSTANCE_TYPEABLE2(IOUArray,iOUArrayTc,"IOUArray")+-- Both parameters have class-based invariants. See also #9220.+type role IOUArray nominal nominal instance Eq (IOUArray i e) where IOUArray s1 == IOUArray s2 = s1 == s2@@ -381,9 +382,8 @@ marr' <- castSTUArray marr return (IOUArray marr') -#ifdef __GLASGOW_HASKELL__ {-# INLINE unsafeThawIOUArray #-}-unsafeThawIOUArray :: Ix ix => UArray ix e -> IO (IOUArray ix e)+unsafeThawIOUArray :: UArray ix e -> IO (IOUArray ix e) unsafeThawIOUArray arr = stToIO $ do marr <- unsafeThawSTUArray arr return (IOUArray marr)@@ -392,7 +392,7 @@ "unsafeThaw/IOUArray" unsafeThaw = unsafeThawIOUArray #-} -thawIOUArray :: Ix ix => UArray ix e -> IO (IOUArray ix e)+thawIOUArray :: UArray ix e -> IO (IOUArray ix e) thawIOUArray arr = stToIO $ do marr <- thawSTUArray arr return (IOUArray marr)@@ -402,18 +402,16 @@ #-} {-# INLINE unsafeFreezeIOUArray #-}-unsafeFreezeIOUArray :: Ix ix => IOUArray ix e -> IO (UArray ix e)+unsafeFreezeIOUArray :: IOUArray ix e -> IO (UArray ix e) unsafeFreezeIOUArray (IOUArray marr) = stToIO (unsafeFreezeSTUArray marr) {-# RULES "unsafeFreeze/IOUArray" unsafeFreeze = unsafeFreezeIOUArray #-} -freezeIOUArray :: Ix ix => IOUArray ix e -> IO (UArray ix e)+freezeIOUArray :: IOUArray ix e -> IO (UArray ix e) freezeIOUArray (IOUArray marr) = stToIO (freezeSTUArray marr) {-# RULES "freeze/IOUArray" freeze = freezeIOUArray #-}-#endif /* __GLASGOW_HASKELL__ */-
Data/Array/IO/Safe.hs view
@@ -1,6 +1,5 @@-{-# LANGUAGE Trustworthy #-}-{-# OPTIONS_GHC -#include "HsBase.h" #-}-{-# OPTIONS_GHC -w #-} --tmp+{-# LANGUAGE Safe #-}+ ----------------------------------------------------------------------------- -- | -- Module : Data.Array.IO.Safe@@ -15,6 +14,7 @@ -- . -- Safe API only of "Data.Array.IO". --+-- @since 0.4.0.0 ----------------------------------------------------------------------------- module Data.Array.IO.Safe (
Data/Array/MArray.hs view
@@ -1,3 +1,5 @@+{-# LANGUAGE CPP, Trustworthy #-}+ ----------------------------------------------------------------------------- -- | -- Module : Data.Array.MArray@@ -25,11 +27,22 @@ newArray, -- :: (MArray a e m, Ix i) => (i,i) -> e -> m (a i e) newArray_, -- :: (MArray a e m, Ix i) => (i,i) -> m (a i e) newListArray, -- :: (MArray a e m, Ix i) => (i,i) -> [e] -> m (a i e)+ newGenArray, -- :: (MArray a e m, Ix i) => (i,i) -> (i -> m e) -> m (a i e) -- * Reading and writing mutable arrays readArray, -- :: (MArray a e m, Ix i) => a i e -> i -> m e writeArray, -- :: (MArray a e m, Ix i) => a i e -> i -> e -> m ()+ modifyArray,+ modifyArray', + -- * Array folds+ foldlMArray',+ foldrMArray',+ mapMArrayM_,+ forMArrayM_,+ foldlMArrayM',+ foldrMArrayM',+ -- * Derived arrays mapArray, -- :: (MArray a e' m, MArray a e m, Ix i) => (e' -> e) -> a i e' -> m (a i e) mapIndices, -- :: (MArray a e m, Ix i, Ix j) => (i,i) -> (i -> j) -> a j e -> m (a i e)@@ -41,87 +54,11 @@ -- * Conversions between mutable and immutable arrays freeze, -- :: (Ix i, MArray a e m, IArray b e) => a i e -> m (b i e)- unsafeFreeze, -- :: (Ix i, MArray a e m, IArray b e) => a i e -> m (b i e) thaw, -- :: (Ix i, IArray a e, MArray b e m) => a i e -> m (b i e)- unsafeThaw, -- :: (Ix i, IArray a e, MArray b e m) => a i e -> m (b i e) ) where import Data.Ix-import Data.Array.Base hiding ( unsafeFreeze, unsafeThaw )-import qualified Data.Array.Base as U ( unsafeFreeze, unsafeThaw )+import Data.Array.Base #ifdef __HADDOCK__ import Data.Array.IArray #endif--{-# DEPRECATED unsafeFreeze, unsafeThaw- "Please import from Data.Array.Unsafe instead; This will be removed in the next release"- #-}--{- |- Converts an mutable array into an immutable array. The- implementation may either simply cast the array from- one type to the other without copying the array, or it- may take a full copy of the array.-- Note that because the array is possibly not copied, any subsequent- modifications made to the mutable version of the array may be- shared with the immutable version. It is safe to use, therefore, if- the mutable version is never modified after the freeze operation.-- The non-copying implementation is supported between certain pairs- of array types only; one constraint is that the array types must- have identical representations. In GHC, The following pairs of- array types have a non-copying O(1) implementation of- 'unsafeFreeze'. Because the optimised versions are enabled by- specialisations, you will need to compile with optimisation (-O) to- get them.-- * 'Data.Array.IO.IOUArray' -> 'Data.Array.Unboxed.UArray'-- * 'Data.Array.ST.STUArray' -> 'Data.Array.Unboxed.UArray'-- * 'Data.Array.IO.IOArray' -> 'Data.Array.Array'-- * 'Data.Array.ST.STArray' -> 'Data.Array.Array'--}-{-# INLINE unsafeFreeze #-}-unsafeFreeze :: (Ix i, MArray a e m, IArray b e) => a i e -> m (b i e)-unsafeFreeze = U.unsafeFreeze--{- |- Converts an immutable array into a mutable array. The- implementation may either simply cast the array from- one type to the other without copying the array, or it- may take a full copy of the array.-- Note that because the array is possibly not copied, any subsequent- modifications made to the mutable version of the array may be- shared with the immutable version. It is only safe to use,- therefore, if the immutable array is never referenced again in this- thread, and there is no possibility that it can be also referenced- in another thread. If you use an unsafeThaw/write/unsafeFreeze- sequence in a multi-threaded setting, then you must ensure that- this sequence is atomic with respect to other threads, or a garbage- collector crash may result (because the write may be writing to a- frozen array).-- The non-copying implementation is supported between certain pairs- of array types only; one constraint is that the array types must- have identical representations. In GHC, The following pairs of- array types have a non-copying O(1) implementation of- 'unsafeThaw'. Because the optimised versions are enabled by- specialisations, you will need to compile with optimisation (-O) to- get them.-- * 'Data.Array.Unboxed.UArray' -> 'Data.Array.IO.IOUArray'-- * 'Data.Array.Unboxed.UArray' -> 'Data.Array.ST.STUArray'-- * 'Data.Array.Array' -> 'Data.Array.IO.IOArray'-- * 'Data.Array.Array' -> 'Data.Array.ST.STArray'--}-{-# INLINE unsafeThaw #-}-unsafeThaw :: (Ix i, IArray a e, MArray b e m) => a i e -> m (b i e)-unsafeThaw = U.unsafeThaw-
Data/Array/MArray/Safe.hs view
@@ -1,4 +1,4 @@-{-# LANGUAGE Trustworthy #-}+{-# LANGUAGE CPP, Trustworthy #-} ----------------------------------------------------------------------------- -- | -- Module : Data.Array.MArray.Safe@@ -15,6 +15,7 @@ -- . -- Safe API only of "Data.Array.MArray". --+-- @since 0.4.0.0 ----------------------------------------------------------------------------- module Data.Array.MArray.Safe (@@ -28,10 +29,19 @@ newArray, -- :: (MArray a e m, Ix i) => (i,i) -> e -> m (a i e) newArray_, -- :: (MArray a e m, Ix i) => (i,i) -> m (a i e) newListArray, -- :: (MArray a e m, Ix i) => (i,i) -> [e] -> m (a i e)+ newGenArray, -- :: (MArray a e m, Ix i) => (i,i) -> (i -> m e) -> m (a i e) -- * Reading and writing mutable arrays readArray, -- :: (MArray a e m, Ix i) => a i e -> i -> m e writeArray, -- :: (MArray a e m, Ix i) => a i e -> i -> e -> m ()++ -- * Array folds+ foldlMArray',+ foldrMArray',+ mapMArrayM_,+ forMArrayM_,+ foldlMArrayM',+ foldrMArrayM', -- * Derived arrays mapArray, -- :: (MArray a e' m, MArray a e m, Ix i) => (e' -> e) -> a i e' -> m (a i e)
Data/Array/ST.hs view
@@ -1,3 +1,4 @@+{-# LANGUAGE RankNTypes, Trustworthy #-} ----------------------------------------------------------------------------- -- | -- Module : Data.Array.ST@@ -20,7 +21,6 @@ -- * Unboxed arrays STUArray, -- instance of: Eq, MArray runSTUArray,- castSTUArray, -- :: STUArray s i a -> ST s (STUArray s i b) -- * Overloaded mutable array interface module Data.Array.MArray,@@ -28,26 +28,16 @@ import Data.Array.Base ( STUArray, UArray, unsafeFreezeSTUArray ) import Data.Array.MArray-import qualified Data.Array.Unsafe as U ( castSTUArray ) import Control.Monad.ST ( ST, runST ) -#ifdef __HUGS__-import Hugs.Array ( Array )-import Hugs.ST ( STArray, unsafeFreezeSTArray )-#endif--#ifdef __GLASGOW_HASKELL__ import GHC.Arr ( STArray, Array, unsafeFreezeSTArray )-#endif -- | A safe way to create and work with a mutable array before returning an -- immutable array for later perusal. This function avoids copying -- the array before returning it - it uses 'unsafeFreeze' internally, but -- this wrapper is a safe interface to that function. ---runSTArray :: (Ix i)- => (forall s . ST s (STArray s i e))- -> Array i e+runSTArray :: (forall s . ST s (STArray s i e)) -> Array i e runSTArray st = runST (st >>= unsafeFreezeSTArray) -- | A safe way to create and work with an unboxed mutable array before@@ -56,9 +46,7 @@ -- 'unsafeFreeze' internally, but this wrapper is a safe interface to -- that function. ---runSTUArray :: (Ix i)- => (forall s . ST s (STUArray s i e))- -> UArray i e+runSTUArray :: (forall s . ST s (STUArray s i e)) -> UArray i e runSTUArray st = runST (st >>= unsafeFreezeSTUArray) @@ -73,15 +61,3 @@ -- unsafeFreezeSTUArray directly in the defn of runSTUArray above, but -- this essentially constrains us to a single unsafeFreeze for all STUArrays -- (in theory we might have a different one for certain element types).--{-# DEPRECATED castSTUArray- "Please import from Data.Array.Unsafe instead; This will be removed in the next release"- #-}---- | Casts an 'STUArray' with one element type into one with a--- different element type. All the elements of the resulting array--- are undefined (unless you know what you\'re doing...).-{-# INLINE castSTUArray #-}-castSTUArray :: STUArray s ix a -> ST s (STUArray s ix b)-castSTUArray = U.castSTUArray-
Data/Array/ST/Safe.hs view
@@ -1,4 +1,4 @@-{-# LANGUAGE Trustworthy #-}+{-# LANGUAGE Safe #-} ----------------------------------------------------------------------------- -- | -- Module : Data.Array.ST.Safe@@ -13,6 +13,7 @@ -- -- Safe API only of "Data.Array.ST". --+-- @since 0.4.0.0 ----------------------------------------------------------------------------- module Data.Array.ST.Safe (
Data/Array/Storable.hs view
@@ -1,3 +1,4 @@+{-# LANGUAGE Trustworthy #-} ----------------------------------------------------------------------------- -- | -- Module : Data.Array.Storable@@ -34,25 +35,7 @@ withStorableArray, -- :: StorableArray i e -> (Ptr e -> IO a) -> IO a touchStorableArray, -- :: StorableArray i e -> IO ()-- unsafeForeignPtrToStorableArray ) where -import Foreign hiding (newArray)- import Data.Array.MArray-import Data.Array.Storable.Internals hiding ( unsafeForeignPtrToStorableArray )-import qualified Data.Array.Unsafe as U ( unsafeForeignPtrToStorableArray )--{-# DEPRECATED unsafeForeignPtrToStorableArray- "Please import from Data.Array.Unsafe instead; This will be removed in the next release"- #-}---- |Construct a 'StorableArray' from an arbitrary 'ForeignPtr'. It is--- the caller's responsibility to ensure that the 'ForeignPtr' points to--- an area of memory sufficient for the specified bounds.-{-# INLINE unsafeForeignPtrToStorableArray #-}-unsafeForeignPtrToStorableArray- :: Ix i => ForeignPtr e -> (i,i) -> IO (StorableArray i e)-unsafeForeignPtrToStorableArray = U.unsafeForeignPtrToStorableArray-+import Data.Array.Storable.Internals
Data/Array/Storable/Internals.hs view
@@ -1,4 +1,5 @@-{-# OPTIONS_HADDOCK hide #-}+{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, RoleAnnotations #-}+{-# OPTIONS_HADDOCK not-home #-} ----------------------------------------------------------------------------- -- | -- Module : Data.Array.Storable.Internals@@ -11,9 +12,21 @@ -- -- Actual implementation of "Data.Array.Storable". --+-- @since 0.4.0.0+--+-- = WARNING+--+-- This module is considered __internal__.+--+-- The Package Versioning Policy __does not apply__.+--+-- The contents of this module may change __in any way whatsoever__+-- and __without any warning__ between minor versions of this package.+--+-- Authors importing this module are expected to track development+-- closely. ----------------------------------------------------------------------------- --- #hide module Data.Array.Storable.Internals ( StorableArray(..), withStorableArray,@@ -27,6 +40,8 @@ -- |The array type data StorableArray i e = StorableArray !i !i Int !(ForeignPtr e)+-- Both parameters have class-based invariants. See also #9220.+type role StorableArray nominal nominal instance Storable e => MArray StorableArray e IO where getBounds (StorableArray l u _ _) = return (l,u)
Data/Array/Storable/Safe.hs view
@@ -20,6 +20,7 @@ -- -- Safe API only of "Data.Array.Storable". --+-- @since 0.4.0.0 ----------------------------------------------------------------------------- module Data.Array.Storable.Safe (
Data/Array/Unsafe.hs view
@@ -11,6 +11,7 @@ -- Contains the various unsafe operations that can be performed -- on arrays. --+-- @since 0.4.0.0 ----------------------------------------------------------------------------- module Data.Array.Unsafe (
LICENSE view
@@ -81,3 +81,4 @@ be a definition of the Haskell 98 Foreign Function Interface. -----------------------------------------------------------------------------+
Setup.hs view
@@ -4,3 +4,4 @@ main :: IO () main = defaultMain+
array.cabal view
@@ -1,30 +1,45 @@-name: array-version: 0.4.0.1-license: BSD3-license-file: LICENSE+cabal-version: >= 1.10+name: array+version: 0.5.8.0++-- NOTE: Don't forget to update ./changelog.md+license: BSD3+license-file: LICENSE maintainer: libraries@haskell.org-bug-reports: http://hackage.haskell.org/trac/ghc/newticket?component=libraries%20%28other%29-synopsis: Mutable and immutable arrays-category: Data Structures+bug-reports: https://gitlab.haskell.org/ghc/packages/array/issues+synopsis: Mutable and immutable arrays+category: Data Structures+build-type: Simple description:- This package defines the classes @IArray@ of immutable arrays and- @MArray@ of arrays mutable within appropriate monads, as well as- some instances of these classes.-cabal-version: >=1.6-build-type: Simple-extra-source-files: include/Typeable.h+ In addition to providing the "Data.Array" module+ <http://www.haskell.org/onlinereport/haskell2010/haskellch14.html as specified in the Haskell 2010 Language Report>,+ this package also defines the classes 'IArray' of+ immutable arrays and 'MArray' of arrays mutable within appropriate+ monads, as well as some instances of these classes. +extra-source-files: changelog.md+ source-repository head- type: git- location: http://darcs.haskell.org/packages/array.git/+ type: git+ location: http://gitlab.haskell.org/ghc/packages/array.git library- build-depends: base >= 4.2 && < 5+ default-language: Haskell2010+ other-extensions:+ BangPatterns,+ CPP,+ FlexibleContexts,+ FlexibleInstances,+ MagicHash,+ MultiParamTypeClasses,+ RankNTypes,+ Trustworthy,+ UnboxedTuples,+ UnliftedFFITypes+ build-depends: base >= 4.9 && < 4.21+ ghc-options: -Wall exposed-modules: Data.Array- extensions: CPP- if !impl(nhc98)- exposed-modules: Data.Array.Base Data.Array.IArray Data.Array.IO@@ -39,18 +54,3 @@ Data.Array.Storable.Internals Data.Array.Unboxed Data.Array.Unsafe- extensions:- MultiParamTypeClasses,- FlexibleContexts,- FlexibleInstances,- TypeSynonymInstances- if impl(ghc)- extensions:- DeriveDataTypeable,- StandaloneDeriving,- Rank2Types,- MagicHash,- UnboxedTuples,- ForeignFunctionInterface,- UnliftedFFITypes- include-dirs: include
+ changelog.md view
@@ -0,0 +1,101 @@+# Changelog for [`array` package](http://hackage.haskell.org/package/array)++## 0.5.8.0 *Aug 2024*++### Added++ * Folds for arrays: `foldrArray`, `foldlArray'`, `foldlArray`, `foldrArray'`,+ `traverseArray_`, `forArray_`, `foldlArrayM'`, `foldrArrayM'`.+ * Folds for mutable arrays: `foldlMArray'`, `foldrMArray'`, `mapMArrayM_`,+ `forMArrayM_`, `foldlMArrayM'`, `foldrMArrayM'`.++### Fixed++ * Fix a build error that the package can't be buildable before `base-4.14`.++## 0.5.7.0 *April 2024*++### Changed++ * `MArray` now has a `MINIMAL` pragma+ * Optimisation of `newListArray` and `newGenArray`++## 0.5.6.0 *July 2023*++### Changed++ * `listArray` and `newListArray` are now good consumers of the input list+ * Bump base bound to `<4.20`++### Added++ * Add the `genArray` and `newGenArray` function+ * Add `Data.Array.MArray.modifyArray` and `Data.Array.MArray.modifyArray'`+ These are also exposed from `Data.Array.IO`, `Data.Array.ST`, and+ `Data.Array.Storable`.+ * Add `Data.Array.IArray.(!?)`++### Fixed++ * Array docs regarding constructing arrays+ * Update note [Inlining and fusion]+ * Unboxed Bool arrays no longer cause spurious alarms+ when used with `-fcheck-prim-bounds`+ * Replace Haddock hide pragma with not-home to make the Haddocks more readable++## 0.5.5.0 *February 2022*++ * Compatibility with GHC's new JavaScript backend.++## 0.5.4.0 *July 2019*++ * Add a `Read` instance for `UArray`++## 0.5.3.0 *Oct 2018*++ * Bundled with GHC 8.6.2+ * Drop support for GHC versions prior to GHC 8.0++## 0.5.2.0 *Jul 2017*++ * Bundled with GHC 8.2.1+ * Overflow check in `unsafeNewArray` (#229)+ * Fix and simplify handling of `Bool` arrays+ * Export `unsafeFreezeIOUArray` from `Data.Array.IO.Internals`+ * Drop support for GHC versions prior to GHC 7.8++## 0.5.1.1 *Apr 2016*++ * Bundled with GHC 8.0.1+ * Use `@since` syntax in Haddock comments+ * Don't needlessly call `bounds` in `Data.Array.Base.elems` (#10014)++## 0.5.1.0 *Mar 2015*++ * Bundled with GHC 7.10.1+ * Add role annotations for GHC >= 7.8 (#9220)++## 0.5.0.0 *Nov 2013*++ * Update to Cabal 1.10 format+ * Remove NHC and Hugs specific code+ * Remove deprecated function exports `Data.Array.IO.castIOUArray`,+ `Data.Array.MArray.unsafeFreeze`, `Data.Array.MArray.unsafeThaw`,+ and `Data.Array.ST.castSTUArray`; These functions are still+ available from the `Data.Array.Unsafe` module.++## 0.4.0.1 *Sep 2012*++ * Bundled with GHC 7.6.1+ * Fix inline rule shadowing warnings++## 0.4.0.0 *Feb 2012*++ * Bundled with GHC 7.4.1+ * Add support for SafeHaskell+ * New `Data.Array.IO.Safe` module+ * New `Data.Array.MArray.safe` module+ * New `Data.Array.ST.safe` module+ * New `Data.Array.Storable.Internals` module+ * New `Data.Array.Storable.Safe` module+ * New `Data.Array.Unsafe` module
− include/Typeable.h
@@ -1,59 +0,0 @@-{- ---------------------------------------------------------------------------// Macros to help make Typeable instances.-//-// INSTANCE_TYPEABLEn(tc,tcname,"tc") defines-//-// instance Typeable/n/ tc-// instance Typeable a => Typeable/n-1/ (tc a)-// instance (Typeable a, Typeable b) => Typeable/n-2/ (tc a b)-// ...-// instance (Typeable a1, ..., Typeable an) => Typeable (tc a1 ... an)-// ----------------------------------------------------------------------------}--#ifndef TYPEABLE_H-#define TYPEABLE_H--#ifdef __GLASGOW_HASKELL__---- // For GHC, we can use DeriveDataTypeable + StandaloneDeriving to--- // generate the instances.--#define INSTANCE_TYPEABLE0(tycon,tcname,str) deriving instance Typeable tycon-#define INSTANCE_TYPEABLE1(tycon,tcname,str) deriving instance Typeable1 tycon-#define INSTANCE_TYPEABLE2(tycon,tcname,str) deriving instance Typeable2 tycon-#define INSTANCE_TYPEABLE3(tycon,tcname,str) deriving instance Typeable3 tycon--#else /* !__GLASGOW_HASKELL__ */--#define INSTANCE_TYPEABLE0(tycon,tcname,str) \-tcname :: TyCon; \-tcname = mkTyCon str; \-instance Typeable tycon where { typeOf _ = mkTyConApp tcname [] }--#define INSTANCE_TYPEABLE1(tycon,tcname,str) \-tcname = mkTyCon str; \-instance Typeable1 tycon where { typeOf1 _ = mkTyConApp tcname [] }; \-instance Typeable a => Typeable (tycon a) where { typeOf = typeOfDefault }--#define INSTANCE_TYPEABLE2(tycon,tcname,str) \-tcname = mkTyCon str; \-instance Typeable2 tycon where { typeOf2 _ = mkTyConApp tcname [] }; \-instance Typeable a => Typeable1 (tycon a) where { \- typeOf1 = typeOf1Default }; \-instance (Typeable a, Typeable b) => Typeable (tycon a b) where { \- typeOf = typeOfDefault }--#define INSTANCE_TYPEABLE3(tycon,tcname,str) \-tcname = mkTyCon str; \-instance Typeable3 tycon where { typeOf3 _ = mkTyConApp tcname [] }; \-instance Typeable a => Typeable2 (tycon a) where { \- typeOf2 = typeOf2Default }; \-instance (Typeable a, Typeable b) => Typeable1 (tycon a b) where { \- typeOf1 = typeOf1Default }; \-instance (Typeable a, Typeable b, Typeable c) => Typeable (tycon a b c) where { \- typeOf = typeOfDefault }--#endif /* !__GLASGOW_HASKELL__ */--#endif