search

dylex / postgresql-typed

Haskell PostgreSQL library with compile-time type inference
http://hackage.haskell.org/package/postgresql-typed
Other
83 stars 12 forks source link

postgresql-typed-0.6.2.1 fails to build with ghc-9.4.3 in Stackage Nightly #30

Closed juhp closed 1 year ago

juhp commented 1 year ago 
Building library for postgresql-typed-0.6.2.1..                                                                         [163/180439]
[10 of 17] Compiling Database.PostgreSQL.Typed.Relation

/var/stackage/work/unpack-dir/unpacked/postgresql-typed-0.6.2.1-d219fe3269ecc3474a5d73ab77764a4e69a4f3589d3d5b572c839b2ba6aa3886/Dat
abase/PostgreSQL/Typed/Relation.hs:64:11: error:
    • solveWanteds: too many iterations (limit = 4)
        Unsolved: WC {wc_simple = 
                        [W] $dPGRep_aa5f {0}:: PGRep a0 (CDictCan) 
                        [W] $dKnownSymbol_aa5I {0}:: GHC.TypeLits.KnownSymbol
                                                       (PGRepType a0) (CDictCan)
                        [W] $dPGParameter_aa5h {0}:: PGParameter
                                                       (PGRepType a0) a0 (CDictCan)
                        [W] $dPGParameter_aa5J {0}:: PGParameter
                                                       (PGRepType a0)
                                                       (PGVal (PGRepType a0)) (CDictCan)
                        [W] $dPGColumn_aa5n {0}:: PGColumn (PGRepType a0) a0 (CDictCan)
                        [W] $dPGColumn_aa5L {0}:: PGColumn
                                                    (PGRepType a0) (PGVal (PGRepType a0)) (CDictCan)
                        [W] $dPGType_aa5M {0}:: PGType (PGRepType a0) (CDictCan(psc))}
        Simples: {[W] $dPGRep_aa5f {0}:: PGRep a0 (CDictCan),
                  [W] $dKnownSymbol_aa5I {0}:: GHC.TypeLits.KnownSymbol
                                                 (PGRepType a0) (CDictCan),
                  [W] $dPGParameter_aa5h {0}:: PGParameter
                                                 (PGRepType a0) a0 (CDictCan),
                  [W] $dPGParameter_aa5J {0}:: PGParameter
                                                 (PGRepType a0) (PGVal (PGRepType a0)) (CDictCan),
                  [W] $dPGColumn_aa5n {0}:: PGColumn (PGRepType a0) a0 (CDictCan),
                  [W] $dPGColumn_aa5L {0}:: PGColumn
                                              (PGRepType a0) (PGVal (PGRepType a0)) (CDictCan),
                  [W] $dPGType_aa5M {0}:: PGType (PGRepType a0) (CDictCan(psc))}
    • In the expression:
        do let c = pgDecodeRep cn 
               n = TH.mkName $ colf $ pgNameString c
               ....
           t <- maybe
                  (fail
                     $ "dataPGRelation "
                         ++
                           typs
                             ++
                               " = "
                                 ++
                                   show pgtab                                                                           [121/180439]
                                     ++ ": column '" ++ show c ++ "' has unknown type " ++ show o)
                  return
                  =<< lookupPGType tpg o
           return
             (pgDecodeRep to, 
              (c, n, TH.LitT (TH.StrTyLit $ pgNameString t), 
               not $ pgDecodeRep cnn))
      In the first argument of ‘mapM’, namely
        ‘(\ [to, cn, ct, cnn]
            -> do let c = ...
                      ....
                  t <- maybe
                         (fail
                            $ "dataPGRelation "
                                ++
                                  typs
                                    ++
                                      " = "
                                        ++
                                          show pgtab
                                            ++
                                              ": column '"
                                                ++ show c ++ "' has unknown type " ++ show o)
                         return
                         =<< lookupPGType tpg o
                  return
                    (pgDecodeRep to, 
                     (c, n, TH.LitT (TH.StrTyLit $ pgNameString t), 
                      not $ pgDecodeRep cnn)))’
      In the first argument of ‘(.)’, namely
        ‘mapM
           (\ [to, cn, ct, cnn]
              -> do let c = ...
                        ....
                    t <- maybe
                           (fail
                              $ "dataPGRelation "
                                  ++
                                    typs
                                      ++
                                        " = "
                                          ++                                                                             [79/180439]
                                            show pgtab                                                                              
                                              ++
                                                ": column '"
                                                  ++ show c ++ "' has unknown type " ++ show o)
                           return 
                           =<< lookupPGType tpg o
                    return
                      (pgDecodeRep to, 
                       (c, n, TH.LitT (TH.StrTyLit $ pgNameString t), 
                        not $ pgDecodeRep cnn)))’
    Suggested fix:
      Set limit with -fconstraint-solver-iterations=n; n=0 for no limit
   |
