Resolving dependencies...
Configuring pappy-0.1.0.2...
Building pappy-0.1.0.2...
Preprocessing executable 'pappy' for pappy-0.1.0.2...
[1 of 9] Compiling Pos              ( src/Pos.hs, dist/build/pappy/pappy-tmp/Pos.o )

src/Pos.hs:8:1: Warning: Tab character

src/Pos.hs:8:24: Warning: Tab character

src/Pos.hs:9:1: Warning: Tab character

src/Pos.hs:9:24: Warning: Tab character

src/Pos.hs:10:1: Warning: Tab character

src/Pos.hs:10:23: Warning: Tab character

src/Pos.hs:11:1: Warning: Tab character

src/Pos.hs:17:1: Warning: Tab character

src/Pos.hs:18:1: Warning: Tab character

src/Pos.hs:19:1: Warning: Tab character

src/Pos.hs:23:1: Warning: Tab character

src/Pos.hs:24:1: Warning: Tab character

src/Pos.hs:28:1: Warning: Tab character

src/Pos.hs:29:1: Warning: Tab character

src/Pos.hs:33:1: Warning: Tab character

src/Pos.hs:41:1: Warning: Tab character

src/Pos.hs:42:1: Warning: Tab character

src/Pos.hs:42:13: Warning: Tab character

src/Pos.hs:43:1: Warning: Tab character

src/Pos.hs:44:1: Warning: Tab character

src/Pos.hs:45:1: Warning: Tab character
[2 of 9] Compiling Parse            ( src/Parse.hs, dist/build/pappy/pappy-tmp/Parse.o )

src/Parse.hs:39:10:
    Could not deduce (Applicative (Parser d))
      arising from the superclasses of an instance declaration
    from the context (Derivs d)
      bound by the instance declaration at src/Parse.hs:39:10-37
    In the instance declaration for ‘Monad (Parser d)’

src/Parse.hs:113:18:
    Could not deduce (Applicative (Parser d))
      arising from a do statement
    from the context (Derivs d)
      bound by the type signature for
                 optional :: Derivs d => Parser d v -> Parser d (Maybe v)
      at src/Parse.hs:112:13-56
    In a stmt of a 'do' block: v <- p
    In the first argument of ‘(</>)’, namely
      ‘(do { v <- p;
             return (Just v) })’
    In the expression:
      (do { v <- p;
            return (Just v) })
      </> return Nothing

src/Parse.hs:125:16:
    Could not deduce (Applicative (Parser d))
      arising from a do statement
    from the context (Derivs d)
      bound by the type signature for
                 many :: Derivs d => Parser d v -> Parser d [v]
      at src/Parse.hs:124:9-46
    In a stmt of a 'do' block: v <- p
    In the first argument of ‘(</>)’, namely
      ‘(do { v <- p;
             vs <- many p;
             return (v : vs) })’
    In the expression:
      (do { v <- p;
            vs <- many p;
            return (v : vs) })
      </> return []

src/Parse.hs:133:16:
    Could not deduce (Applicative (Parser d))
      arising from a do statement
    from the context (Derivs d)
      bound by the type signature for
                 many1 :: Derivs d => Parser d v -> Parser d [v]
      at src/Parse.hs:132:10-47
    In a stmt of a 'do' block: v <- p
    In the expression:
      do { v <- p;
           vs <- many p;
           return (v : vs) }
    In an equation for ‘many1’:
        many1 p
          = do { v <- p;
                 vs <- many p;
                 return (v : vs) }

src/Parse.hs:140:20:
    Could not deduce (Applicative (Parser d))
      arising from a do statement
    from the context (Derivs d)
      bound by the type signature for
                 sepBy1 :: Derivs d => Parser d v -> Parser d vsep -> Parser d [v]
      at src/Parse.hs:139:11-65
    In a stmt of a 'do' block: v <- p
    In the expression:
      do { v <- p;
           vs <- many
                   (do { psep;
                         p });
           return (v : vs) }
    In an equation for ‘sepBy1’:
        sepBy1 p psep
          = do { v <- p;
                 vs <- many
                         (do { psep;
                               p });
                 return (v : vs) }

src/Parse.hs:147:34:
    Could not deduce (Applicative (Parser d))
      arising from a use of ‘return’
    from the context (Derivs d)
      bound by the type signature for
                 sepBy :: Derivs d => Parser d v -> Parser d vsep -> Parser d [v]
      at src/Parse.hs:146:10-64
    In the second argument of ‘(</>)’, namely ‘return []’
    In the expression: sepBy1 p psep </> return []
    In an equation for ‘sepBy’:
        sepBy p psep = sepBy1 p psep </> return []

src/Parse.hs:151:27:
    Could not deduce (Applicative (Parser d))
      arising from a do statement
    from the context (Derivs d)
      bound by the type signature for
                 endBy :: Derivs d => Parser d v -> Parser d vend -> Parser d [v]
      at src/Parse.hs:150:10-64
    In a stmt of a 'do' block: v <- p
    In the first argument of ‘many’, namely
      ‘(do { v <- p;
             pend;
             return v })’
    In the expression:
      many
        (do { v <- p;
              pend;
              return v })

src/Parse.hs:155:29:
    Could not deduce (Applicative (Parser d))
      arising from a do statement
    from the context (Derivs d)
      bound by the type signature for
                 endBy1 :: Derivs d => Parser d v -> Parser d vend -> Parser d [v]
      at src/Parse.hs:154:11-65
    In a stmt of a 'do' block: v <- p
    In the first argument of ‘many1’, namely
      ‘(do { v <- p;
             pend;
             return v })’
    In the expression:
      many1
        (do { v <- p;
              pend;
              return v })

