@@ -36,24 +36,24 @@ module Streamly.Internal.Data.Fold.Window
3636 -- window folds by keeping the second element of the input tuple as
3737 -- @Nothing@.
3838 --
39− lmap
39+ windowLmap
4040 , cumulative
4141
42− , rollingMap
43− , rollingMapM
42+ , windowRollingMap
43+ , windowRollingMapM
4444
4545 -- ** Sums
46− , length
47− , sum
48− , sumInt
49− , powerSum
50− , powerSumFrac
46+ , windowLength
47+ , windowSum
48+ , windowSumInt
49+ , windowPowerSum
50+ , windowPowerSumFrac
5151
5252 -- ** Location
53− , minimum
54− , maximum
55− , range
56− , mean
53+ , windowMinimum
54+ , windowMaximum
55+ , windowRange
56+ , windowMean
5757 )
5858where
5959
@@ -73,7 +73,7 @@ import Prelude hiding (length, sum, minimum, maximum)
7373-- $setup
7474-- >>> import Data.Bifunctor(bimap)
7575-- >>> import qualified Streamly.Data.Fold as Fold
76−-- >>> import qualified Streamly.Internal.Data.Fold.Window as FoldW
76+-- >>> import qualified Streamly.Internal.Data.Fold.Window as Fold
7777-- >>> import qualified Streamly.Internal.Data.Ring as Ring
7878-- >>> import qualified Streamly.Data.Stream as Stream
7979-- >>> import Prelude hiding (length, sum, minimum, maximum)
@@ -87,9 +87,9 @@ import Prelude hiding (length, sum, minimum, maximum)
8787--
8888-- >>> lmap f = Fold.lmap (bimap f (f <$>))
8989--
90−{-# INLINE lmap #-}
91−lmap :: (c -> a) -> Fold m (a, Maybe a) b -> Fold m (c, Maybe c) b
92−lmap f = Fold.lmap (bimap f (f <$>))
90+{-# INLINE windowLmap #-}
91+windowLmap :: (c -> a) -> Fold m (a, Maybe a) b -> Fold m (c, Maybe c) b
92+windowLmap f = Fold.lmap (bimap f (f <$>))
9393
9494-- | Convert an incremental fold to a cumulative fold using the entire input
9595-- stream as a single window.
@@ -105,10 +105,10 @@ cumulative = Fold.lmap (, Nothing)
105105
106106-- | Apply an effectful function on the latest and the oldest element of the
107107-- window.
108−{-# INLINE rollingMapM #-}
109−rollingMapM :: Monad m =>
108+{-# INLINE windowRollingMapM #-}
109+windowRollingMapM :: Monad m =>
110110 (Maybe a -> a -> m (Maybe b)) -> Fold m (a, Maybe a) (Maybe b)
111−rollingMapM f = Fold.foldlM' f1 initial
111+windowRollingMapM f = Fold.foldlM' f1 initial
112112
113113 where
114114
@@ -118,12 +118,12 @@ rollingMapM f = Fold.foldlM' f1 initial
118118
119119-- | Apply a pure function on the latest and the oldest element of the window.
120120--
121−-- >>> rollingMap f = FoldW.rollingMapM (\x y -> return $ f x y)
121+-- >>> windowRollingMap f = Fold.windowRollingMapM (\x y -> return $ f x y)
122122--
123−{-# INLINE rollingMap #-}
124−rollingMap :: Monad m =>
123+{-# INLINE windowRollingMap #-}
124+windowRollingMap :: Monad m =>
125125 (Maybe a -> a -> Maybe b) -> Fold m (a, Maybe a) (Maybe b)
126−rollingMap f = Fold.foldl' f1 initial
126+windowRollingMap f = Fold.foldl' f1 initial
127127
128128 where
129129
@@ -146,9 +146,9 @@ rollingMap f = Fold.foldl' f1 initial
146146--
147147-- /Internal/
148148--
149−{-# INLINE sumInt #-}
150−sumInt :: forall m a. (Monad m, Integral a) => Fold m (a, Maybe a) a
151−sumInt = Fold step initial extract
149+{-# INLINE windowSumInt #-}
150+windowSumInt :: forall m a. (Monad m, Integral a) => Fold m (a, Maybe a) a
151+windowSumInt = Fold step initial extract
152152
153153 where
154154
@@ -180,9 +180,9 @@ sumInt = Fold step initial extract
180180--
181181-- /Time/: \(\mathcal{O}(n)\)
182182--
183−{-# INLINE sum #-}
184−sum :: forall m a. (Monad m, Num a) => Fold m (a, Maybe a) a
185−sum = Fold step initial extract
183+{-# INLINE windowSum #-}
184+windowSum :: forall m a. (Monad m, Num a) => Fold m (a, Maybe a) a
185+windowSum = Fold step initial extract
186186
187187 where
188188
@@ -219,9 +219,9 @@ sum = Fold step initial extract
219219--
220220-- >>> length = powerSum 0
221221--
222−{-# INLINE length #-}
223−length :: (Monad m, Num b) => Fold m (a, Maybe a) b
224−length = Fold.foldl' step 0
222+{-# INLINE windowLength #-}
223+windowLength :: (Monad m, Num b) => Fold m (a, Maybe a) b
224+windowLength = Fold.foldl' step 0
225225
226226 where
227227
@@ -237,18 +237,18 @@ length = Fold.foldl' step 0
237237-- /Space/: \(\mathcal{O}(1)\)
238238--
239239-- /Time/: \(\mathcal{O}(n)\)
240−{-# INLINE powerSum #-}
241−powerSum :: (Monad m, Num a) => Int -> Fold m (a, Maybe a) a
242−powerSum k = lmap (^ k) sum
240+{-# INLINE windowPowerSum #-}
241+windowPowerSum :: (Monad m, Num a) => Int -> Fold m (a, Maybe a) a
242+windowPowerSum k = windowLmap (^ k) windowSum
243243
244244-- | Like 'powerSum' but powers can be negative or fractional. This is slower
245245-- than 'powerSum' for positive intergal powers.
246246--
247247-- >>> powerSumFrac p = lmap (** p) sum
248248--
249−{-# INLINE powerSumFrac #-}
250−powerSumFrac :: (Monad m, Floating a) => a -> Fold m (a, Maybe a) a
251−powerSumFrac p = lmap (** p) sum
249+{-# INLINE windowPowerSumFrac #-}
250+windowPowerSumFrac :: (Monad m, Floating a) => a -> Fold m (a, Maybe a) a
251+windowPowerSumFrac p = windowLmap (** p) windowSum
252252
253253-------------------------------------------------------------------------------
254254-- Location
@@ -265,9 +265,9 @@ powerSumFrac p = lmap (** p) sum
265265--
266266-- /Time/: \(\mathcal{O}(n*w)\) where \(w\) is the window size.
267267--
268−{-# INLINE range #-}
269−range :: (MonadIO m, Storable a, Ord a) => Int -> Fold m a (Maybe (a, a))
270−range n = Fold step initial extract
268+{-# INLINE windowRange #-}
269+windowRange :: (MonadIO m, Storable a, Ord a) => Int -> Fold m a (Maybe (a, a))
270+windowRange n = Fold step initial extract
271271
272272 where
273273
@@ -316,9 +316,9 @@ range n = Fold step initial extract
316316--
317317-- /Time/: \(\mathcal{O}(n*w)\) where \(w\) is the window size.
318318--
319−{-# INLINE minimum #-}
320−minimum :: (MonadIO m, Storable a, Ord a) => Int -> Fold m a (Maybe a)
321−minimum n = fmap (fmap fst) $ range n
319+{-# INLINE windowMinimum #-}
320+windowMinimum :: (MonadIO m, Storable a, Ord a) => Int -> Fold m a (Maybe a)
321+windowMinimum n = fmap (fmap fst) $ windowRange n
322322
323323-- | The maximum element in a rolling window.
324324--
@@ -329,9 +329,9 @@ minimum n = fmap (fmap fst) $ range n
329329--
330330-- /Time/: \(\mathcal{O}(n*w)\) where \(w\) is the window size.
331331--
332−{-# INLINE maximum #-}
333−maximum :: (MonadIO m, Storable a, Ord a) => Int -> Fold m a (Maybe a)
334−maximum n = fmap (fmap snd) $ range n
332+{-# INLINE windowMaximum #-}
333+windowMaximum :: (MonadIO m, Storable a, Ord a) => Int -> Fold m a (Maybe a)
334+windowMaximum n = fmap (fmap snd) $ windowRange n
335335
336336-- | Arithmetic mean of elements in a sliding window:
337337--
@@ -346,6 +346,6 @@ maximum n = fmap (fmap snd) $ range n
346346-- /Space/: \(\mathcal{O}(1)\)
347347--
348348-- /Time/: \(\mathcal{O}(n)\)
349−{-# INLINE mean #-}
350−mean :: forall m a. (Monad m, Fractional a) => Fold m (a, Maybe a) a
351−mean = Fold.teeWith (/) sum length
349+{-# INLINE windowMean #-}
350+windowMean :: forall m a. (Monad m, Fractional a) => Fold m (a, Maybe a) a
351+windowMean = Fold.teeWith (/) windowSum windowLength