77ae4c8 · streamly · git.iko.soy

git.iko.soy/streamly

move functor instances to the common type

commit77ae4c843e3f2a907fd4f65e49a2100979e52030 authorHarendra Kumar <harendra.kumar@gmail.com> dateSat 21 Apr 2018, 22:43 (8 years ago) parente1325ad

2 files changed+10−59

compare with master

unifiedsplit

src/Streamly/Core.hs+4−1 src/Streamly/Streams.hs+6−58

src/Streamly/Core.hs+4−1

@@ -592,7 +592,10 @@ parallel = joinStreamVar2 (SVarStyle Disjunction FIFO)

592592-- require a Monad constraint. Must be defined by the newtypes.

593593

594594instance Monad m => Functor (Stream m) where

595− fmap = undefined

595+ fmap f m = Stream $ \_ stp sng yld ->

596+ let single = sng . f

597+ yield a r = yld (f a) (fmap f r)

598+ in (runStream m) Nothing stp single yield

596599

597600instance Monad m => Applicative (Stream m) where

598601 pure = undefined

src/Streamly/Streams.hs+6−58

@@ -321,7 +321,7 @@ async m = do

321321-- streams as it explores only one stream at a time.

322322--

323323newtype SerialT m a = SerialT {getSerialT :: Stream m a}

324− deriving (Semigroup, Monoid, MonadTrans, MonadIO, MonadThrow)

324+ deriving (Functor, Semigroup, Monoid, MonadTrans, MonadIO, MonadThrow)

325325

326326deriving instance MonadParallel m => Alternative (SerialT m)

327327deriving instance MonadParallel m => MonadPlus (SerialT m)

@@ -374,16 +374,6 @@ instance Monad m => Applicative (SerialT m) where

374374 pure = SerialT . singleton

375375 (<*>) = ap

376376

377−------------------------------------------------------------------------------

378−-- Functor

379−------------------------------------------------------------------------------

380−

381−instance Monad m => Functor (SerialT m) where

382− fmap f m = fromStream $ Stream $ \_ stp sng yld ->

383− let single = sng . f

384− yield a r = yld (f a) (toStream $ fmap f (SerialT r))

385− in (S.runStream (toStream m)) Nothing stp single yield

386−

387377------------------------------------------------------------------------------

388378-- Num

389379------------------------------------------------------------------------------

@@ -463,7 +453,7 @@ instance (Monad m, Floating a) => Floating (SerialT m a) where

463453-- streams as it needs to retain state for each unfinished stream.

464454--

465455newtype CoserialT m a = CoserialT {getCoserialT :: Stream m a}

466− deriving (Monoid, MonadTrans, MonadIO, MonadThrow)

456+ deriving (Functor, Monoid, MonadTrans, MonadIO, MonadThrow)

467457

468458deriving instance MonadParallel m => Alternative (CoserialT m)

469459deriving instance MonadParallel m => MonadPlus (CoserialT m)

@@ -520,16 +510,6 @@ instance Monad m => Applicative (CoserialT m) where

520510 pure = CoserialT . singleton

521511 (<*>) = ap

522512

523−------------------------------------------------------------------------------

524−-- Functor

525−------------------------------------------------------------------------------

526−

527−instance Monad m => Functor (CoserialT m) where

528− fmap f m = fromStream $ Stream $ \_ stp sng yld ->

529− let single = sng . f

530− yield a r = yld (f a) (toStream $ fmap f (CoserialT r))

531− in (S.runStream (toStream m)) Nothing stp single yield

532−

533513------------------------------------------------------------------------------

534514-- Num

535515------------------------------------------------------------------------------

@@ -618,7 +598,7 @@ instance (Monad m, Floating a) => Floating (CoserialT m a) where

618598-- as it explores only a bounded number of streams at a time.

619599--

620600newtype CoparallelT m a = CoparallelT {getCoparallelT :: Stream m a}

621− deriving (MonadTrans)

601+ deriving (Functor, MonadTrans)

622602

623603deriving instance MonadParallel m => Monoid (CoparallelT m a)

624604deriving instance MonadParallel m => Alternative (CoparallelT m)

