Hackage :: [Package]

• Search 
• Browse
• What's new
• Upload
• User accounts

Build #4 for lojysamban-0.0.8.1

[all reports]

Package	lojysamban-0.0.8.1

Install	DependencyFailed lojbanParser-0.1.9.2
Docs	NotTried
Tests	NotTried

Time submitted	2015-11-13 12:14:17.360222 UTC
Compiler	ghc-7.10.2
OS	linux
Arch	x86_64
Dependencies	yjtools-0.9.18, lojbanParser-0.1.9.2, base-4.8.1.0
Flags	none

Code Coverage

No Code Coverage was submitted for this report.

Build log

[view raw]

Resolving dependencies...
Configuring lojbanParser-0.1.9.2...
Building lojbanParser-0.1.9.2...
Preprocessing library lojbanParser-0.1.9.2...
[1 of 6] Compiling Pos              ( src/Pos.hs, dist/build/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 6] Compiling Parse            ( src/Parse.hs, dist/build/Parse.o )

src/Parse.hs:49: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:49:10-37
    In the instance declaration for ‘Monad (Parser d)’

src/Parse.hs:123: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:122: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:135: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:134: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:143: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:142: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:150: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:149: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:157: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:156: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:161: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:160: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:165: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:164: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:173: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:172: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:177: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:176: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:185: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:183: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:189: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:183: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:194: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:193: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:199: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:198: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:207: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:206: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:277: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:276:15-46
    In the expression: fail ("unexpected " ++ str)
    In an equation for ‘unexpected’:
        unexpected str = fail ("unexpected " ++ str)

src/Parse.hs:345: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 lojbanParser-0.1.9.2
Configuring yjtools-0.9.18...
Building yjtools-0.9.18...
Preprocessing library yjtools-0.9.18...
[1 of 7] Compiling Data.Tuple.Tools ( Data/Tuple/Tools.hs, dist/build/Data/Tuple/Tools.o )

Data/Tuple/Tools.hs:2:1: Warning: Tab character

Data/Tuple/Tools.hs:3:1: Warning: Tab character

Data/Tuple/Tools.hs:4:1: Warning: Tab character
[2 of 7] Compiling Data.IORef.Tools ( Data/IORef/Tools.hs, dist/build/Data/IORef/Tools.o )

Data/IORef/Tools.hs:2:1: Warning: Tab character
[3 of 7] Compiling Data.Bool.Tools  ( Data/Bool/Tools.hs, dist/build/Data/Bool/Tools.o )

Data/Bool/Tools.hs:10:1: Warning: Tab character

Data/Bool/Tools.hs:13:1: Warning: Tab character
[4 of 7] Compiling Data.Function.Tools ( Data/Function/Tools.hs, dist/build/Data/Function/Tools.o )
[5 of 7] Compiling Data.List.Tools  ( Data/List/Tools.hs, dist/build/Data/List/Tools.o )
[6 of 7] Compiling Control.Applicative.Tools ( Control/Applicative/Tools.hs, dist/build/Control/Applicative/Tools.o )
[7 of 7] Compiling Control.Monad.Tools ( Control/Monad/Tools.hs, dist/build/Control/Monad/Tools.o )

Control/Monad/Tools.hs:36:1: Warning: Tab character

Control/Monad/Tools.hs:39:1: Warning: Tab character
In-place registering yjtools-0.9.18...
Running Haddock for yjtools-0.9.18...
Running hscolour for yjtools-0.9.18...
Preprocessing library yjtools-0.9.18...
Preprocessing library yjtools-0.9.18...

Data/Tuple/Tools.hs:2:1: Warning: Tab character

Data/Tuple/Tools.hs:3:1: Warning: Tab character

Data/Tuple/Tools.hs:4:1: Warning: Tab character

Data/IORef/Tools.hs:2:1: Warning: Tab character

Data/Bool/Tools.hs:10:1: Warning: Tab character

Data/Bool/Tools.hs:13:1: Warning: Tab character

Control/Monad/Tools.hs:36:1: Warning: Tab character

Control/Monad/Tools.hs:39:1: Warning: Tab character
Haddock coverage:
   0% (  0 /  4) in 'Data.Tuple.Tools'
  Missing documentation for:
    Module header
    curry3 (Data/Tuple/Tools.hs:7)
    uncurry3 (Data/Tuple/Tools.hs:10)
    rotate (Data/Tuple/Tools.hs:13)
   0% (  0 /  2) in 'Data.IORef.Tools'
  Missing documentation for:
    Module header
    atomicModifyIORef_ (Data/IORef/Tools.hs:7)
   0% (  0 /  4) in 'Data.Bool.Tools'
  Missing documentation for:
    Module header
    &&& (Data/Bool/Tools.hs:7)
    ||| (Data/Bool/Tools.hs:7)
    whether (Data/Bool/Tools.hs:15)
   0% (  0 /  6) in 'Data.Function.Tools'
  Missing documentation for:
    Module header
    const2 (Data/Function/Tools.hs:13)
    const3 (Data/Function/Tools.hs:16)
    applyWhen (Data/Function/Tools.hs:19)
    applyUnless (Data/Function/Tools.hs:22)
    apply2way (Data/Function/Tools.hs:25)
   0% (  0 /  8) in 'Data.List.Tools'
  Missing documentation for:
    Module header
    takeUntil (Data/List/Tools.hs:12)
    dropUntil (Data/List/Tools.hs:13)
    mulLists (Data/List/Tools.hs:23)
    defaultElem (Data/List/Tools.hs:27)
    isIncludedElem (Data/List/Tools.hs:31)
    setAt (Data/List/Tools.hs:34)
    modifyAt (Data/List/Tools.hs:37)
   0% (  0 /  2) in 'Control.Applicative.Tools'
  Missing documentation for:
    Module header
    <.> (Control/Applicative/Tools.hs:6)
   0% (  0 / 14) in 'Control.Monad.Tools'
  Missing documentation for:
    Module header
    ifM (Control/Monad/Tools.hs:19)
    whenM (Control/Monad/Tools.hs:23)
    unlessM (Control/Monad/Tools.hs:23)
    doWhile_ (Control/Monad/Tools.hs:27)
    doWhile (Control/Monad/Tools.hs:33)
    doUntil_ (Control/Monad/Tools.hs:27)
    doUntil (Control/Monad/Tools.hs:33)
    for_ (Control/Monad/Tools.hs:41)
    for (Control/Monad/Tools.hs:46)
    filterM (Control/Monad/Tools.hs:51)
    repeatM (Control/Monad/Tools.hs:59)
    repeatM_ (Control/Monad/Tools.hs:62)
    skipRet (Control/Monad/Tools.hs:65)
Documentation created: dist/doc/html/yjtools/index.html,
dist/doc/html/yjtools/yjtools.txt
Creating package registration file:
/tmp/pkgConf-yjtools-0.9608413784756898537.18
Installing library in
/home/builder/hackage-server/build-cache/tmp-install/lib/x86_64-linux-ghc-7.10.2/yjtools-0.9.18-DCDBdNeBkiI51TGHEiAy8k
Registering yjtools-0.9.18...
Installed yjtools-0.9.18
cabal: Error: some packages failed to install:
lojbanParser-0.1.9.2 failed during the building phase. The exception was:
ExitFailure 1
lojysamban-0.0.8.1 depends on lojbanParser-0.1.9.2 which failed to install.

Test log

No test log was submitted for this report.