Resolving dependencies...
Configuring ghc-paths-0.1.0.9...
Configuring mtl-2.2.1...
Building mtl-2.2.1...
Building ghc-paths-0.1.0.9...
Configuring text-1.2.2.1...
Installed mtl-2.2.1
Installed ghc-paths-0.1.0.9
Building text-1.2.2.1...
Installed text-1.2.2.1
Configuring parsec-3.1.11...
Building parsec-3.1.11...
Installed parsec-3.1.11
Configuring husk-scheme-3.4.3...
Building husk-scheme-3.4.3...
Failed to install husk-scheme-3.4.3
Build log ( /home/builder/.cabal/logs/husk-scheme-3.4.3.log ):
cabal: Entering directory '/tmp/cabal-tmp-4019/husk-scheme-3.4.3'
Configuring husk-scheme-3.4.3...
Building husk-scheme-3.4.3...
Preprocessing library husk-scheme-3.4.3...
[ 1 of 10] Compiling Language.Scheme.Types ( hs-src/Language/Scheme/Types.hs, dist/build/Language/Scheme/Types.o )

hs-src/Language/Scheme/Types.hs:22:1: warning: [-Wdeprecations]
    Module ‘Control.Monad.Error’ is deprecated:
      Use Control.Monad.Except instead

hs-src/Language/Scheme/Types.hs:77:10: warning: [-Wdeprecations]
    In the use of type constructor or class ‘Error’
    (imported from Control.Monad.Error, but defined in Control.Monad.Trans.Error):
    Deprecated: "Use Control.Monad.Trans.Except instead"

hs-src/Language/Scheme/Types.hs:77:10: warning: [-Wdeprecations]
    In the use of type constructor or class ‘Error’
    (imported from Control.Monad.Error, but defined in Control.Monad.Trans.Error):
    Deprecated: "Use Control.Monad.Trans.Except instead"

hs-src/Language/Scheme/Types.hs:92:22: warning: [-Wdeprecations]
    In the use of type constructor or class ‘ErrorT’
    (imported from Control.Monad.Error, but defined in Control.Monad.Trans.Error):
    Deprecated: "Use Control.Monad.Trans.Except instead"

hs-src/Language/Scheme/Types.hs:99:22: warning: [-Wdeprecations]
    In the use of ‘runErrorT’
    (imported from Control.Monad.Error, but defined in Control.Monad.Trans.Error):
    Deprecated: "Use Control.Monad.Trans.Except instead"
[ 2 of 10] Compiling Language.Scheme.Variables ( hs-src/Language/Scheme/Variables.hs, dist/build/Language/Scheme/Variables.o )

hs-src/Language/Scheme/Variables.hs:20:1: warning: [-Wdeprecations]
    Module ‘Control.Monad.Error’ is deprecated:
      Use Control.Monad.Except instead
[ 3 of 10] Compiling Language.Scheme.Plugins.CPUTime ( hs-src/Language/Scheme/Plugins/CPUTime.hs, dist/build/Language/Scheme/Plugins/CPUTime.o )

hs-src/Language/Scheme/Plugins/CPUTime.hs:27:1: warning: [-Wdeprecations]
    Module ‘Control.Monad.Error’ is deprecated:
      Use Control.Monad.Except instead
[ 4 of 10] Compiling Language.Scheme.Parser ( hs-src/Language/Scheme/Parser.hs, dist/build/Language/Scheme/Parser.o )

hs-src/Language/Scheme/Parser.hs:20:1: warning: [-Wdeprecations]
    Module ‘Control.Monad.Error’ is deprecated:
      Use Control.Monad.Except instead
[ 5 of 10] Compiling Language.Scheme.Numerical ( hs-src/Language/Scheme/Numerical.hs, dist/build/Language/Scheme/Numerical.o )

hs-src/Language/Scheme/Numerical.hs:50:9: error:
    • Non type-variable argument
        in the constraint: MonadError LispError m
      (Use FlexibleContexts to permit this)
    • When checking the inferred type
        doAdd :: forall (m :: * -> *).
                 MonadError LispError m =>
                 LispVal -> m LispVal
      In an equation for ‘numAdd’:
          numAdd aparams
            = do { foldl1M (\ a b -> doAdd =<< (numCast [...])) aparams }
            where
                doAdd (List [(Number a), (Number b)]) = return $ Number $ a + b
                doAdd (List [(Float a), (Float b)]) = return $ Float $ a + b
                doAdd (List [(Rational a), (Rational b)])
                  = return $ Rational $ a + b
                doAdd (List [(Complex a), (Complex b)]) = return $ Complex $ a + b
                doAdd _ = throwError $ Default "Unexpected error in +"

