Resolving dependencies...
Configuring mtl-2.2.1...
Configuring primitive-0.6.1.0...
Building mtl-2.2.1...
Building primitive-0.6.1.0...
Installed mtl-2.2.1
Configuring syb-0.6...
Configuring text-1.2.2.1...
Installed primitive-0.6.1.0
Building syb-0.6...
Building text-1.2.2.1...
Installed syb-0.6
Configuring th-expand-syns-0.4.1.0...
Building th-expand-syns-0.4.1.0...
Configuring vector-0.11.0.0...
Installed th-expand-syns-0.4.1.0
Building vector-0.11.0.0...
Installed text-1.2.2.1
Installed vector-0.11.0.0
Configuring unpack-funcs-0.3.1...
Building unpack-funcs-0.3.1...
Failed to install unpack-funcs-0.3.1
Build log ( /home/builder/.cabal/logs/unpack-funcs-0.3.1.log ):
cabal: Entering directory '/tmp/cabal-tmp-30129/unpack-funcs-0.3.1'
Configuring unpack-funcs-0.3.1...
Building unpack-funcs-0.3.1...
Preprocessing library unpack-funcs-0.3.1...
[1 of 3] Compiling Control.Monad.Unpack.Class ( Control/Monad/Unpack/Class.hs, dist/build/Control/Monad/Unpack/Class.o )

Control/Monad/Unpack/Class.hs:4:1: warning: [-Wunused-imports]
    The import of ‘Control.Applicative’ is redundant
      except perhaps to import instances from ‘Control.Applicative’
    To import instances alone, use: import Control.Applicative()

Control/Monad/Unpack/Class.hs:29:7: warning: [-Wtabs]
    Tab character found here, and in one further location.
    Please use spaces instead.
[2 of 3] Compiling Control.Monad.Unpack.TH ( Control/Monad/Unpack/TH.hs, dist/build/Control/Monad/Unpack/TH.o )

Control/Monad/Unpack/TH.hs:20:5: error:
    • The constructor ‘DataD’ should have 6 arguments, but has been given 5
    • In the pattern: DataD cxt _ tyvars [con] _
      In a case alternative:
          DataD cxt _ tyvars [con] _ -> unpacker1 cxt tycon tyvars con
      In a stmt of a 'do' block:
        case dec of {
          DataD cxt _ tyvars [con] _ -> unpacker1 cxt tycon tyvars con
          dec -> error ("Cannot unpack: " ++ show dec) }

Control/Monad/Unpack/TH.hs:28:5: error:
    • The constructor ‘DataD’ should have 6 arguments, but has been given 5
    • In the pattern: DataD cxt _ tyvars [con] _
      In a case alternative:
          DataD cxt _ tyvars [con] _ -> unpacker cxt tycon tyvars con
      In a stmt of a 'do' block:
        case dec of {
          DataD cxt _ tyvars [con] _ -> unpacker cxt tycon tyvars con
          NewtypeD cxt _ tyvars con _ -> unpacker cxt tycon tyvars con
          dec -> error ("Cannot unpack: " ++ show dec) }

Control/Monad/Unpack/TH.hs:37:5: error:
    • The constructor ‘DataD’ should have 6 arguments, but has been given 5
    • In the pattern: DataD cxt _ tyvars _ _
      In a case alternative:
          DataD cxt _ tyvars _ _ -> noUnpacker cxt tycon tyvars
      In a stmt of a 'do' block:
        case dec of {
          DataD cxt _ tyvars _ _ -> noUnpacker cxt tycon tyvars
          NewtypeD cxt _ tyvars _ _ -> noUnpacker cxt tycon tyvars
          dec -> error ("Cannot unpack: " ++ show dec) }

Control/Monad/Unpack/TH.hs:54:13: error:
    • Data constructor not in scope: ClassP :: Name -> [Type] -> Pred
    • Perhaps you meant one of these:
        ‘ClassD’ (imported from Language.Haskell.TH),
        ‘ClassI’ (imported from Language.Haskell.TH),
        variable ‘classP’ (imported from Language.Haskell.TH)