src/Parse.hs:163:23:
    Could not deduce (Applicative (Parser d))
      arising from a do statement
    from the context (Derivs d)
      bound by the type signature for
                 sepEndBy1 :: Derivs d =>
                              Parser d v -> Parser d vsep -> Parser d [v]
      at src/Parse.hs:162:14-68
    In a stmt of a 'do' block: v <- sepBy1 p psep
    In the expression:
      do { v <- sepBy1 p psep;
           optional psep;
           return v }
    In an equation for ‘sepEndBy1’:
        sepEndBy1 p psep
          = do { v <- sepBy1 p psep;
                 optional psep;
                 return v }

src/Parse.hs:167:22:
    Could not deduce (Applicative (Parser d))
      arising from a do statement
    from the context (Derivs d)
      bound by the type signature for
                 sepEndBy :: Derivs d => Parser d v -> Parser d vsep -> Parser d [v]
      at src/Parse.hs:166:13-67
    In a stmt of a 'do' block: v <- sepBy p psep
    In the expression:
      do { v <- sepBy p psep;
           optional psep;
           return v }
    In an equation for ‘sepEndBy’:
        sepEndBy p psep
          = do { v <- sepBy p psep;
                 optional psep;
                 return v }

src/Parse.hs:175:29:
    Could not deduce (Applicative (Parser d))
      arising from a do statement
    from the context (Derivs d)
      bound by the type signature for
                 chainl1 :: Derivs d =>
                            Parser d v -> Parser d (v -> v -> v) -> Parser d v
      at src/Parse.hs:173:12-69
    In a stmt of a 'do' block: f <- psep
    In the first argument of ‘(</>)’, namely
      ‘(do { f <- psep;
             v <- p;
             psuffix (f z v) })’
    In the expression:
      (do { f <- psep;
            v <- p;
            psuffix (f z v) })
      </> return z

src/Parse.hs:179:15:
    Could not deduce (Applicative (Parser d))
      arising from a do statement
    from the context (Derivs d)
      bound by the type signature for
                 chainl1 :: Derivs d =>
                            Parser d v -> Parser d (v -> v -> v) -> Parser d v
      at src/Parse.hs:173:12-69
    In a stmt of a 'do' block: v <- p
    In the expression:
      do { v <- p;
           psuffix v }
    In the expression:
      let
        psuffix z
          = (do { f <- psep;
                  .... })
            </> return z
      in
        do { v <- p;
             psuffix v }

src/Parse.hs:184:38:
    Could not deduce (Applicative (Parser d))
      arising from a use of ‘return’
    from the context (Derivs d)
      bound by the type signature for
                 chainl :: Derivs d =>
                           Parser d v -> Parser d (v -> v -> v) -> v -> Parser d v
      at src/Parse.hs:183:11-73
    In the second argument of ‘(</>)’, namely ‘return z’
    In the expression: chainl1 p psep </> return z
    In an equation for ‘chainl’:
        chainl p psep z = chainl1 p psep </> return z

src/Parse.hs:189:22:
    Could not deduce (Applicative (Parser d))
      arising from a do statement
    from the context (Derivs d)
      bound by the type signature for
                 chainr1 :: Derivs d =>
                            Parser d v -> Parser d (v -> v -> v) -> Parser d v
      at src/Parse.hs:188:12-69
    In a stmt of a 'do' block: v <- p
    In the first argument of ‘(</>)’, namely
      ‘(do { v <- p;
             f <- psep;
             w <- chainr1 p psep;
             return (f v w) })’
    In the expression:
      (do { v <- p;
            f <- psep;
            w <- chainr1 p psep;
            return (f v w) })
      </> p

src/Parse.hs:197:38:
    Could not deduce (Applicative (Parser d))
      arising from a use of ‘return’
    from the context (Derivs d)
      bound by the type signature for
                 chainr :: Derivs d =>
                           Parser d v -> Parser d (v -> v -> v) -> v -> Parser d v
      at src/Parse.hs:196:11-73
    In the second argument of ‘(</>)’, namely ‘return z’
    In the expression: chainr1 p psep </> return z
    In an equation for ‘chainr’:
        chainr p psep z = chainr1 p psep </> return z

src/Parse.hs:267:18:
    Could not deduce (Applicative (Parser d))
      arising from a use of ‘fail’
    from the context (Derivs d)
      bound by the type signature for
                 unexpected :: Derivs d => String -> Parser d v
      at src/Parse.hs:266:15-46
    In the expression: fail ("unexpected " ++ str)
    In an equation for ‘unexpected’:
        unexpected str = fail ("unexpected " ++ str)

src/Parse.hs:335:15:
    Non type-variable argument
      in the constraint: Applicative (Parser d)
    (Use FlexibleContexts to permit this)
    When checking that ‘p’ has the inferred type
      p :: forall d.
           (Applicative (Parser d), Derivs d) =>
           [Char] -> Parser d String
    In an equation for ‘string’:
        string str
          = p str <?> show str
          where
              p [] = return str
              p (ch : chs)
                = do { char ch;
                       .... }
Failed to install pappy-0.1.0.2
cabal: Error: some packages failed to install:
pappy-0.1.0.2 failed during the building phase. The exception was:
ExitFailure 1