@@ -1,3 +1,4 @@
1+{-# LANGUAGE StandaloneDeriving #-}
12{-# LANGUAGE UndecidableInstances #-}
23
34-- |
@@ -11,54 +12,41 @@
1112--
1213-- To run examples in this module:
1314--
14−-- >>> import qualified Streamly.Prelude as Stream
15+-- >>> import qualified Streamly.Data.Fold as Fold
16+-- >>> import qualified Streamly.Data.Stream as Stream
17+-- >>> import qualified Streamly.Internal.Data.Stream.Zip as Stream
1518--
1619module Streamly.Internal.Data.Stream.Zip
1720 (
18− ZipSerialM (..)
21+ ZipStream (..)
22+ , ZipSerialM
1923 , ZipSerial
20− , consMZip
2124 , zipWithK
2225 , zipWithMK
2326 )
2427where
2528
26−import Control.Applicative (liftA2)
2729import Control.DeepSeq (NFData(..), NFData1(..))
28−import Data.Foldable (Foldable(foldl'), fold)
29−import Data.Functor.Identity (Identity(..), runIdentity)
30−import Data.Maybe (fromMaybe)
31−import Data.Semigroup (Endo(..))
32−#if __GLASGOW_HASKELL__ < 808
33−import Data.Semigroup (Semigroup(..))
34−#endif
35−import GHC.Exts (IsList(..), IsString(..), oneShot)
30+import Data.Functor.Identity (Identity(..))
31+import GHC.Exts (IsList(..), IsString(..))
32+import Streamly.Internal.Data.Stream.Type (Stream, toStreamD, fromStreamD)
3633import Text.Read
3734 ( Lexeme(Ident), lexP, parens, prec, readPrec, readListPrec
3835 , readListPrecDefault)
39−import Streamly.Internal.BaseCompat ((#.))
40−import Streamly.Internal.Data.Maybe.Strict (Maybe'(..), toMaybe)
41−import Streamly.Internal.Data.Stream.StreamK.Type (Stream)
4236
43−import qualified Streamly.Internal.Data.Stream.Common as P
44− (cmpBy, eqBy, foldl', foldr, fromList, toList)
45−import qualified Streamly.Internal.Data.Stream.StreamK.Type as K
37+import qualified Streamly.Internal.Data.Stream as Stream
4638import qualified Streamly.Internal.Data.Stream.StreamD as D
47−import qualified Streamly.Internal.Data.Stream.Serial as Serial
48−import qualified Streamly.Internal.Data.Stream.Type as Stream
49−
50−import Prelude hiding (map, repeat, zipWith)
51−
52−#include "Instances.hs"
5339
5440-- $setup
55−-- >>> import qualified Streamly.Prelude as Stream
41+-- >>> import qualified Streamly.Data.Fold as Fold
42+-- >>> import qualified Streamly.Data.Stream as Stream
43+-- >>> import qualified Streamly.Internal.Data.Stream.Zip as Stream
5644
5745{-# INLINE zipWithMK #-}
5846zipWithMK :: Monad m =>
5947 (a -> b -> m c) -> Stream m a -> Stream m b -> Stream m c
6048zipWithMK f m1 m2 =
61− D.toStreamK $ D.zipWithM f (D.fromStreamK m1) (D.fromStreamK m2)
49+ fromStreamD $ D.zipWithM f (toStreamD m1) (toStreamD m2)
6250
6351{-# INLINE zipWithK #-}
6452zipWithK :: Monad m
@@ -69,26 +57,48 @@ zipWithK f = zipWithMK (\a b -> return (f a b))
6957-- Serially Zipping Streams
7058------------------------------------------------------------------------------
7159
72−-- | For 'ZipSerialM' streams:
60+-- | For 'ZipStream':
7361--
7462-- @
75−-- (<>) = 'Streamly.Prelude.serial'
76−-- (<*>) = 'Streamly.Prelude.serial.zipWith' id
63+-- (<>) = 'Streamly.Data.Stream.append'
64+-- (<*>) = 'Streamly.Data.Stream.zipWith' id
7765-- @
7866--
7967-- Applicative evaluates the streams being zipped serially:
8068--
81−-- >>> s1 = Stream.fromFoldable [1, 2]
82−-- >>> s2 = Stream.fromFoldable [3, 4]
83−-- >>> s3 = Stream.fromFoldable [5, 6]
84−-- >>> Stream.toList $ Stream.fromZipSerial $ (,,) <$> s1 <*> s2 <*> s3
69+-- >>> s1 = Stream.ZipStream $ Stream.fromFoldable [1, 2]
70+-- >>> s2 = Stream.ZipStream $ Stream.fromFoldable [3, 4]
71+-- >>> s3 = Stream.ZipStream $ Stream.fromFoldable [5, 6]
72+-- >>> s = (,,) <$> s1 <*> s2 <*> s3
73+-- >>> Stream.fold Fold.toList (Stream.getZipStream s)
8574-- [(1,3,5),(2,4,6)]
8675--
8776-- /Since: 0.2.0 ("Streamly")/
8877--
8978-- @since 0.8.0
90−newtype ZipSerialM m a = ZipSerialM {getZipSerialM :: Stream m a}
91− deriving (Semigroup, Monoid)
79+newtype ZipStream m a = ZipStream {getZipStream :: Stream m a}
80+ deriving (Functor, Semigroup, Monoid)
81+
82+deriving instance NFData a => NFData (ZipStream Identity a)
83+deriving instance NFData1 (ZipStream Identity)
84+deriving instance IsList (ZipStream Identity a)
85+deriving instance (a ~ Char) => IsString (ZipStream Identity a)
86+deriving instance Eq a => Eq (ZipStream Identity a)
87+deriving instance Ord a => Ord (ZipStream Identity a)
88+deriving instance (Foldable m, Monad m) => Foldable (ZipStream m)
89+deriving instance Traversable (ZipStream Identity)
90+
91+instance Show a => Show (ZipStream Identity a) where
92+ showsPrec p dl = showParen (p > 10) $
93+ showString "fromList " . shows (toList dl)
94+
95+instance Read a => Read (ZipStream Identity a) where
96+ readPrec = parens $ prec 10 $ do
97+ Ident "fromList" <- lexP
98+ fromList <$> readPrec
99+ readListPrec = readListPrecDefault
100+
101+type ZipSerialM = ZipStream
92102
93103-- | An IO stream whose applicative instance zips streams serially.
94104--
@@ -97,21 +107,8 @@ newtype ZipSerialM m a = ZipSerialM {getZipSerialM :: Stream m a}
97107-- @since 0.8.0
98108type ZipSerial = ZipSerialM IO
99109
100−consMZip :: Monad m => m a -> ZipSerialM m a -> ZipSerialM m a
101−consMZip m (ZipSerialM r) = ZipSerialM $ K.consM m r
102−
103−LIST_INSTANCES(ZipSerialM)
104−NFDATA1_INSTANCE(ZipSerialM)
105−
106−instance Monad m => Functor (ZipSerialM m) where
107− {-# INLINE fmap #-}
108− fmap f (ZipSerialM m) = ZipSerialM $ Stream.toStreamK $ fmap f (Stream.fromStreamK m)
109−
110−instance Monad m => Applicative (ZipSerialM m) where
111− pure = ZipSerialM . Stream.toStreamK . Serial.repeat
110+instance Monad m => Applicative (ZipStream m) where
111+ pure = ZipStream . Stream.repeat
112112
113113 {-# INLINE (<*>) #-}
114− ZipSerialM m1 <*> ZipSerialM m2 = ZipSerialM $ zipWithK id m1 m2
115−
116−FOLDABLE_INSTANCE(ZipSerialM)
117−TRAVERSABLE_INSTANCE(ZipSerialM)
114+ ZipStream m1 <*> ZipStream m2 = ZipStream $ zipWithK id m1 m2