Replace all instances of `return` with `pure`

Due to the accepted "monad of no return" proposal, return becomes an
alias for pure. Return can be a pitfall for newcomers, so we decided to
use pure instead.

src/Data/Observable.hs

@@ -73,13 +73,13 @@ data Disposable
 
 instance IsDisposable Disposable where
   dispose (SomeDisposable x) = dispose x
-  dispose (FunctionDisposable fn) = fn (return ())
+  dispose (FunctionDisposable fn) = fn (pure ())
   dispose d@(MultiDisposable _) = waitFor' $ dispose' d
-  dispose DummyDisposable = return ()
+  dispose DummyDisposable = pure ()
   dispose_ (SomeDisposable x) = dispose_ x
-  dispose_ (FunctionDisposable fn) = fn (return ())
+  dispose_ (FunctionDisposable fn) = fn (pure ())
   dispose_ d@(MultiDisposable _) = waitFor' $ dispose' d
-  dispose_ DummyDisposable = return ()
+  dispose_ DummyDisposable = pure ()
   dispose' (SomeDisposable x) = dispose' x
   dispose' (FunctionDisposable fn) = fn
   dispose' (MultiDisposable xs) = \disposeCallback -> do
@@ -91,7 +91,7 @@ instance IsDisposable Disposable where
       startDispose disposable = do
         mvar <- newEmptyMVar
         dispose' disposable (callback mvar)
-        return (mvar :: MVar ())
+        pure (mvar :: MVar ())
       callback :: MVar () -> IO ()
       callback mvar = do
         success <- tryPutMVar mvar ()
@@ -104,7 +104,7 @@ class IsDisposable a where
   dispose = waitFor' . dispose'
   -- | Dispose a resource. Returns without waiting for the resource to be released.
   dispose_ :: a -> IO ()
-  dispose_ disposable = dispose' disposable (return ())
+  dispose_ disposable = dispose' disposable (pure ())
   -- | Dispose a resource. When the resource has been released the callback is invoked.
   dispose' :: a -> IO () -> IO ()
 instance IsDisposable a => IsDisposable (Maybe a) where
@@ -124,7 +124,7 @@ class IsGettable v o => IsObservable v o | o -> v where
   toObservable :: o -> Observable v
   toObservable = Observable
   mapObservable :: (v -> a) -> o -> Observable a
-  mapObservable f = mapObservableM (return . f)
+  mapObservable f = mapObservableM (pure . f)
   mapObservableM :: (v -> IO a) -> o -> Observable a
   mapObservableM f = Observable . MappedObservable f
 
@@ -133,7 +133,7 @@ instance IsGettable a ((a -> IO ()) -> IO ()) where
 
 -- | Variant of `getValue` that throws exceptions instead of returning them.
 unsafeGetValue :: (Exception e, IsObservable (Either e v) o) => o -> IO v
-unsafeGetValue = either throwIO return <=< getValue
+unsafeGetValue = either throwIO pure <=< getValue
 
 -- | A variant of `subscribe` that passes the `Disposable` to the callback.
 subscribe' :: IsObservable v o => o -> (Disposable -> ObservableMessage v -> IO ()) -> IO Disposable
@@ -195,18 +195,18 @@ instance IsObservable v (ObservableVar v) where
     modifyMVar_ mvar $ \(state, subscribers) -> do
       -- Call listener
       callback (Current, state)
-      return (state, HM.insert key callback subscribers)
-    return $ FunctionDisposable (disposeFn key)
+      pure (state, HM.insert key callback subscribers)
+    pure $ FunctionDisposable (disposeFn key)
     where
       disposeFn :: Unique -> IO () -> IO ()
       disposeFn key disposeCallback = do
-        modifyMVar_ mvar (\(state, subscribers) -> return (state, HM.delete key subscribers))
+        modifyMVar_ mvar (\(state, subscribers) -> pure (state, HM.delete key subscribers))
         disposeCallback
 
 instance IsSettable v (ObservableVar v) where
   setValue (ObservableVar mvar) value = modifyMVar_ mvar $ \(_, subscribers) -> do
     mapM_ (\callback -> callback (Update, value)) subscribers
-    return (value, subscribers)
+    pure (value, subscribers)
 
 
 newObservableVar :: v -> IO (ObservableVar v)
@@ -219,14 +219,14 @@ modifyObservableVar (ObservableVar mvar) f =
   modifyMVar mvar $ \(oldState, subscribers) -> do
     (newState, result) <- f oldState
     mapM_ (\callback -> callback (Update, newState)) subscribers