Control/Monad/Unpack/TH.hs:57:34: error:
    • Data constructor not in scope: NotStrict :: Bang
    • Perhaps you meant variable ‘notStrict’ (imported from Language.Haskell.TH)

Control/Monad/Unpack/TH.hs:67:18: error:
    Data constructor not in scope:
      InlineSpec :: Bool -> Bool -> Maybe a0 -> t

Control/Monad/Unpack/TH.hs:69:22: error:
    • Couldn't match expected type ‘Pragma’
                  with actual type ‘RuleMatch -> Phases -> Pragma’
    • Probable cause: ‘InlineP’ is applied to too few arguments
      In the second argument of ‘($)’, namely
        ‘InlineP (mkName "runUnpackedReaderT") inline’
      In the expression:
        PragmaD $ InlineP (mkName "runUnpackedReaderT") inline
      In the expression:
        [PragmaD $ InlineP (mkName "runUnpackedReaderT") inline,
         PragmaD $ InlineP (mkName "unpackedReaderT") inline]

Control/Monad/Unpack/TH.hs:71:21: error:
    • Couldn't match expected type ‘Pragma’
                  with actual type ‘RuleMatch -> Phases -> Pragma’
    • Probable cause: ‘InlineP’ is applied to too few arguments
      In the second argument of ‘($)’, namely
        ‘InlineP (mkName "unpackedReaderT") inline’
      In the expression:
        PragmaD $ InlineP (mkName "unpackedReaderT") inline
      In the expression:
        [PragmaD $ InlineP (mkName "runUnpackedReaderT") inline,
         PragmaD $ InlineP (mkName "unpackedReaderT") inline]

Control/Monad/Unpack/TH.hs:80:14: error:
    • Couldn't match expected type ‘Maybe Kind’ with actual type ‘Con’
    • In the fourth argument of ‘NewtypeInstD’, namely
        ‘(NormalC
            funcName
            [(NotStrict, 
              foldr
                (\ argTy result -> ArrowT `AppT` argTy `AppT` result)
                (VarT mName `AppT` VarT monadArgName)
                conArgs)])’
      In the expression:
        NewtypeInstD
          []
          ''UnpackedReaderT
          [theTy, VarT mName, VarT monadArgName]
          (NormalC
             funcName
             [(NotStrict, 
               foldr
                 (\ argTy result -> ArrowT `AppT` argTy `AppT` result)
                 (VarT mName `AppT` VarT monadArgName)
                 conArgs)])
          []
      In the first argument of ‘(++)’, namely
        ‘[NewtypeInstD
            []
            ''UnpackedReaderT
            [theTy, VarT mName, ....]
            (NormalC
               funcName
               [(NotStrict, 
                 foldr
                   (\ argTy result -> ArrowT `AppT` argTy `AppT` result)
                   (VarT mName `AppT` VarT monadArgName)
                   conArgs)])
            []]’

Control/Monad/Unpack/TH.hs:80:33: error:
    • Data constructor not in scope: NotStrict :: Bang
    • Perhaps you meant variable ‘notStrict’ (imported from Language.Haskell.TH)

Control/Monad/Unpack/TH.hs:81:68: error:
    • Couldn't match expected type ‘Con’ with actual type ‘[t0]’
    • In the fifth argument of ‘NewtypeInstD’, namely ‘[]’
      In the expression:
        NewtypeInstD
          []
          ''UnpackedReaderT
          [theTy, VarT mName, VarT monadArgName]
          (NormalC
             funcName
             [(NotStrict, 
               foldr
                 (\ argTy result -> ArrowT `AppT` argTy `AppT` result)
                 (VarT mName `AppT` VarT monadArgName)
                 conArgs)])
          []
      In the first argument of ‘(++)’, namely
        ‘[NewtypeInstD
            []
            ''UnpackedReaderT
            [theTy, VarT mName, ....]
            (NormalC
               funcName
               [(NotStrict, 
                 foldr
                   (\ argTy result -> ArrowT `AppT` argTy `AppT` result)
                   (VarT mName `AppT` VarT monadArgName)
                   conArgs)])
            []]’

