git.iko.soy/streamly
on master help sign in
Move implementation details from Data.Array to Internal.Data.Array.
8ac4279Pranay Sashank
src/Streamly/Data/Array.hs+8−67
compare with master
unifiedsplit
@@ -1,12 +1,3 @@
1−{-# LANGUAGE CPP #-}
2−{-# LANGUAGE MagicHash #-}
3−{-# LANGUAGE RankNTypes #-}
4−{-# LANGUAGE RecordWildCards #-}
5−{-# LANGUAGE ScopedTypeVariables #-}
6−{-# LANGUAGE UnboxedTuples #-}
7−
8−#include "inline.hs"
9−
10-- |
1-- |
11-- Module : Streamly.Data.Array
2-- Module : Streamly.Data.Array
12-- Copyright : (c) 2019 Composewell Technologies
3-- Copyright : (c) 2019 Composewell Technologies
@@ -24,8 +15,8 @@ module Streamly.Data.Array
24 , A.fromList
15 , A.fromList
25
16
26 -- Stream Folds
17 -- Stream Folds
27− , fromStreamN
18+ , A.fromStreamN
28− , fromStream
19+ , A.fromStream
29
20
30 -- MonadicAPIs
21 -- MonadicAPIs
31 , A.writeN
22 , A.writeN
@@ -33,70 +24,20 @@ module Streamly.Data.Array
33
24
34 -- * Elimination
25 -- * Elimination
35
26
36− , toStream
27+ , A.toStream
37− , toStreamRev
28+ , A.toStreamRev
38− , read
29+ , A.read
39
30
40 -- * Random Access
31 -- * Random Access
41
32
42 -- * Folding Arrays
33 -- * Folding Arrays
43− , streamFold
34+ , A.streamFold
44− , fold
35+ , A.fold
45
36
46 , A.length
37 , A.length
47 )
38 )
48where
39where
49
40
50−import Prelude hiding (length, read)
51−import Control.Monad (when)
52−import Control.Monad.IO.Class (MonadIO)
53−import GHC.Base (Int(..))
54−import qualified GHC.Exts as Exts
55−
56−import Streamly.Streams.Serial (SerialT)
57−import Streamly.Streams.StreamK.Type (IsStream)
58−import Streamly.Internal.Data.Fold.Types (Fold(..))
41+import Streamly.Internal.Data.Array (Array)
59−import Streamly.Internal.Data.Unfold.Types (Unfold(..))
60−import Streamly.Internal.Data.Array (Array(..))
61
42
62import qualified Streamly.Internal.Data.Array as A
43import qualified Streamly.Internal.Data.Array as A
63−import qualified Streamly.Streams.Prelude as P
64−import qualified Streamly.Streams.StreamD as D
65−
66−{-# INLINE fromStreamN #-}
67−fromStreamN :: MonadIO m => Int -> SerialT m a -> m (Array a)
68−fromStreamN n m = do
69− when (n < 0) $ error "fromStreamN: negative write count specified"
70− A.fromStreamDN n $ D.toStreamD m
71−
72−{-# INLINE fromStream #-}
73−fromStream :: MonadIO m => SerialT m a -> m (Array a)
74−fromStream m = A.fromStreamD $ D.toStreamD m
75−
76−{-# INLINE_EARLY toStream #-}
77−toStream :: (Monad m, IsStream t) => Array a -> t m a
78−toStream = D.fromStreamD . A.toStreamD
79−
80−{-# INLINE_EARLY toStreamRev #-}
81−toStreamRev :: (Monad m, IsStream t) => Array a -> t m a
82−toStreamRev = D.fromStreamD . A.toStreamDRev
83−
84−{-# INLINE fold #-}
85−fold :: forall m a b . Monad m => Fold m a b -> Array a -> m b
86−fold f arr = P.runFold f (toStream arr :: SerialT m a)
87−
88−{-# INLINE streamFold #-}
89−streamFold :: Monad m => (SerialT m a -> m b) -> Array a -> m b
90−streamFold f arr = f (toStream arr)
91−
92−{-# INLINE_NORMAL read #-}
93−read :: Monad m => Unfold m (Array a) a
94−read = Unfold step inject
95− where
96− inject arr = return (arr, 0)
97− step (arr, i)
98− | i == A.length arr = return D.Stop
99− step (arr, (I# i)) =
100− return $
101− case Exts.indexArray# (array# arr) i of
102− (# x #) -> D.Yield x (arr, I# i + 1)
src/Streamly/Internal/Data/Array.hs+56−4
@@ -1,8 +1,8 @@
1{-# OPTIONS_GHC -fno-warn-orphans #-}
1{-# OPTIONS_GHC -fno-warn-orphans #-}
2
2
3−{-# LANGUAGE CPP #-}
3+{-# LANGUAGE CPP #-}
4−{-# LANGUAGE MagicHash #-}
4+{-# LANGUAGE MagicHash #-}
5−{-# LANGUAGE UnboxedTuples #-}
5+{-# LANGUAGE UnboxedTuples #-}
6
6
7#include "inline.hs"
7#include "inline.hs"
8
8
@@ -29,15 +29,26 @@ module Streamly.Internal.Data.Array
29 , toStreamD
29 , toStreamD
30 , toStreamDRev
30 , toStreamDRev
31
31
32+ , toStream
33+ , toStreamRev
34+ , read
35+
32 , fromListN
36 , fromListN
33 , fromList
37 , fromList
34 , fromStreamDN
38 , fromStreamDN
35 , fromStreamD
39 , fromStreamD
40+
41+ , fromStreamN
42+ , fromStream
43+
44+ , streamFold
45+ , fold
36 )
46 )
37where
47where
38
48
39−import Prelude hiding (foldr, length)
49+import Prelude hiding (foldr, length, read)
40import Control.DeepSeq (NFData(..))
50import Control.DeepSeq (NFData(..))
51+import Control.Monad (when)
41import Control.Monad.IO.Class (liftIO, MonadIO)
52import Control.Monad.IO.Class (liftIO, MonadIO)
42import GHC.IO (unsafePerformIO)
53import GHC.IO (unsafePerformIO)
43import GHC.Base (Int(..))
54import GHC.Base (Int(..))
@@ -45,7 +56,10 @@ import Data.Functor.Identity (runIdentity)
45import Data.Primitive.Array hiding (fromList, fromListN)
56import Data.Primitive.Array hiding (fromList, fromListN)
46import qualified GHC.Exts as Exts
57import qualified GHC.Exts as Exts
47
58
59+import Streamly.Internal.Data.Unfold.Types (Unfold(..))
48import Streamly.Internal.Data.Fold.Types (Fold(..))
60import Streamly.Internal.Data.Fold.Types (Fold(..))
61+import Streamly.Streams.StreamK.Type (IsStream)
62+import Streamly.Streams.Serial (SerialT)
49
63
50import qualified Streamly.Streams.StreamD as D
64import qualified Streamly.Streams.StreamD as D
51
65
@@ -149,3 +163,41 @@ fromList xs = unsafePerformIO $ fromStreamD $ D.fromList xs
149instance NFData a => NFData (Array a) where
163instance NFData a => NFData (Array a) where
150 {-# INLINE rnf #-}
164 {-# INLINE rnf #-}
151 rnf = foldl' (\_ x -> rnf x) ()
165 rnf = foldl' (\_ x -> rnf x) ()
166+
167+{-# INLINE fromStreamN #-}
168+fromStreamN :: MonadIO m => Int -> SerialT m a -> m (Array a)
169+fromStreamN n m = do
170+ when (n < 0) $ error "fromStreamN: negative write count specified"
171+ fromStreamDN n $ D.toStreamD m
172+
173+{-# INLINE fromStream #-}
174+fromStream :: MonadIO m => SerialT m a -> m (Array a)
175+fromStream m = fromStreamD $ D.toStreamD m
176+
177+{-# INLINE_EARLY toStream #-}
178+toStream :: (Monad m, IsStream t) => Array a -> t m a
179+toStream = D.fromStreamD . toStreamD
180+
181+{-# INLINE_EARLY toStreamRev #-}
182+toStreamRev :: (Monad m, IsStream t) => Array a -> t m a
183+toStreamRev = D.fromStreamD . toStreamDRev
184+
185+{-# INLINE fold #-}
186+fold :: Monad m => Fold m a b -> Array a -> m b
187+fold f arr = D.runFold f (toStreamD arr)
188+
189+{-# INLINE streamFold #-}
190+streamFold :: Monad m => (SerialT m a -> m b) -> Array a -> m b
191+streamFold f arr = f (toStream arr)
192+
193+{-# INLINE_NORMAL read #-}
194+read :: Monad m => Unfold m (Array a) a
195+read = Unfold step inject
196+ where
197+ inject arr = return (arr, 0)
198+ step (arr, i)
199+ | i == length arr = return D.Stop
200+ step (arr, (I# i)) =
201+ return $
202+ case Exts.indexArray# (array# arr) i of
203+ (# x #) -> D.Yield x (arr, I# i + 1)