Build #9 for lifter-0.1

[all reports]

Package lifter-0.1
Install BuildFailed
Docs NotTried
Tests NotTried
Time submitted 2016-12-24 07:14:40.929713 UTC
Compiler ghc-8.0.1.20161018
OS linux
Arch x86_64
Dependencies array-0.5.1.1, base-4.9.0.0, bitmap-0.0.2, bytestring-0.10.8.1, directory-1.2.6.2, filepath-1.4.1.0, gloss-1.10.2.3, mtl-2.2.1, stb-image-0.2.1
Flags none

Code Coverage

No Code Coverage was submitted for this report.

Build log

[view raw]

Resolving dependencies...
Configuring ObjectName-1.1.0.1...
Configuring bitmap-0.0.2...
Building bitmap-0.0.2...
Building ObjectName-1.1.0.1...
Installed ObjectName-1.1.0.1
Configuring bmp-1.2.6.3...
Building bmp-1.2.6.3...
Configuring fixed-0.2.1.1...
Installed bitmap-0.0.2
Configuring half-0.2.2.3...
Installed bmp-1.2.6.3
Building fixed-0.2.1.1...
Building half-0.2.2.3...
Configuring mtl-2.2.1...
Installed fixed-0.2.1.1
Building mtl-2.2.1...
Configuring stm-2.4.4.1...
Installed half-0.2.2.3
Building stm-2.4.4.1...
Configuring text-1.2.2.1...
Installed stm-2.4.4.1
Building text-1.2.2.1...
Installed mtl-2.2.1
Configuring stb-image-0.2.1...
Building stb-image-0.2.1...
Configuring StateVar-1.1.0.4...
Installed stb-image-0.2.1
Building StateVar-1.1.0.4...
Installed StateVar-1.1.0.4
Installed text-1.2.2.1
Configuring OpenGLRaw-3.2.4.0...
Building OpenGLRaw-3.2.4.0...
Installed OpenGLRaw-3.2.4.0
Configuring GLURaw-2.0.0.3...
Building GLURaw-2.0.0.3...
Installed GLURaw-2.0.0.3
Configuring OpenGL-3.0.1.0...
Building OpenGL-3.0.1.0...
Installed OpenGL-3.0.1.0
Configuring GLUT-2.7.0.10...
Building GLUT-2.7.0.10...
Installed GLUT-2.7.0.10
Configuring gloss-rendering-1.10.3.5...
Building gloss-rendering-1.10.3.5...
Installed gloss-rendering-1.10.3.5
Configuring gloss-1.10.2.3...
Building gloss-1.10.2.3...
Installed gloss-1.10.2.3
Configuring lifter-0.1...
Building lifter-0.1...
Failed to install lifter-0.1
Build log ( /home/builder/.cabal/logs/lifter-0.1.log ):
cabal: Entering directory '/tmp/cabal-tmp-9571/lifter-0.1'
Configuring lifter-0.1...
Building lifter-0.1...
Preprocessing executable 'lifter' for lifter-0.1...
[1 of 4] Compiling Rules            ( src/Rules.hs, dist/build/lifter/lifter-tmp/Rules.o )

src/Rules.hs:124:1: error:
    • Non type-variable argument
        in the constraint: MArray IOArray Tile m
      (Use FlexibleContexts to permit this)
    • When checking the inferred type
        surrounding :: forall (m :: * -> *) a.
                       MArray IOArray Tile m =>
                       GameState a -> (Int, Int) -> m [(Int, Int)]