Control/Monad/Unpack/TH.hs:81:75: error:
    • Couldn't match type ‘Dec’ with ‘Cxt -> Dec’
      Expected type: [Cxt -> Dec]
        Actual type: [Dec]
    • In the second argument of ‘(++)’, namely
        ‘pragmas
         ++
           [FunD
              'runUnpackedReaderT
              [Clause
                 [...] (NormalB (foldl AppE (VarE fName) (map VarE argNames))) []],
            FunD
              'unpackedReaderT
              [Clause
                 [...]
                 (NormalB
                  $ ConE funcName
                    `AppE`
                      LamE
                        (map VarP argNames)
                        (VarE fName
                         `AppE` (foldl AppE (ConE conName) (map VarE argNames))))
                 []]]’
      In the expression:
        [NewtypeInstD
           []
           ''UnpackedReaderT
           [theTy, VarT mName, ....]
           (NormalC
              funcName
              [(NotStrict, 
                foldr
                  (\ argTy result -> ArrowT `AppT` argTy `AppT` result)
                  (VarT mName `AppT` VarT monadArgName)
                  conArgs)])
           []]
        ++
          pragmas
          ++
            [FunD
               'runUnpackedReaderT
               [Clause
                  [...] (NormalB (foldl AppE (VarE fName) (map VarE argNames))) []],
             FunD
               'unpackedReaderT
               [Clause
                  [...]
                  (NormalB
                   $ ConE funcName
                     `AppE`
                       LamE
                         (map VarP argNames)
                         (VarE fName
                          `AppE` (foldl AppE (ConE conName) (map VarE argNames))))
                  []]]
      In an equation for ‘decs’:
          decs
            = [NewtypeInstD
                 []
                 ''UnpackedReaderT
                 [theTy, ....]
                 (NormalC
                    funcName
                    [(NotStrict, 
                      foldr
                        (\ argTy result -> ...)
                        (VarT mName `AppT` VarT monadArgName)
                        conArgs)])
                 []]
              ++
                pragmas
                ++
                  [FunD
                     'runUnpackedReaderT
                     [Clause
                        ... (NormalB (foldl AppE (VarE fName) (map VarE argNames))) ...],
                   FunD
                     'unpackedReaderT
                     [Clause
                        ...
                        (NormalB
                         $ ConE funcName
                           `AppE`
                             LamE
                               (map VarP argNames)
                               (VarE fName
                                `AppE` (foldl AppE (ConE conName) (map VarE argNames))))
                        ...]]

Control/Monad/Unpack/TH.hs:88:5: 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 [InstanceD cxt (ConT ''Unpackable `AppT` theTy) decs]
      In the expression:
        do { argNames <- replicateM (length conArgs) (newName "arg");
             let theTy
                   = foldl
                       (\ t0 arg -> ...) (ConT tyCon) (map (VarT . tyVarBndrName) tyArgs);
             let inline = InlineSpec True False Nothing;
             let pragmas = ...;
             .... }
      In a case alternative:
          (conName, conArgs)
            -> do { argNames <- replicateM (length conArgs) (newName "arg");
                    let theTy = ...;
                    let inline = ...;
                    .... }

Control/Monad/Unpack/TH.hs:88:23: error:
    • Couldn't match type ‘[Pred]’ with ‘Maybe Overlap’
      Expected type: Maybe Overlap
        Actual type: Cxt
    • In the first argument of ‘InstanceD’, namely ‘cxt’
      In the expression:
        InstanceD cxt (ConT ''Unpackable `AppT` theTy) decs
      In the first argument of ‘return’, namely
        ‘[InstanceD cxt (ConT ''Unpackable `AppT` theTy) decs]’

Control/Monad/Unpack/TH.hs:88:28: error:
    • Couldn't match type ‘Type’ with ‘[Pred]’
      Expected type: Cxt
        Actual type: Type
    • In the second argument of ‘InstanceD’, namely
        ‘(ConT ''Unpackable `AppT` theTy)’
      In the expression:
        InstanceD cxt (ConT ''Unpackable `AppT` theTy) decs
      In the first argument of ‘return’, namely
        ‘[InstanceD cxt (ConT ''Unpackable `AppT` theTy) decs]’

