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.5.5...
Building husk-scheme-3.5.5...
Failed to install husk-scheme-3.5.5
Build log ( /home/builder/.cabal/logs/husk-scheme-3.5.5.log ):
cabal: Entering directory '/tmp/cabal-tmp-32150/husk-scheme-3.5.5'
Configuring husk-scheme-3.5.5...
Building husk-scheme-3.5.5...
Preprocessing library husk-scheme-3.5.5...
[ 1 of 11] Compiling Language.Scheme.Types ( hs-src/Language/Scheme/Types.hs, dist/build/Language/Scheme/Types.o )

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

hs-src/Language/Scheme/Types.hs:112: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:112: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:127: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:137:26: 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"

hs-src/Language/Scheme/Types.hs:142:17: 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 11] Compiling Language.Scheme.Variables ( hs-src/Language/Scheme/Variables.hs, dist/build/Language/Scheme/Variables.o )

hs-src/Language/Scheme/Variables.hs:37:1: warning: [-Wdeprecations]
    Module ‘Control.Monad.Error’ is deprecated:
      Use Control.Monad.Except instead
[ 3 of 11] 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:23:1: warning: [-Wdeprecations]
    Module ‘Control.Monad.Error’ is deprecated:
      Use Control.Monad.Except instead
[ 4 of 11] Compiling Language.Scheme.Parser ( hs-src/Language/Scheme/Parser.hs, dist/build/Language/Scheme/Parser.o )

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

hs-src/Language/Scheme/Numerical.hs:97: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:109: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:117: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:131: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:151:9: error:
    • Non type-variable argument
        in the constraint: MonadError LispError m
      (Use FlexibleContexts to permit this)
    • When checking the inferred type
        doMod :: forall (m :: * -> *).
                 MonadError LispError m =>
                 LispVal -> m LispVal
      In an equation for ‘numMod’:
          numMod aparams
            = do { foldl1M (\ a b -> doMod =<< (numCast [...])) aparams }
            where
                doMod (List [(Number a), (Number b)]) = return $ Number $ mod' a b
                doMod (List [(Float a), (Float b)]) = return $ Float $ mod' a b
                doMod (List [(Rational a), (Rational b)])
                  = return $ Rational $ mod' a b
                doMod (List [(Complex a), (Complex b)])
                  = throwError $ Default "modulo not implemented for complex numbers"
                doMod _ = throwError $ Default "Unexpected error in modulo"

hs-src/Language/Scheme/Numerical.hs:161: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:171: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:180: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:189: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:198: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:226: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-32150/husk-scheme-3.5.5'
cabal: Error: some packages failed to install:
husk-scheme-3.5.5 failed during the building phase. The exception was:
ExitFailure 1