diff --git a/src/Control/Monad/Trans/RWS/CPS.hs b/src/Control/Monad/Trans/RWS/CPS.hs
deleted file mode 100644
--- a/src/Control/Monad/Trans/RWS/CPS.hs
+++ /dev/null
@@ -1,67 +0,0 @@
-{-# LANGUAGE CPP #-}
-#if __GLASGOW_HASKELL__ >= 702
-{-# LANGUAGE Safe #-}
-#endif
-#if __GLASGOW_HASKELL__ >= 710
-{-# LANGUAGE AutoDeriveTypeable #-}
-#endif
------------------------------------------------------------------------------
--- |
--- Module      :  Control.Monad.Trans.RWS.CPS
--- Copyright   :  (c) Daniel Mendler 2016,
---                (c) Andy Gill 2001,
---                (c) Oregon Graduate Institute of Science and Technology, 2001
--- License     :  BSD-style (see the file LICENSE)
---
--- Maintainer  :  mail@daniel-mendler.de
--- Stability   :  experimental
--- Portability :  portable
---
--- A monad transformer that combines 'ReaderT', 'WriterT' and 'StateT'.
--- This version uses continuation-passing-style for the writer part
--- to achieve constant space usage. This transformer can be used as a
--- drop-in replacement for "Control.Monad.Trans.RWS.Strict".
------------------------------------------------------------------------------
-
-module Control.Monad.Trans.RWS.CPS (
-  -- * The RWS monad
-  RWS,
-  rws,
-  runRWS,
-  evalRWS,
-  execRWS,
-  mapRWS,
-  withRWS,
-  -- * The RWST monad transformer
-  RWST,
-  rwsT,
-  runRWST,
-  evalRWST,
-  execRWST,
-  mapRWST,
-  withRWST,
-  -- * Reader operations
-  reader,
-  ask,
-  local,
-  asks,
-  -- * Writer operations
-  writer,
-  tell,
-  listen,
-  listens,
-  pass,
-  censor,
-  -- * State operations
-  state,
-  get,
-  put,
-  modify,
-  gets,
-  -- * Lifting other operations
-  liftCallCC,
-  liftCallCC',
-  liftCatch,
-) where
-
-import Control.Monad.Trans.RWS.CPS.Internal
diff --git a/src/Control/Monad/Trans/RWS/CPS/Internal.hs b/src/Control/Monad/Trans/RWS/CPS/Internal.hs
deleted file mode 100644
--- a/src/Control/Monad/Trans/RWS/CPS/Internal.hs
+++ /dev/null
@@ -1,402 +0,0 @@
-{-# LANGUAGE CPP #-}
-#if __GLASGOW_HASKELL__ >= 702
-{-# LANGUAGE Safe #-}
-#endif
-#if __GLASGOW_HASKELL__ >= 710
-{-# LANGUAGE AutoDeriveTypeable #-}
-#endif
------------------------------------------------------------------------------
--- |
--- Module      :  Control.Monad.Trans.RWS.CPS.Internal
--- Copyright   :  (c) Daniel Mendler 2016,
---                (c) Andy Gill 2001,
---                (c) Oregon Graduate Institute of Science and Technology, 2001
--- License     :  BSD-style (see the file LICENSE)
---
--- Maintainer  :  mail@daniel-mendler.de
--- Stability   :  experimental
--- Portability :  portable
---
--- A monad transformer that combines 'ReaderT', 'WriterT' and 'StateT'.
--- This version uses continuation-passing-style for the writer part
--- to achieve constant space usage. This transformer can be used as a
--- drop-in replacement for "Control.Monad.Trans.RWS.Strict".
------------------------------------------------------------------------------
-
-module Control.Monad.Trans.RWS.CPS.Internal (
-  -- * The RWS monad
-  RWS,
-  rws,
-  runRWS,
-  evalRWS,
-  execRWS,
-  mapRWS,
-  withRWS,
-  -- * The RWST monad transformer
-  RWST(..),
-  rwsT,
-  runRWST,
-  evalRWST,
-  execRWST,
-  mapRWST,
-  withRWST,
-  -- * Reader operations
-  reader,
-  ask,
-  local,
-  asks,
-  -- * Writer operations
-  writer,
-  tell,
-  listen,
-  listens,
-  pass,
-  censor,
-  -- * State operations
-  state,
-  get,
-  put,
-  modify,
-  gets,
-  -- * Lifting other operations
-  liftCallCC,
-  liftCallCC',
-  liftCatch,
-) where
-
-import Control.Applicative
-import Control.Monad
-import Control.Monad.Fix
-import Control.Monad.IO.Class
-import Control.Monad.Trans.Class
-import Control.Monad.Signatures
-import Data.Functor.Identity
-
-#if !(MIN_VERSION_base(4,8,0))
-import Data.Monoid
-#endif
-
-#if MIN_VERSION_base(4,9,0)
-import qualified Control.Monad.Fail as Fail
-#endif
-
--- | A monad containing an environment of type @r@, output of type @w@
--- and an updatable state of type @s@.
-type RWS r w s = RWST r w s Identity
-
--- | Construct an RWS computation from a function.
--- (The inverse of 'runRWS'.)
-rws :: Monoid w => (r -> s -> (a, s, w)) -> RWS r w s a
-rws f = RWST (\r s w -> let (a, s', w') = f r s; wt = w `mappend` w' in wt `seq` return (a, s', wt))
-{-# INLINE rws #-}
-
--- | Unwrap an RWS computation as a function.
--- (The inverse of 'rws'.)
-runRWS :: Monoid w => RWS r w s a -> r -> s -> (a, s, w)
-runRWS m r s = runIdentity (runRWST m r s)
-{-# INLINE runRWS #-}
-
--- | Evaluate a computation with the given initial state and environment,
--- returning the final value and output, discarding the final state.
-evalRWS :: Monoid w
-        => RWS r w s a  -- ^RWS computation to execute
-        -> r            -- ^initial environment
-        -> s            -- ^initial value
-        -> (a, w)       -- ^final value and output
-evalRWS m r s = let
-    (a, _, w) = runRWS m r s
-    in (a, w)
-{-# INLINE evalRWS #-}
-
--- | Evaluate a computation with the given initial state and environment,
--- returning the final state and output, discarding the final value.
-execRWS :: Monoid w
-        => RWS r w s a  -- ^RWS computation to execute
-        -> r            -- ^initial environment
-        -> s            -- ^initial value
-        -> (s, w)       -- ^final state and output
-execRWS m r s = let
-    (_, s', w) = runRWS m r s
-    in (s', w)
-{-# INLINE execRWS #-}
-
--- | Map the return value, final state and output of a computation using
--- the given function.
---
--- * @'runRWS' ('mapRWS' f m) r s = f ('runRWS' m r s)@
-mapRWS :: (Monoid w, Monoid w') => ((a, s, w) -> (b, s, w')) -> RWS r w s a -> RWS r w' s b
-mapRWS f = mapRWST (Identity . f . runIdentity)
-{-# INLINE mapRWS #-}
-
--- | @'withRWS' f m@ executes action @m@ with an initial environment
--- and state modified by applying @f@.
---
--- * @'runRWS' ('withRWS' f m) r s = 'uncurry' ('runRWS' m) (f r s)@
-withRWS :: (r' -> s -> (r, s)) -> RWS r w s a -> RWS r' w s a
-withRWS = withRWST
-{-# INLINE withRWS #-}
-
--- ---------------------------------------------------------------------------
--- | A monad transformer adding reading an environment of type @r@,
--- collecting an output of type @w@ and updating a state of type @s@
--- to an inner monad @m@.
-newtype RWST r w s m a = RWST { unRWST :: r -> s -> w -> m (a, s, w) }
-
--- | The RWST constructor is deliberately not exported in the CPS module to avoid exposing the
--- hidden state w.
--- rwsT provides a safe way to construct a RWST with the same api as the
--- original RWST.
-rwsT :: (Functor m, Monoid w) => (r -> s -> m (a, s, w)) -> RWST r w s m a
-rwsT f = RWST $ \r s w -> (\(a, s', w') -> let wt = w `mappend` w' in wt `seq` (a, s', wt)) <$> f r s
-{-# INLINE rwsT #-}
-
--- | Unwrap an RWST computation as a function.
-runRWST :: Monoid w => RWST r w s m a -> r -> s -> m (a, s, w)
-runRWST m r s = unRWST m r s mempty
-{-# INLINE runRWST #-}
-
--- | Evaluate a computation with the given initial state and environment,
--- returning the final value and output, discarding the final state.
-evalRWST :: (Monad m, Monoid w)
-         => RWST r w s m a      -- ^computation to execute
-         -> r                   -- ^initial environment
-         -> s                   -- ^initial value
-         -> m (a, w)            -- ^computation yielding final value and output
-evalRWST m r s = do
-    (a, _, w) <- runRWST m r s
-    return (a, w)
-{-# INLINE evalRWST #-}
-
--- | Evaluate a computation with the given initial state and environment,
--- returning the final state and output, discarding the final value.
-execRWST :: (Monad m, Monoid w)
-         => RWST r w s m a      -- ^computation to execute
-         -> r                   -- ^initial environment
-         -> s                   -- ^initial value
-         -> m (s, w)            -- ^computation yielding final state and output
-execRWST m r s = do
-    (_, s', w) <- runRWST m r s
-    return (s', w)
-{-# INLINE execRWST #-}
-
--- | Map the inner computation using the given function.
---
--- * @'runRWST' ('mapRWST' f m) r s = f ('runRWST' m r s)@
---mapRWST :: (m (a, s, w) -> n (b, s, w')) -> RWST r w s m a -> RWST r w' s n b
-mapRWST :: (Monad n, Monoid w, Monoid w')
-  => (m (a, s, w) -> n (b, s, w')) -> RWST r w s m a -> RWST r w' s n b
-mapRWST f m = RWST $ \r s w -> do
-  (a, s', w') <- f (runRWST m r s)
-  let wt = w `mappend` w'
-  wt `seq` return (a, s', wt)
-{-# INLINE mapRWST #-}
-
--- | @'withRWST' f m@ executes action @m@ with an initial environment
--- and state modified by applying @f@.
---
--- * @'runRWST' ('withRWST' f m) r s = 'uncurry' ('runRWST' m) (f r s)@
-withRWST :: (r' -> s -> (r, s)) -> RWST r w s m a -> RWST r' w s m a
-withRWST f m = RWST $ \r s -> uncurry (unRWST m) (f r s)
-{-# INLINE withRWST #-}
-
-instance Functor m => Functor (RWST r w s m) where
-  fmap f m = RWST $ \r s w -> (\(a, s', w') -> (f a, s', w')) <$> unRWST m r s w
-  {-# INLINE fmap #-}
-
-instance (Functor m, Monad m) => Applicative (RWST r w s m) where
-  pure a = RWST $ \_ s w -> return (a, s, w)
-  {-# INLINE pure #-}
-
-  RWST mf <*> RWST mx = RWST $ \r s w -> do
-    (f, s', w')  <- mf r s w
-    (x, s'', w'') <- mx r s' w'
-    return (f x, s'', w'')
-  {-# INLINE (<*>) #-}
-
-instance (Functor m, MonadPlus m) => Alternative (RWST r w s m) where
-  empty = RWST $ \_ _ _ -> mzero
-  {-# INLINE empty #-}
-
-  RWST m <|> RWST n = RWST $ \r s w -> m r s w `mplus` n r s w
-  {-# INLINE (<|>) #-}
-
-instance Monad m => Monad (RWST r w s m) where
-#if !(MIN_VERSION_base(4,8,0))
-  return a = RWST $ \_ s w -> return (a, s, w)
-  {-# INLINE return #-}
-#endif
-
-  m >>= k = RWST $ \r s w -> do
-    (a, s', w')  <- unRWST m r s w
-    unRWST (k a) r s' w'
-  {-# INLINE (>>=) #-}
-
-  fail msg = RWST $ \_ _ _ -> fail msg
-  {-# INLINE fail #-}
-
-#if MIN_VERSION_base(4,9,0)
-instance Fail.MonadFail m => Fail.MonadFail (RWST r w s m) where
-  fail msg = RWST $ \_ _ _ -> Fail.fail msg
-  {-# INLINE fail #-}
-#endif
-
-instance (Functor m, MonadPlus m) => MonadPlus (RWST r w s m) where
-  mzero = empty
-  {-# INLINE mzero #-}
-  mplus = (<|>)
-  {-# INLINE mplus #-}
-
-instance MonadFix m => MonadFix (RWST r w s m) where
-  mfix f = RWST $ \r s w -> mfix $ \ ~(a, _, _) -> unRWST (f a) r s w
-  {-# INLINE mfix #-}
-
-instance MonadTrans (RWST r w s) where
-  lift m = RWST $ \_ s w -> do
-    a <- m
-    return (a, s, w)
-  {-# INLINE lift #-}
-
-instance MonadIO m => MonadIO (RWST r w s m) where
-  liftIO = lift . liftIO
-  {-# INLINE liftIO #-}
--- ---------------------------------------------------------------------------
--- Reader operations
-
--- | Constructor for computations in the reader monad (equivalent to 'asks').
-reader :: Monad m => (r -> a) -> RWST r w s m a
-reader = asks
-{-# INLINE reader #-}
-
--- | Fetch the value of the environment.
-ask :: Monad m => RWST r w s m r
-ask = asks id
-{-# INLINE ask #-}
-
--- | Execute a computation in a modified environment
---
--- * @'runRWST' ('local' f m) r s = 'runRWST' m (f r) s@
-local :: (r -> r) -> RWST r w s m a -> RWST r w s m a
-local f m = RWST $ \r s w -> unRWST m (f r) s w
-{-# INLINE local #-}
-
--- | Retrieve a function of the current environment.
---
--- * @'asks' f = 'liftM' f 'ask'@
-asks :: Monad m => (r -> a) -> RWST r w s m a
-asks f = RWST $ \r s w -> return (f r, s, w)
-{-# INLINE asks #-}
-
--- ---------------------------------------------------------------------------
--- Writer operations
-
--- | Construct a writer computation from a (result, output) pair.
-writer :: (Monoid w, Monad m) => (a, w) -> RWST r w s m a
-writer (a, w') = RWST $ \_ s w -> let wt = w `mappend` w' in wt `seq` return (a, s, wt)
-{-# INLINE writer #-}
-
--- | @'tell' w@ is an action that produces the output @w@.
-tell :: (Monoid w, Monad m) => w -> RWST r w s m ()
-tell w' = writer ((), w')
-{-# INLINE tell #-}
-
--- | @'listen' m@ is an action that executes the action @m@ and adds its
--- output to the value of the computation.
---
--- * @'runRWST' ('listen' m) r s = 'liftM' (\\ (a, w) -> ((a, w), w)) ('runRWST' m r s)@
-listen :: (Monoid w, Monad m) => RWST r w s m a -> RWST r w s m (a, w)
-listen = listens id
-{-# INLINE listen #-}
-
--- | @'listens' f m@ is an action that executes the action @m@ and adds
--- the result of applying @f@ to the output to the value of the computation.
---
--- * @'listens' f m = 'liftM' (id *** f) ('listen' m)@
---
--- * @'runRWST' ('listens' f m) r s = 'liftM' (\\ (a, w) -> ((a, f w), w)) ('runRWST' m r s)@
-listens :: (Monoid w, Monad m) => (w -> b) -> RWST r w s m a -> RWST r w s m (a, b)
-listens f m = RWST $ \r s w -> do
-  (a, s', w') <- runRWST m r s
-  let wt = w `mappend` w'
-  wt `seq` return ((a, f w'), s', wt)
-{-# INLINE listens #-}
-
--- | @'pass' m@ is an action that executes the action @m@, which returns
--- a value and a function, and returns the value, applying the function
--- to the output.
---
--- * @'runRWST' ('pass' m) r s = 'liftM' (\\ ((a, f), w) -> (a, f w)) ('runRWST' m r s)@
-pass :: (Monoid w, Monoid w', Monad m) => RWST r w s m (a, w -> w') -> RWST r w' s m a
-pass m = RWST $ \r s w -> do
-  ((a, f), s', w') <- runRWST m r s
-  let wt = w `mappend` f w'
-  wt `seq` return (a, s', wt)
-{-# INLINE pass #-}
-
--- | @'censor' f m@ is an action that executes the action @m@ and
--- applies the function @f@ to its output, leaving the return value
--- unchanged.
---
--- * @'censor' f m = 'pass' ('liftM' (\\ x -> (x,f)) m)@
---
--- * @'runRWST' ('censor' f m) r s = 'liftM' (\\ (a, w) -> (a, f w)) ('runRWST' m r s)@
-censor :: (Monoid w, Monad m) => (w -> w) -> RWST r w s m a -> RWST r w s m a
-censor f m = RWST $ \r s w -> do
-  (a, s', w') <- runRWST m r s
-  let wt = w `mappend` f w'
-  wt `seq` return (a, s', wt)
-{-# INLINE censor #-}
-
--- ---------------------------------------------------------------------------
--- State operations
-
--- | Construct a state monad computation from a state transformer function.
-state :: Monad m => (s -> (a, s)) -> RWST r w s m a
-state f = RWST $ \_ s w -> let (a, s') = f s in return (a, s', w)
-{-# INLINE state #-}
-
--- | Fetch the current value of the state within the monad.
-get :: Monad m => RWST r w s m s
-get = gets id
-{-# INLINE get #-}
-
--- | @'put' s@ sets the state within the monad to @s@.
-put :: Monad m => s -> RWST r w s m ()
-put s = RWST $ \_ _ w -> return ((), s, w)
-{-# INLINE put #-}
-
--- | @'modify' f@ is an action that updates the state to the result of
--- applying @f@ to the current state.
---
--- * @'modify' f = 'get' >>= ('put' . f)@
-modify :: Monad m => (s -> s) -> RWST r w s m ()
-modify f = RWST $ \_ s w -> return ((), f s, w)
-{-# INLINE modify #-}
-
--- | Get a specific component of the state, using a projection function
--- supplied.
---
--- * @'gets' f = 'liftM' f 'get'@
-gets :: Monad m => (s -> a) -> RWST r w s m a
-gets f = RWST $ \_ s w -> return (f s, s, w)
-{-# INLINE gets #-}
-
--- | Uniform lifting of a @callCC@ operation to the new monad.
--- This version rolls back to the original state on entering the
--- continuation.
-liftCallCC :: CallCC m (a,s,w) (b,s,w) -> CallCC (RWST r w s m) a b
-liftCallCC callCC f = RWST $ \r s w ->
-  callCC $ \c -> unRWST (f (\a -> RWST $ \_ _ _ -> c (a, s, w))) r s w
-{-# INLINE liftCallCC #-}
-
--- | In-situ lifting of a @callCC@ operation to the new monad.
--- This version uses the current state on entering the continuation.
-liftCallCC' :: CallCC m (a,s,w) (b,s,w) -> CallCC (RWST r w s m) a b
-liftCallCC' callCC f = RWST $ \r s w ->
-  callCC $ \c -> unRWST (f (\a -> RWST $ \_ s' _ -> c (a, s', w))) r s w
-{-# INLINE liftCallCC' #-}
-
--- | Lift a @catchE@ operation to the new monad.
-liftCatch :: Catch e m (a,s,w) -> Catch e (RWST r w s m) a
-liftCatch catchE m h =
-  RWST $ \r s w -> unRWST m r s w `catchE` \e -> unRWST (h e) r s w
-{-# INLINE liftCatch #-}
diff --git a/src/Control/Monad/Trans/Writer/CPS.hs b/src/Control/Monad/Trans/Writer/CPS.hs
deleted file mode 100644
--- a/src/Control/Monad/Trans/Writer/CPS.hs
+++ /dev/null
@@ -1,56 +0,0 @@
-{-# LANGUAGE CPP #-}
-#if __GLASGOW_HASKELL__ >= 702
-{-# LANGUAGE Safe #-}
-#endif
-#if __GLASGOW_HASKELL__ >= 710
-{-# LANGUAGE AutoDeriveTypeable #-}
-#endif
------------------------------------------------------------------------------
--- |
--- Module      :  Control.Monad.Trans.Writer.CPS
--- Copyright   :  (c) Daniel Mendler 2016,
---                (c) Andy Gill 2001,
---                (c) Oregon Graduate Institute of Science and Technology, 2001
--- License     :  BSD-style (see the file LICENSE)
---
--- Maintainer  :  mail@daniel-mendler.de
--- Stability   :  experimental
--- Portability :  portable
---
--- The strict 'WriterT' monad transformer, which adds collection of
--- outputs (such as a count or string output) to a given monad.
---
--- This monad transformer provides only limited access to the output
--- during the computation. For more general access, use
--- "Control.Monad.Trans.State" instead.
---
--- This version builds its output strictly and uses continuation-passing-style
--- to achieve constant space usage. This transformer can be used as a
--- drop-in replacement for "Control.Monad.Trans.Writer.Strict".
------------------------------------------------------------------------------
-
-module Control.Monad.Trans.Writer.CPS (
-  -- * The Writer monad
-  Writer,
-  writer,
-  runWriter,
-  execWriter,
-  mapWriter,
-  -- * The WriterT monad transformer
-  WriterT,
-  writerT,
-  runWriterT,
-  execWriterT,
-  mapWriterT,
-  -- * Writer operations
-  tell,
-  listen,
-  listens,
-  pass,
-  censor,
-  -- * Lifting other operations
-  liftCallCC,
-  liftCatch,
-) where
-
-import Control.Monad.Trans.Writer.CPS.Internal
diff --git a/src/Control/Monad/Trans/Writer/CPS/Internal.hs b/src/Control/Monad/Trans/Writer/CPS/Internal.hs
deleted file mode 100644
--- a/src/Control/Monad/Trans/Writer/CPS/Internal.hs
+++ /dev/null
@@ -1,276 +0,0 @@
-{-# LANGUAGE CPP #-}
-#if __GLASGOW_HASKELL__ >= 702
-{-# LANGUAGE Safe #-}
-#endif
-#if __GLASGOW_HASKELL__ >= 710
-{-# LANGUAGE AutoDeriveTypeable #-}
-#endif
------------------------------------------------------------------------------
--- |
--- Module      :  Control.Monad.Trans.Writer.CPS.Internal
--- Copyright   :  (c) Daniel Mendler 2016,
---                (c) Andy Gill 2001,
---                (c) Oregon Graduate Institute of Science and Technology, 2001
--- License     :  BSD-style (see the file LICENSE)
---
--- Maintainer  :  mail@daniel-mendler.de
--- Stability   :  experimental
--- Portability :  portable
---
--- The strict 'WriterT' monad transformer, which adds collection of
--- outputs (such as a count or string output) to a given monad.
---
--- This monad transformer provides only limited access to the output
--- during the computation. For more general access, use
--- "Control.Monad.Trans.State" instead.
---
--- This version builds its output strictly and uses continuation-passing-style
--- to achieve constant space usage. This transformer can be used as a
--- drop-in replacement for "Control.Monad.Trans.Writer.Strict".
------------------------------------------------------------------------------
-
-module Control.Monad.Trans.Writer.CPS.Internal (
-  -- * The Writer monad
-  Writer,
-  writer,
-  runWriter,
-  execWriter,
-  mapWriter,
-  -- * The WriterT monad transformer
-  WriterT(..),
-  writerT,
-  runWriterT,
-  execWriterT,
-  mapWriterT,
-  -- * Writer operations
-  tell,
-  listen,
-  listens,
-  pass,
-  censor,
-  -- * Lifting other operations
-  liftCallCC,
-  liftCatch,
-) where
-
-import Control.Applicative
-import Control.Monad
-import Control.Monad.Fix
-import Control.Monad.IO.Class
-import Control.Monad.Trans.Class
-import Control.Monad.Signatures
-import Data.Functor.Identity
-
-#if !(MIN_VERSION_base(4,8,0))
-import Data.Monoid
-#endif
-
-#if MIN_VERSION_base(4,9,0)
-import qualified Control.Monad.Fail as Fail
-#endif
-
--- ---------------------------------------------------------------------------
--- | A writer monad parameterized by the type @w@ of output to accumulate.
---
--- The 'return' function produces the output 'mempty', while '>>='
--- combines the outputs of the subcomputations using 'mappend'.
-type Writer w = WriterT w Identity
-
--- | Construct a writer computation from a (result, output) pair.
--- (The inverse of 'runWriter'.)
-writer :: (Monoid w, Monad m) => (a, w) -> WriterT w m a
-writer (a, w') = WriterT $ \w -> let wt = w `mappend` w' in wt `seq` return (a, wt)
-{-# INLINE writer #-}
-
--- | Unwrap a writer computation as a (result, output) pair.
--- (The inverse of 'writer'.)
-runWriter :: Monoid w => Writer w a -> (a, w)
-runWriter = runIdentity . runWriterT
-{-# INLINE runWriter #-}
-
--- | Extract the output from a writer computation.
---
--- * @'execWriter' m = 'snd' ('runWriter' m)@
-execWriter :: Monoid w => Writer w a -> w
-execWriter = runIdentity . execWriterT
-{-# INLINE execWriter #-}
-
--- | Map both the return value and output of a computation using
--- the given function.
---
--- * @'runWriter' ('mapWriter' f m) = f ('runWriter' m)@
-mapWriter :: (Monoid w, Monoid w') => ((a, w) -> (b, w')) -> Writer w a -> Writer w' b
-mapWriter f = mapWriterT (Identity . f . runIdentity)
-{-# INLINE mapWriter #-}
-
--- ---------------------------------------------------------------------------
--- | A writer monad parameterized by:
---
---   * @w@ - the output to accumulate.
---
---   * @m@ - The inner monad.
---
--- The 'return' function produces the output 'mempty', while '>>='
--- combines the outputs of the subcomputations using 'mappend'.
-
-newtype WriterT w m a = WriterT { unWriterT :: w -> m (a, w) }
-
--- | The WriterT constructor is deliberately not exported in the CPS module to avoid exposing the
--- hidden state w.
--- writerT provides a safe way to construct a WriterT with the same api as the
--- original WriterT.
-writerT :: (Functor m, Monoid w) => m (a, w) -> WriterT w m a
-writerT f = WriterT $ \w -> (\(a, w') -> let wt = w `mappend` w' in wt `seq` (a, wt)) <$> f
-{-# INLINE writerT #-}
-
--- | Unwrap a writer computation.
-runWriterT :: Monoid w => WriterT w m a -> m (a, w)
-runWriterT m = unWriterT m mempty
-{-# INLINE runWriterT #-}
-
--- | Extract the output from a writer computation.
---
--- * @'execWriterT' m = 'liftM' 'snd' ('runWriterT' m)@
-execWriterT :: (Monad m, Monoid w) => WriterT w m a -> m w
-execWriterT m = do
-  (_, w) <- runWriterT m
-  return w
-{-# INLINE execWriterT #-}
-
--- | Map both the return value and output of a computation using
--- the given function.
---
--- * @'runWriterT' ('mapWriterT' f m) = f ('runWriterT' m)@
-mapWriterT :: (Monad n, Monoid w, Monoid w') =>
-  (m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b
-mapWriterT f m = WriterT $ \w -> do
-  (a, w') <- f (runWriterT m)
-  let wt = w `mappend` w'
-  wt `seq` return (a, wt)
-{-# INLINE mapWriterT #-}
-
-instance Functor m => Functor (WriterT w m) where
-  fmap f m = WriterT $ \w -> (\(a, w') -> (f a, w')) <$> unWriterT m w
-  {-# INLINE fmap #-}
-
-instance (Functor m, Monad m) => Applicative (WriterT w m) where
-  pure a = WriterT $ \w -> return (a, w)
-  {-# INLINE pure #-}
-
-  WriterT mf <*> WriterT mx = WriterT $ \w -> do
-    (f, w') <- mf w
-    (x, w'') <- mx w'
-    return (f x, w'')
-  {-# INLINE (<*>) #-}
-
-instance (Functor m, MonadPlus m) => Alternative (WriterT w m) where
-  empty = WriterT $ const mzero
-  {-# INLINE empty #-}
-
-  WriterT m <|> WriterT n = WriterT $ \w -> m w `mplus` n w
-  {-# INLINE (<|>) #-}
-
-instance Monad m => Monad (WriterT w m) where
-#if !(MIN_VERSION_base(4,8,0))
-  return a = WriterT $ \w -> return (a, w)
-  {-# INLINE return #-}
-#endif
-
-  m >>= k = WriterT $ \w -> do
-    (a, w') <- unWriterT m w
-    unWriterT (k a) w'
-  {-# INLINE (>>=) #-}
-
-  fail msg = WriterT $ \_ -> fail msg
-  {-# INLINE fail #-}
-
-#if MIN_VERSION_base(4,9,0)
-instance Fail.MonadFail m => Fail.MonadFail (WriterT w m) where
-  fail msg = WriterT $ \_ -> Fail.fail msg
-  {-# INLINE fail #-}
-#endif
-
-instance (Functor m, MonadPlus m) => MonadPlus (WriterT w m) where
-  mzero = empty
-  {-# INLINE mzero #-}
-  mplus = (<|>)
-  {-# INLINE mplus #-}
-
-instance MonadFix m => MonadFix (WriterT w m) where
-  mfix f = WriterT $ \w -> mfix $ \ ~(a, _) -> unWriterT (f a) w
-  {-# INLINE mfix #-}
-
-instance MonadTrans (WriterT w) where
-  lift m = WriterT $ \w -> do
-    a <- m
-    return (a, w)
-  {-# INLINE lift #-}
-
-instance MonadIO m => MonadIO (WriterT w m) where
-  liftIO = lift . liftIO
-  {-# INLINE liftIO #-}
-
--- | @'tell' w@ is an action that produces the output @w@.
-tell :: (Monoid w, Monad m) => w -> WriterT w m ()
-tell w = writer ((), w)
-{-# INLINE tell #-}
-
--- | @'listen' m@ is an action that executes the action @m@ and adds its
--- output to the value of the computation.
---
--- * @'runWriterT' ('listen' m) = 'liftM' (\\ (a, w) -> ((a, w), w)) ('runWriterT' m)@
-listen :: (Monoid w, Monad m) => WriterT w m a -> WriterT w m (a, w)
-listen = listens id
-{-# INLINE listen #-}
-
--- | @'listens' f m@ is an action that executes the action @m@ and adds
--- the result of applying @f@ to the output to the value of the computation.
---
--- * @'listens' f m = 'liftM' (id *** f) ('listen' m)@
---
--- * @'runWriterT' ('listens' f m) = 'liftM' (\\ (a, w) -> ((a, f w), w)) ('runWriterT' m)@
-listens :: (Monoid w, Monad m) => (w -> b) -> WriterT w m a -> WriterT w m (a, b)
-listens f m = WriterT $ \w -> do
-  (a, w') <- runWriterT m
-  let wt = w `mappend` w'
-  wt `seq` return ((a, f w'), wt)
-{-# INLINE listens #-}
-
--- | @'pass' m@ is an action that executes the action @m@, which returns
--- a value and a function, and returns the value, applying the function
--- to the output.
---
--- * @'runWriterT' ('pass' m) = 'liftM' (\\ ((a, f), w) -> (a, f w)) ('runWriterT' m)@
-pass :: (Monoid w, Monoid w', Monad m) => WriterT w m (a, w -> w') -> WriterT w' m a
-pass m = WriterT $ \w -> do
-  ((a, f), w') <- runWriterT m
-  let wt = w `mappend` f w'
-  wt `seq` return (a, wt)
-{-# INLINE pass #-}
-
--- | @'censor' f m@ is an action that executes the action @m@ and
--- applies the function @f@ to its output, leaving the return value
--- unchanged.
---
--- * @'censor' f m = 'pass' ('liftM' (\\ x -> (x,f)) m)@
---
--- * @'runWriterT' ('censor' f m) = 'liftM' (\\ (a, w) -> (a, f w)) ('runWriterT' m)@
-censor :: (Monoid w, Monad m) => (w -> w) -> WriterT w m a -> WriterT w m a
-censor f m = WriterT $ \w -> do
-  (a, w') <- runWriterT m
-  let wt = w `mappend` f w'
-  wt `seq` return (a, wt)
-{-# INLINE censor #-}
-
--- | Uniform lifting of a @callCC@ operation to the new monad.
--- This version rolls back to the original state on entering the
--- continuation.
-liftCallCC :: CallCC m (a, w) (b, w) -> CallCC (WriterT w m) a b
-liftCallCC callCC f = WriterT $ \w ->
-  callCC $ \c -> unWriterT (f (\a -> WriterT $ \_ -> c (a, w))) w
-{-# INLINE liftCallCC #-}
-
--- | Lift a @catchE@ operation to the new monad.
-liftCatch :: Catch e m (a, w) -> Catch e (WriterT w m) a
-liftCatch catchE m h = WriterT $ \w -> unWriterT m w `catchE` \e -> unWriterT (h e) w
-{-# INLINE liftCatch #-}
diff --git a/writer-cps-transformers.cabal b/writer-cps-transformers.cabal
--- a/writer-cps-transformers.cabal
+++ b/writer-cps-transformers.cabal
@@ -1,5 +1,5 @@
 name:           writer-cps-transformers
-version:        0.5.5.0
+version:        0.5.6.0
 license:        BSD3
 license-file:   LICENSE
 tested-with:    GHC == 7.10.3, GHC == 8.0.1, GHC == 8.2.1, GHC == 8.4.3, GHC == 8.4.4, GHC == 8.6.1, GHC == 8.6.2, GHC == 8.6.3, GHC == 8.6.4
@@ -21,13 +21,6 @@
 library
   build-depends:
     base <6,
-    transformers >=0.4 && <= 0.5.6.0
-  hs-source-dirs:
-    src
+    transformers >= 0.5.6.0
   ghc-options: -Wall
-  exposed-modules:
-    Control.Monad.Trans.RWS.CPS
-    Control.Monad.Trans.RWS.CPS.Internal
-    Control.Monad.Trans.Writer.CPS
-    Control.Monad.Trans.Writer.CPS.Internal
   default-language: Haskell2010