023fe25 · streamly · git.iko.soy

git.iko.soy/streamly

on master help sign in

Deprecate internal funcs fromStreamD and fromStreamDN

023fe25Harendra Kumar3 years ago

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

compare with master

unifiedsplit

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

14 , splitOn

15 , sliceIndexerFromLen

16 , slicerFromLen

17− , fromStream

18 -- * Unboxed IORef

17 -- * Unboxed IORef

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

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

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

94 -> Int -- ^ length of the slice

93 -> Int -- ^ length of the slice

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

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

96getSlicesFromLen = slicerFromLen

95getSlicesFromLen = 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

72 , pinnedFromList

73 , fromListRevN

74 , fromListRev

75− , fromStreamDN

75+ , fromStreamN

76− , fromStreamD

76+ , fromStream

77 , fromPureStreamN

78 , fromPureStream

79 , fromByteStr#

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

236 , flattenArrays

237 , flattenArraysRev

238 , fromArrayStreamK

239+ , fromStreamDN

240+ , fromStreamD

239 )

241 )

240where

242where

241

243

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

2044

2046

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

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

2046--

2048--

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

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

2048--

2050--

2049−{-# INLINE_NORMAL fromStreamDN #-}

2051+{-# INLINE_NORMAL fromStreamN #-}

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

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

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

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

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

2054-- 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

2054

2061

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

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

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

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

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

2177fromStreamDAs ps m =

2184fromStreamDAs ps m =

2178 arrayStreamKFromStreamDAs Unpinned m >>= fromChunkskAs ps

2185 arrayStreamKFromStreamDAs Unpinned m >>= fromChunkskAs ps

2179

2186

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

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

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

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

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

2182-- all the arrays.

2203-- all the arrays.

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

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

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

2192--

2213--

2193{-# INLINE fromStreamD #-}

2214{-# INLINE fromStreamD #-}

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

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

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

2195−fromStreamD = fromStreamDAs Unpinned

2217+fromStreamD = fromStream

2196

2218

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

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

2198--

2220--