Simplify 'LoggerT'.

import Prelude hiding (log)

import Control.Applicative

import Control.Monad.Reader

import Control.Monad.Catch

import Data.ByteString (ByteString)

import System.Logger (Logger, Level (..))

import System.Logger.Message as M

import qualified Data.ByteString as BS

import qualified System.Logger as L

newtype LoggerT m a = LoggerT

               , Applicative

               , Monad

               , MonadIO

               , MonadCatch

               , MonadReader Logger

               , MonadTrans

               )

class MonadIO m => MonadLogger m where

    logger :: m Logger

    prefix :: m ByteString

    prefix = return BS.empty

    prefix :: m Builder

    prefix = return id

    log :: Level -> Builder -> m ()

    log l m = do

        g <- logger

        p <- prefix

        L.log g l (msg' p . m)

        L.log g l (p . m)

    logM :: Level -> m Builder -> m ()

    logM l m = do

        g <- logger

        p <- prefix

        L.logM g l ((msg' p .) `liftM` m)

        L.logM g l ((p .) `liftM` m)

    trace, debug, info, warn, err, fatal :: Builder -> m ()

    trace = log Trace

name:                 tinylog

version:              0.3.1

version:              0.4

synopsis:             Simplistic logging using fast-logger.

author:               Toralf Wittner

maintainer:           Toralf Wittner <tw@dtex.org>

          base         == 4.*

        , bytestring   >= 0.10

        , date-cache   >= 0.3

        , exceptions   >= 0.3

        , fast-logger  >= 2.1.2 && < 2.2

        , mtl          >= 2.1

        , transformers >= 0.3