77ae4c8 · streamly · git.iko.soy

git.iko.soy/streamly

on master help sign in

move functor instances to the common type

77ae4c8Harendra Kumar8 years ago

src/Streamly/Core.hs+4−1

compare with master

unifiedsplit

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

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

593

594instance 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

596

599

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

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

598 pure = undefined

601 pure = undefined

src/Streamly/Streams.hs+6−58

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

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

322--

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

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

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

325

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

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

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

374 pure = SerialT . singleton

375 (<*>) = ap

376

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−

387------------------------------------------------------------------------------

377------------------------------------------------------------------------------

388-- Num

378-- Num

389------------------------------------------------------------------------------

379------------------------------------------------------------------------------

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

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

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

464--

454--

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

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

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

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

467

457

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

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

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

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

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

520 pure = CoserialT . singleton

510 pure = CoserialT . singleton

521 (<*>) = ap

511 (<*>) = ap

522

512

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−

533------------------------------------------------------------------------------

513------------------------------------------------------------------------------

534-- Num

514-- Num

535------------------------------------------------------------------------------

515------------------------------------------------------------------------------

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

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

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

619--

599--

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

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

621− deriving (MonadTrans)

601+ deriving (Functor, MonadTrans)

622

602

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

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

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

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

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

689 pure = CoparallelT . singleton

669 pure = CoparallelT . singleton

690 (<*>) = ap

670 (<*>) = ap

691

671

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−

702------------------------------------------------------------------------------

672------------------------------------------------------------------------------

703-- Num

673-- Num

704------------------------------------------------------------------------------

674------------------------------------------------------------------------------

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

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

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

786--

756--

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

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

788− deriving (MonadTrans)

758+ deriving (Functor, MonadTrans)

789

759

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

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

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

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

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

831 pure = ParallelT . singleton

801 pure = ParallelT . singleton

832 (<*>) = ap

802 (<*>) = ap

833

803

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−

844------------------------------------------------------------------------------

804------------------------------------------------------------------------------

845-- Num

805-- Num

846------------------------------------------------------------------------------

806------------------------------------------------------------------------------

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

920-- 'SerialT'.

880-- 'SerialT'.

921--

881--

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

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

923− deriving (Semigroup, Monoid)

883+ deriving (Functor, Semigroup, Monoid)

924

884

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

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

926-- | Same as ZipSerial.

886-- | Same as ZipSerial.

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

928

888

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

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

930

890

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−

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

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

938 pure = ZipSerial . S.repeat

892 pure = ZipSerial . S.repeat

939 (<*>) = zipWith id

893 (<*>) = zipWith id

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

1017-- 'SerialT'.

971-- 'SerialT'.

1018--

972--

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

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

1020− deriving (Semigroup, Monoid)

974+ deriving (Functor, Semigroup, Monoid)

1021

975

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

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

1023type ZipAsync = ZipParallel

977type ZipAsync = ZipParallel

1024

978

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

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

1026

980

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−

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

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

1034 pure = ZipParallel . S.repeat

982 pure = ZipParallel . S.repeat

1035 (<*>) = zipParallelWith id

983 (<*>) = zipParallelWith id