@@ -28,13 +28,13 @@
2828--
2929module Streamly.Internal.Data.Array.Stream.Fold.Foreign
3030 (
31− Fold (..)
31+ ArrayFold (..)
3232
3333 -- * Construction
3434 , fromFold
35+ , adaptFold
3536 , fromParser
3637 , fromParserD
37− , fromArrayFold
3838
3939 -- * Mapping
4040 , rmapM
@@ -47,7 +47,7 @@ module Streamly.Internal.Data.Array.Stream.Fold.Foreign
4747 -- * Monad
4848 , concatMap
4949
50− -- * Transformation
50+ -- * Combinators
5151 , take
5252 )
5353where
@@ -86,7 +86,7 @@ import Prelude hiding (concatMap, take)
8686--
8787-- /Pre-release/
8888--
89−newtype Fold m a b = Fold (ParserD.Parser m (Array a) b)
89+newtype ArrayFold m a b = ArrayFold (ParserD.Parser m (Array a) b)
9090
9191-------------------------------------------------------------------------------
9292-- Constructing array stream folds from element folds and parsers
@@ -97,9 +97,9 @@ newtype Fold m a b = Fold (ParserD.Parser m (Array a) b)
9797-- /Pre-release/
9898{-# INLINE fromFold #-}
9999fromFold :: forall m a b. (MonadIO m, Storable a) =>
100− Fold.Fold m a b -> Fold m a b
100+ Fold.Fold m a b -> ArrayFold m a b
101101fromFold (Fold.Fold fstep finitial fextract) =
102− Fold (ParserD.Parser step initial fextract)
102+ ArrayFold (ParserD.Parser step initial fextract)
103103
104104 where
105105
@@ -136,9 +136,9 @@ fromFold (Fold.Fold fstep finitial fextract) =
136136-- /Pre-release/
137137{-# INLINE fromParserD #-}
138138fromParserD :: forall m a b. (MonadIO m, Storable a) =>
139− ParserD.Parser m a b -> Fold m a b
139+ ParserD.Parser m a b -> ArrayFold m a b
140140fromParserD (ParserD.Parser step1 initial1 extract1) =
141− Fold (ParserD.Parser step initial1 extract1)
141+ ArrayFold (ParserD.Parser step initial1 extract1)
142142
143143 where
144144
@@ -172,22 +172,22 @@ fromParserD (ParserD.Parser step1 initial1 extract1) =
172172 partial arrRem cur next elemSize Continue n fs1
173173 Error err -> return $ Error err
174174
175−-- | Convert an element 'Parser.Parser' into an array stream fold. If the parser
176−-- fails the fold would throw an exception.
175+-- | Convert an element 'Parser.Parser' into an array stream fold. If the
176+-- parser fails the fold would throw an exception.
177177--
178178-- /Pre-release/
179179{-# INLINE fromParser #-}
180180fromParser :: forall m a b. (MonadThrow m, MonadIO m, Storable a) =>
181− Parser.Parser m a b -> Fold m a b
181+ Parser.Parser m a b -> ArrayFold m a b
182182fromParser = fromParserD . ParserD.fromParserK
183183
184184-- | Adapt an array stream fold.
185185--
186186-- /Pre-release/
187−{-# INLINE fromArrayFold #-}
188−fromArrayFold :: forall m a b. (MonadIO m) =>
189− Fold.Fold m (Array a) b -> Fold m a b
190−fromArrayFold f = Fold $ ParserD.fromFold f
187+{-# INLINE adaptFold #-}
188+adaptFold :: forall m a b. (MonadIO m) =>
189+ Fold.Fold m (Array a) b -> ArrayFold m a b
190+adaptFold f = ArrayFold $ ParserD.fromFold f
191191
192192-------------------------------------------------------------------------------
193193-- Functor
@@ -196,16 +196,16 @@ fromArrayFold f = Fold $ ParserD.fromFold f
196196-- | Maps a function over the result of fold.
197197--
198198-- /Pre-release/
199−instance Functor m => Functor (Fold m a) where
199+instance Functor m => Functor (ArrayFold m a) where
200200 {-# INLINE fmap #-}
201− fmap f (Fold p) = Fold $ fmap f p
201+ fmap f (ArrayFold p) = ArrayFold $ fmap f p
202202
203203-- | Map a monadic function on the output of a fold.
204204--
205205-- /Pre-release/
206206{-# INLINE rmapM #-}
207−rmapM :: Monad m => (b -> m c) -> Fold m a b -> Fold m a c
208−rmapM f (Fold p) = Fold $ ParserD.rmapM f p
207+rmapM :: Monad m => (b -> m c) -> ArrayFold m a b -> ArrayFold m a c
208+rmapM f (ArrayFold p) = ArrayFold $ ParserD.rmapM f p
209209
210210-------------------------------------------------------------------------------
211211-- Sequential applicative
@@ -216,8 +216,8 @@ rmapM f (Fold p) = Fold $ ParserD.rmapM f p
216216-- /Pre-release/
217217--
218218{-# INLINE fromPure #-}
219−fromPure :: Monad m => b -> Fold m a b
220−fromPure = Fold . ParserD.fromPure
219+fromPure :: Monad m => b -> ArrayFold m a b
220+fromPure = ArrayFold . ParserD.fromPure
221221
222222-- | A fold that always yields the result of an effectful action without
223223-- consuming any input.
@@ -225,16 +225,18 @@ fromPure = Fold . ParserD.fromPure
225225-- /Pre-release/
226226--
227227{-# INLINE fromEffect #-}
228−fromEffect :: Monad m => m b -> Fold m a b
229−fromEffect = Fold . ParserD.fromEffect
228+fromEffect :: Monad m => m b -> ArrayFold m a b
229+fromEffect = ArrayFold . ParserD.fromEffect
230230
231231-- | Applies two folds sequentially on the input stream and combines their
232232-- results using the supplied function.
233233--
234234-- /Pre-release/
235235{-# INLINE serial_ #-}
236−serial_ :: MonadThrow m => Fold m x a -> Fold m x b -> Fold m x b
237−serial_ (Fold p1) (Fold p2) = Fold $ ParserD.noErrorUnsafeSplit_ p1 p2
236+serial_ :: MonadThrow m =>
237+ ArrayFold m x a -> ArrayFold m x b -> ArrayFold m x b
238+serial_ (ArrayFold p1) (ArrayFold p2) =
239+ ArrayFold $ ParserD.noErrorUnsafeSplit_ p1 p2
238240
239241-- | Applies two folds sequentially on the input stream and combines their
240242-- results using the supplied function.
@@ -242,13 +244,13 @@ serial_ (Fold p1) (Fold p2) = Fold $ ParserD.noErrorUnsafeSplit_ p1 p2
242244-- /Pre-release/
243245{-# INLINE serialWith #-}
244246serialWith :: MonadThrow m
245− => (a -> b -> c) -> Fold m x a -> Fold m x b -> Fold m x c
246−serialWith f (Fold p1) (Fold p2) =
247− Fold $ ParserD.noErrorUnsafeSplitWith f p1 p2
247+ => (a -> b -> c) -> ArrayFold m x a -> ArrayFold m x b -> ArrayFold m x c
248+serialWith f (ArrayFold p1) (ArrayFold p2) =
249+ ArrayFold $ ParserD.noErrorUnsafeSplitWith f p1 p2
248250
249251-- | 'Applicative' form of 'serialWith'.
250252-- > (<*>) = serialWith id
251−instance MonadThrow m => Applicative (Fold m a) where
253+instance MonadThrow m => Applicative (ArrayFold m a) where
252254 {-# INLINE pure #-}
253255 pure = fromPure
254256
@@ -265,6 +267,8 @@ instance MonadThrow m => Applicative (Fold m a) where
265267-- Monad
266268-------------------------------------------------------------------------------
267269
270+-- XXX This should be implemented using CPS
271+--
268272-- | Applies a fold on the input stream, generates the next fold from the
269273-- output of the previously applied fold and then applies that fold.
270274--
@@ -272,15 +276,16 @@ instance MonadThrow m => Applicative (Fold m a) where
272276--
273277{-# INLINE concatMap #-}
274278concatMap :: MonadThrow m =>
275− (b -> Fold m a c) -> Fold m a b -> Fold m a c
276−concatMap func (Fold p) =
277− Fold $ ParserD.noErrorUnsafeConcatMap (\x -> let Fold y = func x in y) p
279+ (b -> ArrayFold m a c) -> ArrayFold m a b -> ArrayFold m a c
280+concatMap func (ArrayFold p) =
281+ let f x = let ArrayFold y = func x in y
282+ in ArrayFold $ ParserD.noErrorUnsafeConcatMap f p
278283
279284-- | Monad instance applies folds sequentially. Next fold can depend on the
280285-- output of the previous fold. See 'concatMap'.
281286--
282287-- > (>>=) = flip concatMap
283−instance MonadThrow m => Monad (Fold m a) where
288+instance MonadThrow m => Monad (ArrayFold m a) where
284289 {-# INLINE return #-}
285290 return = pure
286291
@@ -294,10 +299,12 @@ instance MonadThrow m => Monad (Fold m a) where
294299-- Array to Array folds
295300-------------------------------------------------------------------------------
296301
302+-- | Take @n@ array elements (@a@) from a stream of arrays (@Array a@).
297303{-# INLINE take #-}
298−take :: forall m a b. (Monad m, Storable a) => Int -> Fold m a b -> Fold m a b
299−take n (Fold (ParserD.Parser step1 initial1 extract1)) =
300− Fold $ ParserD.Parser step initial extract
304+take :: forall m a b. (Monad m, Storable a) =>
305+ Int -> ArrayFold m a b -> ArrayFold m a b
306+take n (ArrayFold (ParserD.Parser step1 initial1 extract1)) =
307+ ArrayFold $ ParserD.Parser step initial extract
301308
302309 where
303310