@@ -15,45 +15,42 @@
1515module Streamly.Internal.Data.Array
1616 ( Array(..)
1717
18− , foldl'
19− , foldr
20−
21− , length
22−
18+ -- * Construction
2319 , writeN
2420 , write
2521
26− , toStreamD
27− , toStreamDRev
28−
29− , toStream
30− , toStreamRev
31− , read
32−
33− , fromListN
34− , fromList
3522 , fromStreamDN
3623 , fromStreamD
37−
3824 , fromStreamN
3925 , fromStream
4026
27+ , fromListN
28+ , fromList
29+
30+ -- * Elimination
31+ , length
32+ , read
33+
34+ , toStreamD
35+ , toStreamDRev
36+ , toStream
37+ , toStreamRev
38+
39+ , foldl'
40+ , foldr
4141 , streamFold
4242 , fold
4343 )
4444where
4545
46−import Prelude hiding (foldr, length, read)
4746#if !MIN_VERSION_primitive(0,7,1)
4847import Control.DeepSeq (NFData(..))
4948#endif
5049import Control.Monad (when)
5150import Control.Monad.IO.Class (liftIO, MonadIO)
5251import Data.Functor.Identity (runIdentity)
53−import Data.Primitive.Array hiding (fromList, fromListN)
5452import GHC.Base (Int(..))
5553import GHC.IO (unsafePerformIO)
56−import qualified GHC.Exts as Exts
5754
5855import Streamly.Internal.Data.Fold.Type (Fold(..))
5956import Streamly.Internal.Data.Stream.StreamK.Type (IsStream)
@@ -61,48 +58,20 @@ import Streamly.Internal.Data.Stream.Serial (SerialT)
6158import Streamly.Internal.Data.Tuple.Strict (Tuple'(..), Tuple3'(..))
6259import Streamly.Internal.Data.Unfold.Type (Unfold(..))
6360
61+import qualified GHC.Exts as Exts
6462import qualified Streamly.Internal.Data.Fold.Type as FL
6563import qualified Streamly.Internal.Data.Stream.StreamD as D
6664
65+import Data.Primitive.Array hiding (fromList, fromListN)
66+import Prelude hiding (foldr, length, read)
67+
6768{-# NOINLINE bottomElement #-}
6869bottomElement :: a
6970bottomElement = undefined
7071
71−{-# INLINE_NORMAL toStreamD #-}
72−toStreamD :: Monad m => Array a -> D.Stream m a
73−toStreamD arr = D.Stream step 0
74− where
75− {-# INLINE_LATE step #-}
76− step _ i
77− | i == length arr = return D.Stop
78− step _ (I# i) =
79− return $
80− case Exts.indexArray# (array# arr) i of
81− (# x #) -> D.Yield x (I# i + 1)
82−
83−{-# INLINE length #-}
84−length :: Array a -> Int
85−length = sizeofArray
86−
87−{-# INLINE_NORMAL toStreamDRev #-}
88−toStreamDRev :: Monad m => Array a -> D.Stream m a
89−toStreamDRev arr = D.Stream step (length arr - 1)
90− where
91− {-# INLINE_LATE step #-}
92− step _ i
93− | i < 0 = return D.Stop
94− step _ (I# i) =
95− return $
96− case Exts.indexArray# (array# arr) i of
97− (# x #) -> D.Yield x (I# i - 1)
98−
99−{-# INLINE_NORMAL foldl' #-}
100−foldl' :: (b -> a -> b) -> b -> Array a -> b
101−foldl' f z arr = runIdentity $ D.foldl' f z $ toStreamD arr
102−
103−{-# INLINE_NORMAL foldr #-}
104−foldr :: (a -> b -> b) -> b -> Array a -> b
105−foldr f z arr = runIdentity $ D.foldr f z $ toStreamD arr
72+-------------------------------------------------------------------------------
73+-- Construction - Folds
74+-------------------------------------------------------------------------------
10675
10776-- writeN n = S.evertM (fromStreamDN n)
10877{-# INLINE_NORMAL writeN #-}
@@ -138,6 +107,10 @@ write = Fold step initial extract
138107 return $ FL.Partial $ Tuple3' marr (i + 1) capacity
139108 extract (Tuple3' marr len _) = liftIO $ freezeArray marr 0 len
140109
110+-------------------------------------------------------------------------------
111+-- Construction - from streams
112+-------------------------------------------------------------------------------
113+
141114{-# INLINE_NORMAL fromStreamDN #-}
142115fromStreamDN :: MonadIO m => Int -> D.Stream m a -> m (Array a)
143116fromStreamDN limit str = do
@@ -153,6 +126,16 @@ fromStreamDN limit str = do
153126fromStreamD :: MonadIO m => D.Stream m a -> m (Array a)
154127fromStreamD = D.fold write
155128
129+{-# INLINE fromStreamN #-}
130+fromStreamN :: MonadIO m => Int -> SerialT m a -> m (Array a)
131+fromStreamN n m = do
132+ when (n < 0) $ error "fromStreamN: negative write count specified"
133+ fromStreamDN n $ D.toStreamD m
134+
135+{-# INLINE fromStream #-}
136+fromStream :: MonadIO m => SerialT m a -> m (Array a)
137+fromStream m = fromStreamD $ D.toStreamD m
138+
156139{-# INLINABLE fromListN #-}
157140fromListN :: Int -> [a] -> Array a
158141fromListN n xs = unsafePerformIO $ fromStreamDN n $ D.fromList xs
@@ -161,21 +144,53 @@ fromListN n xs = unsafePerformIO $ fromStreamDN n $ D.fromList xs
161144fromList :: [a] -> Array a
162145fromList xs = unsafePerformIO $ fromStreamD $ D.fromList xs
163146
164−#if !MIN_VERSION_primitive(0,7,1)
165−instance NFData a => NFData (Array a) where
166− {-# INLINE rnf #-}
167− rnf = foldl' (\_ x -> rnf x) ()
168−#endif
147+-------------------------------------------------------------------------------
148+-- Elimination - Unfolds
149+-------------------------------------------------------------------------------
169150
170−{-# INLINE fromStreamN #-}
171−fromStreamN :: MonadIO m => Int -> SerialT m a -> m (Array a)
172−fromStreamN n m = do
173− when (n < 0) $ error "fromStreamN: negative write count specified"
174− fromStreamDN n $ D.toStreamD m
151+{-# INLINE length #-}
152+length :: Array a -> Int
153+length = sizeofArray
175154
176−{-# INLINE fromStream #-}
177−fromStream :: MonadIO m => SerialT m a -> m (Array a)
178−fromStream m = fromStreamD $ D.toStreamD m
155+{-# INLINE_NORMAL read #-}
156+read :: Monad m => Unfold m (Array a) a
157+read = Unfold step inject
158+ where
159+ inject arr = return (arr, 0)
160+ step (arr, i)
161+ | i == length arr = return D.Stop
162+ step (arr, I# i) =
163+ return $
164+ case Exts.indexArray# (array# arr) i of
165+ (# x #) -> D.Yield x (arr, I# i + 1)
166+
167+-------------------------------------------------------------------------------
168+-- Elimination - to streams
169+-------------------------------------------------------------------------------
170+
171+{-# INLINE_NORMAL toStreamD #-}
172+toStreamD :: Monad m => Array a -> D.Stream m a
173+toStreamD arr = D.Stream step 0
174+ where
175+ {-# INLINE_LATE step #-}
176+ step _ i
177+ | i == length arr = return D.Stop
178+ step _ (I# i) =
179+ return $
180+ case Exts.indexArray# (array# arr) i of
181+ (# x #) -> D.Yield x (I# i + 1)
182+
183+{-# INLINE_NORMAL toStreamDRev #-}
184+toStreamDRev :: Monad m => Array a -> D.Stream m a
185+toStreamDRev arr = D.Stream step (length arr - 1)
186+ where
187+ {-# INLINE_LATE step #-}
188+ step _ i
189+ | i < 0 = return D.Stop
190+ step _ (I# i) =
191+ return $
192+ case Exts.indexArray# (array# arr) i of
193+ (# x #) -> D.Yield x (I# i - 1)
179194
180195{-# INLINE_EARLY toStream #-}
181196toStream :: (Monad m, IsStream t) => Array a -> t m a
@@ -185,6 +200,24 @@ toStream = D.fromStreamD . toStreamD
185200toStreamRev :: (Monad m, IsStream t) => Array a -> t m a
186201toStreamRev = D.fromStreamD . toStreamDRev
187202
203+-------------------------------------------------------------------------------
204+-- Elimination - using Folds
205+-------------------------------------------------------------------------------
206+
207+{-# INLINE_NORMAL foldl' #-}
208+foldl' :: (b -> a -> b) -> b -> Array a -> b
209+foldl' f z arr = runIdentity $ D.foldl' f z $ toStreamD arr
210+
211+{-# INLINE_NORMAL foldr #-}
212+foldr :: (a -> b -> b) -> b -> Array a -> b
213+foldr f z arr = runIdentity $ D.foldr f z $ toStreamD arr
214+
215+#if !MIN_VERSION_primitive(0,7,1)
216+instance NFData a => NFData (Array a) where
217+ {-# INLINE rnf #-}
218+ rnf = foldl' (\_ x -> rnf x) ()
219+#endif
220+
188221{-# INLINE fold #-}
189222fold :: Monad m => Fold m a b -> Array a -> m b
190223fold f arr = D.fold f (toStreamD arr)
@@ -192,15 +225,3 @@ fold f arr = D.fold f (toStreamD arr)
192225{-# INLINE streamFold #-}
193226streamFold :: Monad m => (SerialT m a -> m b) -> Array a -> m b
194227streamFold f arr = f (toStream arr)
195−
196−{-# INLINE_NORMAL read #-}
197−read :: Monad m => Unfold m (Array a) a
198−read = Unfold step inject
199− where
200− inject arr = return (arr, 0)
201− step (arr, i)
202− | i == length arr = return D.Stop
203− step (arr, I# i) =
204− return $
205− case Exts.indexArray# (array# arr) i of
206− (# x #) -> D.Yield x (arr, I# i + 1)