gistfile1.txt

Failed to install monad-logger-0.3.20
Build log ( /private/tmp/git-annex-20161028-37304-1fwzy1u/git-annex-6.20161027/.cabal-sandbox/logs/monad-logger-0.3.20.log ):
cabal: Entering directory '/tmp/cabal-tmp-38944/monad-logger-0.3.20'
Configuring monad-logger-0.3.20...
clang: warning: -Wl,-headerpad_max_install_names: 'linker' input unused
clang: warning: argument unused during compilation: '-L/usr/local/lib'
clang: warning: argument unused during compilation: '-L/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.12.sdk/System/Library/Frameworks/OpenGL.framework/Versions/Current/Libraries'
Building monad-logger-0.3.20...
Preprocessing library monad-logger-0.3.20...
[1 of 2] Compiling Control.Monad.Logger ( Control/Monad/Logger.hs, dist/dist-sandbox-697e3b7d/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 '/tmp/cabal-tmp-38944/monad-logger-0.3.20'