diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -1,3 +1,7 @@
+# v0.5.0.1
+
+- Adds support for ghc 8.8.1.
+
 # v0.5.0.0
 
 - Derives `Generic1` instances for all non-existentially-quantified effect datatypes.
diff --git a/benchmark/Bench.hs b/benchmark/Bench.hs
--- a/benchmark/Bench.hs
+++ b/benchmark/Bench.hs
@@ -8,9 +8,9 @@
 import Control.Effect.Writer
 import Control.Effect.State
 import Control.Monad (ap, replicateM_)
-import Criterion.Main
 import Data.Functor.Identity
 import Data.Monoid (Sum(..))
+import Gauge
 
 main :: IO ()
 main = defaultMain
diff --git a/fused-effects.cabal b/fused-effects.cabal
--- a/fused-effects.cabal
+++ b/fused-effects.cabal
@@ -1,7 +1,7 @@
 cabal-version:       2.2
 
 name:                fused-effects
-version:             0.5.0.0
+version:             0.5.0.1
 synopsis:            A fast, flexible, fused effect system.
 description:         A fast, flexible, fused effect system, à la Effect Handlers in Scope, Monad Transformers and Modular Algebraic Effects: What Binds Them Together, and Fusion for Free—Efficient Algebraic Effect Handlers.
 homepage:            https://github.com/fused-effects/fused-effects
@@ -19,12 +19,15 @@
 tested-with:         GHC == 8.2.2
                    , GHC == 8.4.4
                    , GHC == 8.6.2
+                   , GHC == 8.8.1
 
 common common
   default-language:    Haskell2010
   ghc-options:         -Weverything -Wno-missing-local-signatures -Wno-missing-import-lists -Wno-implicit-prelude -Wno-safe -Wno-unsafe -Wno-name-shadowing -Wno-monomorphism-restriction -Wno-missed-specialisations -Wno-all-missed-specialisations
   if (impl(ghc >= 8.6))
     ghc-options:       -Wno-star-is-type
+  if (impl(ghc >= 8.8))
+    ghc-options:       -Wno-missing-deriving-strategies
 
 library
   import:              common
@@ -51,10 +54,10 @@
                      , Control.Effect.Sum
                      , Control.Effect.Trace
                      , Control.Effect.Writer
-  build-depends:       base >=4.9 && <4.13
-                     , deepseq >=1.4.3 && <1.5
-                     , MonadRandom >=0.5 && <0.6
-                     , unliftio-core >= 0.1.2
+  build-depends:       base           >= 4.9 && < 4.14
+                     , deepseq       ^>= 1.4.3
+                     , MonadRandom   ^>= 0.5
+                     , unliftio-core ^>= 0.1.2
                      , random
                      , transformers
   hs-source-dirs:      src
@@ -67,10 +70,10 @@
   other-modules:       Parser
                      , ReinterpretLog
                      , Teletype
-  build-depends:       base >=4.9 && <4.13
+  build-depends:       base        >= 4.9 && < 4.14
                      , fused-effects
-                     , hspec >=2.4.1
-                     , QuickCheck >= 2.7 && < 3
+                     , hspec       >= 2.4.1
+                     , QuickCheck  >= 2.7 && < 3
                      , transformers
   hs-source-dirs:      examples
 
@@ -80,18 +83,18 @@
   main-is:             Spec.hs
   other-modules:       Control.Effect.Spec
                      , Control.Effect.NonDet.Spec
-  build-depends:       base >=4.9 && <4.13
+  build-depends:       base                >= 4.9 && < 4.14
                      , fused-effects
-                     , hspec >=2.4.1
-                     , inspection-testing >= 0.4 && <1
+                     , hspec               >= 2.4.1
+                     , inspection-testing ^>= 0.4
   hs-source-dirs:      test
 
 test-suite doctest
   import:              common
   type:                exitcode-stdio-1.0
   main-is:             Doctest.hs
-  build-depends:       base >=4.9 && <4.13
-                     , doctest >=0.7 && <1.0
+  build-depends:       base     >= 4.9 && < 4.14
+                     , doctest  >= 0.7 && < 1
                      , fused-effects
   hs-source-dirs:      test
 