64 |       let c = pgDecodeRep cn 
   |           ^^^^^^^^^^^^^^^^^^ 

/var/stackage/work/unpack-dir/unpacked/postgresql-typed-0.6.2.1-d219fe3269ecc3474a5d73ab77764a4e69a4f3589d3d5b572c839b2ba6aa3886/Dat
abase/PostgreSQL/Typed/Relation.hs:66:11: error:
    • solveWanteds: too many iterations (limit = 4)
        Unsolved: WC {wc_simple = 
                        [W] $dPGRep_aa4v {0}:: PGRep a0 (CDictCan) 
                        [W] $dKnownSymbol_aa52 {0}:: GHC.TypeLits.KnownSymbol
                                                       (PGRepType a0) (CDictCan)
                        [W] $dPGParameter_aa4B {0}:: PGParameter
                                                       (PGRepType a0) a0 (CDictCan)
                        [W] $dPGParameter_aa53 {0}:: PGParameter
                                                       (PGRepType a0)
                                                       (PGVal (PGRepType a0)) (CDictCan)
                        [W] $dPGColumn_aa4H {0}:: PGColumn (PGRepType a0) a0 (CDictCan)
                        [W] $dPGColumn_aa55 {0}:: PGColumn
                                                    (PGRepType a0) (PGVal (PGRepType a0)) (CDictCan)
                        [W] $dPGType_aa56 {0}:: PGType (PGRepType a0) (CDictCan(psc))}
        Simples: {[W] $dPGRep_aa4v {0}:: PGRep a0 (CDictCan),
                  [W] $dKnownSymbol_aa52 {0}:: GHC.TypeLits.KnownSymbol
                                                 (PGRepType a0) (CDictCan),
                  [W] $dPGParameter_aa4B {0}:: PGParameter
                                                 (PGRepType a0) a0 (CDictCan),
                  [W] $dPGParameter_aa53 {0}:: PGParameter
                                                 (PGRepType a0) (PGVal (PGRepType a0)) (CDictCan),
                  [W] $dPGColumn_aa4H {0}:: PGColumn (PGRepType a0) a0 (CDictCan),
                  [W] $dPGColumn_aa55 {0}:: PGColumn
                  [W] $dPGColumn_aa55 {0}:: PGColumn                                                                     [38/180439]
                                              (PGRepType a0) (PGVal (PGRepType a0)) (CDictCan),
                  [W] $dPGType_aa56 {0}:: PGType (PGRepType a0) (CDictCan(psc))}
    • In the expression:
        do let c = pgDecodeRep cn 
               n = TH.mkName $ colf $ pgNameString c
               ....
           t <- maybe
                  (fail
                     $ "dataPGRelation "
                         ++
                           typs
                             ++
                               " = "
                                 ++
                                   show pgtab
                                     ++ ": column '" ++ show c ++ "' has unknown type " ++ show o)
                  return
                  =<< lookupPGType tpg o
           return
             (pgDecodeRep to, 
              (c, n, TH.LitT (TH.StrTyLit $ pgNameString t), 
               not $ pgDecodeRep cnn))
      In the first argument of ‘mapM’, namely
        ‘(\ [to, cn, ct, cnn]
            -> do let c = ...
                      ....
                  t <- maybe
                         (fail
                            $ "dataPGRelation "
                                ++
                                  typs
                                    ++
                                      " = "
                                        ++
                                          show pgtab
                                            ++
                                              ": column '"
                                                ++ show c ++ "' has unknown type " ++ show o)
                         return
                         =<< lookupPGType tpg o
                  return
                         =<< lookupPGType tpg o
                  return
                    (pgDecodeRep to, 
                     (c, n, TH.LitT (TH.StrTyLit $ pgNameString t), 
                      not $ pgDecodeRep cnn)))’
      In the first argument of ‘(.)’, namely
        ‘mapM
           (\ [to, cn, ct, cnn]
              -> do let c = ...
                        ....
                    t <- maybe
                           (fail
                              $ "dataPGRelation "
                                  ++
                                    typs
                                      ++
                                        " = "
                                          ++
                                            show pgtab
                                              ++
                                                ": column '"
                                                  ++ show c ++ "' has unknown type " ++ show o)
                           return 
                           =<< lookupPGType tpg o
                    return
                      (pgDecodeRep to, 
                       (c, n, TH.LitT (TH.StrTyLit $ pgNameString t), 
                        not $ pgDecodeRep cnn)))’
    Suggested fix:
      Set limit with -fconstraint-solver-iterations=n; n=0 for no limit
   |
66 |           o = pgDecodeRep ct 
   |           ^^^^^^^^^^^^^^^^^^
dylex commented 1 year ago

This is fixed in 0.6.2.2 with some minor type annotations (though it really feels like a compiler regression to me).