@@ -1,8 +1,8 @@
11{-# LANGUAGE UndecidableInstances #-}
2−module Effectful.Async
3− ( -- * Async effect
4− AsyncE
5− , runAsyncE
2+module Effectful.Concurrent.Async
3+ ( -- * Concurrent effect
4+ Concurrent
5+ , runConcurrent
66
77 -- * Asynchronous actions
88 , Async
@@ -80,47 +80,33 @@ import qualified Control.Concurrent.Async as A
8080import qualified UnliftIO.Async as U
8181import qualified UnliftIO.Internals.Async as I
8282
83+import Effectful.Concurrent.Internal
8384import Effectful.Internal.Effect
8485import Effectful.Internal.Env
8586import Effectful.Internal.Monad
8687
87−-- | Run 'Eff' operations asynchronously via the @async@ library.
88−--
89−-- /Note:/ thread local state changes in 'Eff' operations run asynchronously
90−-- will not affect the parent thread.
91−--
92−-- /TODO:/ write about 'AsyncE' not respecting scoped operations.
93−data AsyncE :: Effect where
94− AsyncE :: AsyncE m r
95−
96−runAsyncE :: IOE :> es => Eff (AsyncE : es) a -> Eff es a
97−runAsyncE = evalEffect (IdE AsyncE)
98−
99−----------------------------------------
100−-- Operations
101−
10288-- | Lifted 'A.async'.
103−async :: AsyncE :> es => Eff es a -> Eff es (Async a)
89+async :: Concurrent :> es => Eff es a -> Eff es (Async a)
10490async = liftAsync A.async
10591
10692-- | Lifted 'A.asyncBound'.
107−asyncBound :: AsyncE :> es => Eff es a -> Eff es (Async a)
93+asyncBound :: Concurrent :> es => Eff es a -> Eff es (Async a)
10894asyncBound = liftAsync A.asyncBound
10995
11096-- | Lifted 'A.asyncOn'.
111−asyncOn :: AsyncE :> es => Int -> Eff es a -> Eff es (Async a)
97+asyncOn :: Concurrent :> es => Int -> Eff es a -> Eff es (Async a)
11298asyncOn cpu = liftAsync (A.asyncOn cpu)
11399
114100-- | Lifted 'A.asyncWithUnmask'.
115101asyncWithUnmask
116− :: AsyncE :> es
102+ :: Concurrent :> es
117103 => ((forall b. Eff es b -> Eff es b) -> Eff es a)
118104 -> Eff es (Async a)
119105asyncWithUnmask = liftAsyncWithUnmask A.asyncWithUnmask
120106
121107-- | Lifted 'A.asyncOnWithUnmask'.
122108asyncOnWithUnmask
123− :: AsyncE :> es
109+ :: Concurrent :> es
124110 => Int
125111 -> ((forall b. Eff es b -> Eff es b) -> Eff es a)
126112 -> Eff es (Async a)
@@ -128,7 +114,7 @@ asyncOnWithUnmask cpu = liftAsyncWithUnmask (A.asyncOnWithUnmask cpu)
128114
129115-- | Lifted 'A.withAsync'.
130116withAsync
131− :: AsyncE :> es
117+ :: Concurrent :> es
132118 => Eff es a
133119 -> (Async a -> Eff es b)
134120 -> Eff es b
@@ -136,7 +122,7 @@ withAsync = liftWithAsync A.withAsync
136122
137123-- | Lifted 'A.withAsyncBound'.
138124withAsyncBound
139− :: AsyncE :> es
125+ :: Concurrent :> es
140126 => Eff es a
141127 -> (Async a -> Eff es b)
142128 -> Eff es b
@@ -144,7 +130,7 @@ withAsyncBound = liftWithAsync A.withAsyncBound
144130
145131-- | Lifted 'A.withAsyncOn'.
146132withAsyncOn
147− :: AsyncE :> es
133+ :: Concurrent :> es
148134 => Int
149135 -> Eff es a
150136 -> (Async a -> Eff es b)
@@ -153,7 +139,7 @@ withAsyncOn cpu = liftWithAsync (A.withAsyncOn cpu)
153139
154140-- | Lifted 'A.withAsyncWithUnmask'.
155141withAsyncWithUnmask
156− :: AsyncE :> es
142+ :: Concurrent :> es
157143 => ((forall c. Eff es c -> Eff es c) -> Eff es a)
158144 -> (Async a -> Eff es b)
159145 -> Eff es b
@@ -161,7 +147,7 @@ withAsyncWithUnmask = liftWithAsyncWithUnmask A.withAsyncWithUnmask
161147
162148-- | Lifted 'A.withAsyncOnWithUnmask'.
163149withAsyncOnWithUnmask
164− :: AsyncE :> es
150+ :: Concurrent :> es
165151 => Int
166152 -> ((forall c. Eff es c -> Eff es c) -> Eff es a)
167153 -> (Async a -> Eff es b)
@@ -169,60 +155,60 @@ withAsyncOnWithUnmask
169155withAsyncOnWithUnmask cpu = liftWithAsyncWithUnmask (A.withAsyncOnWithUnmask cpu)
170156
171157-- | Lifted 'A.wait'.
172−wait :: AsyncE :> es => Async a -> Eff es a
158+wait :: Concurrent :> es => Async a -> Eff es a
173159wait = unsafeEff_ . A.wait
174160
175161-- | Lifted 'A.poll'.
176162poll
177− :: AsyncE :> es
163+ :: Concurrent :> es
178164 => Async a
179165 -> Eff es (Maybe (Either SomeException a))
180166poll = unsafeEff_ . A.poll
181167
182168-- | Lifted 'A.cancel'.
183−cancel :: AsyncE :> es => Async a -> Eff es ()
169+cancel :: Concurrent :> es => Async a -> Eff es ()
184170cancel = unsafeEff_ . A.cancel
185171
186172-- | Lifted 'A.cancelWith'.
187−cancelWith :: (Exception e, AsyncE :> es) => Async a -> e -> Eff es ()
173+cancelWith :: (Exception e, Concurrent :> es) => Async a -> e -> Eff es ()
188174cancelWith a = unsafeEff_ . A.cancelWith a
189175
190176-- | Lifted 'A.uninterruptibleCancel'.
191−uninterruptibleCancel :: AsyncE :> es => Async a -> Eff es ()
177+uninterruptibleCancel :: Concurrent :> es => Async a -> Eff es ()
192178uninterruptibleCancel = unsafeEff_ . A.uninterruptibleCancel
193179
194180-- | Lifted 'A.waitCatch'.
195181waitCatch
196− :: AsyncE :> es
182+ :: Concurrent :> es
197183 => Async a
198184 -> Eff es (Either SomeException a)
199185waitCatch = unsafeEff_ . A.waitCatch
200186
201187-- | Lifted 'A.waitAny'.
202−waitAny :: AsyncE :> es => [Async a] -> Eff es (Async a, a)
188+waitAny :: Concurrent :> es => [Async a] -> Eff es (Async a, a)
203189waitAny = unsafeEff_ . A.waitAny
204190
205191-- | Lifted 'A.waitAnyCatch'.
206192waitAnyCatch
207− :: AsyncE :> es
193+ :: Concurrent :> es
208194 => [Async a]
209195 -> Eff es (Async a, Either SomeException a)
210196waitAnyCatch = unsafeEff_ . A.waitAnyCatch
211197
212198-- | Lifted 'A.waitAnyCancel'.
213−waitAnyCancel :: AsyncE :> es => [Async a] -> Eff es (Async a, a)
199+waitAnyCancel :: Concurrent :> es => [Async a] -> Eff es (Async a, a)
214200waitAnyCancel = unsafeEff_ . A.waitAnyCancel
215201
216202-- | Lifted 'A.waitAnyCatchCancel'.
217203waitAnyCatchCancel
218− :: AsyncE :> es
204+ :: Concurrent :> es
219205 => [Async a]
220206 -> Eff es (Async a, Either SomeException a)
221207waitAnyCatchCancel = unsafeEff_ . A.waitAnyCatchCancel
222208
223209-- | Lifted 'A.waitEither'.
224210waitEither
225− :: AsyncE :> es
211+ :: Concurrent :> es
226212 => Async a
227213 -> Async b
228214 -> Eff es (Either a b)
@@ -230,7 +216,7 @@ waitEither a b = unsafeEff_ $ A.waitEither a b
230216
231217-- | Lifted 'A.waitEitherCatch'.
232218waitEitherCatch
233− :: AsyncE :> es
219+ :: Concurrent :> es
234220 => Async a
235221 -> Async b
236222 -> Eff es (Either (Either SomeException a) (Either SomeException b))
@@ -238,7 +224,7 @@ waitEitherCatch a b = unsafeEff_ $ A.waitEitherCatch a b
238224
239225-- | Lifted 'A.waitEitherCancel'.
240226waitEitherCancel
241− :: AsyncE :> es
227+ :: Concurrent :> es
242228 => Async a
243229 -> Async b
244230 -> Eff es (Either a b)
@@ -246,53 +232,53 @@ waitEitherCancel a b = unsafeEff_ $ A.waitEitherCancel a b
246232
247233-- | Lifted 'A.waitEitherCatchCancel'.
248234waitEitherCatchCancel
249− :: AsyncE :> es
235+ :: Concurrent :> es
250236 => Async a
251237 -> Async b
252238 -> Eff es (Either (Either SomeException a) (Either SomeException b))
253239waitEitherCatchCancel a b = unsafeEff_ $ A.waitEitherCatch a b
254240
255241-- | Lifted 'A.waitEither_'.
256−waitEither_ :: AsyncE :> es => Async a -> Async b -> Eff es ()
242+waitEither_ :: Concurrent :> es => Async a -> Async b -> Eff es ()
257243waitEither_ a b = unsafeEff_ $ A.waitEither_ a b
258244
259245-- | Lifted 'A.waitBoth'.
260−waitBoth :: AsyncE :> es => Async a -> Async b -> Eff es (a, b)
246+waitBoth :: Concurrent :> es => Async a -> Async b -> Eff es (a, b)
261247waitBoth a b = unsafeEff_ $ A.waitBoth a b
262248
263249-- | Lifted 'A.link'.
264−link :: AsyncE :> es => Async a -> Eff es ()
250+link :: Concurrent :> es => Async a -> Eff es ()
265251link = unsafeEff_ . A.link
266252
267253-- | Lifted 'A.linkOnly'.
268−linkOnly :: AsyncE :> es => (SomeException -> Bool) -> Async a -> Eff es ()
254+linkOnly :: Concurrent :> es => (SomeException -> Bool) -> Async a -> Eff es ()
269255linkOnly f = unsafeEff_ . A.linkOnly f
270256
271257-- | Lifted 'A.link2'.
272−link2 :: AsyncE :> es => Async a -> Async b -> Eff es ()
258+link2 :: Concurrent :> es => Async a -> Async b -> Eff es ()
273259link2 a b = unsafeEff_ $ A.link2 a b
274260
275261-- | Lifted 'A.link2Only'.
276−link2Only :: AsyncE :> es => (SomeException -> Bool) -> Async a -> Async b -> Eff es ()
262+link2Only :: Concurrent :> es => (SomeException -> Bool) -> Async a -> Async b -> Eff es ()
277263link2Only f a b = unsafeEff_ $ A.link2Only f a b
278264
279265-- | Lifted 'A.race'.
280−race :: AsyncE :> es => Eff es a -> Eff es b -> Eff es (Either a b)
266+race :: Concurrent :> es => Eff es a -> Eff es b -> Eff es (Either a b)
281267race ma mb = unsafeEff $ \es -> do
282268 A.race (unEff ma =<< cloneEnv es) (unEff mb =<< cloneEnv es)
283269
284270-- | Lifted 'A.race_'.
285−race_ :: AsyncE :> es => Eff es a -> Eff es b -> Eff es ()
271+race_ :: Concurrent :> es => Eff es a -> Eff es b -> Eff es ()
286272race_ ma mb = unsafeEff $ \es -> do
287273 A.race_ (unEff ma =<< cloneEnv es) (unEff mb =<< cloneEnv es)
288274
289275-- | Lifted 'A.concurrently'.
290−concurrently :: AsyncE :> es => Eff es a -> Eff es b -> Eff es (a, b)
276+concurrently :: Concurrent :> es => Eff es a -> Eff es b -> Eff es (a, b)
291277concurrently ma mb = unsafeEff $ \es -> do
292278 A.concurrently (unEff ma =<< cloneEnv es) (unEff mb =<< cloneEnv es)
293279
294280-- | Lifted 'A.concurrently_'.
295−concurrently_ :: AsyncE :> es => Eff es a -> Eff es b -> Eff es ()
281+concurrently_ :: Concurrent :> es => Eff es a -> Eff es b -> Eff es ()
296282concurrently_ ma mb = unsafeEff $ \es -> do
297283 A.concurrently_ (unEff ma =<< cloneEnv es) (unEff mb =<< cloneEnv es)
298284
@@ -302,7 +288,7 @@ concurrently_ ma mb = unsafeEff $ \es -> do
302288
303289-- | Lifted 'A.mapConcurrently'.
304290mapConcurrently
305− :: (Traversable f, AsyncE :> es)
291+ :: (Traversable f, Concurrent :> es)
306292 => (a -> Eff es b)
307293 -> f a
308294 -> Eff es (f b)
@@ -311,7 +297,7 @@ mapConcurrently f t = unsafeEff $ \es -> do
311297
312298-- | Lifted 'A.mapConcurrently_'.
313299mapConcurrently_
314− :: (Foldable f, AsyncE :> es)
300+ :: (Foldable f, Concurrent :> es)
315301 => (a -> Eff es b)
316302 -> f a
317303 -> Eff es ()
@@ -320,7 +306,7 @@ mapConcurrently_ f t = unsafeEff $ \es -> do
320306
321307-- | Lifted 'A.forConcurrently'.
322308forConcurrently
323− :: (Traversable f, AsyncE :> es)
309+ :: (Traversable f, Concurrent :> es)
324310 => f a
325311 -> (a -> Eff es b)
326312 -> Eff es (f b)
@@ -329,7 +315,7 @@ forConcurrently t f = unsafeEff $ \es -> do
329315
330316-- | Lifted 'A.forConcurrently_'.
331317forConcurrently_
332− :: (Foldable f, AsyncE :> es)
318+ :: (Foldable f, Concurrent :> es)
333319 => f a
334320 -> (a -> Eff es b)
335321 -> Eff es ()
@@ -337,12 +323,12 @@ forConcurrently_ t f = unsafeEff $ \es -> do
337323 U.forConcurrently_ t (\a -> unEff (f a) =<< cloneEnv es)
338324
339325-- | Lifted 'A.replicateConcurrently'.
340−replicateConcurrently :: AsyncE :> es => Int -> Eff es a -> Eff es [a]
326+replicateConcurrently :: Concurrent :> es => Int -> Eff es a -> Eff es [a]
341327replicateConcurrently n f = unsafeEff $ \es -> do
342328 U.replicateConcurrently n (unEff f =<< cloneEnv es)
343329
344330-- | Lifted 'A.replicateConcurrently_'.
345−replicateConcurrently_ :: AsyncE :> es => Int -> Eff es a -> Eff es ()
331+replicateConcurrently_ :: Concurrent :> es => Int -> Eff es a -> Eff es ()
346332replicateConcurrently_ n f = unsafeEff $ \es -> do
347333 U.replicateConcurrently_ n (unEff f =<< cloneEnv es)
348334
@@ -351,7 +337,7 @@ replicateConcurrently_ n f = unsafeEff $ \es -> do
351337
352338-- | Lifted 'U.pooledMapConcurrentlyN'.
353339pooledMapConcurrentlyN
354− :: (AsyncE :> es, Traversable t)
340+ :: (Concurrent :> es, Traversable t)
355341 => Int
356342 -> (a -> Eff es b)
357343 -> t a
@@ -361,7 +347,7 @@ pooledMapConcurrentlyN threads f t = unsafeEff $ \es -> do
361347
362348-- | Lifted 'U.pooledMapConcurrently'.
363349pooledMapConcurrently
364− :: (AsyncE :> es, Traversable t)
350+ :: (Concurrent :> es, Traversable t)
365351 => (a -> Eff es b)
366352 -> t a
367353 -> Eff es (t b)
@@ -370,7 +356,7 @@ pooledMapConcurrently f t = unsafeEff $ \es -> do
370356
371357-- | Lifted 'U.pooledMapConcurrentlyN'.
372358pooledMapConcurrentlyN_
373− :: (AsyncE :> es, Foldable f)
359+ :: (Concurrent :> es, Foldable f)
374360 => Int
375361 -> (a -> Eff es b)
376362 -> f a
@@ -380,7 +366,7 @@ pooledMapConcurrentlyN_ threads f t = unsafeEff $ \es -> do
380366
381367-- | Lifted 'U.pooledMapConcurrently_'.
382368pooledMapConcurrently_
383− :: (AsyncE :> es, Foldable f)
369+ :: (Concurrent :> es, Foldable f)
384370 => (a -> Eff es b)
385371 -> f a
386372 -> Eff es ()
@@ -389,7 +375,7 @@ pooledMapConcurrently_ f t = unsafeEff $ \es -> do
389375
390376-- | Lifted 'U.pooledForConcurrentlyN'.
391377pooledForConcurrentlyN
392− :: (AsyncE :> es, Traversable t)
378+ :: (Concurrent :> es, Traversable t)
393379 => Int
394380 -> t a
395381 -> (a -> Eff es b)
@@ -399,7 +385,7 @@ pooledForConcurrentlyN threads t f = unsafeEff $ \es -> do
399385
400386-- | Lifted 'U.pooledForConcurrently'.
401387pooledForConcurrently
402− :: (AsyncE :> es, Traversable t)
388+ :: (Concurrent :> es, Traversable t)
403389 => t a
404390 -> (a -> Eff es b)
405391 -> Eff es (t b)
@@ -408,7 +394,7 @@ pooledForConcurrently t f = unsafeEff $ \es -> do
408394
409395-- | Lifted 'U.pooledForConcurrentlyN'.
410396pooledForConcurrentlyN_
411− :: (AsyncE :> es, Foldable f)
397+ :: (Concurrent :> es, Foldable f)
412398 => Int
413399 -> f a
414400 -> (a -> Eff es b)
@@ -418,7 +404,7 @@ pooledForConcurrentlyN_ threads t f = unsafeEff $ \es -> do
418404
419405-- | Lifted 'U.pooledForConcurrently_'.
420406pooledForConcurrently_
421− :: (AsyncE :> es, Foldable f)
407+ :: (Concurrent :> es, Foldable f)
422408 => f a
423409 -> (a -> Eff es b)
424410 -> Eff es ()
@@ -426,22 +412,22 @@ pooledForConcurrently_ t f = unsafeEff $ \es -> do
426412 U.pooledForConcurrently_ t (\a -> unEff (f a) =<< cloneEnv es)
427413
428414-- | Lifted 'U.pooledReplicateConcurrentlyN'.
429−pooledReplicateConcurrentlyN :: AsyncE :> es => Int -> Int -> Eff es a -> Eff es [a]
415+pooledReplicateConcurrentlyN :: Concurrent :> es => Int -> Int -> Eff es a -> Eff es [a]
430416pooledReplicateConcurrentlyN threads n f = unsafeEff $ \es -> do
431417 U.pooledReplicateConcurrentlyN threads n (unEff f =<< cloneEnv es)
432418
433419-- | Lifted 'U.pooledReplicateConcurrently'.
434−pooledReplicateConcurrently :: AsyncE :> es => Int -> Eff es a -> Eff es [a]
420+pooledReplicateConcurrently :: Concurrent :> es => Int -> Eff es a -> Eff es [a]
435421pooledReplicateConcurrently n f = unsafeEff $ \es -> do
436422 U.pooledReplicateConcurrently n (unEff f =<< cloneEnv es)
437423
438424-- | Lifted 'U.pooledReplicateConcurrentlyN_'.
439−pooledReplicateConcurrentlyN_ :: AsyncE :> es => Int -> Int -> Eff es a -> Eff es ()
425+pooledReplicateConcurrentlyN_ :: Concurrent :> es => Int -> Int -> Eff es a -> Eff es ()
440426pooledReplicateConcurrentlyN_ threads n f = unsafeEff $ \es -> do
441427 U.pooledReplicateConcurrentlyN_ threads n (unEff f =<< cloneEnv es)
442428
443429-- | Lifted 'U.pooledReplicateConcurrently_'.
444−pooledReplicateConcurrently_ :: AsyncE :> es => Int -> Eff es a -> Eff es ()
430+pooledReplicateConcurrently_ :: Concurrent :> es => Int -> Eff es a -> Eff es ()
445431pooledReplicateConcurrently_ n f = unsafeEff $ \es -> do
446432 U.pooledReplicateConcurrently_ n (unEff f =<< cloneEnv es)
447433
@@ -481,7 +467,7 @@ conc :: Eff es a -> Conc es a
481467conc = Action
482468
483469-- | Lifted 'U.runConc'.
484−runConc :: AsyncE :> es => Conc es a -> Eff es a
470+runConc :: Concurrent :> es => Conc es a -> Eff es a
485471runConc m = unsafeEff $ \es -> U.runConc (unliftConc es m)
486472 where
487473 unliftConc :: Env es -> Conc es a -> U.Conc IO a
@@ -502,20 +488,20 @@ newtype Concurrently es a = Concurrently { runConcurrently :: Eff es a }
502488instance Functor (Concurrently es) where
503489 fmap f (Concurrently a) = Concurrently (fmap f a)
504490
505−instance AsyncE :> es => Applicative (Concurrently es) where
491+instance Concurrent :> es => Applicative (Concurrently es) where
506492 pure = Concurrently . pure
507493 Concurrently fs <*> Concurrently as =
508494 Concurrently ((\(f, a) -> f a) <$> concurrently fs as)
509495
510−instance AsyncE :> es => Alternative (Concurrently es) where
496+instance Concurrent :> es => Alternative (Concurrently es) where
511497 empty = Concurrently . unsafeEff_ . forever $ threadDelay maxBound
512498 Concurrently as <|> Concurrently bs =
513499 Concurrently (either id id <$> race as bs)
514500
515−instance (AsyncE :> es, Semigroup a) => Semigroup (Concurrently es a) where
501+instance (Concurrent :> es, Semigroup a) => Semigroup (Concurrently es a) where
516502 (<>) = liftA2 (<>)
517503
518−instance (AsyncE :> es, Monoid a) => Monoid (Concurrently es a) where
504+instance (Concurrent :> es, Monoid a) => Monoid (Concurrently es a) where
519505 mempty = pure mempty
520506
521507----------------------------------------