af57e26 · streamly · git.iko.soy

core/docs/ApiChangelogs/0.2.0-0.2.2.txt+8−2

compare with master

unifiedsplit

@@ -111,9 +111,11 @@ Internal API diff

111 [D] sliceOnSuffix :: Monad m => (a -> Bool) -> Stream m a -> Stream m (Int, Int)

112 [A] indexOnSuffix :: Monad m => (a -> Bool) -> Stream m a -> Stream m (Int, Int)

113[C] Streamly.Internal.Data.MutByteArray

114+ [A] unsafePinnedAsPtr :: MonadIO m => MutByteArray -> (Ptr a -> m b) -> m b

115+ [A] unsafeAsPtr :: MonadIO m => MutByteArray -> (Ptr a -> m b) -> m b

114 [D] nil :: MutByteArray

116 [D] nil :: MutByteArray

115 [A] empty :: MutByteArray

117 [A] empty :: MutByteArray

116− [A] asUnpinnedPtrUnsafe :: MonadIO m => MutByteArray -> (Ptr a -> m b) -> m b

118+ [D] asPtrUnsafe :: MonadIO m => MutByteArray -> (Ptr a -> m b) -> m b

117[D] Streamly.Internal.Data.MutArray.Stream

119[D] Streamly.Internal.Data.MutArray.Stream

118 [D] writeChunks :: (MonadIO m, Unbox a) => Int -> Fold m a (StreamK n (MutArray a))

120 [D] writeChunks :: (MonadIO m, Unbox a) => Int -> Fold m a (StreamK n (MutArray a))

119 [D] fromArrayStreamK :: (Unbox a, MonadIO m) => StreamK m (MutArray a) -> m (MutArray a)

121 [D] fromArrayStreamK :: (Unbox a, MonadIO m) => StreamK m (MutArray a) -> m (MutArray a)

@@ -142,8 +144,10 @@ Internal API diff

142 [D] writeAppendWith :: forall m a. (MonadIO m, Unbox a) => (Int -> Int) -> m (MutArray a) -> Fold m a (MutArray a)

144 [D] writeAppendWith :: forall m a. (MonadIO m, Unbox a) => (Int -> Int) -> m (MutArray a) -> Fold m a (MutArray a)

143 [D] writeAppendNUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a) -> Fold m a (MutArray a)

145 [D] writeAppendNUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a) -> Fold m a (MutArray a)

144 [A] unsafePinnedCreateOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)

146 [A] unsafePinnedCreateOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)

147+ [A] unsafePinnedAsPtr :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b

145 [A] unsafeCreateOfWith :: forall m a. (MonadIO m, Unbox a) => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)

148 [A] unsafeCreateOfWith :: forall m a. (MonadIO m, Unbox a) => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)

146 [A] unsafeCreateOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)

149 [A] unsafeCreateOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)

150+ [A] unsafeAsPtr :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b

147 [A] unsafeAppendN :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a) -> Fold m a (MutArray a)

151 [A] unsafeAppendN :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a) -> Fold m a (MutArray a)

148 [A] toStreamWith :: forall m a. (Monad m, Unbox a) => (forall b. IO b -> m b) -> MutArray a -> Stream m a

152 [A] toStreamWith :: forall m a. (Monad m, Unbox a) => (forall b. IO b -> m b) -> MutArray a -> Stream m a

149 [A] toStreamRevWith :: forall m a. (Monad m, Unbox a) => (forall b. IO b -> m b) -> MutArray a -> Stream m a

153 [A] toStreamRevWith :: forall m a. (Monad m, Unbox a) => (forall b. IO b -> m b) -> MutArray a -> Stream m a

@@ -210,7 +214,7 @@ Internal API diff

210 [A] byteEq :: MonadIO m => MutArray a -> MutArray a -> m Bool

214 [A] byteEq :: MonadIO m => MutArray a -> MutArray a -> m Bool

211 [A] byteCmp :: MonadIO m => MutArray a -> MutArray a -> m Ordering

215 [A] byteCmp :: MonadIO m => MutArray a -> MutArray a -> m Ordering

212 [A] buildChunks :: (MonadIO m, Unbox a) => Int -> Fold m a (StreamK n (MutArray a))

216 [A] buildChunks :: (MonadIO m, Unbox a) => Int -> Fold m a (StreamK n (MutArray a))

213− [A] asUnpinnedPtrUnsafe :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b

217+ [D] asPtrUnsafe :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b

