Build #3 for pinchot-0.8.0.0

[all reports]

Package pinchot-0.8.0.0
Install BuildFailed
Docs NotTried
Tests NotTried
Time submitted 2016-11-28 10:22:47.809061 UTC
Compiler ghc-8.0.1.20161018
OS linux
Arch x86_64
Dependencies Earley-0.11.0.1, base-4.9.0.0, containers-0.5.7.1, lens-4.15.1, template-haskell-2.11.0.0, transformers-0.5.2.0
Flags -executables

Code Coverage

No Code Coverage was submitted for this report.

Build log

[view raw]

Resolving dependencies...
Configuring base-orphans-0.5.4...
Configuring dlist-0.8.0.2...
Building dlist-0.8.0.2...
Building base-orphans-0.5.4...
Installed base-orphans-0.5.4
Configuring fmlist-0.9...
Building fmlist-0.9...
Configuring mtl-2.2.1...
Installed dlist-0.8.0.2
Building mtl-2.2.1...
Configuring parallel-3.2.1.0...
Installed fmlist-0.9
Building parallel-3.2.1.0...
Configuring primitive-0.6.1.0...
Installed parallel-3.2.1.0
Building primitive-0.6.1.0...
Configuring prelude-extras-0.4.0.3...
Installed mtl-2.2.1
Building prelude-extras-0.4.0.3...
Configuring reflection-2.1.2...
Installed primitive-0.6.1.0
Configuring semigroups-0.18.2...
Installed prelude-extras-0.4.0.3
Building reflection-2.1.2...
Building semigroups-0.18.2...
Configuring stm-2.4.4.1...
Installed semigroups-0.18.2
Building stm-2.4.4.1...
Configuring text-1.2.2.1...
Installed stm-2.4.4.1
Configuring transformers-compat-0.5.1.4...
Installed reflection-2.1.2
Building text-1.2.2.1...
Building transformers-compat-0.5.1.4...
Configuring utf8-string-1.0.1.1...
Installed transformers-compat-0.5.1.4
Building utf8-string-1.0.1.1...
Installed utf8-string-1.0.1.1
Configuring StateVar-1.1.0.4...
Building StateVar-1.1.0.4...
Configuring tagged-0.8.5...
Installed StateVar-1.1.0.4
Building tagged-0.8.5...
Configuring exceptions-0.8.3...
Installed tagged-0.8.5
Building exceptions-0.8.3...
Configuring vector-0.11.0.0...
Installed text-1.2.2.1
Building vector-0.11.0.0...
Installed exceptions-0.8.3
Configuring distributive-0.5.0.2...
Building distributive-0.5.0.2...
Configuring hashable-1.2.4.0...
Installed distributive-0.5.0.2
Building hashable-1.2.4.0...
Installed hashable-1.2.4.0
Configuring void-0.7.1...
Building void-0.7.1...
Configuring unordered-containers-0.2.7.1...
Installed void-0.7.1
Building unordered-containers-0.2.7.1...
Configuring contravariant-1.4...
Installed unordered-containers-0.2.7.1
Building contravariant-1.4...
Installed vector-0.11.0.0
Configuring ListLike-4.5...
Building ListLike-4.5...
Installed contravariant-1.4
Configuring comonad-5...
Building comonad-5...
Installed comonad-5
Configuring bifunctors-5.4.1...
Building bifunctors-5.4.1...
Installed ListLike-4.5
Configuring Earley-0.11.0.1...
Building Earley-0.11.0.1...
Installed Earley-0.11.0.1
Installed bifunctors-5.4.1
Configuring semigroupoids-5.1...
Configuring profunctors-5.2...
Building profunctors-5.2...
Building semigroupoids-5.1...
Installed profunctors-5.2
Installed semigroupoids-5.1
Configuring free-4.12.4...
Building free-4.12.4...
Installed free-4.12.4
Configuring adjunctions-4.3...
Building adjunctions-4.3...
Installed adjunctions-4.3
Configuring kan-extensions-5.0.1...
Building kan-extensions-5.0.1...
Installed kan-extensions-5.0.1
Configuring lens-4.15.1...
Building lens-4.15.1...
Installed lens-4.15.1
Configuring pinchot-0.8.0.0...
Building pinchot-0.8.0.0...
Failed to install pinchot-0.8.0.0
Build log ( /home/builder/.cabal/logs/pinchot-0.8.0.0.log ):
cabal: Entering directory '/tmp/cabal-tmp-14398/pinchot-0.8.0.0'
Configuring pinchot-0.8.0.0...
Building pinchot-0.8.0.0...
Preprocessing library pinchot-0.8.0.0...
[1 of 9] Compiling Pinchot.Intervals ( lib/Pinchot/Intervals.hs, dist/build/Pinchot/Intervals.o )
[2 of 9] Compiling Pinchot.Internal ( lib/Pinchot/Internal.hs, dist/build/Pinchot/Internal.o )

