a2fd0dc · streamly · git.iko.soy

git.iko.soy/streamly

Add toArrays fold

commita2fd0dc488d61670748ac1d95d05ba2a58d707a5 authorHarendra Kumar <harendra.kumar@gmail.com> dateSat 1 Jun 2019, 10:34 (7 years ago) parent63ce5d9

5 files changed+31−26

compare with master

unifiedsplit

src/Streamly/Fold.hs+2−2 src/Streamly/Mem/Array.hs+8−10 src/Streamly/Mem/Array/Types.hs+12−6 src/Streamly/Streams/StreamD.hs−8 src/Streamly/Streams/StreamD/Type.hs+9

src/Streamly/Fold.hs+2−2

@@ -375,7 +375,7 @@ import qualified Data.Map.Strict as Map

375375

376376import Streamly (MonadAsync, parallel)

377377import Streamly.Fold.Types (Fold(..))

378−import Streamly.Mem.Array (Array)

378+import Streamly.Mem.Array.Types (Array)

379379-- import Streamly.Mem.Ring (Ring)

380380import Streamly.Streams.Serial (SerialT)

381381import Streamly.Streams.StreamK (IsStream())

@@ -385,7 +385,7 @@ import Streamly.Time.Units

385385

386386import Streamly.Strict

387387

388−import qualified Streamly.Mem.Array as A

388+import qualified Streamly.Mem.Array.Types as A

389389import qualified Streamly.Prelude as S

390390import qualified Streamly.Streams.StreamD as D

391391import qualified Streamly.Streams.StreamK as K

src/Streamly/Mem/Array.hs+8−10

@@ -132,6 +132,7 @@ module Streamly.Mem.Array

132132where

133133

134134import Control.Monad.IO.Class (MonadIO(..))

135+import Data.Functor.Identity

135136import Foreign.ForeignPtr (withForeignPtr)

136137import Foreign.Ptr (minusPtr, plusPtr, castPtr)

137138import Foreign.Storable (Storable(..))

@@ -140,6 +141,7 @@ import Prelude hiding (length, null, last, map, (!!), read)

140141import Streamly.Mem.Array.Types hiding (flattenArrays, newArray)

141142import Streamly.Streams.Serial (SerialT)

142143import Streamly.Streams.StreamK.Type (IsStream)

144+import Streamly.Fold (Fold, lchunksOf, toStream)

143145

144146import qualified Streamly.Mem.Array.Types as A

145147import qualified Streamly.Prelude as S

@@ -170,16 +172,6 @@ writeN n m = fromStreamDN n $ D.toStreamD m

170172-- Elimination

171173-------------------------------------------------------------------------------

172174

173−-- | Convert an 'Array' into a stream.

174−--

175−-- @since 0.7.0

176−{-# INLINE_EARLY read #-}

177−read :: (Monad m, IsStream t, Storable a) => Array a -> t m a

178−read = D.fromStreamD . toStreamD

179−-- XXX add fallback to StreamK rule

180−-- {-# RULES "Streamly.Array.read fallback to StreamK" [1]

181−-- forall a. S.readK (read a) = K.fromArray a #-}

182−

183175-- | Convert an 'Array' into a stream in reverse order.

184176--

185177-- @since 0.7.0

@@ -361,6 +353,12 @@ writeSliceRev arr i len s = undefined

361353-- Streams of Arrays

362354-------------------------------------------------------------------------------

363355

356+-- | Fold the input to a pure buffered stream (List) of arrays.

357+{-# INLINE _toArrays #-}

358+_toArrays :: (MonadIO m, Storable a)

359+ => Int -> Fold m a (SerialT Identity (Array a))

360+_toArrays n = lchunksOf n (toArrayN n) toStream

361+

364362-- | Convert a stream of arrays into a stream of their elements.

365363--

366364-- @since 0.7.0

src/Streamly/Mem/Array/Types.hs+12−6

@@ -50,6 +50,7 @@ module Streamly.Mem.Array.Types

5050 , toStreamDRev

5151 , toList

5252 , toArrayN

53+ , read

5354

5455 -- * Utilities

5556 , defaultChunkSize

@@ -70,7 +71,7 @@ import Foreign.ForeignPtr

7071import Foreign.ForeignPtr.Unsafe (unsafeForeignPtrToPtr)

7172import Foreign.Ptr (plusPtr, minusPtr, castPtr)

7273import Foreign.Storable (Storable(..))

73−import Prelude hiding (length, foldr)

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

7475import Text.Read (readPrec, readListPrec, readListPrecDefault)

7576

7677import GHC.Base (Addr#, realWorld#)

@@ -369,11 +370,6 @@ toArrayN n = Fold step initial extract

369370 extract = return

370371

371372{-

372−-- | Fold the input to a pure buffered stream (List) of arrays.

373−{-# INLINE toArrays #-}

374−toArrays :: (Monad m, Storable a) => Int -> Fold m a (List (Array a))

375−toArrays n = Fold step initial extract

376−

377373-- This can be implemented by combining the List of arrays from toArrays into a

378374-- single array.

379375-- | Fold the whole input to a single array.

@@ -620,6 +616,16 @@ instance Foldable Array where

620616 foldr = _foldr

621617#endif

622618

619+-- | Convert an 'Array' into a stream.

620+--

621+-- @since 0.7.0

622+{-# INLINE_EARLY read #-}

623+read :: (Monad m, K.IsStream t, Storable a) => Array a -> t m a

624+read = D.fromStreamD . toStreamD

625+-- XXX add fallback to StreamK rule

626+-- {-# RULES "Streamly.Array.read fallback to StreamK" [1]

627+-- forall a. S.readK (read a) = K.fromArray a #-}

628+

623629-------------------------------------------------------------------------------

624630-- Semigroup and Monoid

625631-------------------------------------------------------------------------------

src/Streamly/Streams/StreamD.hs−8

@@ -1667,14 +1667,6 @@ stripPrefix (Stream stepa ta) (Stream stepb tb) = go (ta, tb, Nothing)

16671667mapM_ :: Monad m => (a -> m b) -> Stream m a -> m ()

16681668mapM_ m = drain . mapM m

16691669

1670−------------------------------------------------------------------------------

1671−-- Converting folds

1672−------------------------------------------------------------------------------

1673−

1674−{-# INLINE fromStreamD #-}

1675−fromStreamD :: (K.IsStream t, Monad m) => Stream m a -> t m a

1676−fromStreamD = K.fromStream . toStreamK

1677−

16781670------------------------------------------------------------------------------

16791671-- Exceptions

16801672------------------------------------------------------------------------------

src/Streamly/Streams/StreamD/Type.hs+9

@@ -35,6 +35,7 @@ module Streamly.Streams.StreamD.Type

3535#endif

3636 , fromStreamK

3737 , toStreamK

38+ , fromStreamD

3839 , map

3940 , mapM

4041 , yield

@@ -136,6 +137,14 @@ toStreamK (Stream step state) = go state

136137 forall s. fromStreamK (toStreamK s) = s #-}

137138#endif

138139

140+------------------------------------------------------------------------------

141+-- Converting folds

142+------------------------------------------------------------------------------

143+

144+{-# INLINE fromStreamD #-}

145+fromStreamD :: (K.IsStream t, Monad m) => Stream m a -> t m a

146+fromStreamD = K.fromStream . toStreamK

147+

139148------------------------------------------------------------------------------

140149-- Instances

141150------------------------------------------------------------------------------