diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -1,3 +1,81 @@
+# ChangeLog for monad-logger
+
+## 0.3.42
+
+* Forward compatibility with `-Wnoncanonical-monad-instances` becoming an error
+
+## 0.3.41
+
+* Add `MonadAccum` instances for `LoggingT` and `NoLoggingT`
+
+## 0.3.40
+
+* Relax `fast-logger` upper bound from 3.2 to 3.3
+* Add `Alternative` instances for `LoggingT` and `NoLoggingT`
+
+## 0.3.39
+
+* Make the previous change backwards compatible with CPP
+
+## 0.3.38
+
+* Drop old deprecated instances to support transformers 0.6 [#39](https://github.com/snoyberg/monad-logger/pull/39)
+
+## 0.3.37
+
+* Add `Semigroup`/`Monoid` instances to `LoggingT`, `NoLoggingT`, and `WriterLoggingT`
+
+## 0.3.36
+
+* Export the `defaultOutput` function, useful for defining custom instances of `MonadLogger`. [#29](https://github.com/snoyberg/monad-logger/pull/29)
+
+## 0.3.35
+
+* Add Hackage status badge
+* Document `Loc` [#26](https://github.com/snoyberg/monad-logger/pull/26)
+
+## 0.3.34
+
+* Fix build for lts-9 resolver
+
+## 0.3.33
+
+* Export `LogLine` type synonym.
+
+## 0.3.32
+
+* Compat with `unliftio-core` 0.2
+
+## 0.3.31
+
+* Re-export `fromLogStr` to make implementing custom instances more convenient.
+  [#14](https://github.com/snoyberg/monad-logger/pull/14)
+
+## 0.3.30
+
+* Added `MonadFail` instances for `LoggingT` and `NoLoggingT`.
+
+## 0.3.29
+
+* Export mapLoggingT and mapNoLoggingT
+
+## 0.3.28.5
+
+* Fix missing module [#1](https://github.com/snoyberg/monad-logger/issues/1)
+
+## 0.3.28.4
+
+* Move to a new repo
+
+## 0.3.28.3
+
+* Compat for older GHCs [#161](https://github.com/kazu-yamamoto/logger/pull/161)
+
+## 0.3.28.2
+
+* Support for exceptions 0.9 and 0.10 [#158](https://github.com/kazu-yamamoto/logger/issues/158)
+* Drop blaze-builder dependency
+
 ## 0.3.28.1
 
 * Fix support for GHC 7.8 [#154](https://github.com/kazu-yamamoto/logger/pull/154)
diff --git a/Control/Monad/Logger.hs b/Control/Monad/Logger.hs
--- a/Control/Monad/Logger.hs
+++ b/Control/Monad/Logger.hs
@@ -1,5 +1,7 @@
 {-# LANGUAGE CPP #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
 {-# LANGUAGE DefaultSignatures #-}
+{-# LANGUAGE StandaloneDeriving #-}
 #if WITH_CALLSTACK
 {-# LANGUAGE ImplicitParams #-}
 #endif
@@ -32,10 +34,12 @@
       MonadLogger(..)
     , MonadLoggerIO (..)
     , LogLevel(..)
+    , LogLine
     , LogSource
     -- * Re-export from fast-logger
     , LogStr
     , ToLogStr(..)
+    , fromLogStr
     -- * Helper transformers
     , LoggingT (..)
     , runStderrLoggingT
@@ -46,9 +50,11 @@
     , withChannelLogger
     , filterLogger
     , NoLoggingT (..)
+    , mapNoLoggingT
     , WriterLoggingT (..)
     , execWriterLoggingT
     , runWriterLoggingT
+    , mapLoggingT
 #if WITH_TEMPLATE_HASKELL
     -- * TH logging
     , logDebug
@@ -94,8 +100,10 @@
 #endif
     -- * utilities for defining your own loggers
     , defaultLogStr
+    -- $locDocs
     , Loc (..)
     , defaultLoc
+    , defaultOutput
     ) where
 
 #if WITH_TEMPLATE_HASKELL
@@ -105,13 +113,16 @@
 import Data.Functor ((<$>))
 import Data.Monoid (Monoid)
 
-import Control.Applicative (Applicative (..), WrappedMonad(..))
+import Control.Applicative (Alternative (..), Applicative (..))
 import Control.Concurrent.Chan (Chan(),writeChan,readChan)
 import Control.Concurrent.STM
 import Control.Concurrent.STM.TBChan
 import Control.Exception.Lifted (onException, bracket)
-import Control.Monad (liftM, ap, when, void, forever)
+import Control.Monad (liftM, when, void, forever)
 import Control.Monad.Base (MonadBase (liftBase), liftBaseDefault)
+#if MIN_VERSION_base(4, 9, 0)
+import qualified Control.Monad.Fail as Fail
+#endif
 import Control.Monad.IO.Unlift
 import Control.Monad.Loops (untilM)
 import Control.Monad.Trans.Control (MonadBaseControl (..), MonadTransControl (..), ComposeSt, defaultLiftBaseWith, defaultRestoreM)
@@ -119,12 +130,18 @@
 
 import Control.Monad.IO.Class (MonadIO (liftIO))
 import Control.Monad.Trans.Resource (MonadResource (liftResourceT))
-import Control.Monad.Catch (MonadThrow (..), MonadCatch (..), MonadMask (..))
+import Control.Monad.Catch (MonadThrow (..), MonadCatch (..), MonadMask (..)
+#if MIN_VERSION_exceptions(0, 10, 0)
+    , ExitCase (..)
+#endif
+                           )
 
 import Control.Monad.Trans.Identity ( IdentityT)
-import Control.Monad.Trans.List     ( ListT    )
 import Control.Monad.Trans.Maybe    ( MaybeT   )
+#if !MIN_VERSION_transformers(0, 6, 0)
+import Control.Monad.Trans.List     ( ListT    )
 import Control.Monad.Trans.Error    ( ErrorT, Error)
+#endif
 import Control.Monad.Trans.Except   ( ExceptT  )
 
 import Control.Monad.Trans.Reader   ( ReaderT  )
@@ -153,13 +170,14 @@
 import Control.Monad.Reader.Class ( MonadReader (..) )
 import Control.Monad.State.Class  ( MonadState (..) )
 import Control.Monad.Writer.Class ( MonadWriter (..) )
+#if MIN_VERSION_mtl(2, 3, 1)
+import Control.Monad.Accum        ( MonadAccum (..) )
+#endif
 
 #if WITH_CALLSTACK
 import GHC.Stack as GHC
 #endif
 
-import Prelude hiding (catch)
-
 import Data.Conduit.Lazy (MonadActive, monadActive)
 
 data LogLevel = LevelDebug | LevelInfo | LevelWarn | LevelError | LevelOther Text
@@ -167,6 +185,22 @@
 
 type LogSource = Text
 
+-- $locDocs
+--
+-- === Loc
+--
+-- When @monad-logger@ is compiled with the @template_haskell@ flag set to true (the default), the 'Loc' below is a re-export from the @template-haskell@ package.
+-- When the flag is false, the 'Loc' below is a copy of that data structure defined in @monad-logger@ itself.
+--
+-- If you are making a library that:
+--
+-- * Uses @monad-logger@
+-- * Uses 'Loc' in a type signature
+-- * But doesn't need to depend on @template-haskell@ for other reasons
+--
+-- You can import 'Loc' directly from this package, instead of adding an dependency on @template-haskell@ and importing from there.
+-- This allows users to compile your package in environments that don't support @template-haskell@.
+
 #if WITH_TEMPLATE_HASKELL
 
 instance Lift LogLevel where
@@ -220,9 +254,11 @@
 
 #define DEF monadLoggerLog a b c d = Trans.lift $ monadLoggerLog a b c d
 instance MonadLogger m => MonadLogger (IdentityT m) where DEF
+#if !MIN_VERSION_transformers(0, 6, 0)
 instance MonadLogger m => MonadLogger (ListT m) where DEF
-instance MonadLogger m => MonadLogger (MaybeT m) where DEF
 instance (MonadLogger m, Error e) => MonadLogger (ErrorT e m) where DEF
+#endif
+instance MonadLogger m => MonadLogger (MaybeT m) where DEF
 instance MonadLogger m => MonadLogger (ExceptT e m) where DEF
 instance MonadLogger m => MonadLogger (ReaderT r m) where DEF
 instance MonadLogger m => MonadLogger (ContT r m) where DEF
@@ -238,9 +274,11 @@
 #undef DEF
 
 instance MonadLoggerIO m => MonadLoggerIO (IdentityT m)
+#if !MIN_VERSION_transformers(0, 6, 0)
 instance MonadLoggerIO m => MonadLoggerIO (ListT m)
-instance MonadLoggerIO m => MonadLoggerIO (MaybeT m)
 instance (MonadLoggerIO m, Error e) => MonadLoggerIO (ErrorT e m)
+#endif
+instance MonadLoggerIO m => MonadLoggerIO (MaybeT m)
 instance MonadLoggerIO m => MonadLoggerIO (ExceptT e m)
 instance MonadLoggerIO m => MonadLoggerIO (ReaderT r m)
 instance MonadLoggerIO m => MonadLoggerIO (ContT r m)
@@ -354,57 +392,17 @@
 --
 -- @since 0.2.4
 newtype NoLoggingT m a = NoLoggingT { runNoLoggingT :: m a }
-
-#if __GLASGOW_HASKELL__ < 710
-instance Monad m => Functor (NoLoggingT m) where
-    fmap = liftM
-
-instance Monad m => Applicative (NoLoggingT m) where
-    pure = return
-    (<*>) = ap
-#else
-instance Functor m => Functor (NoLoggingT m) where
-    fmap f = NoLoggingT . fmap f . runNoLoggingT
-    {-# INLINE fmap #-}
-
-instance Applicative m => Applicative (NoLoggingT m) where
-    pure = NoLoggingT . pure
-    {-# INLINE pure #-}
-    f <*> a = NoLoggingT (runNoLoggingT f <*> runNoLoggingT a)
-    {-# INLINE (<*>) #-}
-#endif
-
-instance Monad m => Monad (NoLoggingT m) where
-    return = NoLoggingT . return
-    NoLoggingT ma >>= f = NoLoggingT $ ma >>= runNoLoggingT . f
-
-instance MonadIO m => MonadIO (NoLoggingT m) where
-    liftIO = Trans.lift . liftIO
-
-instance MonadThrow m => MonadThrow (NoLoggingT m) where
-    throwM = Trans.lift . throwM
+  deriving (
+    Functor, Applicative, Monad, MonadIO, MonadThrow, MonadCatch, MonadMask, MonadActive, MonadBase b
+    , Alternative -- ^ @since 0.3.40
+    )
 
-instance MonadCatch m => MonadCatch (NoLoggingT m) where
-    catch (NoLoggingT m) c =
-        NoLoggingT $ m `catch` \e -> runNoLoggingT (c e)
-instance MonadMask m => MonadMask (NoLoggingT m) where
-    mask a = NoLoggingT $ mask $ \u -> runNoLoggingT (a $ q u)
-      where q u (NoLoggingT b) = NoLoggingT $ u b
-    uninterruptibleMask a =
-        NoLoggingT $ uninterruptibleMask $ \u -> runNoLoggingT (a $ q u)
-      where q u (NoLoggingT b) = NoLoggingT $ u b
+-- For some reason GND is a fool on GHC 7.10 and older, we have to help it by providing the context explicitly.
+deriving instance MonadResource m => MonadResource (NoLoggingT m)
 
-instance MonadActive m => MonadActive (NoLoggingT m) where
-    monadActive = Trans.lift monadActive
 instance MonadActive m => MonadActive (LoggingT m) where
     monadActive = Trans.lift monadActive
 
-instance MonadResource m => MonadResource (NoLoggingT m) where
-    liftResourceT = Trans.lift . liftResourceT
-
-instance MonadBase b m => MonadBase b (NoLoggingT m) where
-    liftBase = Trans.lift . liftBase
-
 instance Trans.MonadTrans NoLoggingT where
     lift = NoLoggingT
 
@@ -415,6 +413,12 @@
     {-# INLINE liftWith #-}
     {-# INLINE restoreT #-}
 
+#if MIN_VERSION_base(4, 9, 0)
+-- | @since 0.3.30
+instance (Fail.MonadFail m) => Fail.MonadFail (NoLoggingT m) where
+  fail = Trans.lift . Fail.fail
+#endif
+
 instance MonadBaseControl b m => MonadBaseControl b (NoLoggingT m) where
      type StM (NoLoggingT m) a = StM m a
      liftBaseWith f = NoLoggingT $
@@ -429,11 +433,26 @@
 
 -- | @since 0.3.26
 instance MonadUnliftIO m => MonadUnliftIO (NoLoggingT m) where
-  askUnliftIO = NoLoggingT $
-                withUnliftIO $ \u ->
-                return (UnliftIO (unliftIO u . runNoLoggingT))
+#if MIN_VERSION_unliftio_core(0, 1, 1)
+  {-# INLINE withRunInIO #-}
+  withRunInIO inner =
+    NoLoggingT $
+    withRunInIO $ \run ->
+    inner (run . runNoLoggingT)
+#else
+  askUnliftIO =
+    NoLoggingT $
+    withUnliftIO $ \u ->
+    return (UnliftIO (unliftIO u . runNoLoggingT))
+#endif
 
--- | @since 0.3.28
+instance (Applicative m, Semigroup a) => Semigroup (NoLoggingT m a) where
+  (<>) = liftA2 (<>)
+
+instance (Applicative m, Monoid a) => Monoid (NoLoggingT m a) where
+  mempty = pure mempty
+
+-- | @since 0.3.32
 type LogLine = (Loc, LogSource, LogLevel, LogStr)
 
 -- | @since 0.3.28
@@ -465,7 +484,6 @@
 execWriterLoggingT ma = snd <$> runWriterLoggingT ma
 
 instance Monad m => Monad (WriterLoggingT m) where
-  return = unwrapMonad . pure
   (WriterLoggingT ma) >>= f = WriterLoggingT $ do
     (a, msgs)   <- ma
     (a', msgs') <- unWriterLoggingT $ f a
@@ -518,6 +536,47 @@
   uninterruptibleMask a = WriterLoggingT $ uninterruptibleMask $ \u -> unWriterLoggingT (a $ q u)
     where q u b = WriterLoggingT $ u (unWriterLoggingT b)
 
+#if MIN_VERSION_exceptions(0, 10, 0)
+  generalBracket acquire release use = WriterLoggingT $ do
+    ((b, _w12), (c, w123)) <- generalBracket
+      (unWriterLoggingT acquire)
+      (\(resource, w1) exitCase -> case exitCase of
+        ExitCaseSuccess (b, w12) -> do
+          (c, w3) <- unWriterLoggingT (release resource (ExitCaseSuccess b))
+          return (c, appendDList w12 w3)
+        -- In the two other cases, the base monad overrides @use@'s state
+        -- changes and the state reverts to @w1@.
+        ExitCaseException e -> do
+          (c, w3) <- unWriterLoggingT (release resource (ExitCaseException e))
+          return (c, appendDList w1 w3)
+        ExitCaseAbort -> do
+          (c, w3) <- unWriterLoggingT (release resource ExitCaseAbort)
+          return (c, appendDList w1 w3))
+      (\(resource, w1) -> do
+        (a, w2) <- unWriterLoggingT (use resource)
+        return (a, appendDList w1 w2))
+    return ((b, c), w123)
+#elif MIN_VERSION_exceptions(0, 9, 0)
+  generalBracket acquire release releaseEx use =
+    WriterLoggingT $ generalBracket
+      (unWriterLoggingT acquire)
+      (\(x, w1) -> do
+          (y, w2) <- unWriterLoggingT (release x)
+          return (y, appendDList w1 w2))
+      (\(x, w1) ex -> do
+          (y, w2) <- unWriterLoggingT (releaseEx x ex)
+          return (y, appendDList w1 w2))
+      (\(x, w1) -> do
+          (y, w2) <- unWriterLoggingT (use x)
+          return (y, appendDList w1 w2))
+#endif
+
+instance (Applicative m, Semigroup a) => Semigroup (WriterLoggingT m a) where
+  (<>) = liftA2 (<>)
+
+instance (Applicative m, Monoid a) => Monoid (WriterLoggingT m a) where
+  mempty = pure mempty
+
 -- | Monad transformer that adds a new logging function.
 --
 -- @since 0.2.2
@@ -544,8 +603,18 @@
     {-# INLINE (<*>) #-}
 #endif
 
+-- | @since 0.3.40
+instance (Alternative m) => Alternative (LoggingT m) where
+  empty = LoggingT (const empty)
+  LoggingT x <|> LoggingT y = LoggingT (\f -> x f <|> y f)
+
+#if MIN_VERSION_base(4, 9, 0)
+-- | @since 0.3.30
+instance (Fail.MonadFail m) => Fail.MonadFail (LoggingT m) where
+  fail = Trans.lift . Fail.fail
+#endif
+
 instance Monad m => Monad (LoggingT m) where
-    return = LoggingT . const . return
     LoggingT ma >>= f = LoggingT $ \r -> do
         a <- ma r
         let LoggingT f' = f a
@@ -565,6 +634,20 @@
   uninterruptibleMask a =
     LoggingT $ \e -> uninterruptibleMask $ \u -> runLoggingT (a $ q u) e
       where q u (LoggingT b) = LoggingT (u . b)
+#if MIN_VERSION_exceptions(0, 10, 0)
+  generalBracket acquire release use =
+    LoggingT $ \e -> generalBracket
+      (runLoggingT acquire e)
+      (\x ec -> runLoggingT (release x ec) e)
+      (\x -> runLoggingT (use x) e)
+#elif MIN_VERSION_exceptions(0, 9, 0)
+  generalBracket acquire release releaseEx use =
+    LoggingT $ \e -> generalBracket
+      (runLoggingT acquire e)
+      (\x -> runLoggingT (release x) e)
+      (\x y -> runLoggingT (releaseEx x y) e)
+      (\x -> runLoggingT (use x) e)
+#endif
 
 instance MonadResource m => MonadResource (LoggingT m) where
     liftResourceT = Trans.lift . liftResourceT
@@ -596,10 +679,37 @@
 
 -- | @since 0.3.26
 instance MonadUnliftIO m => MonadUnliftIO (LoggingT m) where
-  askUnliftIO = LoggingT $ \f ->
-                withUnliftIO $ \u ->
-                return (UnliftIO (unliftIO u . flip runLoggingT f))
+#if MIN_VERSION_unliftio_core(0, 1, 1)
+  {-# INLINE withRunInIO #-}
+  withRunInIO inner =
+    LoggingT $ \r ->
+    withRunInIO $ \run ->
+    inner (run . flip runLoggingT r)
+#else
+  askUnliftIO =
+    LoggingT $ \f ->
+    withUnliftIO $ \u ->
+    return (UnliftIO (unliftIO u . flip runLoggingT f))
+#endif
 
+instance (Applicative m, Semigroup a) => Semigroup (LoggingT m a) where
+  (<>) = liftA2 (<>)
+
+instance (Applicative m, Monoid a) => Monoid (LoggingT m a) where
+  mempty = pure mempty
+
+-- | A default implementation of 'monadLoggerLog' that accepts a file
+-- handle as the first argument.
+--
+-- This is used in the definition of 'runStdoutLoggingT':
+--
+-- @
+-- 'runStdoutLoggingT' :: 'MonadIO' m => 'LoggingT' m a -> m a
+-- 'runStdoutLoggingT' action =
+--     'runLoggingT' action ('defaultOutput' 'stdout')
+-- @
+--
+-- @since 0.3.36
 defaultOutput :: Handle
               -> Loc
               -> LogSource
@@ -610,13 +720,14 @@
     S8.hPutStr h ls
   where
     ls = defaultLogStrBS loc src level msg
+
 defaultLogStrBS :: Loc
                 -> LogSource
                 -> LogLevel
                 -> LogStr
                 -> S8.ByteString
 defaultLogStrBS a b c d =
-    toBS $ defaultLogStr a b c d
+    fromLogStr $ defaultLogStr a b c d
   where
     toBS = fromLogStr
 
@@ -669,10 +780,10 @@
 --
 -- @since 0.3.22
 runFileLoggingT :: MonadBaseControl IO m => FilePath -> LoggingT m a -> m a
-runFileLoggingT fp log = bracket
+runFileLoggingT fp logt = bracket
     (liftBase $ openFile fp AppendMode)
     (liftBase . hClose)
-    $ \h -> liftBase (hSetBuffering h LineBuffering) >> (runLoggingT log) (defaultOutput h)
+    $ \h -> liftBase (hSetBuffering h LineBuffering) >> (runLoggingT logt) (defaultOutput h)
 
 -- | Run a block using a @MonadLogger@ instance which prints to stderr.
 --
@@ -696,7 +807,7 @@
 runChanLoggingT :: MonadIO m => Chan LogLine -> LoggingT m a -> m a
 runChanLoggingT chan = (`runLoggingT` sink chan)
     where
-        sink chan loc src lvl msg = writeChan chan (loc,src,lvl,msg)
+        sink chan' loc src lvl msg = writeChan chan' (loc,src,lvl,msg)
 
 -- | Read logging tuples from an unbounded channel and log them into a
 --   `MonadLoggerIO` monad, forever.
@@ -764,6 +875,9 @@
   ask = Trans.lift ask
   local = mapNoLoggingT . local
 
+-- | Map the unwrapped computation using the given function.
+--
+-- @since 0.3.29
 mapLoggingT :: (m a -> n b) -> LoggingT m a -> LoggingT n b
 mapLoggingT f = LoggingT . (f .) . runLoggingT
 
@@ -776,6 +890,9 @@
   listen = mapLoggingT listen
   pass   = mapLoggingT pass
 
+-- | Map the unwrapped computation using the given function.
+--
+-- @since 0.3.29
 mapNoLoggingT :: (m a -> n b) -> NoLoggingT m a -> NoLoggingT n b
 mapNoLoggingT f = NoLoggingT . f . runNoLoggingT
 
@@ -787,7 +904,17 @@
     tell   = Trans.lift . tell
     listen = mapNoLoggingT listen
     pass   = mapNoLoggingT pass
+    
+#if MIN_VERSION_mtl(2, 3, 1)
+-- | @since 0.3.41
+instance MonadAccum w m => MonadAccum w (LoggingT m) where
+  accum = Trans.lift . accum
 
+-- | @since 0.3.41
+instance MonadAccum w m => MonadAccum w (NoLoggingT m) where
+  accum = Trans.lift . accum
+#endif
+
 -- | dummy location, used with 'logWithoutLoc'
 --
 -- @since 0.3.23
@@ -819,19 +946,19 @@
 logOtherN :: MonadLogger m => LogLevel -> Text -> m ()
 logOtherN = logWithoutLoc ""
 
-logDebugNS :: MonadLogger m => Text -> Text -> m ()
+logDebugNS :: MonadLogger m => LogSource -> Text -> m ()
 logDebugNS src = logWithoutLoc src LevelDebug
 
-logInfoNS :: MonadLogger m => Text -> Text -> m ()
+logInfoNS :: MonadLogger m => LogSource -> Text -> m ()
 logInfoNS src = logWithoutLoc src LevelInfo
 
-logWarnNS :: MonadLogger m => Text -> Text -> m ()
+logWarnNS :: MonadLogger m => LogSource -> Text -> m ()
 logWarnNS src = logWithoutLoc src LevelWarn
 
-logErrorNS :: MonadLogger m => Text -> Text -> m ()
+logErrorNS :: MonadLogger m => LogSource -> Text -> m ()
 logErrorNS src = logWithoutLoc src LevelError
 
-logOtherNS :: MonadLogger m => Text -> LogLevel -> Text -> m ()
+logOtherNS :: MonadLogger m => LogSource -> LogLevel -> Text -> m ()
 logOtherNS = logWithoutLoc
 
 #if WITH_CALLSTACK
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -1,5 +1,9 @@
 ## monad-logger
 
+[![Build Status](https://travis-ci.org/snoyberg/monad-logger.svg?branch=master)](https://travis-ci.org/snoyberg/monad-logger)
+[![Build status](https://ci.appveyor.com/api/projects/status/egsp4r31t54ak4i5/branch/master?svg=true)](https://ci.appveyor.com/project/snoyberg/monad-logger/branch/master)
+[![Hackage](https://img.shields.io/hackage/v/monad-logger)](https://hackage.haskell.org/package/monad-logger)
+
 A monad transformer approach for logging.
 
 This package provides Template Haskell functions for determining source code locations of messages.
diff --git a/monad-logger.cabal b/monad-logger.cabal
--- a/monad-logger.cabal
+++ b/monad-logger.cabal
@@ -1,57 +1,65 @@
-name:                monad-logger
-version:             0.3.28.1
-synopsis:            A class of monads which can log messages.
-description:         Hackage documentation generation is not reliable. For up to date documentation, please see: <http://www.stackage.org/package/monad-logger>.
-homepage:            https://github.com/kazu-yamamoto/logger
-license:             MIT
-license-file:        LICENSE
-author:              Michael Snoyman
-maintainer:          michael@snoyman.com
-category:            System
-build-type:          Simple
-cabal-version:       >=1.8
-extra-source-files:  ChangeLog.md
-                     README.md
-
-source-repository head
-  type:              git
-  location:          https://github.com/kazu-yamamoto/logger.git
+cabal-version: 1.12
 
-flag template_haskell {
-      Description: Enable Template Haskell support
-      Default:     True
-      Manual:      True
-}
+-- This file has been generated from package.yaml by hpack version 0.37.0.
+--
+-- see: https://github.com/sol/hpack
 
-library
-  exposed-modules:     Control.Monad.Logger
+name:           monad-logger
+version:        0.3.42
+synopsis:       A class of monads which can log messages.
+description:    See README and Haddocks at <https://www.stackage.org/package/monad-logger>
+category:       System
+homepage:       https://github.com/snoyberg/monad-logger#readme
+bug-reports:    https://github.com/snoyberg/monad-logger/issues
+author:         Michael Snoyman
+maintainer:     michael@snoyman.com
+license:        MIT
+license-file:   LICENSE
+build-type:     Simple
+extra-source-files:
+    ChangeLog.md
+    README.md
 
-  build-depends:       base                >= 4         && < 5
-                     , transformers
-                     , transformers-compat >= 0.3
-                     , text
-                     , stm
-                     , stm-chans
-                     , lifted-base
-                     , resourcet           >= 1.1       && < 1.3
-                     , conduit             >= 1.0       && < 1.4
-                     , conduit-extra       >= 1.1       && < 1.4
-                     , fast-logger         >= 2.1       && < 2.5
-                     , transformers-base
-                     , monad-control       >= 1.0
-                     , monad-loops
-                     , mtl
-                     , bytestring          >= 0.10.2
-                     , blaze-builder
-                     , exceptions          >= 0.6
-                     , unliftio-core
+source-repository head
+  type: git
+  location: https://github.com/snoyberg/monad-logger
 
-  if impl(ghc >= 8.0.1)
-     cpp-options: -DWITH_CALLSTACK
-     exposed-modules:  Control.Monad.Logger.CallStack
+flag template_haskell
+  description: Enable Template Haskell support
+  manual: True
+  default: True
 
+library
+  exposed-modules:
+      Control.Monad.Logger
+  other-modules:
+      Paths_monad_logger
+  build-depends:
+      base >=4.11 && <5
+    , bytestring >=0.10.2
+    , conduit >=1.0 && <1.4
+    , conduit-extra >=1.1 && <1.4
+    , exceptions >=0.6 && <0.11
+    , fast-logger >=2.1 && <3.3
+    , lifted-base
+    , monad-control >=1.0
+    , monad-loops
+    , mtl
+    , resourcet >=1.1 && <1.4
+    , stm
+    , stm-chans
+    , text
+    , transformers
+    , transformers-base
+    , transformers-compat >=0.3
+    , unliftio-core
+  default-language: Haskell2010
+  if impl(ghc >=8.0.1)
+    exposed-modules:
+        Control.Monad.Logger.CallStack
+    cpp-options: -DWITH_CALLSTACK
   if flag(template_haskell)
-     build-depends:     template-haskell
-
+    build-depends:
+        template-haskell
   if flag(template_haskell)
-     cpp-options: -DWITH_TEMPLATE_HASKELL
+    cpp-options: -DWITH_TEMPLATE_HASKELL