@@ -100,9 +103,9 @@
   import:             common
   type:               exitcode-stdio-1.0
   main-is:            Bench.hs
-  build-depends:      base >=4.9 && <4.13
-                    , criterion
+  build-depends:      base >= 4.9 && < 4.14
                     , fused-effects
+                    , gauge
   hs-source-dirs:     benchmark
   ghc-options:        -threaded -rtsopts "-with-rtsopts=-N -A4m -n2m"
 
diff --git a/src/Control/Effect/Cull.hs b/src/Control/Effect/Cull.hs
--- a/src/Control/Effect/Cull.hs
+++ b/src/Control/Effect/Cull.hs
@@ -14,12 +14,11 @@
 , run
 ) where
 
-import Control.Applicative (Alternative(..))
 import Control.Effect.Carrier
 import Control.Effect.NonDet
 import Control.Effect.Reader
 import Control.Monad (MonadPlus(..))
-import Control.Monad.Fail
+import qualified Control.Monad.Fail as Fail
 import Control.Monad.Fix
 import Control.Monad.IO.Class
 import Control.Monad.Trans.Class
@@ -55,7 +54,7 @@
 runCull (CullC m) = runNonDetC (runReader False m) ((<|>) . pure) empty
 
 newtype CullC m a = CullC { runCullC :: ReaderC Bool (NonDetC m) a }
-  deriving (Applicative, Functor, Monad, MonadFail, MonadFix, MonadIO)
+  deriving (Applicative, Functor, Monad, Fail.MonadFail, MonadFix, MonadIO)
 
 instance Alternative (CullC m) where
   empty = CullC empty
@@ -90,7 +89,7 @@
 runNonDetOnce = runNonDet . runCull . cull . runOnceC
 
 newtype OnceC m a = OnceC { runOnceC :: CullC (NonDetC m) a }
-  deriving (Alternative, Applicative, Functor, Monad, MonadFail, MonadFix, MonadIO, MonadPlus)
+  deriving (Alternative, Applicative, Functor, Monad, Fail.MonadFail, MonadFix, MonadIO, MonadPlus)
 
 instance (Carrier sig m, Effect sig) => Carrier (NonDet :+: sig) (OnceC m) where
   eff = OnceC . eff . R . R . handleCoercible
diff --git a/src/Control/Effect/Cut.hs b/src/Control/Effect/Cut.hs
--- a/src/Control/Effect/Cut.hs
+++ b/src/Control/Effect/Cut.hs
@@ -15,15 +15,13 @@
 , run
 ) where
 
-import Control.Applicative (Alternative(..))
 import Control.Effect.Carrier
 import Control.Effect.NonDet
 import Control.Monad (MonadPlus(..))
-import Control.Monad.Fail
+import qualified Control.Monad.Fail as Fail
 import Control.Monad.Fix
 import Control.Monad.IO.Class
 import Control.Monad.Trans.Class
-import Prelude hiding (fail)
 
 -- | 'Cut' effects are used with 'NonDet' to provide control over backtracking.
 data Cut m k
