Resolving dependencies...
Configuring multiset-0.2.2...
Configuring old-locale-1.0.0.7...
Building old-locale-1.0.0.7...
Building multiset-0.2.2...
Installed old-locale-1.0.0.7
Configuring primitive-0.6.1.0...
Building primitive-0.6.1.0...
Configuring srcloc-0.5.1.0...
Installed multiset-0.2.2
Building srcloc-0.5.1.0...
Configuring random-1.1...
Installed srcloc-0.5.1.0
Building random-1.1...
Configuring text-1.2.2.1...
Installed primitive-0.6.1.0
Building text-1.2.2.1...
Configuring old-time-1.1.0.3...
Installed random-1.1
Building old-time-1.1.0.3...
Installed old-time-1.1.0.3
Configuring tf-random-0.5...
Building tf-random-0.5...
Configuring vector-0.11.0.0...
Installed tf-random-0.5
Building vector-0.11.0.0...
Configuring QuickCheck-2.9.2...
Installed text-1.2.2.1
Building QuickCheck-2.9.2...
Installed QuickCheck-2.9.2
Configuring hashable-1.2.4.0...
Building hashable-1.2.4.0...
Configuring blaze-builder-0.4.0.2...
Installed vector-0.11.0.0
Building blaze-builder-0.4.0.2...
Configuring mainland-pretty-0.4.1.4...
Installed hashable-1.2.4.0
Building mainland-pretty-0.4.1.4...
Installed blaze-builder-0.4.0.2
Configuring scientific-0.3.4.9...
Building scientific-0.3.4.9...
Installed mainland-pretty-0.4.1.4
Configuring unordered-containers-0.2.7.1...
Building unordered-containers-0.2.7.1...
Configuring blaze-markup-0.7.1.0...
Installed scientific-0.3.4.9
Building blaze-markup-0.7.1.0...
Installed blaze-markup-0.7.1.0
Configuring blaze-html-0.8.1.2...
Building blaze-html-0.8.1.2...
Installed unordered-containers-0.2.7.1
Configuring quickcheck-instances-0.3.12...
Building quickcheck-instances-0.3.12...
Installed quickcheck-instances-0.3.12
Installed blaze-html-0.8.1.2
Configuring processing-1.2.0.2...
Building processing-1.2.0.2...
Failed to install processing-1.2.0.2
Build log ( /home/builder/.cabal/logs/processing-1.2.0.2.log ):
cabal: Entering directory '/tmp/cabal-tmp-27211/processing-1.2.0.2'
Configuring processing-1.2.0.2...
Building processing-1.2.0.2...
Preprocessing library processing-1.2.0.2...
[ 1 of 13] Compiling Graphics.Web.Processing.Core.TH ( Graphics/Web/Processing/Core/TH.hs, dist/build/Graphics/Web/Processing/Core/TH.o )

Graphics/Web/Processing/Core/TH.hs:38:12: error:
    • The constructor ‘DataD’ should have 6 arguments, but has been given 5
    • In the pattern: DataD _ _ _ cs _
      In the pattern: TyConI (DataD _ _ _ cs _)
      In a stmt of a 'do' block: (TyConI (DataD _ _ _ cs _)) <- reify t

Graphics/Web/Processing/Core/TH.hs:62:3: error:
    • Couldn't match type ‘[Dec] -> Dec’ with ‘Dec’
      Expected type: Q [Dec]
        Actual type: Q [[Dec] -> Dec]
    • In a stmt of a 'do' block:
        return . return
        $ InstanceD [] (AppT (ConT $ mkName "Recursive") (ConT t)) [r]
      In the expression:
        do { r <- defineRecursor t;
             return . return
             $ InstanceD [] (AppT (ConT $ mkName "Recursive") (ConT t)) [r] }
      In an equation for ‘deriveRecursive’:
          deriveRecursive t
            = do { r <- defineRecursor t;
                   return . return
                   $ InstanceD [] (AppT (ConT $ mkName "Recursive") (ConT t)) [r] }

Graphics/Web/Processing/Core/TH.hs:62:31: error:
    • Couldn't match expected type ‘Maybe Overlap’
                  with actual type ‘[t5]’
    • In the first argument of ‘InstanceD’, namely ‘[]’
      In the second argument of ‘($)’, namely
        ‘InstanceD [] (AppT (ConT $ mkName "Recursive") (ConT t)) [r]’
      In a stmt of a 'do' block:
        return . return
        $ InstanceD [] (AppT (ConT $ mkName "Recursive") (ConT t)) [r]