hs-src/Language/Scheme/Numerical.hs:62:9: error:
    • Non type-variable argument
        in the constraint: MonadError LispError m
      (Use FlexibleContexts to permit this)
    • When checking the inferred type
        doSub :: forall (m :: * -> *).
                 MonadError LispError m =>
                 LispVal -> m LispVal
      In an equation for ‘numSub’:
          numSub aparams
            = do { foldl1M (\ a b -> doSub =<< (numCast [...])) aparams }
            where
                doSub (List [(Number a), (Number b)]) = return $ Number $ a - b
                doSub (List [(Float a), (Float b)]) = return $ Float $ a - b
                doSub (List [(Rational a), (Rational b)])
                  = return $ Rational $ a - b
                doSub (List [(Complex a), (Complex b)]) = return $ Complex $ a - b
                doSub _ = throwError $ Default "Unexpected error in -"

hs-src/Language/Scheme/Numerical.hs:70:9: error:
    • Non type-variable argument
        in the constraint: MonadError LispError m
      (Use FlexibleContexts to permit this)
    • When checking the inferred type
        doMul :: forall (m :: * -> *).
                 MonadError LispError m =>
                 LispVal -> m LispVal
      In an equation for ‘numMul’:
          numMul aparams
            = do { foldl1M (\ a b -> doMul =<< (numCast [...])) aparams }
            where
                doMul (List [(Number a), (Number b)]) = return $ Number $ a * b
                doMul (List [(Float a), (Float b)]) = return $ Float $ a * b
                doMul (List [(Rational a), (Rational b)])
                  = return $ Rational $ a * b
                doMul (List [(Complex a), (Complex b)]) = return $ Complex $ a * b
                doMul _ = throwError $ Default "Unexpected error in *"

hs-src/Language/Scheme/Numerical.hs:82:9: error:
    • Non type-variable argument
        in the constraint: MonadError LispError m
      (Use FlexibleContexts to permit this)
    • When checking the inferred type
        doDiv :: forall (m :: * -> *).
                 MonadError LispError m =>
                 LispVal -> m LispVal
      In an equation for ‘numDiv’:
          numDiv aparams
            = do { foldl1M (\ a b -> doDiv =<< (numCast [...])) aparams }
            where
                doDiv (List [(Number a), (Number b)])
                  = if b == 0 then
                        throwError $ DivideByZero
                    else
                        if (mod a b) == 0 then
                            return $ Number $ div a b
                        else
                            return $ Rational $ (fromInteger a) / (fromInteger b)
                doDiv (List [(Float a), (Float b)])
                  = if b == 0.0 then
                        throwError $ DivideByZero
                    else
                        return $ Float $ a / b
                doDiv (List [(Rational a), (Rational b)])
                  = if b == 0 then
                        throwError $ DivideByZero
                    else
                        return $ Rational $ a / b
                doDiv (List [(Complex a), (Complex b)])
                  = if b == 0 then
                        throwError $ DivideByZero
                    else
                        return $ Complex $ a / b
                doDiv _ = throwError $ Default "Unexpected error in /"

hs-src/Language/Scheme/Numerical.hs:103:9: error:
    • Non type-variable argument
        in the constraint: MonadError LispError m
      (Use FlexibleContexts to permit this)
    • When checking the inferred type
        doOp :: forall (m :: * -> *).
                MonadError LispError m =>
                LispVal -> m LispVal
      In an equation for ‘numBoolBinopEq’:
          numBoolBinopEq aparams
            = do { foldl1M (\ a b -> doOp =<< (numCast [...])) aparams }
            where
                doOp (List [(Number a), (Number b)]) = return $ Bool $ a == b
                doOp (List [(Float a), (Float b)]) = return $ Bool $ a == b
                doOp (List [(Rational a), (Rational b)]) = return $ Bool $ a == b
                doOp (List [(Complex a), (Complex b)]) = return $ Bool $ a == b
                doOp _ = throwError $ Default "Unexpected error in ="