Control/Monad/Unpack/TH.hs:88:60: error:
    • Couldn't match expected type ‘Type’
                  with actual type ‘[Cxt -> Dec]’
    • In the third argument of ‘InstanceD’, namely ‘decs’
      In the expression:
        InstanceD cxt (ConT ''Unpackable `AppT` theTy) decs
      In the first argument of ‘return’, namely
        ‘[InstanceD cxt (ConT ''Unpackable `AppT` theTy) decs]’

Control/Monad/Unpack/TH.hs:95:18: error:
    Data constructor not in scope:
      InlineSpec :: Bool -> Bool -> Maybe a1 -> t

Control/Monad/Unpack/TH.hs:97:22: error:
    • Couldn't match expected type ‘Pragma’
                  with actual type ‘RuleMatch -> Phases -> Pragma’
    • Probable cause: ‘InlineP’ is applied to too few arguments
      In the second argument of ‘($)’, namely
        ‘InlineP (mkName "runUnpackedReaderT") inline’
      In the expression:
        PragmaD $ InlineP (mkName "runUnpackedReaderT") inline
      In the expression:
        [PragmaD $ InlineP (mkName "runUnpackedReaderT") inline,
         PragmaD $ InlineP (mkName "unpackedReaderT") inline]

Control/Monad/Unpack/TH.hs:99:21: error:
    • Couldn't match expected type ‘Pragma’
                  with actual type ‘RuleMatch -> Phases -> Pragma’
    • Probable cause: ‘InlineP’ is applied to too few arguments
      In the second argument of ‘($)’, namely
        ‘InlineP (mkName "unpackedReaderT") inline’
      In the expression:
        PragmaD $ InlineP (mkName "unpackedReaderT") inline
      In the expression:
        [PragmaD $ InlineP (mkName "runUnpackedReaderT") inline,
         PragmaD $ InlineP (mkName "unpackedReaderT") inline]

Control/Monad/Unpack/TH.hs:110:14: error:
    • Couldn't match expected type ‘Maybe Kind’ with actual type ‘Con’
    • In the fourth argument of ‘NewtypeInstD’, namely
        ‘(NormalC
            funcName [(NotStrict, monadStack `AppT` VarT monadArgName)])’
      In the expression:
        NewtypeInstD
          []
          ''UnpackedReaderT
          [theTy, VarT mName, VarT monadArgName]
          (NormalC
             funcName [(NotStrict, monadStack `AppT` VarT monadArgName)])
          []
      In the first argument of ‘(++)’, namely
        ‘[NewtypeInstD
            []
            ''UnpackedReaderT
            [theTy, VarT mName, ....]
            (NormalC
               funcName [(NotStrict, monadStack `AppT` VarT monadArgName)])
            []]’

Control/Monad/Unpack/TH.hs:110:33: error:
    • Data constructor not in scope: NotStrict :: Bang
    • Perhaps you meant variable ‘notStrict’ (imported from Language.Haskell.TH)

Control/Monad/Unpack/TH.hs:110:83: error:
    • Couldn't match expected type ‘Con’ with actual type ‘[t1]’
    • In the fifth argument of ‘NewtypeInstD’, namely ‘[]’
      In the expression:
        NewtypeInstD
          []
          ''UnpackedReaderT
          [theTy, VarT mName, VarT monadArgName]
          (NormalC
             funcName [(NotStrict, monadStack `AppT` VarT monadArgName)])
          []
      In the first argument of ‘(++)’, namely
        ‘[NewtypeInstD
            []
            ''UnpackedReaderT
            [theTy, VarT mName, ....]
            (NormalC
               funcName [(NotStrict, monadStack `AppT` VarT monadArgName)])
            []]’

