a1f4c0e · streamly · git.iko.soy

git.iko.soy/streamly

Move the zip functions from Streams.hs to Prelude.hs

commita1f4c0ebaf6a693ca94ecbc2574242aadd80f39f authorHarendra Kumar <harendra.kumar@gmail.com> dateThu 3 May 2018, 03:20 (8 years ago) parent9922101

2 files changed+16−22

compare with master

unifiedsplit

src/Streamly/Prelude.hs+16 src/Streamly/Streams.hs−22

src/Streamly/Prelude.hs+16

@@ -562,6 +562,10 @@ replicateM n m = fromStream $ go n

562562-- Serially Zipping Streams

563563------------------------------------------------------------------------------

564564

565+-- | Zip two streams serially using a pure zipping function.

566+zipWith :: IsStream t => (a -> b -> c) -> t m a -> t m b -> t m c

567+zipWith f m1 m2 = fromStream $ S.zipWith f (toStream m1) (toStream m2)

568+

565569-- | Zip two streams serially using a monadic zipping function.

566570zipWithM :: IsStream t => (a -> b -> t m c) -> t m a -> t m b -> t m c

567571zipWithM f m1 m2 = fromStream $ go (toStream m1) (toStream m2)

@@ -580,6 +584,18 @@ zipWithM f m1 m2 = fromStream $ go (toStream m1) (toStream m2)

580584-- Parallely Zipping Streams

581585------------------------------------------------------------------------------

582586

587+-- | Zip two streams concurrently (i.e. both the elements being zipped are

588+-- generated concurrently) using a pure zipping function.

589+zipParallelWith :: (IsStream t, MonadParallel m)

590+ => (a -> b -> c) -> t m a -> t m b -> t m c

591+zipParallelWith f m1 m2 =

592+ fromStream $ S.zipParallelWith f (toStream m1) (toStream m2)

593+

594+{-# DEPRECATED zipAsyncWith "Please use zipParallelWith instead." #-}

595+zipAsyncWith :: (IsStream t, MonadParallel m)

596+ => (a -> b -> c) -> t m a -> t m b -> t m c

597+zipAsyncWith = zipParallelWith

598+

583599-- | Zip two streams asyncly (i.e. both the elements being zipped are generated

584600-- concurrently) using a monadic zipping function.

585601zipParallelWithM :: (IsStream t, MonadParallel m)

src/Streamly/Streams.hs−22

@@ -100,11 +100,6 @@ module Streamly.Streams

100100 , runZipStream -- deprecated

101101 , runZipAsync -- deprecated

102102

103− -- * Zipping

104− , zipWith

105− , zipParallelWith

106− , zipAsyncWith -- deprecated

107−

108103 -- * Fold Utilities

109104 , foldWith

110105 , foldMapWith

@@ -121,7 +116,6 @@ import Control.Monad.Reader.Class (MonadReader(..))

121116import Control.Monad.State.Class (MonadState(..))

122117import Control.Monad.Trans.Class (MonadTrans (lift))

123118import Data.Semigroup (Semigroup(..))

124−import Prelude hiding (zipWith)

125119import Streamly.Core ( MonadParallel

126120 , SVar, SVarStyle(..)

127121 , SVarTag(..), SVarSched(..))

@@ -721,10 +715,6 @@ MONAD_COMMON_INSTANCES(ParallelT, MONADPARALLEL)

721715-- Serially Zipping Streams

722716------------------------------------------------------------------------------

723717

724−-- | Zip two streams serially using a pure zipping function.

725−zipWith :: IsStream t => (a -> b -> c) -> t m a -> t m b -> t m c

726−zipWith f m1 m2 = fromStream $ S.zipWith f (toStream m1) (toStream m2)

727−

728718-- | The applicative instance of 'ZipStreamM' zips a number of streams serially

729719-- i.e. it produces one element from each stream serially and then zips all

730720-- those elements.

@@ -757,18 +747,6 @@ instance Monad m => Applicative (ZipStreamM m) where

757747-- Parallely Zipping Streams

758748------------------------------------------------------------------------------

759749

760−-- | Zip two streams concurrently (i.e. both the elements being zipped are

761−-- generated concurrently) using a pure zipping function.

762−zipParallelWith :: (IsStream t, MonadParallel m)

763− => (a -> b -> c) -> t m a -> t m b -> t m c

764−zipParallelWith f m1 m2 =

765− fromStream $ S.zipParallelWith f (toStream m1) (toStream m2)

766−

767−{-# DEPRECATED zipAsyncWith "Please use zipParallelWith instead." #-}

768−zipAsyncWith :: (IsStream t, MonadParallel m)

769− => (a -> b -> c) -> t m a -> t m b -> t m c

770−zipAsyncWith = zipParallelWith

771−

772750-- | Like 'ZipStreamM' but zips in parallel, it generates all the elements to

773751-- be zipped concurrently.

774752--