Graphics/Web/Processing/Core/TH.hs:62:35: error:
    • Couldn't match type ‘Type’ with ‘[Pred]’
      Expected type: Cxt
        Actual type: Type
    • In the second argument of ‘InstanceD’, namely
        ‘(AppT (ConT $ mkName "Recursive") (ConT t))’
      In the second argument of ‘($)’, namely
        ‘InstanceD [] (AppT (ConT $ mkName "Recursive") (ConT t)) [r]’
      In a stmt of a 'do' block:
        return . return
        $ InstanceD [] (AppT (ConT $ mkName "Recursive") (ConT t)) [r]

Graphics/Web/Processing/Core/TH.hs:62:78: error:
    • Couldn't match expected type ‘Type’ with actual type ‘[Dec]’
    • In the third argument of ‘InstanceD’, namely ‘[r]’
      In the second argument of ‘($)’, namely
        ‘InstanceD [] (AppT (ConT $ mkName "Recursive") (ConT t)) [r]’
      In a stmt of a 'do' block:
        return . return
        $ InstanceD [] (AppT (ConT $ mkName "Recursive") (ConT t)) [r]

Graphics/Web/Processing/Core/TH.hs:81:15: error:
    • Couldn't match expected type ‘Dec’ with actual type ‘Cxt -> Dec’
    • Probable cause: ‘DataD’ is applied to too few arguments
      In the expression:
        DataD
          []
          (mkName "ProcArg")
          []
          (fmap cons procTypeNames)
          [mkName "Eq", mkName "Generic"]
      In an equation for ‘dataProcArg’:
          dataProcArg
            = DataD
                []
                (mkName "ProcArg")
                []
                (fmap cons procTypeNames)
                [mkName "Eq", mkName "Generic"]
            where
                cons x
                  = NormalC
                      (mkName $ x ++ "Arg") [(NotStrict, ConT $ mkName $ "Proc_" ++ x)]

Graphics/Web/Processing/Core/TH.hs:81:47: error:
    • Couldn't match type ‘[]’ with ‘Maybe’
      Expected type: Maybe Kind
        Actual type: [Con]
    • In the fourth argument of ‘DataD’, namely
        ‘(fmap cons procTypeNames)’
      In the expression:
        DataD
          []
          (mkName "ProcArg")
          []
          (fmap cons procTypeNames)
          [mkName "Eq", mkName "Generic"]
      In an equation for ‘dataProcArg’:
          dataProcArg
            = DataD
                []
                (mkName "ProcArg")
                []
                (fmap cons procTypeNames)
                [mkName "Eq", mkName "Generic"]
            where
                cons x
                  = NormalC
                      (mkName $ x ++ "Arg") [(NotStrict, ConT $ mkName $ "Proc_" ++ x)]

Graphics/Web/Processing/Core/TH.hs:81:73: error:
    • Couldn't match expected type ‘Con’ with actual type ‘Name’
    • In the expression: mkName "Eq"
      In the fifth argument of ‘DataD’, namely
        ‘[mkName "Eq", mkName "Generic"]’
      In the expression:
        DataD
          []
          (mkName "ProcArg")
          []
          (fmap cons procTypeNames)
          [mkName "Eq", mkName "Generic"]

Graphics/Web/Processing/Core/TH.hs:81:85: error:
    • Couldn't match expected type ‘Con’ with actual type ‘Name’
    • In the expression: mkName "Generic"
      In the fifth argument of ‘DataD’, namely
        ‘[mkName "Eq", mkName "Generic"]’
      In the expression:
        DataD
          []
          (mkName "ProcArg")
          []
          (fmap cons procTypeNames)
          [mkName "Eq", mkName "Generic"]

Graphics/Web/Processing/Core/TH.hs:83:46: error:
    • Data constructor not in scope: NotStrict :: Bang
    • Perhaps you meant variable ‘notStrict’ (imported from Language.Haskell.TH)

Graphics/Web/Processing/Core/TH.hs:86:18: error:
    • Couldn't match expected type ‘Dec’ with actual type ‘Cxt -> Dec’
    • Probable cause: ‘DataD’ is applied to too few arguments
      In the expression:
        DataD
          []
          (mkName "ProcAssign")
          []
          (fmap cons procTypeNames)
          [mkName "Eq", mkName "Generic"]
      In an equation for ‘dataProcAssign’:
          dataProcAssign
            = DataD
                []
                (mkName "ProcAssign")
                []
                (fmap cons procTypeNames)
                [mkName "Eq", mkName "Generic"]
            where
                cons x
                  = NormalC
                      (mkName $ x ++ "Assign") [(NotStrict, ConT $ mkName "Text"), ....]