src/Rules.hs:162:11: error:
    • Non type-variable argument
        in the constraint: MArray IOArray Tile m
      (Use FlexibleContexts to permit this)
    • When checking the inferred type
        update :: forall t (m :: * -> *).
                  MArray IOArray Tile m =>
                  (Int, Int) -> m [t]
      In an equation for ‘applyRules’:
          applyRules s
            = do { ((wl, hl), (wh, hh)) <- getBounds (world s);
                   mapM_
                     (\ p -> do { ... }) [(x, y) | y <- [hl .. hh], x <- [wl .. wh]];
                   squashTest <- mapM
                                   update [(x, y) | y <- [hl .. hh], x <- [wl .. wh]];
                   .... }
            where
                update (x, y)
                  = do { t <- readArray (oldworld s) ...;
                         .... }
                growBeard (x, y)
                  = do { adj <- surrounding s ...;
                         .... }
                moveRock r (x, y) Empty _ _ _ _
                  = do { writeArray (world s) ... Empty;
                         .... }
                moveRock r (x, y) rck Empty Empty _ _
                  | rck `elem` [Rock, LamRock]
                  = do { writeArray (world s) ... Empty;
                         .... }
                moveRock r (x, y) Lambda Empty Empty _ _
                  = do { writeArray (world s) ... Empty;
                         .... }
                moveRock r (x, y) rck _ _ Empty Empty
                  | rck `elem` [Rock, LamRock]
                  = do { writeArray (world s) ... Empty;
                         .... }
                moveRock _ _ _ _ _ _ _ = return []
                checkSquashed p
                  = do { t <- readArray (oldworld s) p;
                         .... }
                ....

src/Rules.hs:186:11: error:
    • Non type-variable argument
        in the constraint: MArray IOArray Tile m
      (Use FlexibleContexts to permit this)
    • When checking the inferred type
        growBeard :: forall (t :: * -> *) (m :: * -> *) t1 t2.
                     (MArray IOArray Tile m, Traversable t) =>
                     (t2, t1) -> m (t ())
      In an equation for ‘applyRules’:
          applyRules s
            = do { ((wl, hl), (wh, hh)) <- getBounds (world s);
                   mapM_
                     (\ p -> do { ... }) [(x, y) | y <- [hl .. hh], x <- [wl .. wh]];
                   squashTest <- mapM
                                   update [(x, y) | y <- [hl .. hh], x <- [wl .. wh]];
                   .... }
            where
                update (x, y)
                  = do { t <- readArray (oldworld s) ...;
                         .... }
                growBeard (x, y)
                  = do { adj <- surrounding s ...;
                         .... }
                moveRock r (x, y) Empty _ _ _ _
                  = do { writeArray (world s) ... Empty;
                         .... }
                moveRock r (x, y) rck Empty Empty _ _
                  | rck `elem` [Rock, LamRock]
                  = do { writeArray (world s) ... Empty;
                         .... }
                moveRock r (x, y) Lambda Empty Empty _ _
                  = do { writeArray (world s) ... Empty;
                         .... }
                moveRock r (x, y) rck _ _ Empty Empty
                  | rck `elem` [Rock, LamRock]
                  = do { writeArray (world s) ... Empty;
                         .... }
                moveRock _ _ _ _ _ _ _ = return []
                checkSquashed p
                  = do { t <- readArray (oldworld s) p;
                         .... }
                ....

src/Rules.hs:195:11: error:
    • Non type-variable argument
        in the constraint: MArray IOArray Tile m
      (Use FlexibleContexts to permit this)
    • When checking the inferred type
        moveRock :: forall (m :: * -> *).
                    MArray IOArray Tile m =>
                    Tile
                    -> (Int, Int)
                    -> Tile
                    -> Tile
                    -> Tile
                    -> Tile
                    -> Tile
                    -> m [(Int, Int)]
      In an equation for ‘applyRules’:
          applyRules s
            = do { ((wl, hl), (wh, hh)) <- getBounds (world s);
                   mapM_
                     (\ p -> do { ... }) [(x, y) | y <- [hl .. hh], x <- [wl .. wh]];
                   squashTest <- mapM
                                   update [(x, y) | y <- [hl .. hh], x <- [wl .. wh]];
                   .... }
            where
                update (x, y)
                  = do { t <- readArray (oldworld s) ...;
                         .... }
                growBeard (x, y)
                  = do { adj <- surrounding s ...;
                         .... }
                moveRock r (x, y) Empty _ _ _ _
                  = do { writeArray (world s) ... Empty;
                         .... }
                moveRock r (x, y) rck Empty Empty _ _
                  | rck `elem` [Rock, LamRock]
                  = do { writeArray (world s) ... Empty;
                         .... }
                moveRock r (x, y) Lambda Empty Empty _ _
                  = do { writeArray (world s) ... Empty;
                         .... }
                moveRock r (x, y) rck _ _ Empty Empty
                  | rck `elem` [Rock, LamRock]
                  = do { writeArray (world s) ... Empty;
                         .... }
                moveRock _ _ _ _ _ _ _ = return []
                checkSquashed p
                  = do { t <- readArray (oldworld s) p;
                         .... }
                ....