Control/Monad/Unpack/TH.hs:110:90: error:
    • Couldn't match type ‘Dec’ with ‘Cxt -> Dec’
      Expected type: [Cxt -> Dec]
        Actual type: [Dec]
    • In the second argument of ‘(++)’, namely
        ‘pragmas
         ++
           [FunD
              'runUnpackedReaderT
              [Clause
                 [...]
                 (NormalB
                    (foldl
                       (\ func arg -> InfixE (Just func) (VarE ...) (Just arg))
                       (VarE fName)
                       (map VarE argNames)))
                 []],
            FunD
              'unpackedReaderT
              [Clause
                 [...]
                 (NormalB
                  $ ConE funcName
                    `AppE`
                      foldr
                        (\ argName func -> VarE ... `AppE` LamE ... func)
                        (VarE fName `AppE` (foldl AppE (ConE conName) (map VarE argNames)))
                        argNames)
                 []]]’
      In the expression:
        [NewtypeInstD
           []
           ''UnpackedReaderT
           [theTy, VarT mName, ....]
           (NormalC
              funcName [(NotStrict, monadStack `AppT` VarT monadArgName)])
           []]
        ++
          pragmas
          ++
            [FunD
               'runUnpackedReaderT
               [Clause
                  [...]
                  (NormalB
                     (foldl
                        (\ func arg -> InfixE (Just func) (VarE ...) (Just arg))
                        (VarE fName)
                        (map VarE argNames)))
                  []],
             FunD
               'unpackedReaderT
               [Clause
                  [...]
                  (NormalB
                   $ ConE funcName
                     `AppE`
                       foldr
                         (\ argName func -> VarE ... `AppE` LamE ... func)
                         (VarE fName `AppE` (foldl AppE (ConE conName) (map VarE argNames)))
                         argNames)
                  []]]
      In an equation for ‘decs’:
          decs
            = [NewtypeInstD
                 []
                 ''UnpackedReaderT
                 [theTy, ....]
                 (NormalC
                    funcName [(NotStrict, monadStack `AppT` VarT monadArgName)])
                 []]
              ++
                pragmas
                ++
                  [FunD
                     'runUnpackedReaderT
                     [Clause
                        ...
                        (NormalB
                           (foldl (\ func arg -> ...) (VarE fName) (map VarE argNames)))
                        ...],
                   FunD
                     'unpackedReaderT
                     [Clause
                        ...
                        (NormalB
                         $ ConE funcName
                           `AppE`
                             foldr
                               (\ argName func -> ...)
                               (VarE fName `AppE` (foldl AppE (ConE conName) (map VarE argNames)))
                               argNames)
                        ...]]

Control/Monad/Unpack/TH.hs:122:5: 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 [InstanceD cxt (ConT ''Unpackable `AppT` theTy) decs]
      In the expression:
        do { argNames <- replicateM (length conArgs) (newName "arg");
             let theTy
                   = foldl
                       (\ t0 arg -> ...) (ConT tyCon) (map (VarT . tyVarBndrName) tyArgs);
             let inline = InlineSpec True False Nothing;
             let pragmas = ...;
             .... }
      In a case alternative:
          (conName, conArgs)
            -> do { argNames <- replicateM (length conArgs) (newName "arg");
                    let theTy = ...;
                    let inline = ...;
                    .... }

Control/Monad/Unpack/TH.hs:122:23: error:
    • Couldn't match type ‘[Pred]’ with ‘Maybe Overlap’
      Expected type: Maybe Overlap
        Actual type: Cxt
    • In the first argument of ‘InstanceD’, namely ‘cxt’
      In the expression:
        InstanceD cxt (ConT ''Unpackable `AppT` theTy) decs
      In the first argument of ‘return’, namely
        ‘[InstanceD cxt (ConT ''Unpackable `AppT` theTy) decs]’

Control/Monad/Unpack/TH.hs:122:28: error:
    • Couldn't match type ‘Type’ with ‘[Pred]’
      Expected type: Cxt
        Actual type: Type
    • In the second argument of ‘InstanceD’, namely
        ‘(ConT ''Unpackable `AppT` theTy)’
      In the expression:
        InstanceD cxt (ConT ''Unpackable `AppT` theTy) decs
      In the first argument of ‘return’, namely
        ‘[InstanceD cxt (ConT ''Unpackable `AppT` theTy) decs]’