hs-src/Language/Scheme/Numerical.hs:113:9: error:
    • Non type-variable argument
        in the constraint: MonadError LispError m
      (Use FlexibleContexts to permit this)
    • When checking the inferred type
        doOp :: forall (m :: * -> *).
                MonadError LispError m =>
                LispVal -> m LispVal
      In an equation for ‘numBoolBinopGt’:
          numBoolBinopGt aparams
            = do { foldl1M (\ a b -> doOp =<< (numCast [...])) aparams }
            where
                doOp (List [(Number a), (Number b)]) = return $ Bool $ a > b
                doOp (List [(Float a), (Float b)]) = return $ Bool $ a > b
                doOp (List [(Rational a), (Rational b)]) = return $ Bool $ a > b
                doOp _ = throwError $ Default "Unexpected error in >"

hs-src/Language/Scheme/Numerical.hs:122:9: error:
    • Non type-variable argument
        in the constraint: MonadError LispError m
      (Use FlexibleContexts to permit this)
    • When checking the inferred type
        doOp :: forall (m :: * -> *).
                MonadError LispError m =>
                LispVal -> m LispVal
      In an equation for ‘numBoolBinopGte’:
          numBoolBinopGte aparams
            = do { foldl1M (\ a b -> doOp =<< (numCast [...])) aparams }
            where
                doOp (List [(Number a), (Number b)]) = return $ Bool $ a >= b
                doOp (List [(Float a), (Float b)]) = return $ Bool $ a >= b
                doOp (List [(Rational a), (Rational b)]) = return $ Bool $ a >= b
                doOp _ = throwError $ Default "Unexpected error in >="

hs-src/Language/Scheme/Numerical.hs:131:9: error:
    • Non type-variable argument
        in the constraint: MonadError LispError m
      (Use FlexibleContexts to permit this)
    • When checking the inferred type
        doOp :: forall (m :: * -> *).
                MonadError LispError m =>
                LispVal -> m LispVal
      In an equation for ‘numBoolBinopLt’:
          numBoolBinopLt aparams
            = do { foldl1M (\ a b -> doOp =<< (numCast [...])) aparams }
            where
                doOp (List [(Number a), (Number b)]) = return $ Bool $ a < b
                doOp (List [(Float a), (Float b)]) = return $ Bool $ a < b
                doOp (List [(Rational a), (Rational b)]) = return $ Bool $ a < b
                doOp _ = throwError $ Default "Unexpected error in <"

hs-src/Language/Scheme/Numerical.hs:140:9: error:
    • Non type-variable argument
        in the constraint: MonadError LispError m
      (Use FlexibleContexts to permit this)
    • When checking the inferred type
        doOp :: forall (m :: * -> *).
                MonadError LispError m =>
                LispVal -> m LispVal
      In an equation for ‘numBoolBinopLte’:
          numBoolBinopLte aparams
            = do { foldl1M (\ a b -> doOp =<< (numCast [...])) aparams }
            where
                doOp (List [(Number a), (Number b)]) = return $ Bool $ a <= b
                doOp (List [(Float a), (Float b)]) = return $ Bool $ a <= b
                doOp (List [(Rational a), (Rational b)]) = return $ Bool $ a <= b
                doOp _ = throwError $ Default "Unexpected error in <="

hs-src/Language/Scheme/Numerical.hs:168:9: error:
    • Non type-variable argument
        in the constraint: MonadError LispError m
      (Use FlexibleContexts to permit this)
    • When checking the inferred type
        doThrowError :: forall a (m :: * -> *).
                        MonadError LispError m =>
                        LispVal -> m a
      In an equation for ‘numCast’:
          numCast [a, b]
            = case a of {
                Number _ -> doThrowError b
                Float _ -> doThrowError b
                Rational _ -> doThrowError b
                Complex _ -> doThrowError b
                _ -> doThrowError a }
            where
                doThrowError num = throwError $ TypeMismatch "number" num
cabal: Leaving directory '/tmp/cabal-tmp-4019/husk-scheme-3.4.3'
cabal: Error: some packages failed to install:
husk-scheme-3.4.3 failed during the building phase. The exception was:
ExitFailure 1