Build #8 for cfopu-0.1.0

[all reports]

Package cfopu-0.1.0
Install BuildFailed
Docs NotTried
Tests NotTried
Time submitted 2016-12-29 15:10:45.093607 UTC
Compiler ghc-8.0.1.20161018
OS linux
Arch x86_64
Dependencies base-4.9.0.0, bytestring-0.10.8.1, containers-0.5.7.1, data-default-0.7.1.1, dequeue-0.1.12, mtl-2.2.1
Flags none

Code Coverage

No Code Coverage was submitted for this report.

Build log

[view raw]

Resolving dependencies...
Configuring data-default-class-0.1.2.0...
Configuring dlist-0.8.0.2...
Building data-default-class-0.1.2.0...
Building dlist-0.8.0.2...
Installed data-default-class-0.1.2.0
Configuring mtl-2.2.1...
Building mtl-2.2.1...
Configuring old-locale-1.0.0.7...
Installed dlist-0.8.0.2
Building old-locale-1.0.0.7...
Configuring random-1.1...
Installed old-locale-1.0.0.7
Building random-1.1...
Configuring safe-0.3.10...
Installed mtl-2.2.1
Building safe-0.3.10...
Configuring primitive-0.6.2.0...
Installed random-1.1
Building primitive-0.6.2.0...
Configuring data-default-instances-containers-0.0.1...
Installed safe-0.3.10
Building data-default-instances-containers-0.0.1...
Installed data-default-instances-containers-0.0.1
Configuring data-default-instances-dlist-0.0.1...
Building data-default-instances-dlist-0.0.1...
Configuring data-default-instances-old-locale-0.0.1...
Installed data-default-instances-dlist-0.0.1
Building data-default-instances-old-locale-0.0.1...
Installed data-default-instances-old-locale-0.0.1
Configuring data-default-0.7.1.1...
Building data-default-0.7.1.1...
Installed data-default-0.7.1.1
Installed primitive-0.6.2.0
Configuring tf-random-0.5...
Building tf-random-0.5...
Installed tf-random-0.5
Configuring QuickCheck-2.9.2...
Building QuickCheck-2.9.2...
Installed QuickCheck-2.9.2
Configuring dequeue-0.1.12...
Building dequeue-0.1.12...
Installed dequeue-0.1.12
Configuring cfopu-0.1.0...
Building cfopu-0.1.0...
Failed to install cfopu-0.1.0
Build log ( /home/builder/.cabal/logs/cfopu-0.1.0.log ):
cabal: Entering directory '/tmp/cabal-tmp-18163/cfopu-0.1.0'
Configuring cfopu-0.1.0...
Building cfopu-0.1.0...
Preprocessing executable 'cfopu' for cfopu-0.1.0...
[1 of 2] Compiling Data.Memory      ( Data/Memory.hs, dist/build/cfopu/cfopu-tmp/Data/Memory.o )