Control/Monad/Unpack/TH.hs:122:60: error:
    • Couldn't match expected type ‘Type’
                  with actual type ‘[Cxt -> Dec]’
    • In the third argument of ‘InstanceD’, namely ‘decs’
      In the expression:
        InstanceD cxt (ConT ''Unpackable `AppT` theTy) decs
      In the first argument of ‘return’, namely
        ‘[InstanceD cxt (ConT ''Unpackable `AppT` theTy) decs]’

Control/Monad/Unpack/TH.hs:128:18: error:
    Data constructor not in scope:
      InlineSpec :: Bool -> Bool -> Maybe a2 -> t

Control/Monad/Unpack/TH.hs:130:22: error:
    • Couldn't match expected type ‘Pragma’
                  with actual type ‘RuleMatch -> Phases -> Pragma’
    • Probable cause: ‘InlineP’ is applied to too few arguments
      In the second argument of ‘($)’, namely
        ‘InlineP (mkName "runUnpackedReaderT") inline’
      In the expression:
        PragmaD $ InlineP (mkName "runUnpackedReaderT") inline
      In the expression:
        [PragmaD $ InlineP (mkName "runUnpackedReaderT") inline,
         PragmaD $ InlineP (mkName "unpackedReaderT") inline]

Control/Monad/Unpack/TH.hs:132:21: error:
    • Couldn't match expected type ‘Pragma’
                  with actual type ‘RuleMatch -> Phases -> Pragma’
    • Probable cause: ‘InlineP’ is applied to too few arguments
      In the second argument of ‘($)’, namely
        ‘InlineP (mkName "unpackedReaderT") inline’
      In the expression:
        PragmaD $ InlineP (mkName "unpackedReaderT") inline
      In the expression:
        [PragmaD $ InlineP (mkName "runUnpackedReaderT") inline,
         PragmaD $ InlineP (mkName "unpackedReaderT") inline]

Control/Monad/Unpack/TH.hs:141:14: error:
    • Couldn't match expected type ‘Maybe Kind’ with actual type ‘Con’
    • In the fourth argument of ‘NewtypeInstD’, namely
        ‘(NormalC
            funcName
            [(NotStrict, 
              ArrowT `AppT` theTy
              `AppT` (VarT mName `AppT` VarT monadArgName))])’
      In the expression:
        NewtypeInstD
          []
          ''UnpackedReaderT
          [theTy, VarT mName, VarT monadArgName]
          (NormalC
             funcName
             [(NotStrict, 
               ArrowT `AppT` theTy `AppT` (VarT mName `AppT` VarT monadArgName))])
          []
      In the first argument of ‘(++)’, namely
        ‘[NewtypeInstD
            []
            ''UnpackedReaderT
            [theTy, VarT mName, ....]
            (NormalC
               funcName
               [(NotStrict, 
                 ArrowT `AppT` theTy `AppT` (VarT mName `AppT` VarT monadArgName))])
            []]’

Control/Monad/Unpack/TH.hs:141:33: error:
    • Data constructor not in scope: NotStrict :: Bang
    • Perhaps you meant variable ‘notStrict’ (imported from Language.Haskell.TH)

Control/Monad/Unpack/TH.hs:141:112: error:
    • Couldn't match expected type ‘Con’ with actual type ‘[t2]’
    • In the fifth argument of ‘NewtypeInstD’, namely ‘[]’
      In the expression:
        NewtypeInstD
          []
          ''UnpackedReaderT
          [theTy, VarT mName, VarT monadArgName]
          (NormalC
             funcName
             [(NotStrict, 
               ArrowT `AppT` theTy `AppT` (VarT mName `AppT` VarT monadArgName))])
          []
      In the first argument of ‘(++)’, namely
        ‘[NewtypeInstD
            []
            ''UnpackedReaderT
            [theTy, VarT mName, ....]
            (NormalC
               funcName
               [(NotStrict, 
                 ArrowT `AppT` theTy `AppT` (VarT mName `AppT` VarT monadArgName))])
            []]’