-    return ((newState, subscribers), result)
+    pure ((newState, subscribers), result)
 
 modifyObservableVar_ :: ObservableVar v -> (v -> IO v) -> IO ()
 modifyObservableVar_ (ObservableVar mvar) f =
   modifyMVar_ mvar $ \(oldState, subscribers) -> do
     newState <- f oldState
     mapM_ (\callback -> callback (Update, newState)) subscribers
-    return (newState, subscribers)
+    pure (newState, subscribers)
 
 withObservableVar :: ObservableVar a -> (a -> IO b) -> IO b
 withObservableVar (ObservableVar mvar) f = withMVar mvar (f . fst)
@@ -246,7 +246,7 @@ instance forall o i v. (IsObservable i o, IsObservable v i) => IsObservable v (J
   subscribe (JoinedObservable outer) callback = do
     innerSubscriptionMVar <- newMVar DummyDisposable
     outerSubscription <- subscribe outer (outerCallback innerSubscriptionMVar)
-    return $ FunctionDisposable (\disposeCallback -> dispose' outerSubscription (readMVar innerSubscriptionMVar >>= \innerSubscription -> dispose' innerSubscription disposeCallback))
+    pure $ FunctionDisposable (\disposeCallback -> dispose' outerSubscription (readMVar innerSubscriptionMVar >>= \innerSubscription -> dispose' innerSubscription disposeCallback))
       where
         outerCallback innerSubscriptionMVar = outerCallback'
           where
@@ -279,20 +279,20 @@ instance forall o0 v0 o1 v1 r. (IsGettable v0 o0, IsGettable v1 o1) => IsGettabl
   getValue (MergedObservable merge obs0 obs1) = do
     x0 <- getValue obs0
     x1 <- getValue obs1
-    return $ merge x0 x1
+    pure $ merge x0 x1
 instance forall o0 v0 o1 v1 r. (IsObservable v0 o0, IsObservable v1 o1) => IsObservable r (MergedObservable o0 v0 o1 v1 r) where
   subscribe (MergedObservable merge obs0 obs1) callback = do
     currentValuesTupleRef <- newIORef (Nothing, Nothing)
     sub0 <- subscribe obs0 (mergeCallback currentValuesTupleRef . fmap Left)
     sub1 <- subscribe obs1 (mergeCallback currentValuesTupleRef . fmap Right)
-    return $ MultiDisposable [sub0, sub1]
+    pure $ MultiDisposable [sub0, sub1]
     where
       mergeCallback :: IORef (Maybe v0, Maybe v1) -> (MessageReason, Either v0 v1) -> IO ()
       mergeCallback currentValuesTupleRef (reason, state) = do
         currentTuple <- atomicModifyIORef' currentValuesTupleRef ((\x -> (x, x)) . updateTuple state)
         case currentTuple of
           (Just l, Just r) -> callback (reason, uncurry merge (l, r))
-          _ -> return () -- Start only once both values have been received
+          _ -> pure () -- Start only once both values have been received
       updateTuple :: Either v0 v1 -> (Maybe v0, Maybe v1) -> (Maybe v0, Maybe v1)
       updateTuple (Left l) (_, r) = (Just l, r)
       updateTuple (Right r) (l, _) = (l, Just r)
@@ -326,11 +326,11 @@ instance IsObservable v (FnObservable v) where
 
 newtype ConstObservable a = ConstObservable a
 instance IsGettable a (ConstObservable a) where
-  getValue (ConstObservable x) = return x
+  getValue (ConstObservable x) = pure x
 instance IsObservable a (ConstObservable a) where
   subscribe (ConstObservable x) callback = do
     callback (Current, x)
-    return DummyDisposable
+    pure DummyDisposable
 -- | Create an observable that contains a constant value.
 constObservable :: a -> Observable a
 constObservable = Observable . ConstObservable

src/Data/Observable/ObservableHashMap.hs

@@ -48,10 +48,10 @@ instance IsObservable (HM.HashMap k v) (ObservableHashMap k v) where
         callback (Current, toHashMap handle)
         unique <- newUnique
         let handle' = handle & set (_subscribers . at unique) (Just callback)
