023fe25 · streamly · git.iko.soy

git.iko.soy/streamly

Deprecate internal funcs fromStreamD and fromStreamDN

commit023fe253b63ac3df0a33485e49cfb55c5402db2b authorHarendra Kumar <harendra@composewell.com> dateSat 30 Dec 2023, 08:51 (3 years ago) parent3519eaf

2 files changed+29−22

compare with master

unifiedsplit

core/src/Streamly/Internal/Data/MutArray.hs−15 core/src/Streamly/Internal/Data/MutArray/Type.hs+29−7

core/src/Streamly/Internal/Data/MutArray.hs−15

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

1414 , splitOn

1515 , sliceIndexerFromLen

1616 , slicerFromLen

17− , fromStream

1817 -- * Unboxed IORef

1918 , module Streamly.Internal.Data.IORef.Unboxed

2019

@@ -94,17 +93,3 @@ getSlicesFromLen :: forall m a. (Monad m, Unbox a)

9493 -> Int -- ^ length of the slice

9594 -> Unfold m (MutArray a) (MutArray a)

9695getSlicesFromLen = slicerFromLen

97−

98−-- | Create an 'Array' from a stream. This is useful when we want to create a

99−-- single array from a stream of unknown size. 'writeN' is at least twice

100−-- as efficient when the size is already known.

101−--

102−-- Note that if the input stream is too large memory allocation for the array

103−-- may fail. When the stream size is not known, `chunksOf` followed by

104−-- processing of indvidual arrays in the resulting stream should be preferred.

105−--

106−-- /Pre-release/

107−{-# INLINE fromStream #-}

108−fromStream :: (MonadIO m, Unbox a) => Stream m a -> m (MutArray a)

109−fromStream = fromStreamD

110−-- fromStream (Stream m) = P.fold write m

core/src/Streamly/Internal/Data/MutArray/Type.hs+29−7

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

7272 , pinnedFromList

7373 , fromListRevN

7474 , fromListRev

75− , fromStreamDN

76− , fromStreamD

75+ , fromStreamN

76+ , fromStream

7777 , fromPureStreamN

7878 , fromPureStream

7979 , fromByteStr#

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

236236 , flattenArrays

237237 , flattenArraysRev

238238 , fromArrayStreamK

239+ , fromStreamDN

240+ , fromStreamD

239241 )

240242where

241243

@@ -2044,13 +2046,18 @@ fromStreamDNAs ps limit str = do

20442046

20452047-- | Use the 'writeN' fold instead.

20462048--

2047−-- >>> fromStreamDN n = Stream.fold (MutArray.writeN n)

2049+-- >>> fromStreamN n = Stream.fold (MutArray.writeN n)

20482050--

2049−{-# INLINE_NORMAL fromStreamDN #-}

2050−fromStreamDN :: forall m a. (MonadIO m, Unbox a)

2051+{-# INLINE_NORMAL fromStreamN #-}

2052+fromStreamN :: forall m a. (MonadIO m, Unbox a)

20512053 => Int -> D.Stream m a -> m (MutArray a)

20522054-- fromStreamDN n = D.fold (writeN n)

2053−fromStreamDN = fromStreamDNAs Unpinned

2055+fromStreamN = fromStreamDNAs Unpinned

2056+

2057+{-# DEPRECATED fromStreamDN "Please use fromStreamN instead." #-}

2058+fromStreamDN :: forall m a. (MonadIO m, Unbox a)

2059+ => Int -> D.Stream m a -> m (MutArray a)

2060+fromStreamDN = fromStreamN

20542061

20552062-- | Create a 'MutArray' from the first N elements of a list. The array is

20562063-- allocated to size N, if the list terminates before N elements then the

@@ -2177,6 +2184,20 @@ fromStreamDAs ::

21772184fromStreamDAs ps m =

21782185 arrayStreamKFromStreamDAs Unpinned m >>= fromChunkskAs ps

21792186

2187+-- | Create an 'Array' from a stream. This is useful when we want to create a

2188+-- single array from a stream of unknown size. 'writeN' is at least twice

2189+-- as efficient when the size is already known.

2190+--

2191+-- Note that if the input stream is too large memory allocation for the array

2192+-- may fail. When the stream size is not known, `chunksOf` followed by

2193+-- processing of indvidual arrays in the resulting stream should be preferred.

2194+--

2195+-- /Pre-release/

2196+{-# INLINE fromStream #-}

2197+fromStream :: (MonadIO m, Unbox a) => Stream m a -> m (MutArray a)

2198+fromStream = fromStreamDAs Unpinned

2199+

2200+-- fromStream (Stream m) = P.fold write m

21802201-- CAUTION: a very large number (millions) of arrays can degrade performance

21812202-- due to GC overhead because we need to buffer the arrays before we flatten

21822203-- all the arrays.

@@ -2191,8 +2212,9 @@ fromStreamDAs ps m =

21912212-- >>> fromStreamD = StreamD.fold MutArray.write

21922213--

21932214{-# INLINE fromStreamD #-}

2215+{-# DEPRECATED fromStreamD "Please use fromStream instead." #-}

21942216fromStreamD :: (MonadIO m, Unbox a) => D.Stream m a -> m (MutArray a)

2195−fromStreamD = fromStreamDAs Unpinned

2217+fromStreamD = fromStream

21962218

21972219-- | Create a 'MutArray' from a list. The list must be of finite size.

21982220--