on master help sign in
Replace unsafeWithArrayContents with unsafeWithArray

This makes the API less ambiguous

commitcc44d9714b90879a5fd0aaf076778e8c0ce7cade authorAdithya Kumar <adithya@composewell.com> dateFri 4 Feb 2022, 01:23 (5 years ago) parentf235118
4 files changed+43−37
src/Streamly/Internal/Data/Array/Foreign.hs+8−7 src/Streamly/Internal/Data/Array/Foreign/Mut/Type.hs+23−25 src/Streamly/Internal/Data/Array/Foreign/Type.hs+8 src/Streamly/Internal/FileSystem/FD.hs+4−5
src/Streamly/Internal/Data/Array/Foreign.hs+8−7
@@ -132,7 +132,8 @@ import Prelude hiding (length, null, last, map, (!!), read, concat)
132132import GHC.Ptr (Ptr(..))
133133
134134import Streamly.Internal.Data.Array.Foreign.Mut.Type (ReadUState(..), touch)
135−import Streamly.Internal.Data.Array.Foreign.Type (Array(..), length)
135+import Streamly.Internal.Data.Array.Foreign.Type
136+ (Array(..), length, unsafeWithArray)
136137import Streamly.Internal.Data.Fold.Type (Fold(..))
137138import Streamly.Internal.Data.Producer.Type (Producer(..))
138139import Streamly.Internal.Data.Stream.Serial (SerialT(..))
@@ -269,7 +270,7 @@ null arr = A.byteLength arr == 0
269270getIndexRev :: forall a. Storable a => Int -> Array a -> Maybe a
270271getIndexRev i arr =
271272 unsafeInlineIO
272− $ MA.unsafeWithArrayContents (arrContents arr) (arrStart arr)
273+ $ unsafeWithArray arr
273274 $ \ptr -> do
274275 let elemPtr = PTR_RINDEX(aEnd arr,i,a)
275276 if i >= 0 && elemPtr >= ptr
@@ -436,7 +437,7 @@ getSlicesFromLen from len =
436437getIndex :: forall a. Storable a => Array a -> Int -> Maybe a
437438getIndex arr i =
438439 unsafeInlineIO
439− $ MA.unsafeWithArrayContents (arrContents arr) (arrStart arr)
440+ $ unsafeWithArray arr
440441 $ \ptr -> do
441442 let elemPtr = PTR_INDEX(ptr,i,a)
442443 if i >= 0 && PTR_VALID(elemPtr,aEnd arr,a)
@@ -561,8 +562,8 @@ cast arr =
561562-- /Pre-release/
562563--
563564unsafeAsPtr :: Array a -> (Ptr b -> IO c) -> IO c
564−unsafeAsPtr Array{..} act = do
565− MA.unsafeWithArrayContents arrContents arrStart $ \ptr -> act (castPtr ptr)
565+unsafeAsPtr arr act = do
566+ unsafeWithArray arr $ \ptr -> act (castPtr ptr)
566567
567568-- | Convert an array of any type into a null terminated CString Ptr.
568569--
@@ -574,8 +575,8 @@ unsafeAsPtr Array{..} act = do
574575--
575576unsafeAsCString :: Array a -> (CString -> IO b) -> IO b
576577unsafeAsCString arr act = do
577− let Array{..} = asBytes arr <> A.fromList [0]
578− MA.unsafeWithArrayContents arrContents arrStart $ \ptr -> act (castPtr ptr)
578+ let arr1 = asBytes arr <> A.fromList [0]
579+ unsafeWithArray arr1 $ \ptr -> act (castPtr ptr)
579580
580581-------------------------------------------------------------------------------
581582-- Folds
src/Streamly/Internal/Data/Array/Foreign/Mut/Type.hs+23−25
@@ -20,7 +20,7 @@ module Streamly.Internal.Data.Array.Foreign.Mut.Type
2020 , ArrayContents
2121 , arrayToFptrContents
2222 , fptrToArrayContents
23− , unsafeWithArrayContents
23+ , unsafeWithArray
2424 , nilArrayContents
2525 , touch
2626
@@ -333,12 +333,10 @@ arrayToFptrContents (ArrayContents contents) = PlainPtr contents
333333#endif
334334
335335-- | Similar to unsafeWithForeignPtr.
336−{-# INLINE unsafeWithArrayContents #-}
337−unsafeWithArrayContents :: MonadIO m =>
338− ArrayContents -> Ptr a -> (Ptr a -> m b) -> m b
339−unsafeWithArrayContents contents ptr f = do
340− r <- f ptr
341− liftIO $ touch contents
336+unsafeWithArray :: MonadIO m => Array a -> (Ptr a -> m b) -> m b
337+unsafeWithArray Array{..} f = do
338+ r <- f arrStart
339+ liftIO $ touch arrContents
342340 return r
343341
344342-------------------------------------------------------------------------------
@@ -532,7 +530,7 @@ withNewArrayUnsafe ::
532530 (MonadIO m, Storable a) => Int -> (Ptr a -> m ()) -> m (Array a)
533531withNewArrayUnsafe count f = do
534532 arr <- newArray count
535− unsafeWithArrayContents (arrContents arr) (arrStart arr)
533+ unsafeWithArray arr
536534 $ \p -> f p >> return arr
537535
538536-------------------------------------------------------------------------------
@@ -546,8 +544,8 @@ withNewArrayUnsafe count f = do
546544{-# INLINE putIndexUnsafe #-}
547545putIndexUnsafe :: forall m a. (MonadIO m, Storable a)
548546 => Int -> a -> Array a -> m ()
549−putIndexUnsafe i x Array{..} =
550− unsafeWithArrayContents arrContents arrStart $ \ptr -> do
547+putIndexUnsafe i x arr@(Array{..}) =
548+ unsafeWithArray arr $ \ptr -> do
551549 let elemPtr = PTR_INDEX(ptr,i,a)
552550 assert (i >= 0 && PTR_VALID(elemPtr,aEnd,a)) (return ())
553551 liftIO $ poke elemPtr x
@@ -576,7 +574,7 @@ putIndexPtr start end i x = do
576574{-# INLINE putIndex #-}
577575putIndex :: (MonadIO m, Storable a) => Int -> a -> Array a -> m ()
578576putIndex i x arr =
579− unsafeWithArrayContents (arrContents arr) (arrStart arr)
577+ unsafeWithArray arr
580578 $ \p -> putIndexPtr p (aEnd arr) i x
581579
582580-- | Write an input stream of (index, value) pairs to an array. Throws an
@@ -601,8 +599,8 @@ putIndices Array{..} = FL.mkFoldM step initial extract
601599-- /Pre-release/
602600modifyIndexUnsafe :: forall m a b. (MonadIO m, Storable a) =>
603601 Int -> (a -> (a, b)) -> Array a -> m b
604−modifyIndexUnsafe i f Array{..} = do
605− liftIO $ unsafeWithArrayContents arrContents arrStart $ \ptr -> do
602+modifyIndexUnsafe i f arr@(Array{..}) = do
603+ liftIO $ unsafeWithArray arr $ \ptr -> do
606604 let elemPtr = PTR_INDEX(ptr,i,a)
607605 assert (i >= 0 && PTR_NEXT(elemPtr,a) <= aEnd) (return ())
608606 r <- peek elemPtr
@@ -628,8 +626,8 @@ modifyIndexPtr i f start end = liftIO $ do
628626-- /Pre-release/
629627modifyIndex :: forall m a b. (MonadIO m, Storable a) =>
630628 Int -> (a -> (a, b)) -> Array a -> m b
631−modifyIndex i f Array{..} = do
632− liftIO $ unsafeWithArrayContents arrContents arrStart $ \ptr -> do
629+modifyIndex i f arr@(Array{..}) = do
630+ liftIO $ unsafeWithArray arr $ \ptr -> do
633631 modifyIndexPtr i f ptr aEnd
634632
635633-- | Modify the array indices generated by the supplied stream.
@@ -655,8 +653,8 @@ modifyIndices f Array{..} = Fold step initial extract
655653-- /Pre-release/
656654modify :: forall m a. (MonadIO m, Storable a)
657655 => (a -> a) -> Array a -> m ()
658−modify f Array{..} = liftIO $
659− unsafeWithArrayContents arrContents arrStart go
656+modify f arr@Array{..} = liftIO $
657+ unsafeWithArray arr go
660658
661659 where
662660
@@ -682,8 +680,8 @@ swapPtrs ptr1 ptr2 = do
682680{-# INLINE unsafeSwapIndices #-}
683681unsafeSwapIndices :: forall m a. (MonadIO m, Storable a)
684682 => Int -> Int -> Array a -> m ()
685−unsafeSwapIndices i1 i2 Array{..} = liftIO $ do
686− unsafeWithArrayContents arrContents arrStart $ \ptr -> do
683+unsafeSwapIndices i1 i2 arr = liftIO $ do
684+ unsafeWithArray arr $ \ptr -> do
687685 let ptr1 = PTR_INDEX(ptr,i1,a)
688686 ptr2 = PTR_INDEX(ptr,i2,a)
689687 swapPtrs ptr1 (ptr2 :: Ptr a)
@@ -1049,8 +1047,8 @@ snoc = snocWith f
10491047-- Unsafe because it does not check the bounds of the array.
10501048{-# INLINE_NORMAL getIndexUnsafe #-}
10511049getIndexUnsafe :: forall m a. (MonadIO m, Storable a) => Int -> Array a -> m a
1052−getIndexUnsafe i Array {..} =
1053− unsafeWithArrayContents arrContents arrStart $ \ptr -> do
1050+getIndexUnsafe i arr@(Array {..}) =
1051+ unsafeWithArray arr $ \ptr -> do
10541052 let elemPtr = PTR_INDEX(ptr,i,a)
10551053 assert (i >= 0 && PTR_VALID(elemPtr,aEnd,a)) (return ())
10561054 liftIO $ peek elemPtr
@@ -1069,7 +1067,7 @@ getIndexPtr start end i = do
10691067{-# INLINE getIndex #-}
10701068getIndex :: (MonadIO m, Storable a) => Int -> Array a -> m a
10711069getIndex i arr =
1072− unsafeWithArrayContents (arrContents arr) (arrStart arr)
1070+ unsafeWithArray arr
10731071 $ \p -> getIndexPtr p (aEnd arr) i
10741072
10751073{-# INLINE getIndexPtrRev #-}
@@ -1089,7 +1087,7 @@ getIndexPtrRev start end i = do
10891087{-# INLINE getIndexRev #-}
10901088getIndexRev :: (MonadIO m, Storable a) => Int -> Array a -> m a
10911089getIndexRev i arr =
1092− unsafeWithArrayContents (arrContents arr) (arrStart arr)
1090+ unsafeWithArray arr
10931091 $ \p -> getIndexPtrRev p (aEnd arr) i
10941092
10951093data GetIndicesState contents start end st =
@@ -2250,8 +2248,8 @@ cast arr =
22502248-- /Pre-release/
22512249--
22522250asPtrUnsafe :: Array a -> (Ptr b -> IO c) -> IO c
2253−asPtrUnsafe Array{..} act = do
2254− unsafeWithArrayContents arrContents arrStart $ \ptr -> act (castPtr ptr)
2251+asPtrUnsafe arr act = do
2252+ unsafeWithArray arr $ \ptr -> act (castPtr ptr)
22552253
22562254-------------------------------------------------------------------------------
22572255-- Equality
src/Streamly/Internal/Data/Array/Foreign/Type.hs+8
@@ -13,6 +13,7 @@ module Streamly.Internal.Data.Array.Foreign.Type
1313 (
1414 -- $arrayNotes
1515 Array (..)
16+ , unsafeWithArray
1617
1718 -- * Freezing and Thawing
1819 , unsafeFreeze
@@ -158,6 +159,13 @@ data Array a =
158159foreign import ccall unsafe "string.h strlen" c_strlen
159160 :: CString -> IO CSize
160161
162+-- | Similar to unsafeWithForeignPtr.
163+unsafeWithArray :: MonadIO m => Array a -> (Ptr a -> m b) -> m b
164+unsafeWithArray Array{..} f = do
165+ r <- f arrStart
166+ liftIO $ touch arrContents
167+ return r
168+
161169-------------------------------------------------------------------------------
162170-- Freezing and Thawing
163171-------------------------------------------------------------------------------
src/Streamly/Internal/FileSystem/FD.hs+4−5
@@ -131,9 +131,8 @@ import qualified GHC.IO.FD as FD
131131import qualified GHC.IO.Device as RawIO
132132
133133import Streamly.Internal.Data.Array.Foreign.Type
134− (Array(..), byteLength, unsafeFreeze)
135−import Streamly.Internal.Data.Array.Foreign.Mut.Type
136− (fromForeignPtrUnsafe, unsafeWithArrayContents)
134+ (Array(..), byteLength, unsafeFreeze, unsafeWithArray)
135+import Streamly.Internal.Data.Array.Foreign.Mut.Type (fromForeignPtrUnsafe)
137136import Streamly.Internal.System.IO (defaultChunkSize)
138137import Streamly.Internal.Data.Stream.Serial (SerialT)
139138import Streamly.Internal.Data.Stream.IsStream.Type
@@ -241,7 +240,7 @@ readArrayUpto size (Handle fd) = do
241240writeArray :: Storable a => Handle -> Array a -> IO ()
242241writeArray _ arr | A.length arr == 0 = return ()
243242writeArray (Handle fd) arr =
244− unsafeWithArrayContents (arrContents arr) (arrStart arr) $ \p ->
243+ unsafeWithArray arr $ \p ->
245244 -- RawIO.writeAll fd (castPtr p) aLen
246245#if MIN_VERSION_base(4,15,0)
247246 RawIO.write fd (castPtr p) 0 aLen
@@ -266,7 +265,7 @@ writeArray (Handle fd) arr =
266265writeIOVec :: Handle -> Array RawIO.IOVec -> IO ()
267266writeIOVec _ iov | A.length iov == 0 = return ()
268267writeIOVec (Handle fd) iov =
269− unsafeWithArrayContents (arrContents iov) (arrStart iov) $ \p ->
268+ unsafeWithArray iov $ \p ->
270269 RawIO.writevAll fd p (A.length iov)
271270#endif
272271