Use IO callbacks in Array modules

Author: adithyaov

core/docs/Changelog.md

@@ -39,6 +39,11 @@
 See [0.2.2-0.3.0 API Changelog](/core/docs/ApiChangelogs/0.2.2-0.3.0.txt) for a
 full list of deprecations, additions, and changes to the function signatures.
 
+### Breaking Changes
+
+* Functions in Array and MutArray that take a callback now explicitly use `IO`
+  instead of a generalized monad `m`.
+
 ## 0.2.2 (Jan 2024)
 
 * Add fixities `infixr 5` for `cons` and `consM` functions.

core/src/Streamly/Internal/Data/Array/Type.hs

@@ -296,7 +296,7 @@ data Array a =
 -- /Pre-release/
 --
 {-# INLINE unsafePinnedAsPtr #-}
-unsafePinnedAsPtr :: MonadIO m => Array a -> (Ptr a -> Int -> m b) -> m b
+unsafePinnedAsPtr :: MonadIO m => Array a -> (Ptr a -> Int -> IO b) -> m b
 unsafePinnedAsPtr arr f = do
     let marr = unsafeThaw arr
     pinned <- liftIO $ MA.pin marr
@@ -311,7 +311,7 @@ unsafePinnedAsPtr arr f = do
 --
 {-# INLINE unsafeAsForeignPtr #-}
 unsafeAsForeignPtr
-    :: MonadIO m => Array a -> (ForeignPtr a -> Int -> m b) -> m b
+    :: MonadIO m => Array a -> (ForeignPtr a -> Int -> IO b) -> m b
 unsafeAsForeignPtr arr0 f = do
     let marr = unsafeThaw arr0
     pinned <- liftIO $ MA.pin marr
@@ -345,7 +345,7 @@ unsafeFromForeignPtr (ForeignPtr addr# _) len =
 
 {-# DEPRECATED asPtrUnsafe "Please use unsafePinnedAsPtr instead." #-}
 {-# INLINE asPtrUnsafe #-}
-asPtrUnsafe :: MonadIO m => Array a -> (Ptr a -> m b) -> m b
+asPtrUnsafe :: MonadIO m => Array a -> (Ptr a -> IO b) -> m b
 asPtrUnsafe arr f = unsafePinnedAsPtr arr (\p _ -> f p)
 
 -------------------------------------------------------------------------------

core/src/Streamly/Internal/Data/MutArray/Type.hs

@@ -573,8 +573,8 @@ isPinned MutArray{..} = Unboxed.isPinned arrContents
 -- /Pre-release/
 {-# INLINE emptyWithAligned #-}
 newArrayWith, emptyWithAligned :: forall m a. (MonadIO m, Unbox a)
-    => (Int -> Int -> m MutByteArray) -> Int -> Int -> m (MutArray a)
-emptyWithAligned alloc alignSize count = do
+    => (Int -> Int -> IO MutByteArray) -> Int -> Int -> m (MutArray a)
+emptyWithAligned alloc alignSize count = liftIO $ do
     let size = max (count * SIZE_OF(a)) 0
     contents <- alloc size alignSize
     return $ MutArray
@@ -2226,6 +2226,7 @@ writeAppend :: forall m a. (MonadIO m, Unbox a) =>
     m (MutArray a) -> Fold m a (MutArray a)
 writeAppend = append
 
+-- XXX Use "IO" instead of "m"
 -- XXX We can carry bound as well in the state to make sure we do not lose the
 -- remaining capacity. Need to check perf impact.
 --
@@ -2292,6 +2293,7 @@ pinnedWriteNUnsafe :: forall m a. (MonadIO m, Unbox a)
     => Int -> Fold m a (MutArray a)
 pinnedWriteNUnsafe = unsafeCreateOf'
 
+-- XXX Use "IO" instead of "m"
 -- | @createWithOf alloc n@ folds a maximum of @n@ elements into an array
 -- allocated using the @alloc@ function.
 --
@@ -3179,14 +3181,14 @@ cast arr =
 -- array after pinning.
 {-# DEPRECATED unsafePinnedAsPtr "Pin the array and then use unsafeAsPtr." #-}
 {-# INLINE unsafePinnedAsPtr #-}
-unsafePinnedAsPtr :: MonadIO m => MutArray a -> (Ptr a -> Int -> m b) -> m b
+unsafePinnedAsPtr :: MonadIO m => MutArray a -> (Ptr a -> Int -> IO b) -> m b
 unsafePinnedAsPtr arr f = do
     arr1 <- liftIO $ pin arr
     unsafeAsPtr arr1 f
 
 {-# DEPRECATED asPtrUnsafe "Pin the array and then use unsafeAsPtr." #-}
 {-# INLINE asPtrUnsafe #-}
-asPtrUnsafe :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b
+asPtrUnsafe :: MonadIO m => MutArray a -> (Ptr a -> IO b) -> m b
 asPtrUnsafe a f = unsafePinnedAsPtr a (\p _ -> f p)
 
 -- | @unsafeAsPtr arr f@, f is a function used as @f ptr len@ where @ptr@ is a
@@ -3200,7 +3202,7 @@ asPtrUnsafe a f = unsafePinnedAsPtr a (\p _ -> f p)
 -- /Pre-release/
 --
 {-# INLINE unsafeAsPtr #-}
-unsafeAsPtr :: MonadIO m => MutArray a -> (Ptr a -> Int -> m b) -> m b
+unsafeAsPtr :: MonadIO m => MutArray a -> (Ptr a -> Int -> IO b) -> m b
 unsafeAsPtr arr f =
     Unboxed.unsafeAsPtr
         (arrContents arr)
@@ -3216,7 +3218,7 @@ unsafeAsPtr arr f =
 -- to the total capacity.
 {-# INLINE unsafePinnedCreateUsingPtr #-}
 unsafePinnedCreateUsingPtr
-    :: MonadIO m => Int -> (Ptr Word8 -> m Int) -> m (MutArray Word8)
+    :: MonadIO m => Int -> (Ptr Word8 -> IO Int) -> m (MutArray Word8)
 unsafePinnedCreateUsingPtr cap pop = do
     (arr :: MutArray Word8) <- emptyOf' cap
     len <- Unboxed.unsafeAsPtr (arrContents arr) pop

core/src/Streamly/Internal/Data/MutByteArray/Type.hs

@@ -113,14 +113,14 @@ touch (MutByteArray contents) =
 -- array after pinning.
 {-# DEPRECATED unsafePinnedAsPtr "Pin the array and then use unsafeAsPtr." #-}
 {-# INLINE unsafePinnedAsPtr #-}
-unsafePinnedAsPtr :: MonadIO m => MutByteArray -> (Ptr a -> m b) -> m b
+unsafePinnedAsPtr :: MonadIO m => MutByteArray -> (Ptr a -> IO b) -> m b
 unsafePinnedAsPtr arr f = do
     arr1 <- liftIO $ pin arr
     unsafeAsPtr arr1 f
 
 {-# DEPRECATED asPtrUnsafe "Pin the array and then use unsafeAsPtr." #-}
 {-# INLINE asPtrUnsafe #-}
-asPtrUnsafe :: MonadIO m => MutByteArray -> (Ptr a -> m b) -> m b
+asPtrUnsafe :: MonadIO m => MutByteArray -> (Ptr a -> IO b) -> m b
 asPtrUnsafe = unsafePinnedAsPtr
 
 -- | Use a @MutByteArray@ as @Ptr a@. This is useful when we want to pass
@@ -137,8 +137,8 @@ asPtrUnsafe = unsafePinnedAsPtr
 -- /Pre-release/
 --
 {-# INLINE unsafeAsPtr #-}
-unsafeAsPtr :: MonadIO m => MutByteArray -> (Ptr a -> m b) -> m b
-unsafeAsPtr arr f = do
+unsafeAsPtr :: MonadIO m => MutByteArray -> (Ptr a -> IO b) -> m b
+unsafeAsPtr arr f = liftIO $ do
     when (not (isPinned arr))
         $ error "unsafeAsPtr requires the array to be pinned"
 
@@ -147,7 +147,7 @@ unsafeAsPtr arr f = do
     r <- f ptr
     -- While f is using the bare pointer, the MutByteArray may be garbage
     -- collected by the GC, tell the GC that we are still using it.
-    liftIO $ touch arr
+    touch arr
     return r
 
 --------------------------------------------------------------------------------