git.iko.soy/streamly
on master help sign in
Simplify fromStream operations
552708fHarendra Kumar
core/src/Streamly/Internal/Data/Array/Generic.hs+16−43
compare with master
unifiedsplit
@@ -17,8 +17,6 @@ module Streamly.Internal.Data.Array.Generic
17 , writeWith
17 , writeWith
18 , writeLastN
18 , writeLastN
19
19
20− , fromStreamDN
21− , fromStreamD
22 , fromStreamN
20 , fromStreamN
23 , fromStream
21 , fromStream
24
22
@@ -30,8 +28,6 @@ module Streamly.Internal.Data.Array.Generic
30 , reader
28 , reader
31
29
32 , toList
30 , toList
33− , readStreamD
34− , readRevStreamD
35 , read
31 , read
36 , readRev
32 , readRev
37
33
@@ -48,7 +44,7 @@ where
48
44
49#include "inline.hs"
45#include "inline.hs"
50
46
51−import Control.Monad (when, replicateM)
47+import Control.Monad (replicateM)
52import Control.Monad.IO.Class (liftIO, MonadIO)
48import Control.Monad.IO.Class (liftIO, MonadIO)
53import GHC.Base (MutableArray#, RealWorld)
49import GHC.Base (MutableArray#, RealWorld)
54import GHC.IO (unsafePerformIO)
50import GHC.IO (unsafePerformIO)
@@ -122,38 +118,23 @@ write = fmap unsafeFreeze MArray.write
122-- Construction - from streams
118-- Construction - from streams
123-------------------------------------------------------------------------------
119-------------------------------------------------------------------------------
124
120
125−{-# INLINE_NORMAL fromStreamDN #-}
126−fromStreamDN :: MonadIO m => Int -> D.Stream m a -> m (Array a)
127−fromStreamDN limit str = do
128− marr <- liftIO $ MArray.new (max limit 0)
129− i <-
130− D.foldlM'
131− (\i x -> i `seq` liftIO $ MArray.putIndexUnsafe i marr x >> return (i + 1))
132− (return 0) $
133− D.take limit str
134− return $ unsafeFreeze $ marr { MArray.arrLen = i }
135−
136−{-# INLINE fromStreamD #-}
137−fromStreamD :: MonadIO m => D.Stream m a -> m (Array a)
138−fromStreamD = D.fold write
139−
140{-# INLINE fromStreamN #-}
121{-# INLINE fromStreamN #-}
141fromStreamN :: MonadIO m => Int -> Stream m a -> m (Array a)
122fromStreamN :: MonadIO m => Int -> Stream m a -> m (Array a)
142−fromStreamN n m = do
123+fromStreamN n = D.fold (writeN n)
143− when (n < 0) $ error "fromStreamN: negative write count specified"
144− fromStreamDN n m
145
124
146{-# INLINE fromStream #-}
125{-# INLINE fromStream #-}
147fromStream :: MonadIO m => Stream m a -> m (Array a)
126fromStream :: MonadIO m => Stream m a -> m (Array a)
148−fromStream = fromStreamD
127+fromStream = D.fold write
128+
129+-- XXX Consider foldr/build fusion in toList/fromList
149
130
150{-# INLINABLE fromListN #-}
131{-# INLINABLE fromListN #-}
151fromListN :: Int -> [a] -> Array a
132fromListN :: Int -> [a] -> Array a
152−fromListN n xs = unsafePerformIO $ fromStreamDN n $ D.fromList xs
133+fromListN n xs = unsafePerformIO $ fromStreamN n $ D.fromList xs
153
134
154{-# INLINABLE fromList #-}
135{-# INLINABLE fromList #-}
155fromList :: [a] -> Array a
136fromList :: [a] -> Array a
156−fromList xs = unsafePerformIO $ fromStreamD $ D.fromList xs
137+fromList xs = unsafePerformIO $ fromStream $ D.fromList xs
157
138
158-------------------------------------------------------------------------------
139-------------------------------------------------------------------------------
159-- Elimination - Unfolds
140-- Elimination - Unfolds
@@ -184,23 +165,15 @@ toList arr = loop 0
184 loop i | i == len = []
165 loop i | i == len = []
185 loop i = getIndexUnsafe arr i : loop (i + 1)
166 loop i = getIndexUnsafe arr i : loop (i + 1)
186
167
187−{-# INLINE_NORMAL readStreamD #-}
168+{-# INLINE_NORMAL read #-}
188−readStreamD :: MonadIO m => Array a -> D.Stream m a
189−readStreamD = MArray.toStreamD . unsafeThaw
190−
191−{-# INLINE_NORMAL readRevStreamD #-}
192−readRevStreamD :: Monad m => Array a -> D.Stream m a
193−readRevStreamD arr@Array{..} =
194− D.map (getIndexUnsafe arr)
195− $ D.enumerateFromThenToIntegral (arrLen - 1) (arrLen - 2) 0
196−
197−{-# INLINE_EARLY read #-}
198read :: MonadIO m => Array a -> Stream m a
169read :: MonadIO m => Array a -> Stream m a
199−read = readStreamD
170+read = MArray.toStreamD . unsafeThaw
200
171
201−{-# INLINE_EARLY readRev #-}
172+{-# INLINE_NORMAL readRev #-}
202readRev :: Monad m => Array a -> Stream m a
173readRev :: Monad m => Array a -> Stream m a
203−readRev = readRevStreamD
174+readRev arr@Array{..} =
175+ D.map (getIndexUnsafe arr)
176+ $ D.enumerateFromThenToIntegral (arrLen - 1) (arrLen - 2) 0
204
177
205-------------------------------------------------------------------------------
178-------------------------------------------------------------------------------
206-- Elimination - using Folds
179-- Elimination - using Folds
@@ -208,15 +181,15 @@ readRev = readRevStreamD
208
181
209{-# INLINE_NORMAL foldl' #-}
182{-# INLINE_NORMAL foldl' #-}
210foldl' :: (b -> a -> b) -> b -> Array a -> b
183foldl' :: (b -> a -> b) -> b -> Array a -> b
211−foldl' f z arr = unsafePerformIO $ D.foldl' f z $ readStreamD arr
184+foldl' f z arr = unsafePerformIO $ D.foldl' f z $ read arr
212
185
213{-# INLINE_NORMAL foldr #-}
186{-# INLINE_NORMAL foldr #-}
214foldr :: (a -> b -> b) -> b -> Array a -> b
187foldr :: (a -> b -> b) -> b -> Array a -> b
215−foldr f z arr = unsafePerformIO $ D.foldr f z $ readStreamD arr
188+foldr f z arr = unsafePerformIO $ D.foldr f z $ read arr
216
189
217{-# INLINE fold #-}
190{-# INLINE fold #-}
218fold :: MonadIO m => Fold m a b -> Array a -> m b
191fold :: MonadIO m => Fold m a b -> Array a -> m b
219−fold f arr = D.fold f (readStreamD arr)
192+fold f arr = D.fold f (read arr)
220
193
221{-# INLINE streamFold #-}
194{-# INLINE streamFold #-}
222streamFold :: MonadIO m => (Stream m a -> m b) -> Array a -> m b
195streamFold :: MonadIO m => (Stream m a -> m b) -> Array a -> m b