Control/Monad/Unpack/TH.hs:141:119: error:
    • Couldn't match type ‘Dec’ with ‘Cxt -> Dec’
      Expected type: [Cxt -> Dec]
        Actual type: [Dec]
    • In the second argument of ‘(++)’, namely
        ‘pragmas
         ++
           [FunD
              'runUnpackedReaderT
              [Clause [...] (NormalB (VarE fName `AppE` VarE argName)) []],
            FunD
              'unpackedReaderT
              [Clause [...] (NormalB $ ConE funcName `AppE` VarE fName) []]]’
      In the expression:
        [NewtypeInstD
           []
           ''UnpackedReaderT
           [theTy, VarT mName, ....]
           (NormalC
              funcName
              [(NotStrict, 
                ArrowT `AppT` theTy `AppT` (VarT mName `AppT` VarT monadArgName))])
           []]
        ++
          pragmas
          ++
            [FunD
               'runUnpackedReaderT
               [Clause [...] (NormalB (VarE fName `AppE` VarE argName)) []],
             FunD
               'unpackedReaderT
               [Clause [...] (NormalB $ ConE funcName `AppE` VarE fName) []]]
      In an equation for ‘decs’:
          decs
            = [NewtypeInstD
                 []
                 ''UnpackedReaderT
                 [theTy, ....]
                 (NormalC
                    funcName
                    [(NotStrict, 
                      ArrowT `AppT` theTy `AppT` (VarT mName `AppT` VarT monadArgName))])
                 []]
              ++
                pragmas
                ++
                  [FunD
                     'runUnpackedReaderT
                     [Clause ... (NormalB (VarE fName `AppE` VarE argName)) ...],
                   FunD
                     'unpackedReaderT
                     [Clause ... (NormalB $ ConE funcName `AppE` VarE fName) ...]]

Control/Monad/Unpack/TH.hs:147:5: 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 [InstanceD cxt (ConT ''Unpackable `AppT` theTy) decs]
      In the expression:
        do { argName <- newName "arg";
             let theTy
                   = foldl
                       (\ t0 arg -> ...) (ConT tyCon) (map (VarT . tyVarBndrName) tyArgs);
             let inline = InlineSpec True False Nothing;
             let pragmas = ...;
             .... }
      In an equation for ‘noUnpacker’:
          noUnpacker cxt tyCon tyArgs
            = do { argName <- newName "arg";
                   let theTy = ...;
                   let inline = ...;
                   .... }

Control/Monad/Unpack/TH.hs:147:23: error:
    • Couldn't match type ‘[Pred]’ with ‘Maybe Overlap’
      Expected type: Maybe Overlap
        Actual type: Cxt
    • In the first argument of ‘InstanceD’, namely ‘cxt’
      In the expression:
        InstanceD cxt (ConT ''Unpackable `AppT` theTy) decs
      In the first argument of ‘return’, namely
        ‘[InstanceD cxt (ConT ''Unpackable `AppT` theTy) decs]’

Control/Monad/Unpack/TH.hs:147:28: error:
    • Couldn't match type ‘Type’ with ‘[Pred]’
      Expected type: Cxt
        Actual type: Type
    • In the second argument of ‘InstanceD’, namely
        ‘(ConT ''Unpackable `AppT` theTy)’
      In the expression:
        InstanceD cxt (ConT ''Unpackable `AppT` theTy) decs
      In the first argument of ‘return’, namely
        ‘[InstanceD cxt (ConT ''Unpackable `AppT` theTy) decs]’

Control/Monad/Unpack/TH.hs:147:60: error:
    • Couldn't match expected type ‘Type’
                  with actual type ‘[Cxt -> Dec]’
    • In the third argument of ‘InstanceD’, namely ‘decs’
      In the expression:
        InstanceD cxt (ConT ''Unpackable `AppT` theTy) decs
      In the first argument of ‘return’, namely
        ‘[InstanceD cxt (ConT ''Unpackable `AppT` theTy) decs]’
cabal: Leaving directory '/tmp/cabal-tmp-30129/unpack-funcs-0.3.1'
cabal: Error: some packages failed to install:
HiggsSet-0.1 depends on unpack-funcs-0.3.1 which failed to install.
TrieMap-4.1.0 depends on unpack-funcs-0.3.1 which failed to install.
unpack-funcs-0.3.1 failed during the building phase. The exception was:
ExitFailure 1