src/Rules.hs:227:11: error:
    • Non type-variable argument
        in the constraint: MArray IOArray Tile m
      (Use FlexibleContexts to permit this)
    • When checking the inferred type
        checkSquashed :: forall (m :: * -> *).
                         MArray IOArray Tile m =>
                         (Int, Int) -> m Bool
      In an equation for ‘applyRules’:
          applyRules s
            = do { ((wl, hl), (wh, hh)) <- getBounds (world s);
                   mapM_
                     (\ p -> do { ... }) [(x, y) | y <- [hl .. hh], x <- [wl .. wh]];
                   squashTest <- mapM
                                   update [(x, y) | y <- [hl .. hh], x <- [wl .. wh]];
                   .... }
            where
                update (x, y)
                  = do { t <- readArray (oldworld s) ...;
                         .... }
                growBeard (x, y)
                  = do { adj <- surrounding s ...;
                         .... }
                moveRock r (x, y) Empty _ _ _ _
                  = do { writeArray (world s) ... Empty;
                         .... }
                moveRock r (x, y) rck Empty Empty _ _
                  | rck `elem` [Rock, LamRock]
                  = do { writeArray (world s) ... Empty;
                         .... }
                moveRock r (x, y) Lambda Empty Empty _ _
                  = do { writeArray (world s) ... Empty;
                         .... }
                moveRock r (x, y) rck _ _ Empty Empty
                  | rck `elem` [Rock, LamRock]
                  = do { writeArray (world s) ... Empty;
                         .... }
                moveRock _ _ _ _ _ _ _ = return []
                checkSquashed p
                  = do { t <- readArray (oldworld s) p;
                         .... }
                ....

src/Rules.hs:233:11: error:
    • Non type-variable argument
        in the constraint: MArray IOArray Tile m
      (Use FlexibleContexts to permit this)
    • When checking the inferred type
        checkTransform :: forall (m :: * -> *).
                          MArray IOArray Tile m =>
                          (Int, Int) -> (Int, Int) -> m ()
      In an equation for ‘applyRules’:
          applyRules s
            = do { ((wl, hl), (wh, hh)) <- getBounds (world s);
                   mapM_
                     (\ p -> do { ... }) [(x, y) | y <- [hl .. hh], x <- [wl .. wh]];
                   squashTest <- mapM
                                   update [(x, y) | y <- [hl .. hh], x <- [wl .. wh]];
                   .... }
            where
                update (x, y)
                  = do { t <- readArray (oldworld s) ...;
                         .... }
                growBeard (x, y)
                  = do { adj <- surrounding s ...;
                         .... }
                moveRock r (x, y) Empty _ _ _ _
                  = do { writeArray (world s) ... Empty;
                         .... }
                moveRock r (x, y) rck Empty Empty _ _
                  | rck `elem` [Rock, LamRock]
                  = do { writeArray (world s) ... Empty;
                         .... }
                moveRock r (x, y) Lambda Empty Empty _ _
                  = do { writeArray (world s) ... Empty;
                         .... }
                moveRock r (x, y) rck _ _ Empty Empty
                  | rck `elem` [Rock, LamRock]
                  = do { writeArray (world s) ... Empty;
                         .... }
                moveRock _ _ _ _ _ _ _ = return []
                checkSquashed p
                  = do { t <- readArray (oldworld s) p;
                         .... }
                ....