@@ -689,16 +669,6 @@ instance MonadParallel m => Applicative (CoparallelT m) where

689669 pure = CoparallelT . singleton

690670 (<*>) = ap

691671

692−------------------------------------------------------------------------------

693−-- Functor

694−------------------------------------------------------------------------------

695−

696−instance Monad m => Functor (CoparallelT m) where

697− fmap f m = fromStream $ Stream $ \_ stp sng yld ->

698− let single = sng . f

699− yield a r = yld (f a) (toStream $ fmap f (CoparallelT r))

700− in (S.runStream (toStream m)) Nothing stp single yield

701−

702672------------------------------------------------------------------------------

703673-- Num

704674------------------------------------------------------------------------------

@@ -785,7 +755,7 @@ instance (MonadParallel m, Floating a) => Floating (CoparallelT m a) where

785755-- streams as it needs to retain state for each unfinished stream.

786756--

787757newtype ParallelT m a = ParallelT {getParallelT :: Stream m a}

788− deriving (MonadTrans)

758+ deriving (Functor, MonadTrans)

789759

790760deriving instance MonadParallel m => Monoid (ParallelT m a)

791761deriving instance MonadParallel m => Alternative (ParallelT m)

@@ -831,16 +801,6 @@ instance MonadParallel m => Applicative (ParallelT m) where

831801 pure = ParallelT . singleton

832802 (<*>) = ap

833803

834−------------------------------------------------------------------------------

835−-- Functor

836−------------------------------------------------------------------------------

837−

838−instance Monad m => Functor (ParallelT m) where

839− fmap f m = fromStream $ Stream $ \_ stp sng yld ->

840− let single = sng . f

841− yield a r = yld (f a) (toStream $ fmap f (ParallelT r))

842− in (S.runStream (toStream m)) Nothing stp single yield

843−

844804------------------------------------------------------------------------------

845805-- Num

846806------------------------------------------------------------------------------

@@ -920,7 +880,7 @@ zipWith f m1 m2 = fromStream $ go (toStream m1) (toStream m2)

920880-- 'SerialT'.

921881--

922882newtype ZipSerial m a = ZipSerial {getZipSerial :: Stream m a}

923− deriving (Semigroup, Monoid)

883+ deriving (Functor, Semigroup, Monoid)

924884

925885{-# Deprecated ZipStream "Please use ZipSerial instead." #-}

926886-- | Same as ZipSerial.

@@ -928,12 +888,6 @@ type ZipStream = ZipSerial

928888

929889deriving instance MonadParallel m => Alternative (ZipSerial m)

930890

931−instance Monad m => Functor (ZipSerial m) where

932− fmap f m = fromStream $ Stream $ \_ stp sng yld ->

933− let single = sng . f

934− yield a r = yld (f a) (toStream $ fmap f (ZipSerial r))

935− in (S.runStream (toStream m)) Nothing stp single yield

936−

937891instance Monad m => Applicative (ZipSerial m) where

938892 pure = ZipSerial . S.repeat

939893 (<*>) = zipWith id

@@ -1017,19 +971,13 @@ zipAsyncWith = zipParallelWith

1017971-- 'SerialT'.

1018972--

1019973newtype ZipParallel m a = ZipParallel {getZipParallel :: Stream m a}

1020− deriving (Semigroup, Monoid)

974+ deriving (Functor, Semigroup, Monoid)

1021975

1022976{-# DEPRECATED ZipAsync "Please use ZipParallel instead." #-}

1023977type ZipAsync = ZipParallel

1024978

1025979deriving instance MonadParallel m => Alternative (ZipParallel m)

1026980

1027−instance Monad m => Functor (ZipParallel m) where

1028− fmap f m = fromStream $ Stream $ \_ stp sng yld ->

1029− let single = sng . f

1030− yield a r = yld (f a) (toStream $ fmap f (ZipParallel r))

1031− in (S.runStream (toStream m)) Nothing stp single yield

1032−

1033981instance MonadParallel m => Applicative (ZipParallel m) where

1034982 pure = ZipParallel . S.repeat

1035983 (<*>) = zipParallelWith id