Graphics/Web/Processing/Core/TH.hs:86:53: error:
    • Couldn't match type ‘[]’ with ‘Maybe’
      Expected type: Maybe Kind
        Actual type: [Con]
    • In the fourth argument of ‘DataD’, namely
        ‘(fmap cons procTypeNames)’
      In the expression:
        DataD
          []
          (mkName "ProcAssign")
          []
          (fmap cons procTypeNames)
          [mkName "Eq", mkName "Generic"]
      In an equation for ‘dataProcAssign’:
          dataProcAssign
            = DataD
                []
                (mkName "ProcAssign")
                []
                (fmap cons procTypeNames)
                [mkName "Eq", mkName "Generic"]
            where
                cons x
                  = NormalC
                      (mkName $ x ++ "Assign") [(NotStrict, ConT $ mkName "Text"), ....]

Graphics/Web/Processing/Core/TH.hs:86:79: error:
    • Couldn't match expected type ‘Con’ with actual type ‘Name’
    • In the expression: mkName "Eq"
      In the fifth argument of ‘DataD’, namely
        ‘[mkName "Eq", mkName "Generic"]’
      In the expression:
        DataD
          []
          (mkName "ProcAssign")
          []
          (fmap cons procTypeNames)
          [mkName "Eq", mkName "Generic"]

Graphics/Web/Processing/Core/TH.hs:86:91: error:
    • Couldn't match expected type ‘Con’ with actual type ‘Name’
    • In the expression: mkName "Generic"
      In the fifth argument of ‘DataD’, namely
        ‘[mkName "Eq", mkName "Generic"]’
      In the expression:
        DataD
          []
          (mkName "ProcAssign")
          []
          (fmap cons procTypeNames)
          [mkName "Eq", mkName "Generic"]

Graphics/Web/Processing/Core/TH.hs:89:13: error:
    • Data constructor not in scope: NotStrict :: Bang
    • Perhaps you meant variable ‘notStrict’ (imported from Language.Haskell.TH)

Graphics/Web/Processing/Core/TH.hs:90:13: error:
    • Data constructor not in scope: NotStrict :: Bang
    • Perhaps you meant variable ‘notStrict’ (imported from Language.Haskell.TH)

Graphics/Web/Processing/Core/TH.hs:111:16: error:
    • Couldn't match expected type ‘Dec’ with actual type ‘Cxt -> Dec’
    • Probable cause: ‘DataD’ is applied to too few arguments
      In the expression:
        DataD
          []
          (mkName "ProcList")
          []
          (fmap cons procTypeNames)
          [mkName "Eq", mkName "Generic"]
      In an equation for ‘dataProcList’:
          dataProcList
            = DataD
                []
                (mkName "ProcList")
                []
                (fmap cons procTypeNames)
                [mkName "Eq", mkName "Generic"]
            where
                cons x
                  = NormalC
                      (mkName $ x ++ "List")
                      [(NotStrict, AppT ListT $ ConT $ mkName $ "Proc_" ++ x)]

Graphics/Web/Processing/Core/TH.hs:111:49: error:
    • Couldn't match type ‘[]’ with ‘Maybe’
      Expected type: Maybe Kind
        Actual type: [Con]
    • In the fourth argument of ‘DataD’, namely
        ‘(fmap cons procTypeNames)’
      In the expression:
        DataD
          []
          (mkName "ProcList")
          []
          (fmap cons procTypeNames)
          [mkName "Eq", mkName "Generic"]
      In an equation for ‘dataProcList’:
          dataProcList
            = DataD
                []
                (mkName "ProcList")
                []
                (fmap cons procTypeNames)
                [mkName "Eq", mkName "Generic"]
            where
                cons x
                  = NormalC
                      (mkName $ x ++ "List")
                      [(NotStrict, AppT ListT $ ConT $ mkName $ "Proc_" ++ x)]

Graphics/Web/Processing/Core/TH.hs:111:75: error:
    • Couldn't match expected type ‘Con’ with actual type ‘Name’
    • In the expression: mkName "Eq"
      In the fifth argument of ‘DataD’, namely
        ‘[mkName "Eq", mkName "Generic"]’
      In the expression:
        DataD
          []
          (mkName "ProcList")
          []
          (fmap cons procTypeNames)
          [mkName "Eq", mkName "Generic"]