lib/Pinchot/Internal.hs:467:18: error:
    • Couldn't match expected type ‘Q Syntax.Dec’
                  with actual type ‘TH.CxtQ -> TH.DecQ’
    • Probable cause: ‘newtypeD’ is applied to too few arguments
      In the expression: newtypeD (cxt []) name [] newtypeCon derives
      In a case alternative:
          RTerminal _
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [strictType notStrict (conT typeName)]
      In the expression:
        case ruleType of {
          RTerminal _
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RBranch (b1, bs)
            -> dataD (cxt []) name [] cons derives
            where
                cons = thBranch b1 : toList (fmap thBranch bs)
          RUnion (b1, bs)
            -> dataD (cxt []) name [] cons derives
            where
                cons = thUnionBranch nm b1 : toList (fmap (thUnionBranch nm) bs)
          RSeqTerm _
            -> newtypeD (cxt []) name [] cons derives
            where
                cons = normalC name [...]
          ROptional (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RList (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RList1 (Rule inner _ _)
            -> newtypeD (cxt []) name [] cons derives
            where
                cons = normalC name [...]
          RWrap (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RRecord sq
            -> dataD (cxt []) name [] [ctor] derives
            where
                ctor = recC name . zipWith mkField [(0 :: Int) .. ] . toList $ sq
                mkField num (Rule rn _ _)
                  = varStrictType
                      (mkName fldNm) (strictType notStrict (conT (mkName rn)))
                  where
                      fldNm = ... }

lib/Pinchot/Internal.hs:467:44: error:
    • Couldn't match type ‘Q Syntax.Con’ with ‘Maybe Syntax.Kind’
      Expected type: Maybe Syntax.Kind
        Actual type: ConQ
    • In the fourth argument of ‘newtypeD’, namely ‘newtypeCon’
      In the expression: newtypeD (cxt []) name [] newtypeCon derives
      In a case alternative:
          RTerminal _
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [strictType notStrict (conT typeName)]

lib/Pinchot/Internal.hs:467:55: error:
    • Couldn't match type ‘[Name]’ with ‘Q Syntax.Con’
      Expected type: ConQ
        Actual type: [Name]
    • In the fifth argument of ‘newtypeD’, namely ‘derives’
      In the expression: newtypeD (cxt []) name [] newtypeCon derives
      In a case alternative:
          RTerminal _
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [strictType notStrict (conT typeName)]

lib/Pinchot/Internal.hs:472:23: error:
    • Couldn't match expected type ‘Q Syntax.Dec’
                  with actual type ‘TH.CxtQ -> TH.DecQ’
    • Probable cause: ‘dataD’ is applied to too few arguments
      In the expression: dataD (cxt []) name [] cons derives
      In a case alternative:
          RBranch (b1, bs)
            -> dataD (cxt []) name [] cons derives
            where
                cons = thBranch b1 : toList (fmap thBranch bs)
      In the expression:
        case ruleType of {
          RTerminal _
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RBranch (b1, bs)
            -> dataD (cxt []) name [] cons derives
            where
                cons = thBranch b1 : toList (fmap thBranch bs)
          RUnion (b1, bs)
            -> dataD (cxt []) name [] cons derives
            where
                cons = thUnionBranch nm b1 : toList (fmap (thUnionBranch nm) bs)
          RSeqTerm _
            -> newtypeD (cxt []) name [] cons derives
            where
                cons = normalC name [...]
          ROptional (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RList (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RList1 (Rule inner _ _)
            -> newtypeD (cxt []) name [] cons derives
            where
                cons = normalC name [...]
          RWrap (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RRecord sq
            -> dataD (cxt []) name [] [ctor] derives
            where
                ctor = recC name . zipWith mkField [(0 :: Int) .. ] . toList $ sq
                mkField num (Rule rn _ _)
                  = varStrictType
                      (mkName fldNm) (strictType notStrict (conT (mkName rn)))
                  where
                      fldNm = ... }

lib/Pinchot/Internal.hs:472:46: error:
    • Couldn't match expected type ‘Maybe Syntax.Kind’
                  with actual type ‘[ConQ]’
    • In the fourth argument of ‘dataD’, namely ‘cons’
      In the expression: dataD (cxt []) name [] cons derives
      In a case alternative:
          RBranch (b1, bs)
            -> dataD (cxt []) name [] cons derives
            where
                cons = thBranch b1 : toList (fmap thBranch bs)

lib/Pinchot/Internal.hs:472:51: error:
    • Couldn't match type ‘Name’ with ‘Q Syntax.Con’
      Expected type: [ConQ]
        Actual type: [Name]
    • In the fifth argument of ‘dataD’, namely ‘derives’
      In the expression: dataD (cxt []) name [] cons derives
      In a case alternative:
          RBranch (b1, bs)
            -> dataD (cxt []) name [] cons derives
            where
                cons = thBranch b1 : toList (fmap thBranch bs)

lib/Pinchot/Internal.hs:476:22: error:
    • Couldn't match expected type ‘Q Syntax.Dec’
                  with actual type ‘TH.CxtQ -> TH.DecQ’
    • Probable cause: ‘dataD’ is applied to too few arguments
      In the expression: dataD (cxt []) name [] cons derives
      In a case alternative:
          RUnion (b1, bs)
            -> dataD (cxt []) name [] cons derives
            where
                cons = thUnionBranch nm b1 : toList (fmap (thUnionBranch nm) bs)
      In the expression:
        case ruleType of {
          RTerminal _
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RBranch (b1, bs)
            -> dataD (cxt []) name [] cons derives
            where
                cons = thBranch b1 : toList (fmap thBranch bs)
          RUnion (b1, bs)
            -> dataD (cxt []) name [] cons derives
            where
                cons = thUnionBranch nm b1 : toList (fmap (thUnionBranch nm) bs)
          RSeqTerm _
            -> newtypeD (cxt []) name [] cons derives
            where
                cons = normalC name [...]
          ROptional (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RList (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RList1 (Rule inner _ _)
            -> newtypeD (cxt []) name [] cons derives
            where
                cons = normalC name [...]
          RWrap (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RRecord sq
            -> dataD (cxt []) name [] [ctor] derives
            where
                ctor = recC name . zipWith mkField [(0 :: Int) .. ] . toList $ sq
                mkField num (Rule rn _ _)
                  = varStrictType
                      (mkName fldNm) (strictType notStrict (conT (mkName rn)))
                  where
                      fldNm = ... }

lib/Pinchot/Internal.hs:476:45: error:
    • Couldn't match expected type ‘Maybe Syntax.Kind’
                  with actual type ‘[ConQ]’
    • In the fourth argument of ‘dataD’, namely ‘cons’
      In the expression: dataD (cxt []) name [] cons derives
      In a case alternative:
          RUnion (b1, bs)
            -> dataD (cxt []) name [] cons derives
            where
                cons = thUnionBranch nm b1 : toList (fmap (thUnionBranch nm) bs)

lib/Pinchot/Internal.hs:476:50: error:
    • Couldn't match type ‘Name’ with ‘Q Syntax.Con’
      Expected type: [ConQ]
        Actual type: [Name]
    • In the fifth argument of ‘dataD’, namely ‘derives’
      In the expression: dataD (cxt []) name [] cons derives
      In a case alternative:
          RUnion (b1, bs)
            -> dataD (cxt []) name [] cons derives
            where
                cons = thUnionBranch nm b1 : toList (fmap (thUnionBranch nm) bs)

lib/Pinchot/Internal.hs:480:17: error:
    • Couldn't match expected type ‘Q Syntax.Dec’
                  with actual type ‘TH.CxtQ -> TH.DecQ’
    • Probable cause: ‘newtypeD’ is applied to too few arguments
      In the expression: newtypeD (cxt []) name [] cons derives
      In a case alternative:
          RSeqTerm _
            -> newtypeD (cxt []) name [] cons derives
            where
                cons
                  = normalC name [strictType notStrict (appT ... (conT typeName))]
      In the expression:
        case ruleType of {
          RTerminal _
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RBranch (b1, bs)
            -> dataD (cxt []) name [] cons derives
            where
                cons = thBranch b1 : toList (fmap thBranch bs)
          RUnion (b1, bs)
            -> dataD (cxt []) name [] cons derives
            where
                cons = thUnionBranch nm b1 : toList (fmap (thUnionBranch nm) bs)
          RSeqTerm _
            -> newtypeD (cxt []) name [] cons derives
            where
                cons = normalC name [...]
          ROptional (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RList (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RList1 (Rule inner _ _)
            -> newtypeD (cxt []) name [] cons derives
            where
                cons = normalC name [...]
          RWrap (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RRecord sq
            -> dataD (cxt []) name [] [ctor] derives
            where
                ctor = recC name . zipWith mkField [(0 :: Int) .. ] . toList $ sq
                mkField num (Rule rn _ _)
                  = varStrictType
                      (mkName fldNm) (strictType notStrict (conT (mkName rn)))
                  where
                      fldNm = ... }

lib/Pinchot/Internal.hs:480:43: error:
    • Couldn't match type ‘Q Syntax.Con’ with ‘Maybe Syntax.Kind’
      Expected type: Maybe Syntax.Kind
        Actual type: ConQ
    • In the fourth argument of ‘newtypeD’, namely ‘cons’
      In the expression: newtypeD (cxt []) name [] cons derives
      In a case alternative:
          RSeqTerm _
            -> newtypeD (cxt []) name [] cons derives
            where
                cons
                  = normalC name [strictType notStrict (appT ... (conT typeName))]

lib/Pinchot/Internal.hs:480:48: error:
    • Couldn't match type ‘[Name]’ with ‘Q Syntax.Con’
      Expected type: ConQ
        Actual type: [Name]
    • In the fifth argument of ‘newtypeD’, namely ‘derives’
      In the expression: newtypeD (cxt []) name [] cons derives
      In a case alternative:
          RSeqTerm _
            -> newtypeD (cxt []) name [] cons derives
            where
                cons
                  = normalC name [strictType notStrict (appT ... (conT typeName))]

lib/Pinchot/Internal.hs:486:33: error:
    • Couldn't match expected type ‘Q Syntax.Dec’
                  with actual type ‘TH.CxtQ -> TH.DecQ’
    • Probable cause: ‘newtypeD’ is applied to too few arguments
      In the expression: newtypeD (cxt []) name [] newtypeCon derives
      In a case alternative:
          ROptional (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon
                  = normalC
                      name [strictType notStrict (appT ... (conT (mkName inner)))]
      In the expression:
        case ruleType of {
          RTerminal _
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RBranch (b1, bs)
            -> dataD (cxt []) name [] cons derives
            where
                cons = thBranch b1 : toList (fmap thBranch bs)
          RUnion (b1, bs)
            -> dataD (cxt []) name [] cons derives
            where
                cons = thUnionBranch nm b1 : toList (fmap (thUnionBranch nm) bs)
          RSeqTerm _
            -> newtypeD (cxt []) name [] cons derives
            where
                cons = normalC name [...]
          ROptional (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RList (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RList1 (Rule inner _ _)
            -> newtypeD (cxt []) name [] cons derives
            where
                cons = normalC name [...]
          RWrap (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RRecord sq
            -> dataD (cxt []) name [] [ctor] derives
            where
                ctor = recC name . zipWith mkField [(0 :: Int) .. ] . toList $ sq
                mkField num (Rule rn _ _)
                  = varStrictType
                      (mkName fldNm) (strictType notStrict (conT (mkName rn)))
                  where
                      fldNm = ... }

lib/Pinchot/Internal.hs:486:59: error:
    • Couldn't match type ‘Q Syntax.Con’ with ‘Maybe Syntax.Kind’
      Expected type: Maybe Syntax.Kind
        Actual type: ConQ
    • In the fourth argument of ‘newtypeD’, namely ‘newtypeCon’
      In the expression: newtypeD (cxt []) name [] newtypeCon derives
      In a case alternative:
          ROptional (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon
                  = normalC
                      name [strictType notStrict (appT ... (conT (mkName inner)))]

lib/Pinchot/Internal.hs:486:70: error:
    • Couldn't match type ‘[Name]’ with ‘Q Syntax.Con’
      Expected type: ConQ
        Actual type: [Name]
    • In the fifth argument of ‘newtypeD’, namely ‘derives’
      In the expression: newtypeD (cxt []) name [] newtypeCon derives
      In a case alternative:
          ROptional (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon
                  = normalC
                      name [strictType notStrict (appT ... (conT (mkName inner)))]

lib/Pinchot/Internal.hs:492:29: error:
    • Couldn't match expected type ‘Q Syntax.Dec’
                  with actual type ‘TH.CxtQ -> TH.DecQ’
    • Probable cause: ‘newtypeD’ is applied to too few arguments
      In the expression: newtypeD (cxt []) name [] newtypeCon derives
      In a case alternative:
          RList (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon
                  = normalC
                      name [strictType notStrict (appT ... (conT (mkName inner)))]
      In the expression:
        case ruleType of {
          RTerminal _
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RBranch (b1, bs)
            -> dataD (cxt []) name [] cons derives
            where
                cons = thBranch b1 : toList (fmap thBranch bs)
          RUnion (b1, bs)
            -> dataD (cxt []) name [] cons derives
            where
                cons = thUnionBranch nm b1 : toList (fmap (thUnionBranch nm) bs)
          RSeqTerm _
            -> newtypeD (cxt []) name [] cons derives
            where
                cons = normalC name [...]
          ROptional (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RList (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RList1 (Rule inner _ _)
            -> newtypeD (cxt []) name [] cons derives
            where
                cons = normalC name [...]
          RWrap (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RRecord sq
            -> dataD (cxt []) name [] [ctor] derives
            where
                ctor = recC name . zipWith mkField [(0 :: Int) .. ] . toList $ sq
                mkField num (Rule rn _ _)
                  = varStrictType
                      (mkName fldNm) (strictType notStrict (conT (mkName rn)))
                  where
                      fldNm = ... }

lib/Pinchot/Internal.hs:492:55: error:
    • Couldn't match type ‘Q Syntax.Con’ with ‘Maybe Syntax.Kind’
      Expected type: Maybe Syntax.Kind
        Actual type: ConQ
    • In the fourth argument of ‘newtypeD’, namely ‘newtypeCon’
      In the expression: newtypeD (cxt []) name [] newtypeCon derives
      In a case alternative:
          RList (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon
                  = normalC
                      name [strictType notStrict (appT ... (conT (mkName inner)))]

lib/Pinchot/Internal.hs:492:66: error:
    • Couldn't match type ‘[Name]’ with ‘Q Syntax.Con’
      Expected type: ConQ
        Actual type: [Name]
    • In the fifth argument of ‘newtypeD’, namely ‘derives’
      In the expression: newtypeD (cxt []) name [] newtypeCon derives
      In a case alternative:
          RList (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon
                  = normalC
                      name [strictType notStrict (appT ... (conT (mkName inner)))]

lib/Pinchot/Internal.hs:498:30: error:
    • Couldn't match expected type ‘Q Syntax.Dec’
                  with actual type ‘TH.CxtQ -> TH.DecQ’
    • Probable cause: ‘newtypeD’ is applied to too few arguments
      In the expression: newtypeD (cxt []) name [] cons derives
      In a case alternative:
          RList1 (Rule inner _ _)
            -> newtypeD (cxt []) name [] cons derives
            where
                cons
                  = normalC
                      name
                      [strictType
                         notStrict
                         (TH.tupleT 2 `appT` (conT (mkName inner))
                          `appT` (... `appT` (conT (mkName inner))))]
      In the expression:
        case ruleType of {
          RTerminal _
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RBranch (b1, bs)
            -> dataD (cxt []) name [] cons derives
            where
                cons = thBranch b1 : toList (fmap thBranch bs)
          RUnion (b1, bs)
            -> dataD (cxt []) name [] cons derives
            where
                cons = thUnionBranch nm b1 : toList (fmap (thUnionBranch nm) bs)
          RSeqTerm _
            -> newtypeD (cxt []) name [] cons derives
            where
                cons = normalC name [...]
          ROptional (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RList (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RList1 (Rule inner _ _)
            -> newtypeD (cxt []) name [] cons derives
            where
                cons = normalC name [...]
          RWrap (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RRecord sq
            -> dataD (cxt []) name [] [ctor] derives
            where
                ctor = recC name . zipWith mkField [(0 :: Int) .. ] . toList $ sq
                mkField num (Rule rn _ _)
                  = varStrictType
                      (mkName fldNm) (strictType notStrict (conT (mkName rn)))
                  where
                      fldNm = ... }

lib/Pinchot/Internal.hs:498:56: error:
    • Couldn't match type ‘Q Syntax.Con’ with ‘Maybe Syntax.Kind’
      Expected type: Maybe Syntax.Kind
        Actual type: ConQ
    • In the fourth argument of ‘newtypeD’, namely ‘cons’
      In the expression: newtypeD (cxt []) name [] cons derives
      In a case alternative:
          RList1 (Rule inner _ _)
            -> newtypeD (cxt []) name [] cons derives
            where
                cons
                  = normalC
                      name
                      [strictType
                         notStrict
                         (TH.tupleT 2 `appT` (conT (mkName inner))
                          `appT` (... `appT` (conT (mkName inner))))]

lib/Pinchot/Internal.hs:498:61: error:
    • Couldn't match type ‘[Name]’ with ‘Q Syntax.Con’
      Expected type: ConQ
        Actual type: [Name]
    • In the fifth argument of ‘newtypeD’, namely ‘derives’
      In the expression: newtypeD (cxt []) name [] cons derives
      In a case alternative:
          RList1 (Rule inner _ _)
            -> newtypeD (cxt []) name [] cons derives
            where
                cons
                  = normalC
                      name
                      [strictType
                         notStrict
                         (TH.tupleT 2 `appT` (conT (mkName inner))
                          `appT` (... `appT` (conT (mkName inner))))]

lib/Pinchot/Internal.hs:504:29: error:
    • Couldn't match expected type ‘Q Syntax.Dec’
                  with actual type ‘TH.CxtQ -> TH.DecQ’
    • Probable cause: ‘newtypeD’ is applied to too few arguments
      In the expression: newtypeD (cxt []) name [] newtypeCon derives
      In a case alternative:
          RWrap (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon
                  = normalC name [strictType notStrict (conT (mkName inner))]
      In the expression:
        case ruleType of {
          RTerminal _
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RBranch (b1, bs)
            -> dataD (cxt []) name [] cons derives
            where
                cons = thBranch b1 : toList (fmap thBranch bs)
          RUnion (b1, bs)
            -> dataD (cxt []) name [] cons derives
            where
                cons = thUnionBranch nm b1 : toList (fmap (thUnionBranch nm) bs)
          RSeqTerm _
            -> newtypeD (cxt []) name [] cons derives
            where
                cons = normalC name [...]
          ROptional (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RList (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RList1 (Rule inner _ _)
            -> newtypeD (cxt []) name [] cons derives
            where
                cons = normalC name [...]
          RWrap (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RRecord sq
            -> dataD (cxt []) name [] [ctor] derives
            where
                ctor = recC name . zipWith mkField [(0 :: Int) .. ] . toList $ sq
                mkField num (Rule rn _ _)
                  = varStrictType
                      (mkName fldNm) (strictType notStrict (conT (mkName rn)))
                  where
                      fldNm = ... }

lib/Pinchot/Internal.hs:504:55: error:
    • Couldn't match type ‘Q Syntax.Con’ with ‘Maybe Syntax.Kind’
      Expected type: Maybe Syntax.Kind
        Actual type: ConQ
    • In the fourth argument of ‘newtypeD’, namely ‘newtypeCon’
      In the expression: newtypeD (cxt []) name [] newtypeCon derives
      In a case alternative:
          RWrap (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon
                  = normalC name [strictType notStrict (conT (mkName inner))]

lib/Pinchot/Internal.hs:504:66: error:
    • Couldn't match type ‘[Name]’ with ‘Q Syntax.Con’
      Expected type: ConQ
        Actual type: [Name]
    • In the fifth argument of ‘newtypeD’, namely ‘derives’
      In the expression: newtypeD (cxt []) name [] newtypeCon derives
      In a case alternative:
          RWrap (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon
                  = normalC name [strictType notStrict (conT (mkName inner))]

lib/Pinchot/Internal.hs:509:17: error:
    • Couldn't match expected type ‘Q Syntax.Dec’
                  with actual type ‘TH.CxtQ -> TH.DecQ’
    • Probable cause: ‘dataD’ is applied to too few arguments
      In the expression: dataD (cxt []) name [] [ctor] derives
      In a case alternative:
          RRecord sq
            -> dataD (cxt []) name [] [ctor] derives
            where
                ctor = recC name . zipWith mkField [(0 :: Int) .. ] . toList $ sq
                mkField num (Rule rn _ _)
                  = varStrictType
                      (mkName fldNm) (strictType notStrict (conT (mkName rn)))
                  where
                      fldNm = '_' : fieldName num nm rn
      In the expression:
        case ruleType of {
          RTerminal _
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RBranch (b1, bs)
            -> dataD (cxt []) name [] cons derives
            where
                cons = thBranch b1 : toList (fmap thBranch bs)
          RUnion (b1, bs)
            -> dataD (cxt []) name [] cons derives
            where
                cons = thUnionBranch nm b1 : toList (fmap (thUnionBranch nm) bs)
          RSeqTerm _
            -> newtypeD (cxt []) name [] cons derives
            where
                cons = normalC name [...]
          ROptional (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RList (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RList1 (Rule inner _ _)
            -> newtypeD (cxt []) name [] cons derives
            where
                cons = normalC name [...]
          RWrap (Rule inner _ _)
            -> newtypeD (cxt []) name [] newtypeCon derives
            where
                newtypeCon = normalC name [...]
          RRecord sq
            -> dataD (cxt []) name [] [ctor] derives
            where
                ctor = recC name . zipWith mkField [(0 :: Int) .. ] . toList $ sq
                mkField num (Rule rn _ _)
                  = varStrictType
                      (mkName fldNm) (strictType notStrict (conT (mkName rn)))
                  where
                      fldNm = ... }

lib/Pinchot/Internal.hs:509:40: error:
    • Couldn't match expected type ‘Maybe Syntax.Kind’
                  with actual type ‘[ConQ]’
    • In the fourth argument of ‘dataD’, namely ‘[ctor]’
      In the expression: dataD (cxt []) name [] [ctor] derives
      In a case alternative:
          RRecord sq
            -> dataD (cxt []) name [] [ctor] derives
            where
                ctor = recC name . zipWith mkField [(0 :: Int) .. ] . toList $ sq
                mkField num (Rule rn _ _)
                  = varStrictType
                      (mkName fldNm) (strictType notStrict (conT (mkName rn)))
                  where
                      fldNm = '_' : fieldName num nm rn

lib/Pinchot/Internal.hs:509:47: error:
    • Couldn't match type ‘Name’ with ‘Q Syntax.Con’
      Expected type: [ConQ]
        Actual type: [Name]
    • In the fifth argument of ‘dataD’, namely ‘derives’
      In the expression: dataD (cxt []) name [] [ctor] derives
      In a case alternative:
          RRecord sq
            -> dataD (cxt []) name [] [ctor] derives
            where
                ctor = recC name . zipWith mkField [(0 :: Int) .. ] . toList $ sq
                mkField num (Rule rn _ _)
                  = varStrictType
                      (mkName fldNm) (strictType notStrict (conT (mkName rn)))
                  where
                      fldNm = '_' : fieldName num nm rn

lib/Pinchot/Internal.hs:555:30: error:
    • Couldn't match expected type ‘Syntax.Dec’
                  with actual type ‘[Syntax.Dec] -> Syntax.Dec’
    • Probable cause: ‘Syntax.InstanceD’ is applied to too few arguments
      In the expression: Syntax.InstanceD [] typ decs
      In an equation for ‘makeWrapped’:
          makeWrapped wrappedType nm
            = Syntax.InstanceD [] typ decs
            where
                name = mkName nm
                local = mkName "_x"
                typ = (Syntax.ConT ''Lens.Wrapped) `Syntax.AppT` (Syntax.ConT name)
                decs
                  = [assocType, ....]
                  where
                      assocType = Syntax.TySynInstD ... (Syntax.TySynEqn ... wrappedType)
                      wrapper
                        = Syntax.FunD ... ...
                        where
                            ...

lib/Pinchot/Internal.hs:555:43: error:
    • Couldn't match expected type ‘Maybe Syntax.Overlap’
                  with actual type ‘[t0]’
    • In the first argument of ‘Syntax.InstanceD’, namely ‘[]’
      In the expression: Syntax.InstanceD [] typ decs
      In an equation for ‘makeWrapped’:
          makeWrapped wrappedType nm
            = Syntax.InstanceD [] typ decs
            where
                name = mkName nm
                local = mkName "_x"
                typ = (Syntax.ConT ''Lens.Wrapped) `Syntax.AppT` (Syntax.ConT name)
                decs
                  = [assocType, ....]
                  where
                      assocType = Syntax.TySynInstD ... (Syntax.TySynEqn ... wrappedType)
                      wrapper
                        = Syntax.FunD ... ...
                        where
                            ...

lib/Pinchot/Internal.hs:555:46: error:
    • Couldn't match type ‘Syntax.Type’ with ‘[Syntax.Pred]’
      Expected type: Syntax.Cxt
        Actual type: Syntax.Type
    • In the second argument of ‘Syntax.InstanceD’, namely ‘typ’
      In the expression: Syntax.InstanceD [] typ decs
      In an equation for ‘makeWrapped’:
          makeWrapped wrappedType nm
            = Syntax.InstanceD [] typ decs
            where
                name = mkName nm
                local = mkName "_x"
                typ = (Syntax.ConT ''Lens.Wrapped) `Syntax.AppT` (Syntax.ConT name)
                decs
                  = [assocType, ....]
                  where
                      assocType = Syntax.TySynInstD ... (Syntax.TySynEqn ... wrappedType)
                      wrapper
                        = Syntax.FunD ... ...
                        where
                            ...

lib/Pinchot/Internal.hs:555:50: error:
    • Couldn't match expected type ‘Syntax.Type’
                  with actual type ‘[Syntax.Dec]’
    • In the third argument of ‘Syntax.InstanceD’, namely ‘decs’
      In the expression: Syntax.InstanceD [] typ decs
      In an equation for ‘makeWrapped’:
          makeWrapped wrappedType nm
            = Syntax.InstanceD [] typ decs
            where
                name = mkName nm
                local = mkName "_x"
                typ = (Syntax.ConT ''Lens.Wrapped) `Syntax.AppT` (Syntax.ConT name)
                decs
                  = [assocType, ....]
                  where
                      assocType = Syntax.TySynInstD ... (Syntax.TySynEqn ... wrappedType)
                      wrapper
                        = Syntax.FunD ... ...
                        where
                            ...
cabal: Leaving directory '/tmp/cabal-tmp-14398/pinchot-0.8.0.0'
cabal: Error: some packages failed to install:
pinchot-0.8.0.0 failed during the building phase. The exception was:
ExitFailure 1

Test log

No test log was submitted for this report.