214 [A] appendWith :: forall m a. (MonadIO m, Unbox a) => (Int -> Int) -> m (MutArray a) -> Fold m a (MutArray a)

218 [A] appendWith :: forall m a. (MonadIO m, Unbox a) => (Int -> Int) -> m (MutArray a) -> Fold m a (MutArray a)

215 [A] appendN :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a) -> Fold m a (MutArray a)

219 [A] appendN :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a) -> Fold m a (MutArray a)

216 [A] append :: forall m a. (MonadIO m, Unbox a) => m (MutArray a) -> Fold m a (MutArray a)

220 [A] append :: forall m a. (MonadIO m, Unbox a) => m (MutArray a) -> Fold m a (MutArray a)

@@ -229,6 +233,7 @@ Internal API diff

229 [A] create :: MonadIO m => Fold m a (Array a)

233 [A] create :: MonadIO m => Fold m a (Array a)

230[C] Streamly.Internal.Data.Array

234[C] Streamly.Internal.Data.Array

231 [R] ArrayUnsafe

235 [R] ArrayUnsafe

236+ [A] unsafePinnedAsPtr :: MonadIO m => Array a -> (Ptr a -> m b) -> m b

232 [D] toStreamDRev :: forall m a. (Monad m, Unbox a) => Array a -> Stream m a

237 [D] toStreamDRev :: forall m a. (Monad m, Unbox a) => Array a -> Stream m a

233 [D] toStreamD :: forall m a. (Monad m, Unbox a) => Array a -> Stream m a

238 [D] toStreamD :: forall m a. (Monad m, Unbox a) => Array a -> Stream m a

234 [C] splice

239 [C] splice

@@ -276,3 +281,4 @@ Internal API diff

276 [A] byteCmp :: Array a -> Array a -> Ordering

281 [A] byteCmp :: Array a -> Array a -> Ordering

277 [A] buildChunks :: (MonadIO m, Unbox a) => Stream m a -> m (StreamK m (Array a))

282 [A] buildChunks :: (MonadIO m, Unbox a) => Stream m a -> m (StreamK m (Array a))

278 [D] bufferChunks :: (MonadIO m, Unbox a) => Stream m a -> m (StreamK m (Array a))

283 [D] bufferChunks :: (MonadIO m, Unbox a) => Stream m a -> m (StreamK m (Array a))

284+ [D] asPtrUnsafe :: MonadIO m => Array a -> (Ptr a -> m b) -> m b

core/src/Streamly/Internal/Data/Array.hs+2−2

@@ -498,8 +498,8 @@ cast arr =

498asCStringUnsafe :: Array a -> (CString -> IO b) -> IO b

499asCStringUnsafe arr act = do

500 let arr1 = asBytes arr <> fromList [0]

501− -- asPtrUnsafe makes sure the array is pinned

501+ -- unsafePinnedAsPtr makes sure the array is pinned

502− asPtrUnsafe arr1 $ \ptr -> act (castPtr ptr)

502+ unsafePinnedAsPtr arr1 $ \ptr -> act (castPtr ptr)

503

504-------------------------------------------------------------------------------

505-- Folds

core/src/Streamly/Internal/Data/Array/Type.hs+9−3

@@ -28,7 +28,7 @@ module Streamly.Internal.Data.Array.Type

28 , isPinned

29

30 -- *** Casting

31− , asPtrUnsafe

31+ , unsafePinnedAsPtr

32

33 -- ** Construction

34 , empty

@@ -129,6 +129,7 @@ module Streamly.Internal.Data.Array.Type

129 , compactGE

130

131 -- ** Deprecated

132+ , asPtrUnsafe

132 , unsafeIndex

133 , unsafeIndex

133 , bufferChunks

134 , bufferChunks

134 , flattenArrays

135 , flattenArrays

@@ -231,15 +232,20 @@ data Array a =

231

232

232-- | Use an @Array a@ as @Ptr a@.

233-- | Use an @Array a@ as @Ptr a@.

233--

234--

234−-- See 'MA.asPtrUnsafe' in the Mutable array module for more details.

235+-- See 'MA.unsafePinnedAsPtr' in the Mutable array module for more details.

235--

236--

236-- /Unsafe/

237-- /Unsafe/

237--

238--

238-- /Pre-release/

239-- /Pre-release/

239--

240--

