array 0.5.7.0 → 0.5.8.0

raw patch · 6 files changed

+204/−8 lines, 6 filesdep ~basePVP ok

version bump matches the API change (PVP)

Dependency ranges changed: base

API changes (from Hackage documentation)

Files

• Data/Array/Base.hs +164/−7
• Data/Array/IArray.hs +10/−0
• Data/Array/MArray.hs +8/−0
• Data/Array/MArray/Safe.hs +8/−0
• array.cabal +1/−1
• changelog.md +13/−0

@@ -47,10 +47,9 @@ 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 @@  {-# 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 @@ {-# 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 (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 @@ -921,6 +1012,8 @@ {-# 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 +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) @@ -1464,12 +1621,12 @@  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

@@ -39,6 +39,16 @@     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

@@ -35,6 +35,14 @@     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)

@@ -35,6 +35,14 @@     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)

@@ -1,6 +1,6 @@ cabal-version: >= 1.10 name:          array-version:       0.5.7.0+version:       0.5.8.0  -- NOTE: Don't forget to update ./changelog.md license:       BSD3

@@ -1,5 +1,18 @@ # 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