Building monad-logger-0.3.19...
Preprocessing library monad-logger-0.3.19...
[1 of 2] Compiling Control.Monad.Logger ( Control\Monad\Logger.hs, dist\dist-sandbox-8fd4742d\build\Control\Monad\Logger.o )

Control\Monad\Logger.hs:249:10: error:
    * Couldn't match type `m' with `IdentityT m'
      `m' is a rigid type variable bound by
        the instance declaration at Control\Monad\Logger.hs:249:10
      Expected type: IdentityT
                       m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
        Actual type: IdentityT
                       (IdentityT m) (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
    * In the expression:
        Control.Monad.Logger.$dmaskLoggerIO @IdentityT m
      In an equation for `askLoggerIO':
          askLoggerIO = Control.Monad.Logger.$dmaskLoggerIO @IdentityT m
      In the instance declaration for `MonadLoggerIO (IdentityT m)'
    * Relevant bindings include
        askLoggerIO :: IdentityT
                         m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
          (bound at Control\Monad\Logger.hs:249:10)

Control\Monad\Logger.hs:250:10: error:
    * Couldn't match type `m' with `ListT m'
      `m' is a rigid type variable bound by
        the instance declaration at Control\Monad\Logger.hs:250:10
      Expected type: ListT
                       m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
        Actual type: ListT
                       (ListT m) (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
    * In the expression: Control.Monad.Logger.$dmaskLoggerIO @ListT m
      In an equation for `askLoggerIO':
          askLoggerIO = Control.Monad.Logger.$dmaskLoggerIO @ListT m
      In the instance declaration for `MonadLoggerIO (ListT m)'
    * Relevant bindings include
        askLoggerIO :: ListT
                         m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
          (bound at Control\Monad\Logger.hs:250:10)

Control\Monad\Logger.hs:251:10: error:
    * Couldn't match type `m' with `MaybeT m'
      `m' is a rigid type variable bound by
        the instance declaration at Control\Monad\Logger.hs:251:10
      Expected type: MaybeT
                       m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
        Actual type: MaybeT
                       (MaybeT m) (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
    * In the expression: Control.Monad.Logger.$dmaskLoggerIO @MaybeT m
      In an equation for `askLoggerIO':
          askLoggerIO = Control.Monad.Logger.$dmaskLoggerIO @MaybeT m
      In the instance declaration for `MonadLoggerIO (MaybeT m)'
    * Relevant bindings include
        askLoggerIO :: MaybeT
                         m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
          (bound at Control\Monad\Logger.hs:251:10)

Control\Monad\Logger.hs:252:10: error:
    * Couldn't match type `m' with `ErrorT e m'
      `m' is a rigid type variable bound by
        the instance declaration at Control\Monad\Logger.hs:252:10
      Expected type: ErrorT
                       e m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
        Actual type: ErrorT
                       e (ErrorT e m) (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
    * In the expression:
        Control.Monad.Logger.$dmaskLoggerIO @ErrorT e m
      In an equation for `askLoggerIO':
          askLoggerIO = Control.Monad.Logger.$dmaskLoggerIO @ErrorT e m
      In the instance declaration for `MonadLoggerIO (ErrorT e m)'
    * Relevant bindings include
        askLoggerIO :: ErrorT
                         e m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
          (bound at Control\Monad\Logger.hs:252:10)

Control\Monad\Logger.hs:253:10: error:
    * Couldn't match type `m' with `ExceptT e m'
      `m' is a rigid type variable bound by
        the instance declaration at Control\Monad\Logger.hs:253:10
      Expected type: ExceptT
                       e m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
        Actual type: ExceptT
                       e (ExceptT e m) (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
    * In the expression:
        Control.Monad.Logger.$dmaskLoggerIO @ExceptT e m
      In an equation for `askLoggerIO':
          askLoggerIO = Control.Monad.Logger.$dmaskLoggerIO @ExceptT e m
      In the instance declaration for `MonadLoggerIO (ExceptT e m)'
    * Relevant bindings include
        askLoggerIO :: ExceptT
                         e m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
          (bound at Control\Monad\Logger.hs:253:10)

Control\Monad\Logger.hs:254:10: error:
    * Couldn't match type `m' with `ReaderT r m'
      `m' is a rigid type variable bound by
        the instance declaration at Control\Monad\Logger.hs:254:10
      Expected type: ReaderT
                       r m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
        Actual type: ReaderT
                       r (ReaderT r m) (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
    * In the expression:
        Control.Monad.Logger.$dmaskLoggerIO @ReaderT r m
      In an equation for `askLoggerIO':
          askLoggerIO = Control.Monad.Logger.$dmaskLoggerIO @ReaderT r m
      In the instance declaration for `MonadLoggerIO (ReaderT r m)'
    * Relevant bindings include
        askLoggerIO :: ReaderT
                         r m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
          (bound at Control\Monad\Logger.hs:254:10)

Control\Monad\Logger.hs:255:10: error:
    * Couldn't match type `m' with `ContT r m'
      `m' is a rigid type variable bound by
        the instance declaration at Control\Monad\Logger.hs:255:10
      Expected type: ContT
                       r m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
        Actual type: ContT
                       r (ContT r m) (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
    * In the expression: Control.Monad.Logger.$dmaskLoggerIO @ContT r m
      In an equation for `askLoggerIO':
          askLoggerIO = Control.Monad.Logger.$dmaskLoggerIO @ContT r m
      In the instance declaration for `MonadLoggerIO (ContT r m)'
    * Relevant bindings include
        askLoggerIO :: ContT
                         r m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
          (bound at Control\Monad\Logger.hs:255:10)

Control\Monad\Logger.hs:256:10: error:
    * Couldn't match type `m' with `StateT s m'
      `m' is a rigid type variable bound by
        the instance declaration at Control\Monad\Logger.hs:256:10
      Expected type: StateT
                       s m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
        Actual type: StateT
                       s (StateT s m) (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
    * In the expression:
        Control.Monad.Logger.$dmaskLoggerIO @StateT s m
      In an equation for `askLoggerIO':
          askLoggerIO = Control.Monad.Logger.$dmaskLoggerIO @StateT s m
      In the instance declaration for `MonadLoggerIO (StateT s m)'
    * Relevant bindings include
        askLoggerIO :: StateT
                         s m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
          (bound at Control\Monad\Logger.hs:256:10)

Control\Monad\Logger.hs:257:10: error:
    * Couldn't match type `m' with `WriterT w m'
      `m' is a rigid type variable bound by
        the instance declaration at Control\Monad\Logger.hs:257:10
      Expected type: WriterT
                       w m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
        Actual type: WriterT
                       w (WriterT w m) (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
    * In the expression:
        Control.Monad.Logger.$dmaskLoggerIO @WriterT w m
      In an equation for `askLoggerIO':
          askLoggerIO = Control.Monad.Logger.$dmaskLoggerIO @WriterT w m
      In the instance declaration for `MonadLoggerIO (WriterT w m)'
    * Relevant bindings include
        askLoggerIO :: WriterT
                         w m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
          (bound at Control\Monad\Logger.hs:257:10)

Control\Monad\Logger.hs:258:10: error:
    * Couldn't match type `m' with `RWST r w s m'
      `m' is a rigid type variable bound by
        the instance declaration at Control\Monad\Logger.hs:258:10
      Expected type: RWST
                       r w s m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
        Actual type: RWST
                       r
                       w
                       s
                       (RWST r w s m)
                       (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
    * In the expression:
        Control.Monad.Logger.$dmaskLoggerIO @RWST r w s m
      In an equation for `askLoggerIO':
          askLoggerIO = Control.Monad.Logger.$dmaskLoggerIO @RWST r w s m
      In the instance declaration for `MonadLoggerIO (RWST r w s m)'
    * Relevant bindings include
        askLoggerIO :: RWST
                         r w s m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
          (bound at Control\Monad\Logger.hs:258:10)

Control\Monad\Logger.hs:259:10: error:
    * Couldn't match type `m' with `ResourceT m'
      `m' is a rigid type variable bound by
        the instance declaration at Control\Monad\Logger.hs:259:10
      Expected type: ResourceT
                       m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
        Actual type: ResourceT
                       (ResourceT m) (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
    * In the expression:
        Control.Monad.Logger.$dmaskLoggerIO @ResourceT m
      In an equation for `askLoggerIO':
          askLoggerIO = Control.Monad.Logger.$dmaskLoggerIO @ResourceT m
      In the instance declaration for `MonadLoggerIO (ResourceT m)'
    * Relevant bindings include
        askLoggerIO :: ResourceT
                         m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
          (bound at Control\Monad\Logger.hs:259:10)

Control\Monad\Logger.hs:260:10: error:
    * Couldn't match type `m' with `Pipe l i o u m'
      `m' is a rigid type variable bound by
        the instance declaration at Control\Monad\Logger.hs:260:10
      Expected type: Pipe
                       l i o u m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
        Actual type: Pipe
                       l
                       i
                       o
                       u
                       (Pipe l i o u m)
                       (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
    * In the expression:
        Control.Monad.Logger.$dmaskLoggerIO @Pipe l i o u m
      In an equation for `askLoggerIO':
          askLoggerIO = Control.Monad.Logger.$dmaskLoggerIO @Pipe l i o u m
      In the instance declaration for `MonadLoggerIO (Pipe l i o u m)'
    * Relevant bindings include
        askLoggerIO :: Pipe
                         l i o u m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
          (bound at Control\Monad\Logger.hs:260:10)

Control\Monad\Logger.hs:261:10: error:
    * Couldn't match type `m' with `ConduitM i o m'
      `m' is a rigid type variable bound by
        the instance declaration at Control\Monad\Logger.hs:261:10
      Expected type: ConduitM
                       i o m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
        Actual type: ConduitM
                       i
                       o
                       (ConduitM i o m)
                       (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
    * In the expression:
        Control.Monad.Logger.$dmaskLoggerIO @ConduitM i o m
      In an equation for `askLoggerIO':
          askLoggerIO = Control.Monad.Logger.$dmaskLoggerIO @ConduitM i o m
      In the instance declaration for `MonadLoggerIO (ConduitM i o m)'
    * Relevant bindings include
        askLoggerIO :: ConduitM
                         i o m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
          (bound at Control\Monad\Logger.hs:261:10)

Control\Monad\Logger.hs:262:10: error:
    * Couldn't match type `m' with `Strict.StateT s m'
      `m' is a rigid type variable bound by
        the instance declaration at Control\Monad\Logger.hs:262:10
      Expected type: Strict.StateT
                       s m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
        Actual type: Strict.StateT
                       s
                       (Strict.StateT s m)
                       (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
    * In the expression:
        Control.Monad.Logger.$dmaskLoggerIO @Strict.StateT s m
      In an equation for `askLoggerIO':
          askLoggerIO
            = Control.Monad.Logger.$dmaskLoggerIO @Strict.StateT s m
      In the instance declaration for `MonadLoggerIO (Strict.StateT s m)'
    * Relevant bindings include
        askLoggerIO :: Strict.StateT
                         s m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
          (bound at Control\Monad\Logger.hs:262:10)

Control\Monad\Logger.hs:263:10: error:
    * Couldn't match type `m' with `Strict.WriterT w m'
      `m' is a rigid type variable bound by
        the instance declaration at Control\Monad\Logger.hs:263:10
      Expected type: Strict.WriterT
                       w m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
        Actual type: Strict.WriterT
                       w
                       (Strict.WriterT w m)
                       (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
    * In the expression:
        Control.Monad.Logger.$dmaskLoggerIO @Strict.WriterT w m
      In an equation for `askLoggerIO':
          askLoggerIO
            = Control.Monad.Logger.$dmaskLoggerIO @Strict.WriterT w m
      In the instance declaration for
        `MonadLoggerIO (Strict.WriterT w m)'
    * Relevant bindings include
        askLoggerIO :: Strict.WriterT
                         w m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
          (bound at Control\Monad\Logger.hs:263:10)

Control\Monad\Logger.hs:264:10: error:
    * Couldn't match type `m' with `Strict.RWST r w s m'
      `m' is a rigid type variable bound by
        the instance declaration at Control\Monad\Logger.hs:264:10
      Expected type: Strict.RWST
                       r w s m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
        Actual type: Strict.RWST
                       r
                       w
                       s
                       (Strict.RWST r w s m)
                       (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
    * In the expression:
        Control.Monad.Logger.$dmaskLoggerIO @Strict.RWST r w s m
      In an equation for `askLoggerIO':
          askLoggerIO
            = Control.Monad.Logger.$dmaskLoggerIO @Strict.RWST r w s m
      In the instance declaration for
        `MonadLoggerIO (Strict.RWST r w s m)'
    * Relevant bindings include
        askLoggerIO :: Strict.RWST
                         r w s m (Loc -> LogSource -> LogLevel -> LogStr -> IO ())
          (bound at Control\Monad\Logger.hs:264:10)
cabal: Leaving directory 'C:\Users\Josh\AppData\Local\Temp\cabal-tmp-8268\monad-logger-0.3.19'