-        return (handle', FunctionDisposable $ unsubscribe unique)
+        pure (handle', FunctionDisposable $ unsubscribe unique)
       unsubscribe :: Unique -> IO () -> IO ()
       unsubscribe unique unsubscribedCallback = do
-        modifyHandle_ (return . set (_subscribers . at unique) Nothing) ohm
+        modifyHandle_ (pure . set (_subscribers . at unique) Nothing) ohm
         unsubscribedCallback
 
 instance IsDeltaObservable k v (ObservableHashMap k v) where
@@ -62,10 +62,10 @@ instance IsDeltaObservable k v (ObservableHashMap k v) where
         callback (Reset $ toHashMap handle)
         unique <- newUnique
         let handle' = handle & set (_deltaSubscribers . at unique) (Just callback)
-        return (handle', FunctionDisposable $ unsubscribe unique)
+        pure (handle', FunctionDisposable $ unsubscribe unique)
       unsubscribe :: Unique -> IO () -> IO ()
       unsubscribe unique unsubscribedCallback = do
-        modifyHandle_ (return . set (_deltaSubscribers . at unique) Nothing) ohm
+        modifyHandle_ (pure . set (_deltaSubscribers . at unique) Nothing) ohm
         unsubscribedCallback
 
 
@@ -99,16 +99,16 @@ modifyKeyHandleNotifying :: (Eq k, Hashable k) => (KeyHandle v -> IO (KeyHandle
 modifyKeyHandleNotifying f k = modifyHandle $ \handle -> do
   (newHandle, (delta, result)) <- updateKeyHandle f k handle
   notifySubscribers newHandle delta
-  return (newHandle, result)
+  pure (newHandle, result)
 
 modifyKeyHandleNotifying_ :: (Eq k, Hashable k) => (KeyHandle v -> IO (KeyHandle v, Maybe (Delta k v))) -> k -> ObservableHashMap k v -> IO ()
 modifyKeyHandleNotifying_ f k = modifyHandle_ $ \handle -> do
   (newHandle, delta) <- updateKeyHandle f k handle
   notifySubscribers newHandle delta
-  return newHandle
+  pure newHandle
 
 notifySubscribers :: Handle k v -> Maybe (Delta k v) -> IO ()
-notifySubscribers _ Nothing = return ()
+notifySubscribers _ Nothing = pure ()
 notifySubscribers handle@Handle{deltaSubscribers, subscribers} (Just delta) = do
   mapM_ ($ delta) $ HM.elems deltaSubscribers
   mapM_ ($ (Update, toHashMap handle)) $ HM.elems subscribers
@@ -128,15 +128,15 @@ observeKey key ohm@(ObservableHashMap mvar) = Observable FnObservable{getValueFn
     subscribeFn callback = do
       subscriptionKey <- newUnique
       modifyKeyHandle_ (subscribeFn' subscriptionKey) key ohm
-      return $ FunctionDisposable $ unsubscribe subscriptionKey
+      pure $ FunctionDisposable $ unsubscribe subscriptionKey
       where
         subscribeFn' :: Unique -> KeyHandle v -> IO (KeyHandle v)
         subscribeFn' subKey keyHandle@KeyHandle{value} = do
           callback (Current, value)
-          return $ modifyKeySubscribers (HM.insert subKey callback) keyHandle
+          pure $ modifyKeySubscribers (HM.insert subKey callback) keyHandle
         unsubscribe :: Unique -> IO () -> IO ()
         unsubscribe subKey unsubscribedCallback = do
-          modifyKeyHandle_ (return . modifyKeySubscribers (HM.delete subKey)) key ohm
+          modifyKeyHandle_ (pure . modifyKeySubscribers (HM.delete subKey)) key ohm
           unsubscribedCallback
 
 insert :: forall k v. (Eq k, Hashable k) => k -> v -> ObservableHashMap k v -> IO ()
@@ -145,7 +145,7 @@ insert key value = modifyKeyHandleNotifying_ fn key
     fn :: KeyHandle v -> IO (KeyHandle v, Maybe (Delta k v))
     fn keyHandle@KeyHandle{keySubscribers} = do
       mapM_ ($ (Update, Just value)) $ HM.elems keySubscribers
-      return (keyHandle{value=Just value}, Just (Insert key value))
+      pure (keyHandle{value=Just value}, Just (Insert key value))
 
 delete :: forall k v. (Eq k, Hashable k) => k -> ObservableHashMap k v -> IO ()
 delete key = modifyKeyHandleNotifying_ fn key
@@ -154,12 +154,12 @@ delete key = modifyKeyHandleNotifying_ fn key
     fn keyHandle@KeyHandle{value=oldValue, keySubscribers} = do
       mapM_ ($ (Update, Nothing)) $ HM.elems keySubscribers
       let delta = if isJust oldValue then Just (Delete key) else Nothing
-      return (keyHandle{value=Nothing}, delta)
+      pure (keyHandle{value=Nothing}, delta)
 
 lookup :: forall k v. (Eq k, Hashable k) => k -> ObservableHashMap k v -> IO (Maybe v)
 lookup key (ObservableHashMap mvar) = do
   Handle{keyHandles} <- readMVar mvar
-  return $ join $ value <$> HM.lookup key keyHandles
+  pure $ join $ value <$> HM.lookup key keyHandles
 
 lookupDelete :: forall k v. (Eq k, Hashable k) => k -> ObservableHashMap k v -> IO (Maybe v)
 lookupDelete key = modifyKeyHandleNotifying fn key
@@ -168,4 +168,4 @@ lookupDelete key = modifyKeyHandleNotifying fn key
     fn keyHandle@KeyHandle{value=oldValue, keySubscribers} = do
       mapM_ ($ (Update, Nothing)) $ HM.elems keySubscribers
       let delta = if isJust oldValue then Just (Delete key) else Nothing
-      return (keyHandle{value=Nothing}, (delta, oldValue))
+      pure (keyHandle{value=Nothing}, (delta, oldValue))

src/Data/Observable/ObservablePriority.hs

@@ -32,12 +32,12 @@ instance IsObservable (Maybe v) (ObservablePriority p v) where
     modifyMVar_ mvar $ \internals@Internals{subscribers} -> do
       -- Call listener
       callback (Current, currentValue internals)
-      return internals{subscribers = HM.insert key callback subscribers}
-    return $ FunctionDisposable (unsubscribe key)
+      pure internals{subscribers = HM.insert key callback subscribers}
+    pure $ FunctionDisposable (unsubscribe key)
     where
       unsubscribe :: Unique -> IO () -> IO ()
       unsubscribe key disposeCallback = do
-        modifyMVar_ mvar $ \internals@Internals{subscribers} -> return internals{subscribers=HM.delete key subscribers}
+        modifyMVar_ mvar $ \internals@Internals{subscribers} -> pure internals{subscribers=HM.delete key subscribers}
         disposeCallback
 
 type PriorityMap p v = HM.HashMap p (NonEmpty (Entry v))
@@ -65,15 +65,15 @@ insertValue :: forall p v. (Ord p, Hashable p) => ObservablePriority p v -> p ->
 insertValue (ObservablePriority mvar) priority value = modifyMVar mvar $ \internals -> do
   key <- newUnique
   newInternals <- insertValue' key internals
-  return (newInternals, FunctionDisposable (\callback -> removeValue key >> callback))
+  pure (newInternals, FunctionDisposable (\callback -> removeValue key >> callback))
   where
     insertValue' :: Unique -> Internals p v -> IO (Internals p v)
     insertValue' key internals@Internals{priorityMap, current}
       | hasToUpdateCurrent current = do
         let newInternals = internals{priorityMap=insertEntry priorityMap, current=Just (key, priority, value)}
         notifySubscribers newInternals
-        return newInternals
-      | otherwise = return $ internals{priorityMap=insertEntry priorityMap}
+        pure newInternals
+      | otherwise = pure internals{priorityMap=insertEntry priorityMap}
       where
         insertEntry :: PriorityMap p v -> PriorityMap p v
         insertEntry = HM.alter addToEntryList priority
@@ -95,7 +95,7 @@ insertValue (ObservablePriority mvar) priority value = modifyMVar mvar $ \intern
           let newInternals = internals{priorityMap = removeEntry priorityMap}
           if hasToUpdateCurrent current
             then updateCurrent newInternals
-            else return newInternals
+            else pure newInternals
 
         removeEntry :: PriorityMap p v -> PriorityMap p v
         removeEntry = HM.alter removeEntryFromList priority
@@ -107,7 +107,7 @@ insertValue (ObservablePriority mvar) priority value = modifyMVar mvar $ \intern
         updateCurrent internals@Internals{priorityMap} = do
           let newInternals = internals{current = selectCurrent $ HM.toList priorityMap}
           notifySubscribers newInternals
-          return newInternals
+          pure newInternals
         selectCurrent :: [(p, (NonEmpty (Entry v)))] -> Maybe (Unique, p, v)
         selectCurrent [] = Nothing
         selectCurrent list = Just . selectCurrentFromList . maximumBy (comparing fst) $ list

src/Quasar/Prelude.hs

@@ -126,4 +126,4 @@ traceShowIO = traceIO . show
 
 {-# DEPRECATED traceShowIdIO "Trace." #-}
 traceShowIdIO :: (Control.Monad.IO.Class.MonadIO m, Show a) => a -> m a
-traceShowIdIO a = traceShowIO a >> return a
+traceShowIdIO a = traceShowIO a >> pure a