Data/Memory.hs:79:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe Cell, InternalContainer)’
    • In the pattern: ((Just cell), p')
      In a case alternative:
          ((Just cell), p') -> ID p' (pushFront i cell) d
      In the expression:
        case popBack p of {
          ((Just cell), p') -> ID p' (pushFront i cell) d
          ((Nothing), _) -> ID p (pushFront i defaultCell) d }

Data/Memory.hs:80:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe t0, t1)’
    • In the pattern: ((Nothing), _)
      In a case alternative:
          ((Nothing), _) -> ID p (pushFront i defaultCell) d
      In the expression:
        case popBack p of {
          ((Just cell), p') -> ID p' (pushFront i cell) d
          ((Nothing), _) -> ID p (pushFront i defaultCell) d }

Data/Memory.hs:83:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe Cell, BankersDequeue Cell)’
    • In the pattern: ((Just cell), d')
      In a case alternative:
          ((Just cell), d')
            -> case () of {
                 _ | null d' -> E p $ pushFront i cell
                   | otherwise -> DI p d' $ pushFront i cell }
      In the expression:
        case popBack d of {
          ((Just cell), d')
            -> case () of {
                 _ | null d' -> E p $ pushFront i cell
                   | otherwise -> DI p d' $ pushFront i cell }
          ((Nothing), _) -> moveInstructionPointerLeft $ E p i }

Data/Memory.hs:86:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe t2, t3)’
    • In the pattern: ((Nothing), _)
      In a case alternative:
          ((Nothing), _) -> moveInstructionPointerLeft $ E p i
      In the expression:
        case popBack d of {
          ((Just cell), d')
            -> case () of {
                 _ | null d' -> E p $ pushFront i cell
                   | otherwise -> DI p d' $ pushFront i cell }
          ((Nothing), _) -> moveInstructionPointerLeft $ E p i }

Data/Memory.hs:89:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe Cell, InternalContainer)’
    • In the pattern: ((Just cell), p')
      In a case alternative:
          ((Just cell), p') -> ID p' (pushFront empty cell) e
      In the expression:
        case popBack p of {
          ((Just cell), p') -> ID p' (pushFront empty cell) e
          ((Nothing), _) -> ID p (pushFront empty defaultCell) e }

Data/Memory.hs:90:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe t4, t5)’
    • In the pattern: ((Nothing), _)
      In a case alternative:
          ((Nothing), _) -> ID p (pushFront empty defaultCell) e
      In the expression:
        case popBack p of {
          ((Just cell), p') -> ID p' (pushFront empty cell) e
          ((Nothing), _) -> ID p (pushFront empty defaultCell) e }

Data/Memory.hs:95:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe Cell, BankersDequeue Cell)’
    • In the pattern: ((Just cell), i')
      In a case alternative:
          ((Just cell), i')
            -> case () of {
                 _ | null i' -> E (pushBack p cell) d
                   | otherwise -> ID (pushBack p cell) i' d }
      In the expression:
        case popFront i of {
          ((Just cell), i')
            -> case () of {
                 _ | null i' -> E (pushBack p cell) d
                   | otherwise -> ID (pushBack p cell) i' d }
          ((Nothing), _) -> moveInstructionPointerRight $ E p i }

Data/Memory.hs:98:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe t6, t7)’
    • In the pattern: ((Nothing), _)
      In a case alternative:
          ((Nothing), _) -> moveInstructionPointerRight $ E p i
      In the expression:
        case popFront i of {
          ((Just cell), i')
            -> case () of {
                 _ | null i' -> E (pushBack p cell) d
                   | otherwise -> ID (pushBack p cell) i' d }
          ((Nothing), _) -> moveInstructionPointerRight $ E p i }

Data/Memory.hs:101:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe Cell, BankersDequeue Cell)’
    • In the pattern: ((Just cell), i')
      In a case alternative:
          ((Just cell), i')
            -> case () of {
                 _ | null i' -> DI p (pushBack d cell) $ pushBack i' defaultCell
                   | otherwise -> DI p (pushBack d cell) $ i' }
      In the expression:
        case popFront i of {
          ((Just cell), i')
            -> case () of {
                 _ | null i' -> DI p (pushBack d cell) $ pushBack i' defaultCell
                   | otherwise -> DI p (pushBack d cell) $ i' }
          ((Nothing), _) -> moveInstructionPointerRight $ E p d }

Data/Memory.hs:104:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe t8, t9)’
    • In the pattern: ((Nothing), _)
      In a case alternative:
          ((Nothing), _) -> moveInstructionPointerRight $ E p d
      In the expression:
        case popFront i of {
          ((Just cell), i')
            -> case () of {
                 _ | null i' -> DI p (pushBack d cell) $ pushBack i' defaultCell
                   | otherwise -> DI p (pushBack d cell) $ i' }
          ((Nothing), _) -> moveInstructionPointerRight $ E p d }

Data/Memory.hs:107:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe Cell, BankersDequeue Cell)’
    • In the pattern: ((Just cell), e')
      In a case alternative:
          ((Just cell), e')
            -> case () of {
                 _ | null e'
                   -> DI p (pushBack empty cell) $ pushBack empty defaultCell
                   | otherwise -> DI p (pushBack empty cell) e' }
      In the expression:
        case popFront e of {
          ((Just cell), e')
            -> case () of {
                 _ | null e'
                   -> DI p (pushBack empty cell) $ pushBack empty defaultCell
                   | otherwise -> DI p (pushBack empty cell) e' }
          ((Nothing), _)
            -> moveInstructionPointerRight $ E p $ pushBack empty defaultCell }

Data/Memory.hs:110:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe t10, t11)’
    • In the pattern: ((Nothing), _)
      In a case alternative:
          ((Nothing), _)
            -> moveInstructionPointerRight $ E p $ pushBack empty defaultCell
      In the expression:
        case popFront e of {
          ((Just cell), e')
            -> case () of {
                 _ | null e'
                   -> DI p (pushBack empty cell) $ pushBack empty defaultCell
                   | otherwise -> DI p (pushBack empty cell) e' }
          ((Nothing), _)
            -> moveInstructionPointerRight $ E p $ pushBack empty defaultCell }

Data/Memory.hs:115:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe Cell, BankersDequeue Cell)’
    • In the pattern: ((Just cell), i')
      In a case alternative:
          ((Just cell), i')
            -> case () of {
                 _ | null i' -> E p $ pushFront d cell
                   | otherwise -> ID p i' $ pushFront d cell }
      In the expression:
        case popBack i of {
          ((Just cell), i')
            -> case () of {
                 _ | null i' -> E p $ pushFront d cell
                   | otherwise -> ID p i' $ pushFront d cell }
          ((Nothing), _) -> moveDataPointerLeft $ E p d }

Data/Memory.hs:118:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe t12, t13)’
    • In the pattern: ((Nothing), _)
      In a case alternative:
          ((Nothing), _) -> moveDataPointerLeft $ E p d
      In the expression:
        case popBack i of {
          ((Just cell), i')
            -> case () of {
                 _ | null i' -> E p $ pushFront d cell
                   | otherwise -> ID p i' $ pushFront d cell }
          ((Nothing), _) -> moveDataPointerLeft $ E p d }

Data/Memory.hs:121:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe Cell, InternalContainer)’
    • In the pattern: ((Just cell), p')
      In a case alternative:
          ((Just cell), p') -> DI p' (pushFront d cell) i
      In the expression:
        case popBack p of {
          ((Just cell), p') -> DI p' (pushFront d cell) i
          ((Nothing), _) -> DI p (pushFront d defaultCell) i }

Data/Memory.hs:122:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe t14, t15)’
    • In the pattern: ((Nothing), _)
      In a case alternative:
          ((Nothing), _) -> DI p (pushFront d defaultCell) i
      In the expression:
        case popBack p of {
          ((Just cell), p') -> DI p' (pushFront d cell) i
          ((Nothing), _) -> DI p (pushFront d defaultCell) i }

Data/Memory.hs:125:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe Cell, InternalContainer)’
    • In the pattern: ((Just cell), p')
      In a case alternative:
          ((Just cell), p') -> DI p' (pushFront empty cell) e
      In the expression:
        case popBack p of {
          ((Just cell), p') -> DI p' (pushFront empty cell) e
          ((Nothing), _) -> DI p (pushFront empty defaultCell) e }

Data/Memory.hs:126:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe t16, t17)’
    • In the pattern: ((Nothing), _)
      In a case alternative:
          ((Nothing), _) -> DI p (pushFront empty defaultCell) e
      In the expression:
        case popBack p of {
          ((Just cell), p') -> DI p' (pushFront empty cell) e
          ((Nothing), _) -> DI p (pushFront empty defaultCell) e }

Data/Memory.hs:131:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe Cell, BankersDequeue Cell)’
    • In the pattern: ((Just cell), d')
      In a case alternative:
          ((Just cell), d')
            -> case () of {
                 _ | null d' -> ID p (pushBack i cell) $ pushBack d' defaultCell
                   | otherwise -> ID p (pushBack i cell) $ d' }
      In the expression:
        case popFront d of {
          ((Just cell), d')
            -> case () of {
                 _ | null d' -> ID p (pushBack i cell) $ pushBack d' defaultCell
                   | otherwise -> ID p (pushBack i cell) $ d' }
          ((Nothing), _) -> moveDataPointerRight $ E p i }

Data/Memory.hs:134:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe t18, t19)’
    • In the pattern: ((Nothing), _)
      In a case alternative:
          ((Nothing), _) -> moveDataPointerRight $ E p i
      In the expression:
        case popFront d of {
          ((Just cell), d')
            -> case () of {
                 _ | null d' -> ID p (pushBack i cell) $ pushBack d' defaultCell
                   | otherwise -> ID p (pushBack i cell) $ d' }
          ((Nothing), _) -> moveDataPointerRight $ E p i }

Data/Memory.hs:137:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe Cell, BankersDequeue Cell)’
    • In the pattern: ((Just cell), d')
      In a case alternative:
          ((Just cell), d')
            -> case () of {
                 _ | null d' -> E (pushBack p cell) i
                   | otherwise -> DI (pushBack p cell) d' i }
      In the expression:
        case popFront d of {
          ((Just cell), d')
            -> case () of {
                 _ | null d' -> E (pushBack p cell) i
                   | otherwise -> DI (pushBack p cell) d' i }
          ((Nothing), _) -> moveDataPointerRight $ E p d }

Data/Memory.hs:140:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe t20, t21)’
    • In the pattern: ((Nothing), _)
      In a case alternative:
          ((Nothing), _) -> moveDataPointerRight $ E p d
      In the expression:
        case popFront d of {
          ((Just cell), d')
            -> case () of {
                 _ | null d' -> E (pushBack p cell) i
                   | otherwise -> DI (pushBack p cell) d' i }
          ((Nothing), _) -> moveDataPointerRight $ E p d }

Data/Memory.hs:143:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe Cell, BankersDequeue Cell)’
    • In the pattern: ((Just cell), e')
      In a case alternative:
          ((Just cell), e')
            -> case () of {
                 _ | null e'
                   -> ID p (pushBack empty cell) $ pushBack empty defaultCell
                   | otherwise -> ID p (pushBack empty cell) e' }
      In the expression:
        case popFront e of {
          ((Just cell), e')
            -> case () of {
                 _ | null e'
                   -> ID p (pushBack empty cell) $ pushBack empty defaultCell
                   | otherwise -> ID p (pushBack empty cell) e' }
          ((Nothing), _)
            -> moveDataPointerRight $ E p $ pushBack empty defaultCell }

Data/Memory.hs:146:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe t22, t23)’
    • In the pattern: ((Nothing), _)
      In a case alternative:
          ((Nothing), _)
            -> moveDataPointerRight $ E p $ pushBack empty defaultCell
      In the expression:
        case popFront e of {
          ((Just cell), e')
            -> case () of {
                 _ | null e'
                   -> ID p (pushBack empty cell) $ pushBack empty defaultCell
                   | otherwise -> ID p (pushBack empty cell) e' }
          ((Nothing), _)
            -> moveDataPointerRight $ E p $ pushBack empty defaultCell }

Data/Memory.hs:161:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe Cell, t24)’
    • In the pattern: ((Just cell), _)
      In a case alternative: ((Just cell), _) -> cell
      In the expression:
        case popFront i of {
          ((Just cell), _) -> cell
          ((Nothing), _) -> getInstruction $ E p i }

Data/Memory.hs:162:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe t25, t26)’
    • In the pattern: ((Nothing), _)
      In a case alternative: ((Nothing), _) -> getInstruction $ E p i
      In the expression:
        case popFront i of {
          ((Just cell), _) -> cell
          ((Nothing), _) -> getInstruction $ E p i }

Data/Memory.hs:165:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe Cell, t27)’
    • In the pattern: ((Just cell), _)
      In a case alternative: ((Just cell), _) -> cell
      In the expression:
        case popFront i of {
          ((Just cell), _) -> cell
          ((Nothing), _) -> defaultCell }

Data/Memory.hs:166:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe t28, t29)’
    • In the pattern: ((Nothing), _)
      In a case alternative: ((Nothing), _) -> defaultCell
      In the expression:
        case popFront i of {
          ((Just cell), _) -> cell
          ((Nothing), _) -> defaultCell }

Data/Memory.hs:169:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe Cell, t30)’
    • In the pattern: ((Just cell), _)
      In a case alternative: ((Just cell), _) -> cell
      In the expression:
        case popFront e of {
          ((Just cell), _) -> cell
          ((Nothing), _) -> defaultCell }

Data/Memory.hs:170:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe t31, t32)’
    • In the pattern: ((Nothing), _)
      In a case alternative: ((Nothing), _) -> defaultCell
      In the expression:
        case popFront e of {
          ((Just cell), _) -> cell
          ((Nothing), _) -> defaultCell }

Data/Memory.hs:175:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe Cell, t33)’
    • In the pattern: ((Just cell), _)
      In a case alternative: ((Just cell), _) -> cell
      In the expression:
        case popFront d of {
          ((Just cell), _) -> cell
          ((Nothing), _) -> defaultCell }

Data/Memory.hs:176:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe t34, t35)’
    • In the pattern: ((Nothing), _)
      In a case alternative: ((Nothing), _) -> defaultCell
      In the expression:
        case popFront d of {
          ((Just cell), _) -> cell
          ((Nothing), _) -> defaultCell }

Data/Memory.hs:179:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe Cell, t36)’
    • In the pattern: ((Just cell), _)
      In a case alternative: ((Just cell), _) -> cell
      In the expression:
        case popFront d of {
          ((Just cell), _) -> cell
          ((Nothing), _) -> getData $ E p i }

Data/Memory.hs:180:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe t37, t38)’
    • In the pattern: ((Nothing), _)
      In a case alternative: ((Nothing), _) -> getData $ E p i
      In the expression:
        case popFront d of {
          ((Just cell), _) -> cell
          ((Nothing), _) -> getData $ E p i }

Data/Memory.hs:183:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe Cell, t39)’
    • In the pattern: ((Just cell), _)
      In a case alternative: ((Just cell), _) -> cell
      In the expression:
        case popFront e of {
          ((Just cell), _) -> cell
          ((Nothing), _) -> defaultCell }

Data/Memory.hs:184:9: error:
    • Couldn't match expected type ‘Maybe (Cell, BankersDequeue Cell)’
                  with actual type ‘(Maybe t40, t41)’
    • In the pattern: ((Nothing), _)
      In a case alternative: ((Nothing), _) -> defaultCell
      In the expression:
        case popFront e of {
          ((Just cell), _) -> cell
          ((Nothing), _) -> defaultCell }

Data/Memory.hs:187:70: error:
    • Couldn't match expected type ‘(a0, BankersDequeue Cell)’
                  with actual type ‘Maybe (Cell, BankersDequeue Cell)’
    • In the second argument of ‘($)’, namely ‘popFront d’
      In the ‘id_d’ field of a record
      In the expression:
        mem {id_d = flip pushFront cell . snd $ popFront d}

Data/Memory.hs:190:59: error:
    • Couldn't match expected type ‘(a1, BankersDequeue Cell)’
                  with actual type ‘Maybe (Cell, BankersDequeue Cell)’
    • In the second argument of ‘($)’, namely ‘popFront d’
      In the ‘di_d’ field of a record
      In the expression:
        mem {di_d = flip pushFront cell . snd $ popFront d}

Data/Memory.hs:191:70: error:
    • Couldn't match expected type ‘(a2, BankersDequeue Cell)’
                  with actual type ‘Maybe (Cell, BankersDequeue Cell)’
    • In the second argument of ‘($)’, namely ‘popFront e’
      In the ‘e_e’ field of a record
      In the expression:
        mem {e_e = flip pushFront cell . snd $ popFront e}
cabal: Leaving directory '/tmp/cabal-tmp-18163/cfopu-0.1.0'
cabal: Error: some packages failed to install:
cfopu-0.1.0 failed during the building phase. The exception was:
ExitFailure 1