git.iko.soy/streamly
on master help sign in
Arrange the code in dependency order
41575ffHarendra Kumar
src/Streamly/Internal/Data/Array.hs+99−78
compare with master
unifiedsplit
@@ -15,45 +15,42 @@
15module Streamly.Internal.Data.Array
15module Streamly.Internal.Data.Array
16 ( Array(..)
16 ( Array(..)
17
17
18− , foldl'
18+ -- * Construction
19− , foldr
20−
21− , length
22−
23 , writeN
19 , writeN
24 , write
20 , write
25
21
26− , toStreamD
27− , toStreamDRev
28−
29− , toStream
30− , toStreamRev
31− , read
32−
33− , fromListN
34− , fromList
35 , fromStreamDN
22 , fromStreamDN
36 , fromStreamD
23 , fromStreamD
37−
38 , fromStreamN
24 , fromStreamN
39 , fromStream
25 , fromStream
40
26
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
41 , streamFold
41 , streamFold
42 , fold
42 , fold
43 )
43 )
44where
44where
45
45
46−import Prelude hiding (foldr, length, read)
47#if !MIN_VERSION_primitive(0,7,1)
46#if !MIN_VERSION_primitive(0,7,1)
48import Control.DeepSeq (NFData(..))
47import Control.DeepSeq (NFData(..))
49#endif
48#endif
50import Control.Monad (when)
49import Control.Monad (when)
51import Control.Monad.IO.Class (liftIO, MonadIO)
50import Control.Monad.IO.Class (liftIO, MonadIO)
52import Data.Functor.Identity (runIdentity)
51import Data.Functor.Identity (runIdentity)
53−import Data.Primitive.Array hiding (fromList, fromListN)
54import GHC.Base (Int(..))
52import GHC.Base (Int(..))
55import GHC.IO (unsafePerformIO)
53import GHC.IO (unsafePerformIO)
56−import qualified GHC.Exts as Exts
57
54
58import Streamly.Internal.Data.Fold.Type (Fold(..))
55import Streamly.Internal.Data.Fold.Type (Fold(..))
59import Streamly.Internal.Data.Stream.StreamK.Type (IsStream)
56import Streamly.Internal.Data.Stream.StreamK.Type (IsStream)
@@ -61,48 +58,20 @@ import Streamly.Internal.Data.Stream.Serial (SerialT)
61import Streamly.Internal.Data.Tuple.Strict (Tuple'(..), Tuple3'(..))
58import Streamly.Internal.Data.Tuple.Strict (Tuple'(..), Tuple3'(..))
62import Streamly.Internal.Data.Unfold.Type (Unfold(..))
59import Streamly.Internal.Data.Unfold.Type (Unfold(..))
63
60
61+import qualified GHC.Exts as Exts
64import qualified Streamly.Internal.Data.Fold.Type as FL
62import qualified Streamly.Internal.Data.Fold.Type as FL
65import qualified Streamly.Internal.Data.Stream.StreamD as D
63import qualified Streamly.Internal.Data.Stream.StreamD as D
66
64
65+import Data.Primitive.Array hiding (fromList, fromListN)
66+import Prelude hiding (foldr, length, read)
67+
67{-# NOINLINE bottomElement #-}
68{-# NOINLINE bottomElement #-}
68bottomElement :: a
69bottomElement :: a
69bottomElement = undefined
70bottomElement = undefined
70
71
71−{-# INLINE_NORMAL toStreamD #-}
72+-------------------------------------------------------------------------------
72−toStreamD :: Monad m => Array a -> D.Stream m a
73+-- Construction - Folds
73−toStreamD arr = D.Stream step 0
74+-------------------------------------------------------------------------------
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
106
75
107-- writeN n = S.evertM (fromStreamDN n)
76-- writeN n = S.evertM (fromStreamDN n)
108{-# INLINE_NORMAL writeN #-}
77{-# INLINE_NORMAL writeN #-}
@@ -138,6 +107,10 @@ write = Fold step initial extract
138 return $ FL.Partial $ Tuple3' marr (i + 1) capacity
107 return $ FL.Partial $ Tuple3' marr (i + 1) capacity
139 extract (Tuple3' marr len _) = liftIO $ freezeArray marr 0 len
108 extract (Tuple3' marr len _) = liftIO $ freezeArray marr 0 len
140
109
110+-------------------------------------------------------------------------------
111+-- Construction - from streams
112+-------------------------------------------------------------------------------
113+
141{-# INLINE_NORMAL fromStreamDN #-}
114{-# INLINE_NORMAL fromStreamDN #-}
142fromStreamDN :: MonadIO m => Int -> D.Stream m a -> m (Array a)
115fromStreamDN :: MonadIO m => Int -> D.Stream m a -> m (Array a)
143fromStreamDN limit str = do
116fromStreamDN limit str = do
@@ -153,6 +126,16 @@ fromStreamDN limit str = do
153fromStreamD :: MonadIO m => D.Stream m a -> m (Array a)
126fromStreamD :: MonadIO m => D.Stream m a -> m (Array a)
154fromStreamD = D.fold write
127fromStreamD = D.fold write
155
128
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+
156{-# INLINABLE fromListN #-}
139{-# INLINABLE fromListN #-}
157fromListN :: Int -> [a] -> Array a
140fromListN :: Int -> [a] -> Array a
158fromListN n xs = unsafePerformIO $ fromStreamDN n $ D.fromList xs
141fromListN n xs = unsafePerformIO $ fromStreamDN n $ D.fromList xs
@@ -161,21 +144,53 @@ fromListN n xs = unsafePerformIO $ fromStreamDN n $ D.fromList xs
161fromList :: [a] -> Array a
144fromList :: [a] -> Array a
162fromList xs = unsafePerformIO $ fromStreamD $ D.fromList xs
145fromList xs = unsafePerformIO $ fromStreamD $ D.fromList xs
163
146
164−#if !MIN_VERSION_primitive(0,7,1)
147+-------------------------------------------------------------------------------
165−instance NFData a => NFData (Array a) where
148+-- Elimination - Unfolds
166− {-# INLINE rnf #-}
149+-------------------------------------------------------------------------------
167− rnf = foldl' (\_ x -> rnf x) ()
168−#endif
169
150
170−{-# INLINE fromStreamN #-}
151+{-# INLINE length #-}
171−fromStreamN :: MonadIO m => Int -> SerialT m a -> m (Array a)
152+length :: Array a -> Int
172−fromStreamN n m = do
153+length = sizeofArray
173− when (n < 0) $ error "fromStreamN: negative write count specified"
174− fromStreamDN n $ D.toStreamD m
175
154
176−{-# INLINE fromStream #-}
155+{-# INLINE_NORMAL read #-}
177−fromStream :: MonadIO m => SerialT m a -> m (Array a)
156+read :: Monad m => Unfold m (Array a) a
178−fromStream m = fromStreamD $ D.toStreamD m
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)
179
194
180{-# INLINE_EARLY toStream #-}
195{-# INLINE_EARLY toStream #-}
181toStream :: (Monad m, IsStream t) => Array a -> t m a
196toStream :: (Monad m, IsStream t) => Array a -> t m a
@@ -185,6 +200,24 @@ toStream = D.fromStreamD . toStreamD
185toStreamRev :: (Monad m, IsStream t) => Array a -> t m a
200toStreamRev :: (Monad m, IsStream t) => Array a -> t m a
186toStreamRev = D.fromStreamD . toStreamDRev
201toStreamRev = D.fromStreamD . toStreamDRev
187
202
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+
188{-# INLINE fold #-}
221{-# INLINE fold #-}
189fold :: Monad m => Fold m a b -> Array a -> m b
222fold :: Monad m => Fold m a b -> Array a -> m b
190fold f arr = D.fold f (toStreamD arr)
223fold f arr = D.fold f (toStreamD arr)
@@ -192,15 +225,3 @@ fold f arr = D.fold f (toStreamD arr)
192{-# INLINE streamFold #-}
225{-# INLINE streamFold #-}
193streamFold :: Monad m => (SerialT m a -> m b) -> Array a -> m b
226streamFold :: Monad m => (SerialT m a -> m b) -> Array a -> m b
194streamFold f arr = f (toStream arr)
227streamFold 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)