241+{-# INLINE unsafePinnedAsPtr #-}

242+unsafePinnedAsPtr :: MonadIO m => Array a -> (Ptr a -> m b) -> m b

243+unsafePinnedAsPtr arr = MA.unsafePinnedAsPtr (unsafeThaw arr)

244+

245+{-# DEPRECATED asPtrUnsafe "Please use unsafePinnedAsPtr instead." #-}

240{-# INLINE asPtrUnsafe #-}

246{-# INLINE asPtrUnsafe #-}

241asPtrUnsafe :: MonadIO m => Array a -> (Ptr a -> m b) -> m b

247asPtrUnsafe :: MonadIO m => Array a -> (Ptr a -> m b) -> m b

242−asPtrUnsafe arr = MA.asPtrUnsafe (unsafeThaw arr)

248+asPtrUnsafe = unsafePinnedAsPtr

243

249

244-------------------------------------------------------------------------------

250-------------------------------------------------------------------------------

245-- Freezing and Thawing

251-- Freezing and Thawing

core/src/Streamly/Internal/Data/MutArray/Type.hs+18−12

@@ -42,8 +42,8 @@ module Streamly.Internal.Data.MutArray.Type

42 , cast

43 , castUnsafe -- XXX unsafeCast

44 , asBytes

45− , asPtrUnsafe -- XXX rename to unsafePinnedAsPtr?

45+ , unsafePinnedAsPtr

46− , asUnpinnedPtrUnsafe -- XXX rename to unsafeAsPtr

46+ , unsafeAsPtr

47

48 -- ** Construction

49 , empty

@@ -264,6 +264,7 @@ module Streamly.Internal.Data.MutArray.Type

264 , c_memchr

265

266 -- * Deprecated

267+ , asPtrUnsafe

267 , writeChunks

268 , writeChunks

268 , flattenArrays

269 , flattenArrays

269 , flattenArraysRev

270 , flattenArraysRev

@@ -2431,7 +2432,7 @@ fromPtrN len addr = do

2431 -- XXX We can implement a stream copy in a similar way by streaming Word64

2432 -- XXX We can implement a stream copy in a similar way by streaming Word64

2432 -- first and then remaining Word8.

2433 -- first and then remaining Word8.

2433 arr <- new len

2434 arr <- new len

2434− _ <- asUnpinnedPtrUnsafe arr

2435+ _ <- unsafeAsPtr arr

2435 (\ptr -> liftIO $ c_memcpy ptr addr (fromIntegral len))

2436 (\ptr -> liftIO $ c_memcpy ptr addr (fromIntegral len))

2436 return (arr {arrEnd = len})

2437 return (arr {arrEnd = len})

2437

2438

@@ -2447,7 +2448,7 @@ fromByteStr# addr = do

2447 len <- liftIO $ c_strlen (Ptr addr)

2448 len <- liftIO $ c_strlen (Ptr addr)

2448 let lenInt = fromIntegral len

2449 let lenInt = fromIntegral len

2449 arr <- new lenInt

2450 arr <- new lenInt

2450− _ <- asUnpinnedPtrUnsafe arr (\ptr -> liftIO $ c_memcpy ptr (Ptr addr) len)

2451+ _ <- unsafeAsPtr arr (\ptr -> liftIO $ c_memcpy ptr (Ptr addr) len)

2451 return (arr {arrEnd = lenInt})

2452 return (arr {arrEnd = lenInt})

2452

2453

2453-------------------------------------------------------------------------------

2454-------------------------------------------------------------------------------

@@ -2735,7 +2736,7 @@ splitOn predicate arr =

2735{-# INLINE breakOn #-}

2736{-# INLINE breakOn #-}

2736breakOn :: MonadIO m

2737breakOn :: MonadIO m

2737 => Word8 -> MutArray Word8 -> m (MutArray Word8, Maybe (MutArray Word8))

2738 => Word8 -> MutArray Word8 -> m (MutArray Word8, Maybe (MutArray Word8))

2738−breakOn sep arr@MutArray{..} = asUnpinnedPtrUnsafe arr $ \p -> liftIO $ do

2739+breakOn sep arr@MutArray{..} = unsafeAsPtr arr $ \p -> liftIO $ do

2739 -- XXX We do not need memchr here, we can use a Haskell equivalent.

2740 -- XXX We do not need memchr here, we can use a Haskell equivalent.

2740 -- Need efficient stream based primitives that work on Word64.

2741 -- Need efficient stream based primitives that work on Word64.

2741 loc <- c_memchr p sep (fromIntegral $ byteLength arr)

2742 loc <- c_memchr p sep (fromIntegral $ byteLength arr)

@@ -2866,16 +2867,21 @@ cast arr =

2866--

2867--

2867-- /Pre-release/

2868-- /Pre-release/

2868--

2869--

2870+{-# INLINE unsafePinnedAsPtr #-}

2871+unsafePinnedAsPtr :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b

2872+unsafePinnedAsPtr arr f =

2873+ Unboxed.unsafePinnedAsPtr

2874+ (arrContents arr) (\ptr -> f (ptr `plusPtr` arrStart arr))

2875+

2876+{-# DEPRECATED asPtrUnsafe "Please use unsafePinnedAsPtr instead." #-}

2869{-# INLINE asPtrUnsafe #-}

2877{-# INLINE asPtrUnsafe #-}

2870asPtrUnsafe :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b

2878asPtrUnsafe :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b

2871−asPtrUnsafe arr f =

2879+asPtrUnsafe = unsafePinnedAsPtr

2872− Unboxed.asPtrUnsafe

2873− (arrContents arr) (\ptr -> f (ptr `plusPtr` arrStart arr))

2874

2880

2875−{-# INLINE asUnpinnedPtrUnsafe #-}

2881+{-# INLINE unsafeAsPtr #-}

2876−asUnpinnedPtrUnsafe :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b

2882+unsafeAsPtr :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b

2877−asUnpinnedPtrUnsafe arr f =

2883+unsafeAsPtr arr f =

2878− Unboxed.asUnpinnedPtrUnsafe

2884+ Unboxed.unsafeAsPtr

2879 (arrContents arr) (\ptr -> f (ptr `plusPtr` arrStart arr))

2885 (arrContents arr) (\ptr -> f (ptr `plusPtr` arrStart arr))

2880

2886

2881-------------------------------------------------------------------------------

2887-------------------------------------------------------------------------------

core/src/Streamly/Internal/Data/MutByteArray/Type.hs+14−8

@@ -34,10 +34,11 @@ module Streamly.Internal.Data.MutByteArray.Type

34 , cloneSliceUnsafeAs

35 , cloneSliceUnsafe

36 , pinnedCloneSliceUnsafe

37− , asPtrUnsafe -- XXX unsafePinnedAsPtr

37+ , unsafePinnedAsPtr

38− , asUnpinnedPtrUnsafe -- XXX unsafeAsPtr

38+ , unsafeAsPtr

39

40 -- ** Deprecated

41+ , asPtrUnsafe

41 , nil

42 , nil

42 ) where

43 ) where

43

44

@@ -117,9 +118,9 @@ touch (MutByteArray contents) =

117--

118--

118-- /Pre-release/

119-- /Pre-release/

119--

120--

120−{-# INLINE asPtrUnsafe #-}

121+{-# INLINE unsafePinnedAsPtr #-}

121−asPtrUnsafe :: MonadIO m => MutByteArray -> (Ptr a -> m b) -> m b

122+unsafePinnedAsPtr :: MonadIO m => MutByteArray -> (Ptr a -> m b) -> m b

122−asPtrUnsafe arr f = do

123+unsafePinnedAsPtr arr f = do

123 contents <- liftIO $ pin arr

124 contents <- liftIO $ pin arr

124 let !ptr = Ptr (byteArrayContents#

125 let !ptr = Ptr (byteArrayContents#

125 (unsafeCoerce# (getMutableByteArray# contents)))

126 (unsafeCoerce# (getMutableByteArray# contents)))

@@ -127,10 +128,15 @@ asPtrUnsafe arr f = do

127 liftIO $ touch contents

128 liftIO $ touch contents

128 return r

129 return r

129

130

131+{-# DEPRECATED asPtrUnsafe "Please use unsafePinnedAsPtr instead." #-}

132+{-# INLINE asPtrUnsafe #-}

133+asPtrUnsafe :: MonadIO m => MutByteArray -> (Ptr a -> m b) -> m b

134+asPtrUnsafe = unsafePinnedAsPtr

135+

130-- | For use with unsafe FFI functions. Does not force pin the array memory.

136-- | For use with unsafe FFI functions. Does not force pin the array memory.

131−{-# INLINE asUnpinnedPtrUnsafe #-}

137+{-# INLINE unsafeAsPtr #-}

132−asUnpinnedPtrUnsafe :: MonadIO m => MutByteArray -> (Ptr a -> m b) -> m b

138+unsafeAsPtr :: MonadIO m => MutByteArray -> (Ptr a -> m b) -> m b

133−asUnpinnedPtrUnsafe arr f = do

139+unsafeAsPtr arr f = do

134 let !ptr = Ptr (byteArrayContents#

140 let !ptr = Ptr (byteArrayContents#

135 (unsafeCoerce# (getMutableByteArray# arr)))

141 (unsafeCoerce# (getMutableByteArray# arr)))

136 r <- f ptr

142 r <- f ptr

core/src/Streamly/Internal/FileSystem/Handle.hs+3−3

@@ -180,7 +180,7 @@ getChunk :: MonadIO m => Int -> Handle -> m (Array Word8)

180getChunk size h = liftIO $ do

181 arr :: MArray.MutArray Word8 <- MArray.pinnedEmptyOf size

182 -- ptr <- mallocPlainForeignPtrAlignedBytes size (alignment (undefined :: Word8))

183− MArray.asPtrUnsafe arr $ \p -> do

183+ MArray.unsafePinnedAsPtr arr $ \p -> do

184 n <- hGetBufSome h p size

185 -- XXX shrink only if the diff is significant

186 return $

@@ -380,12 +380,12 @@ read = A.concat . readChunks

380{-# INLINABLE putChunk #-}

381putChunk :: MonadIO m => Handle -> Array a -> m ()

382putChunk _ arr | byteLength arr == 0 = return ()

383−putChunk h arr = A.asPtrUnsafe arr $ \ptr ->

383+putChunk h arr = A.unsafePinnedAsPtr arr $ \ptr ->

384 liftIO $ hPutBuf h ptr aLen

385

386 where

387

388− -- XXX We should have the length passed by asPtrUnsafe itself.

388+ -- XXX We should have the length passed by unsafePinnedAsPtr itself.

389 aLen = A.byteLength arr

390

391-------------------------------------------------------------------------------

src/Streamly/Internal/FileSystem/Event/Darwin.hs+1−1

@@ -451,7 +451,7 @@ openWatch Config{..} paths = do

451

452 withPathName :: Array Word8 -> (PathName -> IO a) -> IO a

453 withPathName arr act = do

454− A.asPtrUnsafe arr $ \ptr ->

454+ A.unsafePinnedAsPtr arr $ \ptr ->

455 let pname = PathName (castPtr ptr) (fromIntegral (A.length arr))

456 in act pname

457

src/Streamly/Internal/FileSystem/Event/Linux.hs+2−2

@@ -188,7 +188,7 @@ import qualified Streamly.FileSystem.Handle as FH

188import qualified Streamly.Unicode.Stream as U

189

190import qualified Streamly.Internal.Data.Array as A

191− ( fromStream, asCStringUnsafe, asPtrUnsafe

191+ ( fromStream, asCStringUnsafe, unsafePinnedAsPtr

192 , getSliceUnsafe, read

193 )

194import qualified Streamly.Internal.FileSystem.Dir as Dir (readDirs)

@@ -809,7 +809,7 @@ readOneEvent :: Config -> Watch -> Parser Word8 IO Event

809readOneEvent cfg wt@(Watch _ wdMap) = do

810 let headerLen = sizeOf (undefined :: CInt) + 12

811 arr <- PR.takeEQ headerLen (A.writeN headerLen)

812− (ewd, eflags, cookie, pathLen) <- PR.fromEffect $ A.asPtrUnsafe arr readHeader

812+ (ewd, eflags, cookie, pathLen) <- PR.fromEffect $ A.unsafePinnedAsPtr arr readHeader

813 -- XXX need the "initial" in parsers to return a step type so that "take 0"

814 -- can return without an input. otherwise if pathLen is 0 we will keep

815 -- waiting to read one more char before we return this event.

src/Streamly/Internal/FileSystem/FD.hs+5−5

@@ -130,7 +130,7 @@ import qualified GHC.IO.Device as RawIO

130import Streamly.Data.Array (Array, Unbox)

131import Streamly.Data.Stream (Stream)

132

133−import Streamly.Internal.Data.Array (byteLength, unsafeFreeze, asPtrUnsafe)

133+import Streamly.Internal.Data.Array (byteLength, unsafeFreeze, unsafePinnedAsPtr)

134import Streamly.Internal.System.IO (defaultChunkSize)

135

136#if !defined(mingw32_HOST_OS)

@@ -147,7 +147,7 @@ import qualified Streamly.Internal.System.IOVec.Type as RawIO

147import qualified Streamly.Data.Array as A

148import qualified Streamly.Data.Fold as FL

149import qualified Streamly.Internal.Data.MutArray as MArray

150− (MutArray(..), asPtrUnsafe, pinnedNewBytes)

150+ (MutArray(..), unsafePinnedAsPtr, pinnedNewBytes)

151import qualified Streamly.Internal.Data.Array.Stream as AS

152import qualified Streamly.Internal.Data.Stream as S

153import qualified Streamly.Internal.Data.Stream as D

@@ -220,7 +220,7 @@ readArrayUpto :: Int -> Handle -> IO (Array Word8)

220readArrayUpto size (Handle fd) = do

221 arr <- MArray.pinnedNewBytes size

222 -- ptr <- mallocPlainForeignPtrAlignedBytes size (alignment (undefined :: Word8))

223− MArray.asPtrUnsafe arr $ \p -> do

223+ MArray.unsafePinnedAsPtr arr $ \p -> do

224 -- n <- hGetBufSome h p size

225#if MIN_VERSION_base(4,15,0)

226 n <- RawIO.read fd p 0 size

@@ -244,7 +244,7 @@ readArrayUpto size (Handle fd) = do

244writeArray :: Unbox a => Handle -> Array a -> IO ()

245writeArray _ arr | A.length arr == 0 = return ()

246writeArray (Handle fd) arr =

247− asPtrUnsafe arr $ \p ->

247+ unsafePinnedAsPtr arr $ \p ->

248 -- RawIO.writeAll fd (castPtr p) aLen

249#if MIN_VERSION_base(4,15,0)

250 RawIO.write fd (castPtr p) 0 aLen

@@ -270,7 +270,7 @@ writeArray (Handle fd) arr =

270writeIOVec :: Handle -> Array RawIO.IOVec -> IO ()

271writeIOVec _ iov | A.length iov == 0 = return ()

272writeIOVec (Handle fd) iov =

273− asPtrUnsafe iov $ \p ->

273+ unsafePinnedAsPtr iov $ \p ->

274 RawIO.writevAll fd p (A.length iov)

275-}

276#endif

src/Streamly/Internal/Network/Socket.hs+4−4

@@ -98,10 +98,10 @@ import qualified Streamly.Data.Fold as FL

98import qualified Streamly.Data.Stream as S

99import qualified Streamly.Data.Unfold as UF

100import qualified Streamly.Internal.Data.Array as A

101− ( unsafeFreeze, asPtrUnsafe, byteLength, pinnedChunksOf,

101+ ( unsafeFreeze, unsafePinnedAsPtr, byteLength, pinnedChunksOf,

102 pinnedWriteN, pinnedWriteNUnsafe, lCompactGE )

103import qualified Streamly.Internal.Data.MutArray as MArray

104− (MutArray(..), asPtrUnsafe, pinnedEmptyOf)

104+ (MutArray(..), unsafePinnedAsPtr, pinnedEmptyOf)

105import qualified Streamly.Internal.Data.Stream as S (fromStreamK, Stream(..), Step(..))

106import qualified Streamly.Internal.Data.StreamK as K (mkStream)

107

@@ -263,7 +263,7 @@ readArrayUptoWith

263readArrayUptoWith f size h = do

264 arr <- MArray.pinnedEmptyOf size

265 -- ptr <- mallocPlainForeignPtrAlignedBytes size (alignment (undefined :: Word8))

266− MArray.asPtrUnsafe arr $ \p -> do

266+ MArray.unsafePinnedAsPtr arr $ \p -> do

267 n <- f h p size

268 let v = A.unsafeFreeze

269 $ arr { MArray.arrEnd = n, MArray.arrBound = size }

@@ -311,7 +311,7 @@ writeArrayWith :: Unbox a

311 -> Array a

312 -> IO ()

313writeArrayWith _ _ arr | A.length arr == 0 = return ()

314−writeArrayWith f h arr = A.asPtrUnsafe arr $ \ptr -> f h (castPtr ptr) aLen

314+writeArrayWith f h arr = A.unsafePinnedAsPtr arr $ \ptr -> f h (castPtr ptr) aLen

315

316 where

317

test/Streamly/Test/Data/Array.hs+1−1

@@ -185,7 +185,7 @@ testUnsafeIndxedFromList inp =

185testAsPtrUnsafeMA :: IO ()

186testAsPtrUnsafeMA = do

187 arr <- MA.fromList ([0 .. 99] :: [Int])

188− MA.asPtrUnsafe arr (getList (0 :: Int)) `shouldReturn` [0 .. 99]

188+ MA.unsafePinnedAsPtr arr (getList (0 :: Int)) `shouldReturn` [0 .. 99]

189

190 where

191