8ac4279 · streamly · git.iko.soy

git.iko.soy/streamly

Move implementation details from Data.Array to Internal.Data.Array.

commit8ac427983ed43f9999d605864881ea2afb321dcb authorPranay Sashank <pranaysashank@gmail.com> dateWed 4 Dec 2019, 10:07 (7 years ago) parent4e04eff

2 files changed+64−71

compare with master

unifiedsplit

src/Streamly/Data/Array.hs+8−67 src/Streamly/Internal/Data/Array.hs+56−4

src/Streamly/Data/Array.hs+8−67

@@ -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−

101-- |

112-- Module : Streamly.Data.Array

@@ -24,8 +15,8 @@ module Streamly.Data.Array

2415 , A.fromList

2516

2617 -- Stream Folds

27− , fromStreamN

28− , fromStream

18+ , A.fromStreamN

19+ , A.fromStream

2920

3021 -- MonadicAPIs

3122 , A.writeN

@@ -33,70 +24,20 @@ module Streamly.Data.Array

3324

3425 -- * Elimination

3526

36− , toStream

37− , toStreamRev

38− , read

27+ , A.toStream

28+ , A.toStreamRev

29+ , A.read

3930

4031 -- * Random Access

4132

4233 -- * Folding Arrays

43− , streamFold

44− , fold

34+ , A.streamFold

35+ , A.fold

4536

4637 , A.length

4738 )

4839where

4940

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(..))

59−import Streamly.Internal.Data.Unfold.Types (Unfold(..))

60−import Streamly.Internal.Data.Array (Array(..))

41+import Streamly.Internal.Data.Array (Array)

6142

6243import 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 @@

11{-# OPTIONS_GHC -fno-warn-orphans #-}

3−{-# LANGUAGE CPP #-}

4−{-# LANGUAGE MagicHash #-}

5−{-# LANGUAGE UnboxedTuples #-}

3+{-# LANGUAGE CPP #-}

4+{-# LANGUAGE MagicHash #-}

5+{-# LANGUAGE UnboxedTuples #-}

77#include "inline.hs"

@@ -29,15 +29,26 @@ module Streamly.Internal.Data.Array

2929 , toStreamD

3030 , toStreamDRev

3131

32+ , toStream

33+ , toStreamRev

34+ , read

35+

3236 , fromListN

3337 , fromList

3438 , fromStreamDN

3539 , fromStreamD

40+

41+ , fromStreamN

42+ , fromStream

43+

44+ , streamFold

45+ , fold

3646 )

3747where

3848

39−import Prelude hiding (foldr, length)

49+import Prelude hiding (foldr, length, read)

4050import Control.DeepSeq (NFData(..))

51+import Control.Monad (when)

4152import Control.Monad.IO.Class (liftIO, MonadIO)

4253import GHC.IO (unsafePerformIO)

4354import GHC.Base (Int(..))

@@ -45,7 +56,10 @@ import Data.Functor.Identity (runIdentity)

4556import Data.Primitive.Array hiding (fromList, fromListN)

4657import qualified GHC.Exts as Exts

4758

59+import Streamly.Internal.Data.Unfold.Types (Unfold(..))

4860import Streamly.Internal.Data.Fold.Types (Fold(..))

61+import Streamly.Streams.StreamK.Type (IsStream)

62+import Streamly.Streams.Serial (SerialT)

4963

5064import qualified Streamly.Streams.StreamD as D

5165

@@ -149,3 +163,41 @@ fromList xs = unsafePerformIO $ fromStreamD $ D.fromList xs

149163instance NFData a => NFData (Array a) where

150164 {-# INLINE rnf #-}

151165 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)