@@ -71,8 +71,8 @@ import Asyncly.AsyncT
7171------------------------------------------------------------------------------
7272
7373newtype StreamT m a = StreamT {getStreamT :: Stream m a}
74− deriving (Functor, Applicative, Monad, Semigroup, Monoid, Num, Fractional,
75− Floating, MonadTrans, MonadIO, MonadThrow)
74+ deriving (Functor, Applicative, Monad, Semigroup, Monoid,
75+ MonadTrans, MonadIO, MonadThrow)
7676
7777deriving instance MonadAsync m => Alternative (StreamT m)
7878deriving instance MonadAsync m => MonadPlus (StreamT m)
@@ -85,15 +85,63 @@ instance Streaming StreamT where
8585 toStream = getStreamT
8686 fromStream = StreamT
8787
88+-- XXX The Functor/Applicative/Num instances for all the types are exactly the
89+-- same, how can we reduce this boilerplate (use TH)? We cannot derive them
90+-- from a single base type because they depend on the Monad instance which is
91+-- different for each type.
92+
93+------------------------------------------------------------------------------
94+-- Num
95+------------------------------------------------------------------------------
96+
97+instance (Monad m, Num a) => Num (StreamT m a) where
98+ fromInteger n = pure (fromInteger n)
99+
100+ negate = fmap negate
101+ abs = fmap abs
102+ signum = fmap signum
103+
104+ (+) = liftA2 (+)
105+ (*) = liftA2 (*)
106+ (-) = liftA2 (-)
107+
108+instance (Monad m, Fractional a) => Fractional (StreamT m a) where
109+ fromRational n = pure (fromRational n)
110+
111+ recip = fmap recip
112+
113+ (/) = liftA2 (/)
114+
115+instance (Monad m, Floating a) => Floating (StreamT m a) where
116+ pi = pure pi
117+
118+ exp = fmap exp
119+ sqrt = fmap sqrt
120+ log = fmap log
121+ sin = fmap sin
122+ tan = fmap tan
123+ cos = fmap cos
124+ asin = fmap asin
125+ atan = fmap atan
126+ acos = fmap acos
127+ sinh = fmap sinh
128+ tanh = fmap tanh
129+ cosh = fmap cosh
130+ asinh = fmap asinh
131+ atanh = fmap atanh
132+ acosh = fmap acosh
133+
134+ (**) = liftA2 (**)
135+ logBase = liftA2 logBase
136+
88137------------------------------------------------------------------------------
89138-- InterleavedT interleaves the iterations in the Monad and Applicative
90139-- compositions. It does not make much sense for infinite streams.
91140------------------------------------------------------------------------------
92141
93−-- XXX the applicative, functor and num instances may not be correct
94142newtype InterleavedT m a = InterleavedT {getInterleavedT :: Stream m a}
95− deriving (Functor, Applicative, Semigroup, Monoid, Num, Fractional,
96− Floating, MonadTrans, MonadIO, MonadThrow)
143+ deriving (Functor, Applicative, Semigroup, Monoid,
144+ MonadTrans, MonadIO, MonadThrow)
97145
98146deriving instance MonadAsync m => Alternative (InterleavedT m)
99147deriving instance MonadAsync m => MonadPlus (InterleavedT m)
@@ -106,9 +154,9 @@ instance Streaming InterleavedT where
106154 toStream = getInterleavedT
107155 fromStream = InterleavedT
108156
157+-- | Execute a monadic action for each element in the stream, in a fairly
158+-- interleaved manner i.e. iterations yield alternately.
109159instance Monad m => Monad (InterleavedT m) where
110− -- | Execute a monadic action for each element in the stream, in a fairly
111− -- interleaved manner i.e. iterations yield alternately.
112160 (InterleavedT (Stream m)) >>= f = InterleavedT $ Stream $ \_ stp yld ->
113161 let run x = (runStream x) Nothing stp yld
114162 yield a Nothing = run $ getInterleavedT (f a)
@@ -117,6 +165,50 @@ instance Monad m => Monad (InterleavedT m) where
117165 getInterleavedT ((InterleavedT r) >>= f)
118166 in m Nothing stp yield
119167
168+------------------------------------------------------------------------------
169+-- Num
170+------------------------------------------------------------------------------
171+
172+instance (Monad m, Num a) => Num (InterleavedT m a) where
173+ fromInteger n = pure (fromInteger n)
174+
175+ negate = fmap negate
176+ abs = fmap abs
177+ signum = fmap signum
178+
179+ (+) = liftA2 (+)
180+ (*) = liftA2 (*)
181+ (-) = liftA2 (-)
182+
183+instance (Monad m, Fractional a) => Fractional (InterleavedT m a) where
184+ fromRational n = pure (fromRational n)
185+
186+ recip = fmap recip
187+
188+ (/) = liftA2 (/)
189+
190+instance (Monad m, Floating a) => Floating (InterleavedT m a) where
191+ pi = pure pi
192+
193+ exp = fmap exp
194+ sqrt = fmap sqrt
195+ log = fmap log
196+ sin = fmap sin
197+ tan = fmap tan
198+ cos = fmap cos
199+ asin = fmap asin
200+ atan = fmap atan
201+ acos = fmap acos
202+ sinh = fmap sinh
203+ tanh = fmap tanh
204+ cosh = fmap cosh
205+ asinh = fmap asinh
206+ atanh = fmap atanh
207+ acosh = fmap acosh
208+
209+ (**) = liftA2 (**)
210+ logBase = liftA2 logBase
211+
120212------------------------------------------------------------------------------
121213-- AsyncT runs the iterations asynchronously in the Monad and Applicative
122214-- compositions. More iterations are started in parallel on demand. It can work
@@ -124,8 +216,7 @@ instance Monad m => Monad (InterleavedT m) where
124216------------------------------------------------------------------------------
125217
126218newtype AsyncT m a = AsyncT {getAsyncT :: Stream m a}
127− deriving (Functor, Applicative, Semigroup, Monoid, Num, Fractional,
128− Floating, MonadTrans)
219+ deriving (Functor, Applicative, Semigroup, Monoid, MonadTrans)
129220
130221deriving instance MonadAsync m => MonadIO (AsyncT m)
131222deriving instance MonadAsync m => MonadThrow (AsyncT m)
@@ -155,14 +246,58 @@ parbind k m f = go m
155246 yield a (Just r) = run $ f a `k` (go r)
156247 in g Nothing stp yield
157248
249+-- | Execute a monadic action for each element in the stream, running
250+-- iterations in parallel, but giving preference to iterations started
251+-- earlier.
158252instance MonadAsync m => Monad (AsyncT m) where
159− -- | Execute a monadic action for each element in the stream, running
160− -- iterations in parallel, but giving preference to iterations started
161− -- earlier.
162253 (AsyncT m) >>= f = AsyncT $ parbind par m g
163254 where g x = getAsyncT (f x)
164255 par = parallel (CtxType Conjunction LIFO)
165256
257+------------------------------------------------------------------------------
258+-- Num
259+------------------------------------------------------------------------------
260+
261+instance (Monad m, Num a) => Num (AsyncT m a) where
262+ fromInteger n = pure (fromInteger n)
263+
264+ negate = fmap negate
265+ abs = fmap abs
266+ signum = fmap signum
267+
268+ (+) = liftA2 (+)
269+ (*) = liftA2 (*)
270+ (-) = liftA2 (-)
271+
272+instance (Monad m, Fractional a) => Fractional (AsyncT m a) where
273+ fromRational n = pure (fromRational n)
274+
275+ recip = fmap recip
276+
277+ (/) = liftA2 (/)
278+
279+instance (Monad m, Floating a) => Floating (AsyncT m a) where
280+ pi = pure pi
281+
282+ exp = fmap exp
283+ sqrt = fmap sqrt
284+ log = fmap log
285+ sin = fmap sin
286+ tan = fmap tan
287+ cos = fmap cos
288+ asin = fmap asin
289+ atan = fmap atan
290+ acos = fmap acos
291+ sinh = fmap sinh
292+ tanh = fmap tanh
293+ cosh = fmap cosh
294+ asinh = fmap asinh
295+ atanh = fmap atanh
296+ acosh = fmap acosh
297+
298+ (**) = liftA2 (**)
299+ logBase = liftA2 logBase
300+
166301------------------------------------------------------------------------------
167302-- ParallelT runs all iterations in parallel in the Monad and Applicative
168303-- compositions. Iterations are scheduled in a round-robin fashion. It cannot
@@ -170,8 +305,7 @@ instance MonadAsync m => Monad (AsyncT m) where
170305------------------------------------------------------------------------------
171306
172307newtype ParallelT m a = ParallelT {getParallelT :: Stream m a}
173− deriving (Functor, Applicative, Semigroup, Monoid, Num, Fractional,
174− Floating, MonadTrans)
308+ deriving (Functor, Applicative, Semigroup, Monoid, MonadTrans)
175309
176310deriving instance MonadAsync m => MonadIO (ParallelT m)
177311deriving instance MonadAsync m => MonadThrow (ParallelT m)
@@ -186,14 +320,58 @@ instance Streaming ParallelT where
186320 toStream = getParallelT
187321 fromStream = ParallelT
188322
323+-- | Execute a monadic action for each element in the stream, running
324+-- iterations in a fairly parallel manner, i.e. all iterations are equally
325+-- likely to run.
189326instance MonadAsync m => Monad (ParallelT m) where
190− -- | Execute a monadic action for each element in the stream, running
191− -- iterations in a fairly parallel manner, i.e. all iterations are equally
192− -- likely to run.
193327 (ParallelT m) >>= f = ParallelT $ parbind par m g
194328 where g x = getParallelT (f x)
195329 par = parallel (CtxType Conjunction FIFO)
196330
331+------------------------------------------------------------------------------
332+-- Num
333+------------------------------------------------------------------------------
334+
335+instance (Monad m, Num a) => Num (ParallelT m a) where
336+ fromInteger n = pure (fromInteger n)
337+
338+ negate = fmap negate
339+ abs = fmap abs
340+ signum = fmap signum
341+
342+ (+) = liftA2 (+)
343+ (*) = liftA2 (*)
344+ (-) = liftA2 (-)
345+
346+instance (Monad m, Fractional a) => Fractional (ParallelT m a) where
347+ fromRational n = pure (fromRational n)
348+
349+ recip = fmap recip
350+
351+ (/) = liftA2 (/)
352+
353+instance (Monad m, Floating a) => Floating (ParallelT m a) where
354+ pi = pure pi
355+
356+ exp = fmap exp
357+ sqrt = fmap sqrt
358+ log = fmap log
359+ sin = fmap sin
360+ tan = fmap tan
361+ cos = fmap cos
362+ asin = fmap asin
363+ atan = fmap atan
364+ acos = fmap acos
365+ sinh = fmap sinh
366+ tanh = fmap tanh
367+ cosh = fmap cosh
368+ asinh = fmap asinh
369+ atanh = fmap atanh
370+ acosh = fmap acosh
371+
372+ (**) = liftA2 (**)
373+ logBase = liftA2 logBase
374+
197375------------------------------------------------------------------------------
198376-- Serially Zipping Streams
199377------------------------------------------------------------------------------