monad-logger 0.3.28.1 → 0.3.42
raw patch · 4 files changed
Files
- ChangeLog.md +78/−0
- Control/Monad/Logger.hs +199/−72
- README.md +4/−0
- monad-logger.cabal +58/−50
ChangeLog.md view
@@ -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)
Control/Monad/Logger.hs view
@@ -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
README.md view
@@ -1,5 +1,9 @@ ## monad-logger +[](https://travis-ci.org/snoyberg/monad-logger)+[](https://ci.appveyor.com/project/snoyberg/monad-logger/branch/master)+[](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.
monad-logger.cabal view
@@ -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