Remove some redundant definitions/constraints

Starting with GHC 7.10 and base-4.8, `Monad` implies `Applicative`,
which allows to simplify some definitions to exploit the superclass
relationship. This a first refactoring to that end.

46 files changed, 10 insertions, 60 deletions

diff --git a/compiler/basicTypes/UniqSupply.hs b/compiler/basicTypes/UniqSupply.hs
index 16734bc78f..e7e44cad9d 100644
--- a/compiler/basicTypes/UniqSupply.hs
+++ b/compiler/basicTypes/UniqSupply.hs
@@ -127,7 +127,6 @@ splitUniqSupply4 us = (us1, us2, us3, us4)
 newtype UniqSM result = USM { unUSM :: UniqSupply -> (# result, UniqSupply #) }
 
 instance Monad UniqSM where
-  return = pure
   (>>=) = thenUs
   (>>)  = (*>)
 
diff --git a/compiler/cmm/CmmLint.hs b/compiler/cmm/CmmLint.hs
index 3f85053514..015337bdad 100644
--- a/compiler/cmm/CmmLint.hs
+++ b/compiler/cmm/CmmLint.hs
@@ -222,7 +222,6 @@ instance Monad CmmLint where
                                 case m dflags of
                                 Left e -> Left e
                                 Right a -> unCL (k a) dflags
-  return = pure
 
 instance HasDynFlags CmmLint where
     getDynFlags = CmmLint (\dflags -> Right dflags)
diff --git a/compiler/cmm/PprC.hs b/compiler/cmm/PprC.hs
index af24b17a6f..3d3acec47d 100644
--- a/compiler/cmm/PprC.hs
+++ b/compiler/cmm/PprC.hs
@@ -1008,7 +1008,6 @@ instance Applicative TE where
 
 instance Monad TE where
    TE m >>= k  = TE $ \s -> case m s of (a, s') -> unTE (k a) s'
-   return = pure
 
 te_lbl :: CLabel -> TE ()
 te_lbl lbl = TE $ \(temps,lbls) -> ((), (temps, Map.insert lbl () lbls))
diff --git a/compiler/codeGen/StgCmmExtCode.hs b/compiler/codeGen/StgCmmExtCode.hs
index db03a3883b..f3bb6ee5b8 100644
--- a/compiler/codeGen/StgCmmExtCode.hs
+++ b/compiler/codeGen/StgCmmExtCode.hs
@@ -89,7 +89,6 @@ instance Applicative CmmParse where
 
 instance Monad CmmParse where
   (>>=) = thenExtFC
-  return = pure
 
 instance HasDynFlags CmmParse where
     getDynFlags = EC (\_ _ d -> do dflags <- getDynFlags
diff --git a/compiler/codeGen/StgCmmMonad.hs b/compiler/codeGen/StgCmmMonad.hs
index dd82b7f941..6611b2944e 100644
--- a/compiler/codeGen/StgCmmMonad.hs
+++ b/compiler/codeGen/StgCmmMonad.hs
@@ -77,7 +77,6 @@ import UniqSupply
 import FastString
 import Outputable
 
-import qualified Control.Applicative as A
 import Control.Monad
 import Data.List
 import Prelude hiding( sequence, succ )
@@ -117,13 +116,12 @@ newtype FCode a = FCode (CgInfoDownwards -> CgState -> (# a, CgState #))
 instance Functor FCode where
   fmap f (FCode g) = FCode $ \i s -> case g i s of (# a, s' #) -> (# f a, s' #)
 
-instance A.Applicative FCode where
+instance Applicative FCode where
       pure = returnFC
       (<*>) = ap
 
 instance Monad FCode where
         (>>=) = thenFC
-        return = A.pure
 
 {-# INLINE thenC #-}
 {-# INLINE thenFC #-}
diff --git a/compiler/coreSyn/CoreLint.hs b/compiler/coreSyn/CoreLint.hs
index 0030e3c433..2f6ab1cb9b 100644
--- a/compiler/coreSyn/CoreLint.hs
+++ b/compiler/coreSyn/CoreLint.hs
@@ -1576,7 +1576,6 @@ instance Applicative LintM where
       (<*>) = ap
 
 instance Monad LintM where
-  return = pure
   fail err = failWithL (text err)
   m >>= k  = LintM (\ env errs ->
                        let (res, errs') = unLintM m env errs in
diff --git a/compiler/deSugar/Coverage.hs b/compiler/deSugar/Coverage.hs
index 2711925161..08014229e9 100644
--- a/compiler/deSugar/Coverage.hs
+++ b/compiler/deSugar/Coverage.hs
@@ -1055,7 +1055,6 @@ instance Applicative TM where
     (<*>) = ap
 
 instance Monad TM where
-  return = pure
   (TM m) >>= k = TM $ \ env st ->
                                 case m env st of
                                   (r1,fv1,st1) ->
diff --git a/compiler/ghci/ByteCodeAsm.hs b/compiler/ghci/ByteCodeAsm.hs
index cfb78fbd47..41450530fd 100644
--- a/compiler/ghci/ByteCodeAsm.hs
+++ b/compiler/ghci/ByteCodeAsm.hs
@@ -170,7 +170,6 @@ instance Applicative Assembler where
     (<*>) = ap
 
 instance Monad Assembler where
-  return = pure
   NullAsm x >>= f = f x
   AllocPtr p k >>= f = AllocPtr p (k >=> f)
   AllocLit l k >>= f = AllocLit l (k >=> f)
diff --git a/compiler/ghci/ByteCodeGen.hs b/compiler/ghci/ByteCodeGen.hs
index d9a504b649..4311fcddea 100644
--- a/compiler/ghci/ByteCodeGen.hs
+++ b/compiler/ghci/ByteCodeGen.hs
@@ -1684,7 +1684,6 @@ instance Applicative BcM where
 instance Monad BcM where
   (>>=) = thenBc
   (>>)  = (*>)
-  return = pure
 
 instance HasDynFlags BcM where
     getDynFlags = BcM $ \st -> return (st, hsc_dflags (bcm_hsc_env st))
diff --git a/compiler/hsSyn/Convert.hs b/compiler/hsSyn/Convert.hs
index 9b904514a1..b28432f3d8 100644
--- a/compiler/hsSyn/Convert.hs
+++ b/compiler/hsSyn/Convert.hs
@@ -87,7 +87,6 @@ instance Applicative CvtM where
     (<*>) = ap
 
 instance Monad CvtM where
-  return = pure
   (CvtM m) >>= k = CvtM $ \loc -> case m loc of
                                   Left err -> Left err
                                   Right (loc',v) -> unCvtM (k v) loc'
diff --git a/compiler/llvmGen/LlvmCodeGen/Base.hs b/compiler/llvmGen/LlvmCodeGen/Base.hs
index ac352ff9a4..3a60891810 100644
--- a/compiler/llvmGen/LlvmCodeGen/Base.hs
+++ b/compiler/llvmGen/LlvmCodeGen/Base.hs
@@ -218,7 +218,6 @@ instance Applicative LlvmM where
     (<*>) = ap
 
 instance Monad LlvmM where
-    return = pure
     m >>= f  = LlvmM $ \env -> do (x, env') <- runLlvmM m env
                                   runLlvmM (f x) env'
 
diff --git a/compiler/main/CmdLineParser.hs b/compiler/main/CmdLineParser.hs
index 83ac593935..0a24be5579 100644
--- a/compiler/main/CmdLineParser.hs
+++ b/compiler/main/CmdLineParser.hs
@@ -103,7 +103,6 @@ instance Monad m => Applicative (EwM m) where
 instance Monad m => Monad (EwM m) where
     (EwM f) >>= k = EwM (\l e w -> do (e', w', r) <- f l e w
                                       unEwM (k r) l e' w')
-    return = pure
 
 runEwM :: EwM m a -> m (Errs, Warns, a)
 runEwM action = unEwM action (panic "processArgs: no arg yet") emptyBag emptyBag
@@ -151,7 +150,6 @@ instance Monad (CmdLineP s) where
                   let (a, s') = runCmdLine m s
                   in runCmdLine (k a) s'
 
-    return = pure
 
 getCmdLineState :: CmdLineP s s
 getCmdLineState   = CmdLineP $ \s -> (s,s)
diff --git a/compiler/main/GhcMonad.hs b/compiler/main/GhcMonad.hs
index c28e87753d..2673dd8e45 100644
--- a/compiler/main/GhcMonad.hs
+++ b/compiler/main/GhcMonad.hs
@@ -104,7 +104,6 @@ instance Applicative Ghc where
   g <*> m = do f <- g; a <- m; return (f a)
 
 instance Monad Ghc where
-  return = pure
   m >>= g  = Ghc $ \s -> do a <- unGhc m s; unGhc (g a) s
 
 instance MonadIO Ghc where
@@ -168,11 +167,10 @@ instance Applicative m => Applicative (GhcT m) where
   pure x  = GhcT $ \_ -> pure x
   g <*> m = GhcT $ \s -> unGhcT g s <*> unGhcT m s
 
-instance (Applicative m, Monad m) => Monad (GhcT m) where
-  return = pure
+instance Monad m => Monad (GhcT m) where
   m >>= k  = GhcT $ \s -> do a <- unGhcT m s; unGhcT (k a) s
 
-instance (Applicative m, MonadIO m) => MonadIO (GhcT m) where
+instance MonadIO m => MonadIO (GhcT m) where
   liftIO ioA = GhcT $ \_ -> liftIO ioA
 
 instance ExceptionMonad m => ExceptionMonad (GhcT m) where
diff --git a/compiler/main/HscTypes.hs b/compiler/main/HscTypes.hs
index ea921fe79a..0a7682157e 100644
--- a/compiler/main/HscTypes.hs
+++ b/compiler/main/HscTypes.hs
@@ -228,7 +228,6 @@ instance Applicative Hsc where
     (<*>) = ap
 
 instance Monad Hsc where
-    return = pure
     Hsc m >>= k = Hsc $ \e w -> do (a, w1) <- m e w
                                    case k a of
                                        Hsc k' -> k' e w1
diff --git a/compiler/main/PipelineMonad.hs b/compiler/main/PipelineMonad.hs
index 6b20db719d..614c4fa30f 100644
--- a/compiler/main/PipelineMonad.hs
+++ b/compiler/main/PipelineMonad.hs
@@ -31,7 +31,6 @@ instance Applicative CompPipeline where
     (<*>) = ap
 
 instance Monad CompPipeline where
-  return = pure
   P m >>= k = P $ \env state -> do (state',a) <- m env state
                                    unP (k a) env state'
 
diff --git a/compiler/main/TidyPgm.hs b/compiler/main/TidyPgm.hs
index 122440133f..8a27fd7b6e 100644
--- a/compiler/main/TidyPgm.hs
+++ b/compiler/main/TidyPgm.hs
@@ -775,7 +775,6 @@ instance Applicative DFFV where
     (<*>) = ap
 
 instance Monad DFFV where
-  return = pure
   (DFFV m) >>= k = DFFV $ \env st ->
     case m env st of
        (st',a) -> case k a of
diff --git a/compiler/nativeGen/AsmCodeGen.hs b/compiler/nativeGen/AsmCodeGen.hs
index 7d3f98be85..fc18c6bbe1 100644
--- a/compiler/nativeGen/AsmCodeGen.hs
+++ b/compiler/nativeGen/AsmCodeGen.hs
@@ -983,7 +983,6 @@ instance Applicative CmmOptM where
     (<*>) = ap
 
 instance Monad CmmOptM where
-  return = pure
   (CmmOptM f) >>= g =
     CmmOptM $ \dflags this_mod imports ->
                 case f dflags this_mod imports of
diff --git a/compiler/nativeGen/NCGMonad.hs b/compiler/nativeGen/NCGMonad.hs
index 1dde1bc0f7..43547d0515 100644
--- a/compiler/nativeGen/NCGMonad.hs
+++ b/compiler/nativeGen/NCGMonad.hs
@@ -94,7 +94,6 @@ instance Applicative NatM where
 
 instance Monad NatM where
   (>>=) = thenNat
-  return = pure
 
 
 thenNat :: NatM a -> (a -> NatM b) -> NatM b
diff --git a/compiler/nativeGen/RegAlloc/Linear/State.hs b/compiler/nativeGen/RegAlloc/Linear/State.hs
index e407a80fe1..8b17d3ab88 100644
--- a/compiler/nativeGen/RegAlloc/Linear/State.hs
+++ b/compiler/nativeGen/RegAlloc/Linear/State.hs
@@ -57,7 +57,6 @@ instance Applicative (RegM freeRegs) where
 
 instance Monad (RegM freeRegs) where
   m >>= k   =  RegM $ \s -> case unReg m s of { (# s, a #) -> unReg (k a) s }
-  return    =  pure
 
 instance HasDynFlags (RegM a) where
     getDynFlags = RegM $ \s -> (# s, ra_DynFlags s #)
diff --git a/compiler/parser/Lexer.x b/compiler/parser/Lexer.x
index 26809db5ad..0f6becb9f6 100644
--- a/compiler/parser/Lexer.x
+++ b/compiler/parser/Lexer.x
@@ -1783,7 +1783,6 @@ instance Applicative P where
   (<*>) = ap
 
 instance Monad P where
-  return = pure
   (>>=) = thenP
   fail = failP
 
diff --git a/compiler/prelude/PrelRules.hs b/compiler/prelude/PrelRules.hs
index 49cfa982fb..2a174b13fc 100644
--- a/compiler/prelude/PrelRules.hs
+++ b/compiler/prelude/PrelRules.hs
@@ -645,7 +645,6 @@ instance Applicative RuleM where
     (<*>) = ap
 
 instance Monad RuleM where
-  return = pure
   RuleM f >>= g = RuleM $ \dflags iu e -> case f dflags iu e of
     Nothing -> Nothing
     Just r -> runRuleM (g r) dflags iu e
diff --git a/compiler/profiling/SCCfinal.hs b/compiler/profiling/SCCfinal.hs
index 69ebb59c1b..6cab87c9cd 100644
--- a/compiler/profiling/SCCfinal.hs
+++ b/compiler/profiling/SCCfinal.hs
@@ -233,7 +233,6 @@ instance Applicative MassageM where
       (*>) = thenMM_
 
 instance Monad MassageM where
-    return = pure
     (>>=) = thenMM
     (>>)  = (*>)
 
diff --git a/compiler/rename/RnPat.hs b/compiler/rename/RnPat.hs
index 8ee214193c..3b526d128a 100644
--- a/compiler/rename/RnPat.hs
+++ b/compiler/rename/RnPat.hs
@@ -107,7 +107,6 @@ instance Applicative CpsRn where
     (<*>) = ap
 
 instance Monad CpsRn where
-  return = pure
   (CpsRn m) >>= mk = CpsRn (\k -> m (\v -> unCpsRn (mk v) k))
 
 runCps :: CpsRn a -> RnM (a, FreeVars)
diff --git a/compiler/simplCore/CoreMonad.hs b/compiler/simplCore/CoreMonad.hs
index 5e2de54180..4958474a9d 100644
--- a/compiler/simplCore/CoreMonad.hs
+++ b/compiler/simplCore/CoreMonad.hs
@@ -88,8 +88,8 @@ import Data.IORef
 import Data.Map (Map)
 import qualified Data.Map as Map
 import Data.Word
-import qualified Control.Applicative as A
 import Control.Monad
+import Control.Applicative ( Alternative(..) )
 
 import Prelude hiding   ( read )
 
@@ -557,7 +557,6 @@ instance Functor CoreM where
     fmap = liftM
 
 instance Monad CoreM where
-    return = pure
     mx >>= f = CoreM $ \s -> do
             (x, s', w1) <- unCoreM mx s
             (y, s'', w2) <- unCoreM (f x) s'
@@ -566,12 +565,12 @@ instance Monad CoreM where
             -- forcing w before building the tuple avoids a space leak
             -- (Trac #7702)
 
-instance A.Applicative CoreM where
+instance Applicative CoreM where
     pure x = CoreM $ \s -> nop s x
     (<*>) = ap
     m *> k = m >>= \_ -> k
 
-instance MonadPlus IO => A.Alternative CoreM where
+instance MonadPlus IO => Alternative CoreM where
     empty = mzero
     (<|>) = mplus
 
diff --git a/compiler/simplCore/SimplMonad.hs b/compiler/simplCore/SimplMonad.hs
index 8835494d64..f165c65db5 100644
--- a/compiler/simplCore/SimplMonad.hs
+++ b/compiler/simplCore/SimplMonad.hs
@@ -109,7 +109,6 @@ instance Applicative SimplM where
 instance Monad SimplM where
    (>>)   = (*>)
    (>>=)  = thenSmpl
-   return = pure
 
 returnSmpl :: a -> SimplM a
 returnSmpl e = SM (\_st_env us sc -> return (e, us, sc))
diff --git a/compiler/specialise/Specialise.hs b/compiler/specialise/Specialise.hs
index 7a3257e79c..1507510b0d 100644
--- a/compiler/specialise/Specialise.hs
+++ b/compiler/specialise/Specialise.hs
@@ -2091,7 +2091,6 @@ instance Monad SpecM where
                                case f y of
                                    SpecM z ->
                                        z
-    return = pure
     fail str = SpecM $ fail str
 
 #if __GLASGOW_HASKELL__ > 710
diff --git a/compiler/stgSyn/CoreToStg.hs b/compiler/stgSyn/CoreToStg.hs
index e5954ab440..54d20b3d05 100644
--- a/compiler/stgSyn/CoreToStg.hs
+++ b/compiler/stgSyn/CoreToStg.hs
@@ -994,7 +994,6 @@ instance Applicative LneM where
     (<*>) = ap
 
 instance Monad LneM where
-    return = pure
     (>>=)  = thenLne
 
 instance MonadFix LneM where
diff --git a/compiler/stgSyn/StgLint.hs b/compiler/stgSyn/StgLint.hs
index e8bfe113b6..7aa07b25d3 100644
--- a/compiler/stgSyn/StgLint.hs
+++ b/compiler/stgSyn/StgLint.hs
@@ -315,7 +315,6 @@ instance Applicative LintM where
       (*>)  = thenL_
 
 instance Monad LintM where
-    return = pure
     (>>=) = thenL
     (>>)  = (*>)
 
diff --git a/compiler/typecheck/TcFlatten.hs b/compiler/typecheck/TcFlatten.hs
index 281da4049b..20f77a7650 100644
--- a/compiler/typecheck/TcFlatten.hs
+++ b/compiler/typecheck/TcFlatten.hs
@@ -526,7 +526,6 @@ newtype FlatM a
   = FlatM { runFlatM :: FlattenEnv -> TcS a }
 
 instance Monad FlatM where
-  return = pure
   m >>= k  = FlatM $ \env ->
              do { a  <- runFlatM m env
                 ; runFlatM (k a) env }
diff --git a/compiler/typecheck/TcRnTypes.hs b/compiler/typecheck/TcRnTypes.hs
index d0cf737058..457e6f8426 100644
--- a/compiler/typecheck/TcRnTypes.hs
+++ b/compiler/typecheck/TcRnTypes.hs
@@ -2903,7 +2903,6 @@ instance Applicative TcPluginM where
   (<*>) = ap
 
 instance Monad TcPluginM where
-  return = pure
   fail x   = TcPluginM (const $ fail x)
   TcPluginM m >>= k =
     TcPluginM (\ ev -> do a <- m ev
diff --git a/compiler/typecheck/TcSMonad.hs b/compiler/typecheck/TcSMonad.hs
index ac38e171b8..c508bb1e08 100644
--- a/compiler/typecheck/TcSMonad.hs
+++ b/compiler/typecheck/TcSMonad.hs
@@ -2246,7 +2246,6 @@ instance Applicative TcS where
   (<*>) = ap
 
 instance Monad TcS where
-  return = pure
   fail err  = TcS (\_ -> fail err)
   m >>= k   = TcS (\ebs -> unTcS m ebs >>= \r -> unTcS (k r) ebs)
 
diff --git a/compiler/typecheck/TcTyDecls.hs b/compiler/typecheck/TcTyDecls.hs
index c17d78b9cc..47f5b64d10 100644
--- a/compiler/typecheck/TcTyDecls.hs
+++ b/compiler/typecheck/TcTyDecls.hs
@@ -788,7 +788,6 @@ instance Applicative RoleM where
     (<*>) = ap
 
 instance Monad RoleM where
-  return   = pure
   a >>= f  = RM $ \m_info vps nvps state ->
                   let (a', state') = unRM a m_info vps nvps state in
                   unRM (f a') m_info vps nvps state'
diff --git a/compiler/typecheck/TcType.hs b/compiler/typecheck/TcType.hs
index 8e8f3375f3..fca5f475a3 100644
--- a/compiler/typecheck/TcType.hs
+++ b/compiler/typecheck/TcType.hs
@@ -1433,7 +1433,6 @@ instance Applicative OccCheckResult where
       (<*>) = ap
 
 instance Monad OccCheckResult where
-  return            = pure
   OC_OK x     >>= k = k x
   OC_Forall   >>= _ = OC_Forall
   OC_NonTyVar >>= _ = OC_NonTyVar
diff --git a/compiler/types/FamInstEnv.hs b/compiler/types/FamInstEnv.hs
index 00a128d026..16c176d28e 100644
--- a/compiler/types/FamInstEnv.hs
+++ b/compiler/types/FamInstEnv.hs
@@ -1378,7 +1378,6 @@ withLC :: LiftingContext -> NormM a -> NormM a
 withLC lc thing = NormM $ \ envs _old_lc r -> runNormM thing envs lc r
 
 instance Monad NormM where
-  return     = pure
   ma >>= fmb = NormM $ \env lc r ->
                let a = runNormM ma env lc r in
                runNormM (fmb a) env lc r
diff --git a/compiler/types/Type.hs b/compiler/types/Type.hs
index cd2b5873c6..6a86f70885 100644
--- a/compiler/types/Type.hs
+++ b/compiler/types/Type.hs
@@ -437,7 +437,7 @@ data TyCoMapper env m
       }
 
 {-# INLINABLE mapType #-}  -- See Note [Specialising mappers]
-mapType :: (Applicative m, Monad m) => TyCoMapper env m -> env -> Type -> m Type
+mapType :: Monad m => TyCoMapper env m -> env -> Type -> m Type
 mapType mapper@(TyCoMapper { tcm_smart = smart, tcm_tyvar = tyvar
                            , tcm_tybinder = tybinder })
         env ty
@@ -460,7 +460,7 @@ mapType mapper@(TyCoMapper { tcm_smart = smart, tcm_tyvar = tyvar
       | otherwise = (TyConApp,   AppTy,   CastTy,   ForAllTy . Anon)
 
 {-# INLINABLE mapCoercion #-}  -- See Note [Specialising mappers]
-mapCoercion :: (Applicative m, Monad m)
+mapCoercion :: Monad m
             => TyCoMapper env m -> env -> Coercion -> m Coercion
 mapCoercion mapper@(TyCoMapper { tcm_smart = smart, tcm_covar = covar
                                , tcm_hole = cohole, tcm_tybinder = tybinder })
diff --git a/compiler/types/Unify.hs b/compiler/types/Unify.hs
index 769f505ee0..c4c95bfd73 100644
--- a/compiler/types/Unify.hs
+++ b/compiler/types/Unify.hs
@@ -374,7 +374,6 @@ instance Applicative UnifyResultM where
   (<*>) = ap
 
 instance Monad UnifyResultM where
-  return = pure
 
   SurelyApart  >>= _ = SurelyApart
   MaybeApart x >>= f = case f x of
@@ -908,7 +907,6 @@ instance Applicative UM where
       (<*>)  = ap
 
 instance Monad UM where
-  return   = pure
   fail _   = UM (\_ _ -> SurelyApart) -- failed pattern match
   m >>= k  = UM (\env state ->
                   do { (state', v) <- unUM m env state
diff --git a/compiler/utils/Exception.hs b/compiler/utils/Exception.hs
index 8168992e00..850393e359 100644
--- a/compiler/utils/Exception.hs
+++ b/compiler/utils/Exception.hs
@@ -6,7 +6,6 @@ module Exception
     )
     where
 
-import Control.Applicative as A
 import Control.Exception
 import Control.Monad.IO.Class
 
@@ -29,7 +28,7 @@ tryIO = try
 -- implementations of 'gbracket' and 'gfinally' use 'gmask'
 -- thus rarely require overriding.
 --
-class (A.Applicative m, MonadIO m) => ExceptionMonad m where
+class MonadIO m => ExceptionMonad m where
 
   -- | Generalised version of 'Control.Exception.catch', allowing an arbitrary
   -- exception handling monad instead of just 'IO'.
diff --git a/compiler/utils/IOEnv.hs b/compiler/utils/IOEnv.hs
index 804ddd8e70..4470420a64 100644
--- a/compiler/utils/IOEnv.hs
+++ b/compiler/utils/IOEnv.hs
@@ -62,7 +62,6 @@ unIOEnv (IOEnv m) = m
 instance Monad (IOEnv m) where
     (>>=)  = thenM
     (>>)   = (*>)
-    return = pure
     fail _ = failM -- Ignore the string
 
 #if __GLASGOW_HASKELL__ > 710
diff --git a/compiler/utils/Maybes.hs b/compiler/utils/Maybes.hs
index ac5107029b..83dc9b6864 100644
--- a/compiler/utils/Maybes.hs
+++ b/compiler/utils/Maybes.hs
@@ -17,7 +17,6 @@ module Maybes (
         MaybeT(..), liftMaybeT
     ) where
 
-import Control.Applicative as A
 import Control.Monad
 import Control.Monad.Trans.Maybe
 import Data.Maybe
@@ -84,7 +83,6 @@ instance Applicative (MaybeErr err) where
   (<*>) = ap
 
 instance Monad (MaybeErr err) where
-  return = A.pure
   Succeeded v >>= k = k v
   Failed e    >>= _ = Failed e
 
diff --git a/compiler/utils/State.hs b/compiler/utils/State.hs
index fb6f2c3554..8eca4657df 100644
--- a/compiler/utils/State.hs
+++ b/compiler/utils/State.hs
@@ -15,7 +15,6 @@ instance Applicative (State s) where
                                            (# x, s'' #) -> (# f x, s'' #)
 
 instance Monad (State s) where
-    return = pure
     m >>= n  = State $ \s -> case runState' m s of
                              (# r, s' #) -> runState' (n r) s'
 
diff --git a/compiler/utils/Stream.hs b/compiler/utils/Stream.hs
index a347206e61..f7b21017cf 100644
--- a/compiler/utils/Stream.hs
+++ b/compiler/utils/Stream.hs
@@ -46,7 +46,6 @@ instance Monad m => Applicative (Stream m a) where
   (<*>) = ap
 
 instance Monad m => Monad (Stream m a) where
-  return = pure
 
   Stream m >>= k = Stream $ do
                 r <- m
diff --git a/compiler/vectorise/Vectorise/Monad/Base.hs b/compiler/vectorise/Vectorise/Monad/Base.hs
index da53e8b94d..b084da67dc 100644
--- a/compiler/vectorise/Vectorise/Monad/Base.hs
+++ b/compiler/vectorise/Vectorise/Monad/Base.hs
@@ -51,7 +51,6 @@ newtype VM a
   = VM { runVM :: Builtins -> GlobalEnv -> LocalEnv -> DsM (VResult a) }
 
 instance Monad VM where
-  return = pure
   VM p >>= f = VM $ \bi genv lenv -> do
                                        r <- p bi genv lenv
                                        case r of
diff --git a/libraries/ghci/GHCi/TH.hs b/libraries/ghci/GHCi/TH.hs
index f379dbc546..717192e39d 100644
--- a/libraries/ghci/GHCi/TH.hs
+++ b/libraries/ghci/GHCi/TH.hs
@@ -72,7 +72,6 @@ instance Monad GHCiQ where
     do (m', s')  <- runGHCiQ m s
        (a,  s'') <- runGHCiQ (f m') s'
        return (a, s'')
-  return    = pure
   fail err  = GHCiQ $ \s -> throwIO (GHCiQException s err)
 
 getState :: GHCiQ QState
diff --git a/libraries/template-haskell/Language/Haskell/TH/PprLib.hs b/libraries/template-haskell/Language/Haskell/TH/PprLib.hs
index 594d7dc54d..378888d77f 100644
--- a/libraries/template-haskell/Language/Haskell/TH/PprLib.hs
+++ b/libraries/template-haskell/Language/Haskell/TH/PprLib.hs
@@ -155,7 +155,6 @@ instance Applicative PprM where
       (<*>) = ap
 
 instance Monad PprM where
-    return = pure
     m >>= k  = PprM $ \s -> let (x, s') = runPprM m s
                             in runPprM (k x) s'
 
diff --git a/libraries/template-haskell/Language/Haskell/TH/Syntax.hs b/libraries/template-haskell/Language/Haskell/TH/Syntax.hs
index becbbd6d7a..269bb70753 100644
--- a/libraries/template-haskell/Language/Haskell/TH/Syntax.hs
+++ b/libraries/template-haskell/Language/Haskell/TH/Syntax.hs
@@ -52,7 +52,7 @@ import Numeric.Natural
 --
 -----------------------------------------------------
 
-class (Applicative m, Monad m) => Quasi m where
+class Monad m => Quasi m where
   qNewName :: String -> m Name
         -- ^ Fresh names
 
@@ -170,7 +170,6 @@ runQ (Q m) = m
 instance Monad Q where
   Q m >>= k  = Q (m >>= \x -> unQ (k x))
   (>>) = (*>)
-  return     = pure
   fail s     = report True s >> Q (fail "Q monad failure")
 
 instance Functor Q where
diff --git a/utils/ghc-pkg/Main.hs b/utils/ghc-pkg/Main.hs
index eb8e311fb6..4a3fbdb294 100644
--- a/utils/ghc-pkg/Main.hs
+++ b/utils/ghc-pkg/Main.hs
@@ -1517,7 +1517,6 @@ instance Applicative Validate where
     (<*>) = ap
 
 instance Monad Validate where
-   return = pure
    m >>= k = V $ do
       (a, es, ws) <- runValidate m
       (b, es', ws') <- runValidate (k a)