@@ -103,8 +101,8 @@
     a (\ a' as -> runCutC (f a') cons as fail) nil fail
   {-# INLINE (>>=) #-}
 
-instance MonadFail m => MonadFail (CutC m) where
-  fail s = CutC (\ _ _ _ -> fail s)
+instance Fail.MonadFail m => Fail.MonadFail (CutC m) where
+  fail s = CutC (\ _ _ _ -> Fail.fail s)
   {-# INLINE fail #-}
 
 instance MonadFix m => MonadFix (CutC m) where
diff --git a/src/Control/Effect/Error.hs b/src/Control/Effect/Error.hs
--- a/src/Control/Effect/Error.hs
+++ b/src/Control/Effect/Error.hs
@@ -16,11 +16,10 @@
 import Control.Applicative (Alternative(..), liftA2)
 import Control.Effect.Carrier
 import Control.Monad (MonadPlus(..), (<=<))
-import Control.Monad.Fail
+import qualified Control.Monad.Fail as Fail
 import Control.Monad.Fix
 import Control.Monad.IO.Class
 import Control.Monad.Trans.Class
-import Prelude hiding (fail)
 
 data Error exc m k
   = Throw exc
@@ -90,8 +89,8 @@
   liftIO io = ErrorC (Right <$> liftIO io)
   {-# INLINE liftIO #-}
 
-instance MonadFail m => MonadFail (ErrorC e m) where
-  fail s = ErrorC (fail s)
+instance Fail.MonadFail m => Fail.MonadFail (ErrorC e m) where
+  fail s = ErrorC (Fail.fail s)
   {-# INLINE fail #-}
 
 instance (Alternative m, Monad m) => MonadPlus (ErrorC e m)
diff --git a/src/Control/Effect/Fail.hs b/src/Control/Effect/Fail.hs
--- a/src/Control/Effect/Fail.hs
+++ b/src/Control/Effect/Fail.hs
@@ -8,7 +8,7 @@
   -- * Re-exports
 , Carrier
 , Member
-, MonadFail(..)
+, Fail.MonadFail(..)
 , run
 ) where
 
@@ -16,12 +16,11 @@
 import Control.Effect.Carrier
 import Control.Effect.Error
 import Control.Monad (MonadPlus(..))
-import Control.Monad.Fail
+import qualified Control.Monad.Fail as Fail
 import Control.Monad.Fix
 import Control.Monad.IO.Class
 import Control.Monad.Trans.Class
 import GHC.Generics (Generic1)
-import Prelude hiding (fail)
 
 newtype Fail (m :: * -> *) k = Fail String
   deriving stock (Functor, Generic1)
@@ -36,12 +35,12 @@
 newtype FailC m a = FailC { runFailC :: ErrorC String m a }
   deriving newtype (Alternative, Applicative, Functor, Monad, MonadFix, MonadIO, MonadPlus, MonadTrans)
 
-instance (Carrier sig m, Effect sig) => MonadFail (FailC m) where
+instance (Carrier sig m, Effect sig) => Fail.MonadFail (FailC m) where
   fail s = FailC (throwError s)
   {-# INLINE fail #-}
 
 instance (Carrier sig m, Effect sig) => Carrier (Fail :+: sig) (FailC m) where
-  eff (L (Fail s)) = fail s
+  eff (L (Fail s)) = Fail.fail s
   eff (R other)    = FailC (eff (R (handleCoercible other)))
   {-# INLINE eff #-}
 
diff --git a/src/Control/Effect/Fresh.hs b/src/Control/Effect/Fresh.hs
--- a/src/Control/Effect/Fresh.hs
+++ b/src/Control/Effect/Fresh.hs
@@ -17,7 +17,7 @@
 import Control.Effect.Carrier
 import Control.Effect.State
 import Control.Monad (MonadPlus(..))
-import Control.Monad.Fail
+import qualified Control.Monad.Fail as Fail
 import Control.Monad.Fix
 import Control.Monad.IO.Class
 import Control.Monad.Trans.Class
@@ -57,7 +57,7 @@
 runFresh = evalState 0 . runFreshC
 
 newtype FreshC m a = FreshC { runFreshC :: StateC Int m a }
-  deriving (Alternative, Applicative, Functor, Monad, MonadFail, MonadFix, MonadIO, MonadPlus, MonadTrans)
+  deriving (Alternative, Applicative, Functor, Monad, Fail.MonadFail, MonadFix, MonadIO, MonadPlus, MonadTrans)
 
 instance (Carrier sig m, Effect sig) => Carrier (Fresh :+: sig) (FreshC m) where
   eff (L (Fresh   k)) = FreshC $ do
diff --git a/src/Control/Effect/Interpose.hs b/src/Control/Effect/Interpose.hs
--- a/src/Control/Effect/Interpose.hs
+++ b/src/Control/Effect/Interpose.hs
@@ -14,7 +14,7 @@
 import Control.Effect.Carrier
 import Control.Effect.Reader
 import Control.Monad (MonadPlus (..))
-import Control.Monad.Fail
+import qualified Control.Monad.Fail as Fail
 import Control.Monad.Fix
 import Control.Monad.IO.Class
 import Control.Monad.Trans.Class
@@ -31,7 +31,7 @@
 runInterpose handler = runReader (Handler handler) . runInterposeC
 
 newtype InterposeC eff m a = InterposeC { runInterposeC :: ReaderC (Handler eff m) m a }
-  deriving (Alternative, Applicative, Functor, Monad, MonadFail, MonadFix, MonadIO, MonadPlus)
+  deriving (Alternative, Applicative, Functor, Monad, Fail.MonadFail, MonadFix, MonadIO, MonadPlus)
 
 instance MonadTrans (InterposeC eff) where
   lift = InterposeC . lift
diff --git a/src/Control/Effect/Interpret.hs b/src/Control/Effect/Interpret.hs
--- a/src/Control/Effect/Interpret.hs
+++ b/src/Control/Effect/Interpret.hs
@@ -11,7 +11,7 @@
 import Control.Effect.Reader
 import Control.Effect.State
 import Control.Monad (MonadPlus(..))
-import Control.Monad.Fail
+import qualified Control.Monad.Fail as Fail
 import Control.Monad.Fix
 import Control.Monad.IO.Class
 import Control.Monad.Trans.Class
@@ -27,7 +27,7 @@
 runInterpret handler = runReader (Handler handler) . runInterpretC
 
 newtype InterpretC eff m a = InterpretC { runInterpretC :: ReaderC (Handler eff m) m a }
-  deriving (Alternative, Applicative, Functor, Monad, MonadFail, MonadFix, MonadIO, MonadPlus)
+  deriving (Alternative, Applicative, Functor, Monad, Fail.MonadFail, MonadFix, MonadIO, MonadPlus)
 
 instance MonadTrans (InterpretC eff) where
   lift = InterpretC . lift
@@ -57,7 +57,7 @@
 runInterpretState handler state = runState state . runReader (HandlerState (\ eff -> StateC (\ s -> handler s eff))) . runInterpretStateC
 
 newtype InterpretStateC eff s m a = InterpretStateC { runInterpretStateC :: ReaderC (HandlerState eff s m) (StateC s m) a }
-  deriving (Alternative, Applicative, Functor, Monad, MonadFail, MonadFix, MonadIO, MonadPlus)
+  deriving (Alternative, Applicative, Functor, Monad, Fail.MonadFail, MonadFix, MonadIO, MonadPlus)
 
 instance MonadTrans (InterpretStateC eff s) where
   lift = InterpretStateC . lift . lift
diff --git a/src/Control/Effect/Lift.hs b/src/Control/Effect/Lift.hs
--- a/src/Control/Effect/Lift.hs
+++ b/src/Control/Effect/Lift.hs
@@ -15,7 +15,7 @@
 import Control.Applicative (Alternative(..))
 import Control.Effect.Carrier
 import Control.Monad (MonadPlus(..))
-import Control.Monad.Fail
+import qualified Control.Monad.Fail as Fail
 import Control.Monad.Fix
 import Control.Monad.IO.Class
 import Control.Monad.IO.Unlift
@@ -37,7 +37,7 @@
 sendM = send . Lift . fmap pure
 
 newtype LiftC m a = LiftC { runLiftC :: m a }
-  deriving newtype (Alternative, Applicative, Functor, Monad, MonadFail, MonadFix, MonadIO, MonadPlus)
+  deriving newtype (Alternative, Applicative, Functor, Monad, Fail.MonadFail, MonadFix, MonadIO, MonadPlus)
 
 instance MonadTrans LiftC where
   lift = LiftC
diff --git a/src/Control/Effect/NonDet.hs b/src/Control/Effect/NonDet.hs
--- a/src/Control/Effect/NonDet.hs
+++ b/src/Control/Effect/NonDet.hs
@@ -15,12 +15,11 @@
 import Control.Applicative (Alternative(..))
 import Control.Effect.Carrier
 import Control.Monad (MonadPlus(..))
-import Control.Monad.Fail
+import qualified Control.Monad.Fail as Fail
 import Control.Monad.Fix
 import Control.Monad.IO.Class
 import Control.Monad.Trans.Class
 import GHC.Generics (Generic1)
-import Prelude hiding (fail)
 
 data NonDet m k
   = Empty
@@ -63,8 +62,8 @@
     a (\ a' -> runNonDetC (f a') cons)
   {-# INLINE (>>=) #-}
 
-instance MonadFail m => MonadFail (NonDetC m) where
-  fail s = NonDetC (\ _ _ -> fail s)
+instance Fail.MonadFail m => Fail.MonadFail (NonDetC m) where
+  fail s = NonDetC (\ _ _ -> Fail.fail s)
   {-# INLINE fail #-}
 
 instance MonadFix m => MonadFix (NonDetC m) where
diff --git a/src/Control/Effect/Pure.hs b/src/Control/Effect/Pure.hs
--- a/src/Control/Effect/Pure.hs
+++ b/src/Control/Effect/Pure.hs
@@ -10,7 +10,6 @@
 import Control.Applicative
 import Control.Monad.Fix
 import Data.Coerce
-import Data.Function (fix)
 import GHC.Generics (Generic1)
 
 data Pure (m :: * -> *) k
diff --git a/src/Control/Effect/Random.hs b/src/Control/Effect/Random.hs
--- a/src/Control/Effect/Random.hs
+++ b/src/Control/Effect/Random.hs
@@ -20,7 +20,7 @@
 import Control.Effect.Carrier
 import Control.Effect.State
 import Control.Monad (MonadPlus(..))
-import Control.Monad.Fail
+import qualified Control.Monad.Fail as Fail
 import Control.Monad.Fix
 import Control.Monad.Random.Class (MonadInterleave(..), MonadRandom(..))
 import Control.Monad.IO.Class (MonadIO(..))
@@ -69,7 +69,7 @@
 evalRandomIO m = liftIO R.newStdGen >>= flip evalRandom m
 
 newtype RandomC g m a = RandomC { runRandomC :: StateC g m a }
-  deriving (Alternative, Applicative, Functor, Monad, MonadFail, MonadFix, MonadIO, MonadPlus, MonadTrans)
+  deriving (Alternative, Applicative, Functor, Monad, Fail.MonadFail, MonadFix, MonadIO, MonadPlus, MonadTrans)
 
 instance (Carrier sig m, Effect sig, R.RandomGen g) => MonadRandom (RandomC g m) where
   getRandom = RandomC $ do
diff --git a/src/Control/Effect/Reader.hs b/src/Control/Effect/Reader.hs
--- a/src/Control/Effect/Reader.hs
+++ b/src/Control/Effect/Reader.hs
@@ -17,12 +17,11 @@
 import Control.Applicative (Alternative(..), liftA2)
 import Control.Effect.Carrier
 import Control.Monad (MonadPlus(..))
-import Control.Monad.Fail
+import qualified Control.Monad.Fail as Fail
 import Control.Monad.Fix
 import Control.Monad.IO.Class
 import Control.Monad.IO.Unlift
 import Control.Monad.Trans.Class
-import Prelude hiding (fail)
 
 data Reader r m k
   = Ask (r -> m k)
@@ -88,8 +87,8 @@
   ReaderC a >>= f = ReaderC (\ r -> a r >>= runReader r . f)
   {-# INLINE (>>=) #-}
 
-instance MonadFail m => MonadFail (ReaderC r m) where
-  fail = ReaderC . const . fail
+instance Fail.MonadFail m => Fail.MonadFail (ReaderC r m) where
+  fail = ReaderC . const . Fail.fail
   {-# INLINE fail #-}
 
 instance MonadFix m => MonadFix (ReaderC s m) where
diff --git a/src/Control/Effect/Resource.hs b/src/Control/Effect/Resource.hs
--- a/src/Control/Effect/Resource.hs
+++ b/src/Control/Effect/Resource.hs
@@ -16,7 +16,7 @@
 import           Control.Effect.Reader
 import qualified Control.Exception as Exc
 import           Control.Monad (MonadPlus(..))
-import           Control.Monad.Fail
+import qualified Control.Monad.Fail as Fail
 import           Control.Monad.Fix
 import           Control.Monad.IO.Class
 import           Control.Monad.IO.Unlift
@@ -99,7 +99,7 @@
 runResource r = withRunInIO (\f -> runHandler (Handler f) r)
 
 newtype ResourceC m a = ResourceC { runResourceC :: ReaderC (Handler m) m a }
-  deriving (Alternative, Applicative, Functor, Monad, MonadFail, MonadFix, MonadIO, MonadPlus)
+  deriving (Alternative, Applicative, Functor, Monad, Fail.MonadFail, MonadFix, MonadIO, MonadPlus)
 
 instance MonadUnliftIO m => MonadUnliftIO (ResourceC m) where
   askUnliftIO = ResourceC . ReaderC $ \(Handler h) ->
diff --git a/src/Control/Effect/Resumable.hs b/src/Control/Effect/Resumable.hs
--- a/src/Control/Effect/Resumable.hs
+++ b/src/Control/Effect/Resumable.hs
@@ -21,7 +21,7 @@
 import Control.Effect.Error
 import Control.Effect.Reader
 import Control.Monad (MonadPlus(..))
-import Control.Monad.Fail
+import qualified Control.Monad.Fail as Fail
 import Control.Monad.Fix
 import Control.Monad.IO.Class
 import Control.Monad.Trans.Class
@@ -92,7 +92,7 @@
 runResumable = runError . runResumableC
 
 newtype ResumableC err m a = ResumableC { runResumableC :: ErrorC (SomeError err) m a }
-  deriving newtype (Alternative, Applicative, Functor, Monad, MonadFail, MonadFix, MonadIO, MonadPlus, MonadTrans)
+  deriving newtype (Alternative, Applicative, Functor, Monad, Fail.MonadFail, MonadFix, MonadIO, MonadPlus, MonadTrans)
 
 instance (Carrier sig m, Effect sig) => Carrier (Resumable err :+: sig) (ResumableC err m) where
   eff (L (Resumable err _)) = ResumableC (throwError (SomeError err))
@@ -114,7 +114,7 @@
 runResumableWith with = runReader (Handler with) . runResumableWithC
 
 newtype ResumableWithC err m a = ResumableWithC { runResumableWithC :: ReaderC (Handler err m) m a }
-  deriving newtype (Alternative, Applicative, Functor, Monad, MonadFail, MonadFix, MonadIO, MonadPlus)
+  deriving newtype (Alternative, Applicative, Functor, Monad, Fail.MonadFail, MonadFix, MonadIO, MonadPlus)
 
 instance MonadTrans (ResumableWithC err) where
   lift = ResumableWithC . lift
diff --git a/src/Control/Effect/State/Lazy.hs b/src/Control/Effect/State/Lazy.hs
--- a/src/Control/Effect/State/Lazy.hs
+++ b/src/Control/Effect/State/Lazy.hs
@@ -16,11 +16,10 @@
 import Control.Effect.Carrier
 import Control.Effect.State.Internal as State
 import Control.Monad (MonadPlus(..))
-import Control.Monad.Fail
+import qualified Control.Monad.Fail as Fail
 import Control.Monad.Fix
 import Control.Monad.IO.Class
 import Control.Monad.Trans.Class
-import Prelude hiding (fail)
 
 newtype StateC s m a = StateC { runStateC :: s -> m (s, a) }
 
@@ -51,8 +50,8 @@
   StateC l <|> StateC r = StateC (\ s -> l s <|> r s)
   {-# INLINE (<|>) #-}
 
-instance MonadFail m => MonadFail (StateC s m) where
-  fail s = StateC (const (fail s))
+instance Fail.MonadFail m => Fail.MonadFail (StateC s m) where
+  fail s = StateC (const (Fail.fail s))
   {-# INLINE fail #-}
 
 instance MonadFix m => MonadFix (StateC s m) where
diff --git a/src/Control/Effect/State/Strict.hs b/src/Control/Effect/State/Strict.hs
--- a/src/Control/Effect/State/Strict.hs
+++ b/src/Control/Effect/State/Strict.hs
@@ -16,11 +16,10 @@
 import Control.Effect.Carrier
 import Control.Effect.State.Internal as State
 import Control.Monad (MonadPlus(..))
-import Control.Monad.Fail
+import qualified Control.Monad.Fail as Fail
 import Control.Monad.Fix
 import Control.Monad.IO.Class
 import Control.Monad.Trans.Class
-import Prelude hiding (fail)
 
 -- | Run a 'State' effect starting from the passed value.
 --
@@ -72,8 +71,8 @@
     fa `seq` runState s' fa
   {-# INLINE (>>=) #-}
 
-instance MonadFail m => MonadFail (StateC s m) where
-  fail s = StateC (const (fail s))
+instance Fail.MonadFail m => Fail.MonadFail (StateC s m) where
+  fail s = StateC (const (Fail.fail s))
   {-# INLINE fail #-}
 
 instance MonadFix m => MonadFix (StateC s m) where
diff --git a/src/Control/Effect/Trace.hs b/src/Control/Effect/Trace.hs
--- a/src/Control/Effect/Trace.hs
+++ b/src/Control/Effect/Trace.hs
@@ -20,7 +20,7 @@
 import Control.Effect.Carrier
 import Control.Effect.State
 import Control.Monad (MonadPlus(..))
-import Control.Monad.Fail
+import qualified Control.Monad.Fail as Fail
 import Control.Monad.Fix
 import Control.Monad.IO.Class
 import Control.Monad.Trans.Class
@@ -45,7 +45,7 @@
 runTraceByPrinting = runTraceByPrintingC
 
 newtype TraceByPrintingC m a = TraceByPrintingC { runTraceByPrintingC :: m a }
-  deriving newtype (Alternative, Applicative, Functor, Monad, MonadFail, MonadFix, MonadIO, MonadPlus)
+  deriving newtype (Alternative, Applicative, Functor, Monad, Fail.MonadFail, MonadFix, MonadIO, MonadPlus)
 
 instance MonadTrans TraceByPrintingC where
   lift = TraceByPrintingC
@@ -64,7 +64,7 @@
 runTraceByIgnoring = runTraceByIgnoringC
 
 newtype TraceByIgnoringC m a = TraceByIgnoringC { runTraceByIgnoringC :: m a }
-  deriving newtype (Alternative, Applicative, Functor, Monad, MonadFail, MonadFix, MonadIO, MonadPlus)
+  deriving newtype (Alternative, Applicative, Functor, Monad, Fail.MonadFail, MonadFix, MonadIO, MonadPlus)
 
 instance MonadTrans TraceByIgnoringC where
   lift = TraceByIgnoringC
@@ -83,7 +83,7 @@
 runTraceByReturning = fmap (first reverse) . runState [] . runTraceByReturningC
 
 newtype TraceByReturningC m a = TraceByReturningC { runTraceByReturningC :: StateC [String] m a }
-  deriving newtype (Alternative, Applicative, Functor, Monad, MonadFail, MonadFix, MonadIO, MonadPlus, MonadTrans)
+  deriving newtype (Alternative, Applicative, Functor, Monad, Fail.MonadFail, MonadFix, MonadIO, MonadPlus, MonadTrans)
 
 instance (Carrier sig m, Effect sig) => Carrier (Trace :+: sig) (TraceByReturningC m) where
   eff (L (Trace m k)) = TraceByReturningC (modify (m :)) *> k
diff --git a/src/Control/Effect/Writer.hs b/src/Control/Effect/Writer.hs
--- a/src/Control/Effect/Writer.hs
+++ b/src/Control/Effect/Writer.hs
@@ -20,7 +20,7 @@
 import Control.Effect.Carrier
 import Control.Effect.State
 import Control.Monad (MonadPlus(..))
-import Control.Monad.Fail
+import qualified Control.Monad.Fail as Fail
 import Control.Monad.Fix
 import Control.Monad.IO.Class
 import Control.Monad.Trans.Class
@@ -93,7 +93,7 @@
 --
 --   This is based on a post Gabriel Gonzalez made to the Haskell mailing list: https://mail.haskell.org/pipermail/libraries/2013-March/019528.html
 newtype WriterC w m a = WriterC { runWriterC :: StateC w m a }
-  deriving (Alternative, Applicative, Functor, Monad, MonadFail, MonadFix, MonadIO, MonadPlus, MonadTrans)
+  deriving (Alternative, Applicative, Functor, Monad, Fail.MonadFail, MonadFix, MonadIO, MonadPlus, MonadTrans)
 
 instance (Monoid w, Carrier sig m, Effect sig) => Carrier (Writer w :+: sig) (WriterC w m) where
   eff (L (Tell w     k)) = WriterC $ do