.github/workflows/build.yml

+name: Building
+
+on:
+  pull_request:
+    branches:
+      - '**'
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      fail-fast: false
+      matrix:
+        ghc: ['9.10', '9.8', '9.6', '9.4', '9.2', '9.0', '8.10', '8.8', '8.6', '8.4', '8.2', '8.0']
+        os: ['ubuntu-22.04', 'windows-latest']
+
+    name: Build on ${{ matrix.os }} with GHC ${{ matrix.ghc }}
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: haskell-actions/setup@v2
+        with:
+          ghc-version: ${{ matrix.ghc }}
+      - run: cabal build

Data/Array/Base.hs

@@ -47,10 +47,9 @@ import Foreign.C.Types
 import Foreign.StablePtr
 
 import Data.Char
-import GHC.Arr          ( STArray )
+import GHC.Arr          ( STArray, unsafeIndex )
 import qualified GHC.Arr as Arr
 import qualified GHC.Arr as ArrST
-import GHC.Ix           ( unsafeIndex )
 import GHC.ST           ( ST(..), runST )
 import GHC.Base         ( IO(..), divInt# )
 import GHC.Exts
@@ -197,6 +196,8 @@ listArray (l,u) es =
 
 {-# 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)
 
@@ -282,6 +283,8 @@ type ListUArray e = forall i . Ix i => (i,i) -> [e] -> UArray i e
 {-# 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
@@ -383,6 +386,94 @@ ixmap :: (IArray a e, Ix i, Ix j) => (i,i) -> (i -> j) -> a j e -> a i e
 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
 
@@ -496,11 +587,6 @@ cmpIntUArray arr1@(UArray l1 u1 n1 _) arr2@(UArray l2 u2 n2 _) =
 -----------------------------------------------------------------------------
 -- Showing and Reading IArrays
 
-{-# 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 p a =
     showParen (p > appPrec) $
@@ -508,11 +594,7 @@ showsIArray p a =
     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 $
@@ -921,6 +1003,8 @@ newListArray (l,u) es = do
 {-# 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
@@ -1019,6 +1103,70 @@ mapIndices (l',u') f marr = do
               | 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)
 
@@ -1464,12 +1612,12 @@ freeze marr = do
 
 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

Data/Array/IArray.hs

@@ -39,6 +39,16 @@ module Data.Array.IArray (
     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
     accum,      -- :: (IArray a e, Ix i) => (e -> e' -> e) -> a i e -> [(i, e')] -> a i e

Data/Array/IO/Safe.hs

-{-# LANGUAGE Trustworthy #-}
+{-# LANGUAGE Safe #-}
 
 -----------------------------------------------------------------------------
 -- |

Data/Array/MArray.hs

@@ -35,6 +35,14 @@ module Data.Array.MArray (
     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)

Data/Array/MArray/Safe.hs

@@ -35,6 +35,14 @@ module Data.Array.MArray.Safe (
     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)
     mapIndices,   -- :: (MArray a e m, Ix i, Ix j) => (i,i) -> (i -> j) -> a j e -> m (a i e)

Data/Array/ST/Safe.hs

-{-# LANGUAGE Trustworthy #-}
+{-# LANGUAGE Safe #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Array.ST.Safe

array.cabal

 cabal-version: >= 1.10
 name:          array
-version:       0.5.6.0
+version:       0.5.8.0
 
 -- NOTE: Don't forget to update ./changelog.md
 license:       BSD3
 license-file:  LICENSE
 maintainer:    libraries@haskell.org
-bug-reports:   https://gitlab.haskell.org/ghc/packages/array/issues
+bug-reports:   https://github.com/haskell/array/issues
 synopsis:      Mutable and immutable arrays
 category:      Data Structures
 build-type:    Simple
@@ -21,7 +21,7 @@ extra-source-files: changelog.md
 
 source-repository head
   type:     git
-  location: http://gitlab.haskell.org/ghc/packages/array.git
+  location: https://github.com/haskell/array.git
 
 library
   default-language: Haskell2010
@@ -36,7 +36,7 @@ library
       Trustworthy,
       UnboxedTuples,
       UnliftedFFITypes
-  build-depends: base >= 4.9 && < 4.20
+  build-depends: base >= 4.9 && < 4.23
   ghc-options: -Wall
   exposed-modules:
       Data.Array

changelog.md

 # 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

tests/T229.hs

@@ -2,12 +2,13 @@
 
 #include "MachDeps.h"
 
+import Control.Exception
 import Data.Array.MArray
 import Data.Array.IO
 import Data.Word
 
 main :: IO ()
-main = do
+main = handle (\(exc :: SomeException) -> print exc) $ do
   -- This should fail due to integer overflow
 #if WORD_SIZE_IN_BITS == 64
   m <- newArray_ (0,2^62-1) :: IO (IOUArray Int Word32) -- allocates 0 bytes

tests/T229.stderr-ws-32

-T229: Data.Array.Base.safe_scale: Overflow; scale: 4, n: 1073741824
-CallStack (from HasCallStack):
-  error, called at libraries/array/Data/Array/Base.hs:1356:20 in array-0.5.1.2:Data.Array.Base

tests/T229.stderr-ws-64

-T229: Data.Array.Base.safe_scale: Overflow; scale: 4, n: 4611686018427387904
-CallStack (from HasCallStack):
-  error, called at libraries/array/Data/Array/Base.hs:1356:20 in array-0.5.1.2:Data.Array.Base

tests/T229.stdout-ws-32

+Data.Array.Base.safe_scale: Overflow; scale: 4, n: 1073741824

tests/T229.stdout-ws-64

+Data.Array.Base.safe_scale: Overflow; scale: 4, n: 4611686018427387904

tests/all.T

@@ -6,4 +6,4 @@ test('array001', [
   compile_and_run, [''])
 
 test('T9220', filter_stdout_lines('.*type role .*'), ghci_script, ['T9220.script'])
-test('T229', [exit_code(1)], compile_and_run, [''])
+test('T229', normal, compile_and_run, [''])