Graphics/Web/Processing/Core/TH.hs:111:87: error:
    • Couldn't match expected type ‘Con’ with actual type ‘Name’
    • In the expression: mkName "Generic"
      In the fifth argument of ‘DataD’, namely
        ‘[mkName "Eq", mkName "Generic"]’
      In the expression:
        DataD
          []
          (mkName "ProcList")
          []
          (fmap cons procTypeNames)
          [mkName "Eq", mkName "Generic"]

Graphics/Web/Processing/Core/TH.hs:113:47: error:
    • Data constructor not in scope: NotStrict :: Bang
    • Perhaps you meant variable ‘notStrict’ (imported from Language.Haskell.TH)

Graphics/Web/Processing/Core/TH.hs:118:7: error:
    • The constructor ‘DataD’ should have 6 arguments, but has been given 5
    • In the pattern: DataD _ _ _ cs _
      In a pattern binding: DataD _ _ _ cs _ = procList
      In the expression:
        let
          DataD _ _ _ cs _ = procList
          _fmap e1 e2 = AppE (VarE $ mkName "fmap") e1 `AppE` e2
          _ppr = VarE $ mkName "ppr"
          ....
        in
          InstanceD
            []
            (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcList"))
            [inst]

Graphics/Web/Processing/Core/TH.hs:133:7: error:
    • Couldn't match expected type ‘Dec’
                  with actual type ‘[Dec] -> Dec’
    • Probable cause: ‘InstanceD’ is applied to too few arguments
      In the expression:
        InstanceD
          []
          (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcList"))
          [inst]
      In the expression:
        let
          DataD _ _ _ cs _ = procList
          _fmap e1 e2 = AppE (VarE $ mkName "fmap") e1 `AppE` e2
          _ppr = VarE $ mkName "ppr"
          ....
        in
          InstanceD
            []
            (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcList"))
            [inst]
      In an equation for ‘procListPrettyInst’:
          procListPrettyInst procList
            = let
                DataD _ _ _ cs _ = procList
                _fmap e1 e2 = AppE (VarE $ mkName "fmap") e1 `AppE` e2
                ....
              in
                InstanceD
                  []
                  (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcList"))
                  [inst]

Graphics/Web/Processing/Core/TH.hs:133:17: error:
    • Couldn't match expected type ‘Maybe Overlap’
                  with actual type ‘[t4]’
    • In the first argument of ‘InstanceD’, namely ‘[]’
      In the expression:
        InstanceD
          []
          (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcList"))
          [inst]
      In the expression:
        let
          DataD _ _ _ cs _ = procList
          _fmap e1 e2 = AppE (VarE $ mkName "fmap") e1 `AppE` e2
          _ppr = VarE $ mkName "ppr"
          ....
        in
          InstanceD
            []
            (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcList"))
            [inst]

Graphics/Web/Processing/Core/TH.hs:133:21: error:
    • Couldn't match type ‘Type’ with ‘[Pred]’
      Expected type: Cxt
        Actual type: Type
    • In the second argument of ‘InstanceD’, namely
        ‘(AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcList"))’
      In the expression:
        InstanceD
          []
          (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcList"))
          [inst]
      In the expression:
        let
          DataD _ _ _ cs _ = procList
          _fmap e1 e2 = AppE (VarE $ mkName "fmap") e1 `AppE` e2
          _ppr = VarE $ mkName "ppr"
          ....
        in
          InstanceD
            []
            (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcList"))
            [inst]

Graphics/Web/Processing/Core/TH.hs:133:79: error:
    • Couldn't match expected type ‘Type’ with actual type ‘[Dec]’
    • In the third argument of ‘InstanceD’, namely ‘[inst]’
      In the expression:
        InstanceD
          []
          (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcList"))
          [inst]
      In the expression:
        let
          DataD _ _ _ cs _ = procList
          _fmap e1 e2 = AppE (VarE $ mkName "fmap") e1 `AppE` e2
          _ppr = VarE $ mkName "ppr"
          ....
        in
          InstanceD
            []
            (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcList"))
            [inst]

Graphics/Web/Processing/Core/TH.hs:138:22: error:
    • Couldn't match expected type ‘Dec’
                  with actual type ‘[Dec] -> Dec’
    • Probable cause: ‘InstanceD’ is applied to too few arguments
      In the expression:
        InstanceD
          []
          (AppT (ConT $ mkName "ProcType") $ ConT $ mkName $ "Proc_" ++ n)
          [FunD
             (mkName "proc_assign")
             [Clause [] (NormalB $ ConE $ mkName $ n ++ "Assign") []],
           FunD
             (mkName "proc_list")
             [Clause [] (NormalB $ ConE $ mkName $ n ++ "List") []],
           FunD
             (mkName "proc_arg")
             [Clause [] (NormalB $ ConE $ mkName $ n ++ "Arg") []],
           FunD
             (mkName "proc_read")
             [Clause
                [...]
                (NormalB $ AppE (ConE $ mkName $ n ++ "_Var") (VarE $ mkName "v"))
                []],
           ....]
      In an equation for ‘procTypeInst’:
          procTypeInst n cfa
            = InstanceD
                []
                (AppT (ConT $ mkName "ProcType") $ ConT $ mkName $ "Proc_" ++ n)
                [FunD
                   (mkName "proc_assign")
                   [Clause ... (NormalB $ ConE $ mkName $ n ++ "Assign") ...],
                 FunD
                   (mkName "proc_list")
                   [Clause ... (NormalB $ ConE $ mkName $ n ++ "List") ...],
                 FunD
                   (mkName "proc_arg")
                   [Clause ... (NormalB $ ConE $ mkName $ n ++ "Arg") ...],
                 ....]

Graphics/Web/Processing/Core/TH.hs:138:32: error:
    • Couldn't match expected type ‘Maybe Overlap’
                  with actual type ‘[t3]’
    • In the first argument of ‘InstanceD’, namely ‘[]’
      In the expression:
        InstanceD
          []
          (AppT (ConT $ mkName "ProcType") $ ConT $ mkName $ "Proc_" ++ n)
          [FunD
             (mkName "proc_assign")
             [Clause [] (NormalB $ ConE $ mkName $ n ++ "Assign") []],
           FunD
             (mkName "proc_list")
             [Clause [] (NormalB $ ConE $ mkName $ n ++ "List") []],
           FunD
             (mkName "proc_arg")
             [Clause [] (NormalB $ ConE $ mkName $ n ++ "Arg") []],
           FunD
             (mkName "proc_read")
             [Clause
                [...]
                (NormalB $ AppE (ConE $ mkName $ n ++ "_Var") (VarE $ mkName "v"))
                []],
           ....]
      In an equation for ‘procTypeInst’:
          procTypeInst n cfa
            = InstanceD
                []
                (AppT (ConT $ mkName "ProcType") $ ConT $ mkName $ "Proc_" ++ n)
                [FunD
                   (mkName "proc_assign")
                   [Clause ... (NormalB $ ConE $ mkName $ n ++ "Assign") ...],
                 FunD
                   (mkName "proc_list")
                   [Clause ... (NormalB $ ConE $ mkName $ n ++ "List") ...],
                 FunD
                   (mkName "proc_arg")
                   [Clause ... (NormalB $ ConE $ mkName $ n ++ "Arg") ...],
                 ....]

Graphics/Web/Processing/Core/TH.hs:138:36: error:
    • Couldn't match type ‘Type’ with ‘[Pred]’
      Expected type: Cxt
        Actual type: Type
    • In the second argument of ‘InstanceD’, namely
        ‘(AppT (ConT $ mkName "ProcType") $ ConT $ mkName $ "Proc_" ++ n)’
      In the expression:
        InstanceD
          []
          (AppT (ConT $ mkName "ProcType") $ ConT $ mkName $ "Proc_" ++ n)
          [FunD
             (mkName "proc_assign")
             [Clause [] (NormalB $ ConE $ mkName $ n ++ "Assign") []],
           FunD
             (mkName "proc_list")
             [Clause [] (NormalB $ ConE $ mkName $ n ++ "List") []],
           FunD
             (mkName "proc_arg")
             [Clause [] (NormalB $ ConE $ mkName $ n ++ "Arg") []],
           FunD
             (mkName "proc_read")
             [Clause
                [...]
                (NormalB $ AppE (ConE $ mkName $ n ++ "_Var") (VarE $ mkName "v"))
                []],
           ....]
      In an equation for ‘procTypeInst’:
          procTypeInst n cfa
            = InstanceD
                []
                (AppT (ConT $ mkName "ProcType") $ ConT $ mkName $ "Proc_" ++ n)
                [FunD
                   (mkName "proc_assign")
                   [Clause ... (NormalB $ ConE $ mkName $ n ++ "Assign") ...],
                 FunD
                   (mkName "proc_list")
                   [Clause ... (NormalB $ ConE $ mkName $ n ++ "List") ...],
                 FunD
                   (mkName "proc_arg")
                   [Clause ... (NormalB $ ConE $ mkName $ n ++ "Arg") ...],
                 ....]

Graphics/Web/Processing/Core/TH.hs:139:3: error:
    • Couldn't match expected type ‘Type’ with actual type ‘[Dec]’
    • In the third argument of ‘InstanceD’, namely
        ‘[FunD
            (mkName "proc_assign")
            [Clause [] (NormalB $ ConE $ mkName $ n ++ "Assign") []],
          FunD
            (mkName "proc_list")
            [Clause [] (NormalB $ ConE $ mkName $ n ++ "List") []],
          FunD
            (mkName "proc_arg")
            [Clause [] (NormalB $ ConE $ mkName $ n ++ "Arg") []],
          FunD
            (mkName "proc_read")
            [Clause
               [...]
               (NormalB $ AppE (ConE $ mkName $ n ++ "_Var") (VarE $ mkName "v"))
               []],
          ....]’
      In the expression:
        InstanceD
          []
          (AppT (ConT $ mkName "ProcType") $ ConT $ mkName $ "Proc_" ++ n)
          [FunD
             (mkName "proc_assign")
             [Clause [] (NormalB $ ConE $ mkName $ n ++ "Assign") []],
           FunD
             (mkName "proc_list")
             [Clause [] (NormalB $ ConE $ mkName $ n ++ "List") []],
           FunD
             (mkName "proc_arg")
             [Clause [] (NormalB $ ConE $ mkName $ n ++ "Arg") []],
           FunD
             (mkName "proc_read")
             [Clause
                [...]
                (NormalB $ AppE (ConE $ mkName $ n ++ "_Var") (VarE $ mkName "v"))
                []],
           ....]
      In an equation for ‘procTypeInst’:
          procTypeInst n cfa
            = InstanceD
                []
                (AppT (ConT $ mkName "ProcType") $ ConT $ mkName $ "Proc_" ++ n)
                [FunD
                   (mkName "proc_assign")
                   [Clause ... (NormalB $ ConE $ mkName $ n ++ "Assign") ...],
                 FunD
                   (mkName "proc_list")
                   [Clause ... (NormalB $ ConE $ mkName $ n ++ "List") ...],
                 FunD
                   (mkName "proc_arg")
                   [Clause ... (NormalB $ ConE $ mkName $ n ++ "Arg") ...],
                 ....]

Graphics/Web/Processing/Core/TH.hs:155:10: error:
    • The constructor ‘DataD’ should have 6 arguments, but has been given 5
    • In the pattern: DataD _ _ _ cs _
      In the pattern: TyConI (DataD _ _ _ cs _)
      In a stmt of a 'do' block:
        TyConI (DataD _ _ _ cs _) <- reify $ mkName $ "Proc_" ++ t

Graphics/Web/Processing/Core/TH.hs:180:7: error:
    • The constructor ‘DataD’ should have 6 arguments, but has been given 5
    • In the pattern: DataD _ _ _ cs _
      In a pattern binding: DataD _ _ _ cs _ = procArg
      In the expression:
        let
          DataD _ _ _ cs _ = procArg
          defs
            = fmap
                (\ (NormalC n _)
                   -> Clause
                        ... (NormalB $ AppE (VarE $ mkName "ppr") (VarE $ mkName "x")) ...)
                cs
          inst = FunD (mkName "ppr") defs
        in
          InstanceD
            [] (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcArg")) [inst]

Graphics/Web/Processing/Core/TH.hs:186:7: error:
    • Couldn't match expected type ‘Dec’
                  with actual type ‘[Dec] -> Dec’
    • Probable cause: ‘InstanceD’ is applied to too few arguments
      In the expression:
        InstanceD
          [] (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcArg")) [inst]
      In the expression:
        let
          DataD _ _ _ cs _ = procArg
          defs
            = fmap
                (\ (NormalC n _)
                   -> Clause
                        ... (NormalB $ AppE (VarE $ mkName "ppr") (VarE $ mkName "x")) ...)
                cs
          inst = FunD (mkName "ppr") defs
        in
          InstanceD
            [] (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcArg")) [inst]
      In an equation for ‘procArgPrettyInst’:
          procArgPrettyInst procArg
            = let
                DataD _ _ _ cs _ = procArg
                defs = fmap (\ (NormalC n _) -> ...) cs
                ....
              in
                InstanceD
                  [] (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcArg")) [inst]

Graphics/Web/Processing/Core/TH.hs:186:17: error:
    • Couldn't match expected type ‘Maybe Overlap’
                  with actual type ‘[t2]’
    • In the first argument of ‘InstanceD’, namely ‘[]’
      In the expression:
        InstanceD
          [] (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcArg")) [inst]
      In the expression:
        let
          DataD _ _ _ cs _ = procArg
          defs
            = fmap
                (\ (NormalC n _)
                   -> Clause
                        ... (NormalB $ AppE (VarE $ mkName "ppr") (VarE $ mkName "x")) ...)
                cs
          inst = FunD (mkName "ppr") defs
        in
          InstanceD
            [] (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcArg")) [inst]

Graphics/Web/Processing/Core/TH.hs:186:21: error:
    • Couldn't match type ‘Type’ with ‘[Pred]’
      Expected type: Cxt
        Actual type: Type
    • In the second argument of ‘InstanceD’, namely
        ‘(AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcArg"))’
      In the expression:
        InstanceD
          [] (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcArg")) [inst]
      In the expression:
        let
          DataD _ _ _ cs _ = procArg
          defs
            = fmap
                (\ (NormalC n _)
                   -> Clause
                        ... (NormalB $ AppE (VarE $ mkName "ppr") (VarE $ mkName "x")) ...)
                cs
          inst = FunD (mkName "ppr") defs
        in
          InstanceD
            [] (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcArg")) [inst]

Graphics/Web/Processing/Core/TH.hs:186:78: error:
    • Couldn't match expected type ‘Type’ with actual type ‘[Dec]’
    • In the third argument of ‘InstanceD’, namely ‘[inst]’
      In the expression:
        InstanceD
          [] (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcArg")) [inst]
      In the expression:
        let
          DataD _ _ _ cs _ = procArg
          defs
            = fmap
                (\ (NormalC n _)
                   -> Clause
                        ... (NormalB $ AppE (VarE $ mkName "ppr") (VarE $ mkName "x")) ...)
                cs
          inst = FunD (mkName "ppr") defs
        in
          InstanceD
            [] (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcArg")) [inst]

Graphics/Web/Processing/Core/TH.hs:191:7: error:
    • The constructor ‘DataD’ should have 6 arguments, but has been given 5
    • In the pattern: DataD _ _ _ cs _
      In a pattern binding: DataD _ _ _ cs _ = procAssign
      In the expression:
        let
          DataD _ _ _ cs _ = procAssign
          defs = fmap (\ (NormalC n _) -> ...) cs
          inst = FunD (mkName "ppr") defs
        in
          InstanceD
            []
            (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcAssign"))
            [inst]

Graphics/Web/Processing/Core/TH.hs:201:7: error:
    • Couldn't match expected type ‘Dec’
                  with actual type ‘[Dec] -> Dec’
    • Probable cause: ‘InstanceD’ is applied to too few arguments
      In the expression:
        InstanceD
          []
          (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcAssign"))
          [inst]
      In the expression:
        let
          DataD _ _ _ cs _ = procAssign
          defs = fmap (\ (NormalC n _) -> ...) cs
          inst = FunD (mkName "ppr") defs
        in
          InstanceD
            []
            (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcAssign"))
            [inst]
      In an equation for ‘procAssignPrettyInst’:
          procAssignPrettyInst procAssign
            = let
                DataD _ _ _ cs _ = procAssign
                defs = fmap (\ (NormalC n _) -> ...) cs
                ....
              in
                InstanceD
                  []
                  (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcAssign"))
                  [inst]

Graphics/Web/Processing/Core/TH.hs:201:17: error:
    • Couldn't match expected type ‘Maybe Overlap’
                  with actual type ‘[t1]’
    • In the first argument of ‘InstanceD’, namely ‘[]’
      In the expression:
        InstanceD
          []
          (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcAssign"))
          [inst]
      In the expression:
        let
          DataD _ _ _ cs _ = procAssign
          defs = fmap (\ (NormalC n _) -> ...) cs
          inst = FunD (mkName "ppr") defs
        in
          InstanceD
            []
            (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcAssign"))
            [inst]

Graphics/Web/Processing/Core/TH.hs:201:21: error:
    • Couldn't match type ‘Type’ with ‘[Pred]’
      Expected type: Cxt
        Actual type: Type
    • In the second argument of ‘InstanceD’, namely
        ‘(AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcAssign"))’
      In the expression:
        InstanceD
          []
          (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcAssign"))
          [inst]
      In the expression:
        let
          DataD _ _ _ cs _ = procAssign
          defs = fmap (\ (NormalC n _) -> ...) cs
          inst = FunD (mkName "ppr") defs
        in
          InstanceD
            []
            (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcAssign"))
            [inst]

Graphics/Web/Processing/Core/TH.hs:201:81: error:
    • Couldn't match expected type ‘Type’ with actual type ‘[Dec]’
    • In the third argument of ‘InstanceD’, namely ‘[inst]’
      In the expression:
        InstanceD
          []
          (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcAssign"))
          [inst]
      In the expression:
        let
          DataD _ _ _ cs _ = procAssign
          defs = fmap (\ (NormalC n _) -> ...) cs
          inst = FunD (mkName "ppr") defs
        in
          InstanceD
            []
            (AppT (ConT $ mkName "Pretty") (ConT $ mkName "ProcAssign"))
            [inst]

Graphics/Web/Processing/Core/TH.hs:271:19: error:
    • Couldn't match expected type ‘Dec’
                  with actual type ‘[Dec] -> Dec’
    • Probable cause: ‘InstanceD’ is applied to too few arguments
      In the expression:
        InstanceD
          []
          (AppT (ConT $ mkName "VarLength") (ConT $ mkName $ "Proc_" ++ t))
          [FunD
             (mkName "varLength")
             [Clause [...] (NormalB $ LitE $ IntegerL 1) []]]
      In an equation for ‘varLengthInst’:
          varLengthInst t
            = InstanceD
                []
                (AppT (ConT $ mkName "VarLength") (ConT $ mkName $ "Proc_" ++ t))
                [FunD
                   (mkName "varLength")
                   [Clause ... (NormalB $ LitE $ IntegerL 1) ...]]

Graphics/Web/Processing/Core/TH.hs:271:29: error:
    • Couldn't match expected type ‘Maybe Overlap’
                  with actual type ‘[t0]’
    • In the first argument of ‘InstanceD’, namely ‘[]’
      In the expression:
        InstanceD
          []
          (AppT (ConT $ mkName "VarLength") (ConT $ mkName $ "Proc_" ++ t))
          [FunD
             (mkName "varLength")
             [Clause [...] (NormalB $ LitE $ IntegerL 1) []]]
      In an equation for ‘varLengthInst’:
          varLengthInst t
            = InstanceD
                []
                (AppT (ConT $ mkName "VarLength") (ConT $ mkName $ "Proc_" ++ t))
                [FunD
                   (mkName "varLength")
                   [Clause ... (NormalB $ LitE $ IntegerL 1) ...]]

Graphics/Web/Processing/Core/TH.hs:271:33: error:
    • Couldn't match type ‘Type’ with ‘[Pred]’
      Expected type: Cxt
        Actual type: Type
    • In the second argument of ‘InstanceD’, namely
        ‘(AppT (ConT $ mkName "VarLength") (ConT $ mkName $ "Proc_" ++ t))’
      In the expression:
        InstanceD
          []
          (AppT (ConT $ mkName "VarLength") (ConT $ mkName $ "Proc_" ++ t))
          [FunD
             (mkName "varLength")
             [Clause [...] (NormalB $ LitE $ IntegerL 1) []]]
      In an equation for ‘varLengthInst’:
          varLengthInst t
            = InstanceD
                []
                (AppT (ConT $ mkName "VarLength") (ConT $ mkName $ "Proc_" ++ t))
                [FunD
                   (mkName "varLength")
                   [Clause ... (NormalB $ LitE $ IntegerL 1) ...]]

Graphics/Web/Processing/Core/TH.hs:271:98: error:
    • Couldn't match expected type ‘Type’ with actual type ‘[Dec]’
    • In the third argument of ‘InstanceD’, namely
        ‘[FunD
            (mkName "varLength")
            [Clause [...] (NormalB $ LitE $ IntegerL 1) []]]’
      In the expression:
        InstanceD
          []
          (AppT (ConT $ mkName "VarLength") (ConT $ mkName $ "Proc_" ++ t))
          [FunD
             (mkName "varLength")
             [Clause [...] (NormalB $ LitE $ IntegerL 1) []]]
      In an equation for ‘varLengthInst’:
          varLengthInst t
            = InstanceD
                []
                (AppT (ConT $ mkName "VarLength") (ConT $ mkName $ "Proc_" ++ t))
                [FunD
                   (mkName "varLength")
                   [Clause ... (NormalB $ LitE $ IntegerL 1) ...]]

Graphics/Web/Processing/Core/TH.hs:312:11: error:
    • The constructor ‘DataD’ should have 6 arguments, but has been given 5
    • In the pattern: DataD _ _ _ cs _
      In the pattern: TyConI (DataD _ _ _ cs _)
      In a stmt of a 'do' block: TyConI (DataD _ _ _ cs _) <- reify t
cabal: Leaving directory '/tmp/cabal-tmp-27211/processing-1.2.0.2'
cabal: Error: some packages failed to install:
processing-1.2.0.2 failed during the building phase. The exception was:
ExitFailure 1