src/Rules.hs:247:11: error:
    • Non type-variable argument
        in the constraint: MArray IOArray Tile m
      (Use FlexibleContexts to permit this)
    • When checking the inferred type
        update :: forall (m :: * -> *).
                  MArray IOArray Tile m =>
                  (Int, Int) -> m Bool
      In an equation for ‘moveBugs’:
          moveBugs s
            = do { ((wl, hl), (wh, hh)) <- getBounds (world s);
                   mapM_
                     (\ p -> do { ... }) [(x, y) | x <- [wl .. wh], y <- [hl .. hh]];
                   eaten <- mapM update [(x, y) | x <- [wl .. wh], y <- [hl .. hh]];
                   .... }
            where
                update (x, y)
                  = do { t <- readArray (oldworld s) ...;
                         .... }
                moveBug (x, y) d d'
                  = do { let ...;
                         .... }
                getNext (x, y) d
                  = case d of {
                      UP -> ...
                      DOWN -> ...
                      LEFT -> ...
                      RIGHT -> ... }

src/Rules.hs:252:11: error:
    • Non type-variable argument
        in the constraint: MArray IOArray Tile m
      (Use FlexibleContexts to permit this)
    • When checking the inferred type
        moveBug :: forall (m :: * -> *).
                   MArray IOArray Tile m =>
                   (Int, Int) -> Direction -> Direction -> m (Int, Int)
      In an equation for ‘moveBugs’:
          moveBugs s
            = do { ((wl, hl), (wh, hh)) <- getBounds (world s);
                   mapM_
                     (\ p -> do { ... }) [(x, y) | x <- [wl .. wh], y <- [hl .. hh]];
                   eaten <- mapM update [(x, y) | x <- [wl .. wh], y <- [hl .. hh]];
                   .... }
            where
                update (x, y)
                  = do { t <- readArray (oldworld s) ...;
                         .... }
                moveBug (x, y) d d'
                  = do { let ...;
                         .... }
                getNext (x, y) d
                  = case d of {
                      UP -> ...
                      DOWN -> ...
                      LEFT -> ...
                      RIGHT -> ... }

src/Rules.hs:292:35: error:
    • Ambiguous type variable ‘t0’ arising from a use of ‘mapM_’
      prevents the constraint ‘(Foldable t0)’ from being solved.
      Relevant bindings include
        adj :: t0 a0 (bound at src/Rules.hs:291:35)
      Probable fix: use a type annotation to specify what ‘t0’ should be.
      These potential instances exist:
        instance Foldable (Either a) -- Defined in ‘Data.Foldable’
        instance Foldable Maybe -- Defined in ‘Data.Foldable’
        instance Foldable ((,) a) -- Defined in ‘Data.Foldable’
        ...plus one other
        ...plus 24 instances involving out-of-scope types
        (use -fprint-potential-instances to see them all)
    • In a stmt of a 'do' block: mapM_ shaveBeard adj
      In the expression:
        do { adj <- surrounding s (x, y);
             mapM_ shaveBeard adj;
             return (razors s - 1) }
      In a stmt of a 'do' block:
        r <- if (razors s > 0) then
                 do { adj <- surrounding s (x, y);
                      mapM_ shaveBeard adj;
                      return (razors s - 1) }
             else
                 return $ razors s

src/Rules.hs:296:11: error:
    • Non type-variable argument
        in the constraint: MArray IOArray Tile m
      (Use FlexibleContexts to permit this)
    • When checking the inferred type
        shaveBeard :: forall (m :: * -> *).
                      MArray IOArray Tile m =>
                      (Int, Int) -> m ()
      In an equation for ‘movePlayer’:
          movePlayer s
            | shave s
            = do { let (x, y) = ...;
                   r <- if (razors s > 0) then do { ... } else return $ razors s;
                   return $ s {shave = False, razors = r, score = score s - 1} }
            where
                shaveBeard (x, y)
                  = do { t <- readArray (world s) ...;
                         .... }

src/Rules.hs:308:1: error:
    • Non type-variable argument
        in the constraint: MArray IOArray Tile m
      (Use FlexibleContexts to permit this)
    • When checking the inferred type
        execMove :: forall (m :: * -> *) a.
                    MArray IOArray Tile m =>
                    Tile -> (Int, Int) -> (Int, Int) -> GameState a -> m (GameState a)
cabal: Leaving directory '/tmp/cabal-tmp-9571/lifter-0.1'
cabal: Error: some packages failed to install:
lifter-0.1 failed during the building phase. The exception was:
ExitFailure 1