From 894908377f0ee5cf626a6bdd8c4fdd29411b8e80 Mon Sep 17 00:00:00 2001
From: Jens Nolte <git@queezle.net>
Date: Mon, 9 Aug 2021 20:20:41 +0200
Subject: [PATCH] Rename AsyncTask to Task

---
 src/Quasar/Core.hs       | 44 ++++++++++++++++++++--------------------
 src/Quasar/Observable.hs | 12 +++++------
 2 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/src/Quasar/Core.hs b/src/Quasar/Core.hs
index 0b3b5c9..d809050 100644
--- a/src/Quasar/Core.hs
+++ b/src/Quasar/Core.hs
@@ -10,11 +10,11 @@ module Quasar.Core (
   defaultResourceManagerConfiguration,
   unlimitedResourceManagerConfiguration,
 
-  -- * AsyncTask
-  AsyncTask,
+  -- * Task
+  Task,
   cancelTask,
   cancelTaskIO,
-  toAsyncTask,
+  toTask,
   successfulTask,
 
   -- * AsyncIO
@@ -53,11 +53,11 @@ newtype AsyncIO a = AsyncIO (ReaderT ResourceManager IO a)
 
 
 -- | Run the synchronous part of an `AsyncIO` and then return an `Awaitable` that can be used to wait for completion of the synchronous part.
-async :: HasResourceManager m => AsyncIO r -> m (AsyncTask r)
+async :: HasResourceManager m => AsyncIO r -> m (Task r)
 async action = asyncWithUnmask (\unmask -> unmask action)
 
 -- | Run the synchronous part of an `AsyncIO` and then return an `Awaitable` that can be used to wait for completion of the synchronous part.
-asyncWithUnmask :: HasResourceManager m => ((forall a. AsyncIO a -> AsyncIO a) -> AsyncIO r) -> m (AsyncTask r)
+asyncWithUnmask :: HasResourceManager m => ((forall a. AsyncIO a -> AsyncIO a) -> AsyncIO r) -> m (Task r)
 -- TODO resource limits
 asyncWithUnmask action = do
   resourceManager <- askResourceManager
@@ -66,7 +66,7 @@ asyncWithUnmask action = do
     void $ forkIOWithUnmask $ \unmask -> do
       result <- try $ runOnResourceManager resourceManager (action (liftUnmask unmask))
       putAsyncVarEither_ resultVar result
-    pure $ AsyncTask (toAwaitable resultVar)
+    pure $ Task (toAwaitable resultVar)
 
 liftUnmask :: (IO a -> IO a) -> AsyncIO a -> AsyncIO a
 liftUnmask unmask action = do
@@ -104,34 +104,34 @@ instance IsDisposable ResourceManager where
 -- The result (or exception) can be aquired by using the `Awaitable` class (e.g. by calling `await` or `awaitIO`).
 -- It might be possible to cancel the task by using the `Disposable` class if the operation has not been completed.
 -- If the result is no longer required the task should be cancelled, to avoid leaking memory.
-newtype AsyncTask r = AsyncTask (Awaitable r)
+newtype Task r = Task (Awaitable r)
 
-instance IsAwaitable r (AsyncTask r) where
-  toAwaitable (AsyncTask awaitable) = awaitable
+instance IsAwaitable r (Task r) where
+  toAwaitable (Task awaitable) = awaitable
 
-instance IsDisposable (AsyncTask r) where
+instance IsDisposable (Task r) where
   dispose = undefined
 
-instance Functor AsyncTask where
-  fmap fn (AsyncTask x) = AsyncTask (fn <$> x)
+instance Functor Task where
+  fmap fn (Task x) = Task (fn <$> x)
 
-instance Applicative AsyncTask where
-  pure = AsyncTask . pure
-  liftA2 fn (AsyncTask fx) (AsyncTask fy) = AsyncTask $ liftA2 fn fx fy
+instance Applicative Task where
+  pure = Task . pure
+  liftA2 fn (Task fx) (Task fy) = Task $ liftA2 fn fx fy
 
-cancelTask :: AsyncTask r -> IO (Awaitable ())
+cancelTask :: Task r -> IO (Awaitable ())
 cancelTask = dispose
 
-cancelTaskIO :: AsyncTask r -> IO ()
+cancelTaskIO :: Task r -> IO ()
 cancelTaskIO = awaitIO <=< dispose
 
--- | Creates an `AsyncTask` from an `Awaitable`.
+-- | Creates an `Task` from an `Awaitable`.
 -- The resulting task only depends on an external resource, so disposing it has no effect.
-toAsyncTask :: IsAwaitable r a => a -> AsyncTask r
-toAsyncTask = AsyncTask . toAwaitable
+toTask :: IsAwaitable r a => a -> Task r
+toTask = Task . toAwaitable
 
-successfulTask :: r -> AsyncTask r
-successfulTask = AsyncTask . successfulAwaitable
+successfulTask :: r -> Task r
+successfulTask = Task . successfulAwaitable
 
 
 
diff --git a/src/Quasar/Observable.hs b/src/Quasar/Observable.hs
index 63cf838..73cfd90 100644
--- a/src/Quasar/Observable.hs
+++ b/src/Quasar/Observable.hs
@@ -71,7 +71,7 @@ instance Applicative ObservableMessage where
 
 
 class IsRetrievable v a | a -> v where
-  retrieve :: HasResourceManager m => a -> m (AsyncTask v)
+  retrieve :: HasResourceManager m => a -> m (Task v)
 
 retrieveIO :: IsRetrievable v a => a -> IO v
 retrieveIO x = awaitIO =<< withDefaultResourceManager (retrieve x)
@@ -94,7 +94,7 @@ type ObservableCallback v = ObservableMessage v -> IO ()
 
 
 instance IsRetrievable v o => IsRetrievable v (IO o) where
-  retrieve :: HasResourceManager m => IO o -> m (AsyncTask v)
+  retrieve :: HasResourceManager m => IO o -> m (Task v)
   retrieve = retrieve <=< liftIO
 
 instance IsObservable v o => IsObservable v (IO o) where
@@ -191,7 +191,7 @@ instance IsDisposable JoinedObservableState where
 
 newtype JoinedObservable o = JoinedObservable o
 instance forall v o i. (IsRetrievable i o, IsRetrievable v i) => IsRetrievable v (JoinedObservable o) where
-  retrieve :: HasResourceManager m => JoinedObservable o -> m (AsyncTask v)
+  retrieve :: HasResourceManager m => JoinedObservable o -> m (Task v)
   retrieve (JoinedObservable outer) = async $ await =<< retrieve =<< await =<< retrieve outer
 instance forall v o i. (IsObservable i o, IsObservable v i) => IsObservable v (JoinedObservable o) where
   observe :: JoinedObservable o -> (ObservableMessage v -> IO ()) -> IO Disposable
@@ -283,7 +283,7 @@ mergeObservableMaybe merge x y = Observable $ MergedObservable (liftA2 merge) x
 
 
 data FnObservable v = FnObservable {
-  retrieveFn :: forall m. HasResourceManager m => m (AsyncTask v),
+  retrieveFn :: forall m. HasResourceManager m => m (Task v),
   observeFn :: (ObservableMessage v -> IO ()) -> IO Disposable
 }
 instance IsRetrievable v (FnObservable v) where
@@ -298,7 +298,7 @@ instance IsObservable v (FnObservable v) where
 -- | Implement an Observable by directly providing functions for `retrieve` and `subscribe`.
 fnObservable
   :: ((ObservableMessage v -> IO ()) -> IO Disposable)
-  -> (forall m. HasResourceManager m => m (AsyncTask v))
+  -> (forall m. HasResourceManager m => m (Task v))
   -> Observable v
 fnObservable observeFn retrieveFn = toObservable FnObservable{observeFn, retrieveFn}
 
@@ -309,7 +309,7 @@ synchronousFnObservable
   -> Observable v
 synchronousFnObservable observeFn synchronousRetrieveFn = fnObservable observeFn retrieveFn
   where
-    retrieveFn :: (forall m. HasResourceManager m => m (AsyncTask v))
+    retrieveFn :: (forall m. HasResourceManager m => m (Task v))
     retrieveFn = liftIO $ successfulTask <$> synchronousRetrieveFn
 
 
-- 
GitLab