th-data-compat 0.0.2.7 → 0.1.0.0

raw patch · 7 files changed

+120/−24 lines, 7 filesdep ~template-haskellPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: template-haskell

API changes (from Hackage documentation)

Files

• src/Language/Haskell/TH/Compat/Data.hs +3/−1
• src/Language/Haskell/TH/Compat/Data/Current.hs +4/−4
• src/Language/Haskell/TH/Compat/Data/Util.hs +9/−0
• src/Language/Haskell/TH/Compat/Data/V210.hs +6/−4
• src/Language/Haskell/TH/Compat/Data/V211.hs +6/−4
• src/Language/Haskell/TH/Compat/Data/V214.hs +73/−0
• th-data-compat.cabal +19/−11

@@ -19,8 +19,10 @@   unDataD, unNewtypeD, unDataInstD, unNewtypeInstD, unInstanceD,   ) where -#if MIN_VERSION_template_haskell(2,12,0)+#if MIN_VERSION_template_haskell(2,15,0) import Language.Haskell.TH.Compat.Data.Current+#elif MIN_VERSION_template_haskell(2,12,0)+import Language.Haskell.TH.Compat.Data.V214 #elif MIN_VERSION_template_haskell(2,11,0) import Language.Haskell.TH.Compat.Data.V211 #else

@@ -49,8 +49,8 @@ dataInstD' cxt n as cs ds = dataInstD cxt n as Nothing cs $ derivesFromNames ds  -- | Compatible interface to destruct 'DataInstD'-unDataInstD :: Dec -> Maybe (Cxt, Name, [Type], Maybe Kind, [Con], [Type])-unDataInstD (DataInstD cxt n as mk cs ds) = Just (cxt, n, as, mk, cs, ds >>= unDerivClause)+unDataInstD :: Dec -> Maybe (Cxt, Maybe [TyVarBndr], Type, Maybe Kind, [Con], [Type])+unDataInstD (DataInstD cxt b ty mk cs ds) = Just (cxt, b, ty, mk, cs, ds >>= unDerivClause) unDataInstD  _                            = Nothing  -- | Definition against 'newtypeInstD',@@ -60,8 +60,8 @@ newtypeInstD' cxt n as c ds = newtypeInstD cxt n as Nothing c $ derivesFromNames ds  -- | Compatible interface to destruct 'NewtypeInstD'-unNewtypeInstD :: Dec -> Maybe (Cxt, Name, [Type], Maybe Kind, Con, [Type])-unNewtypeInstD (NewtypeInstD cxt n as mk c ds) = Just (cxt, n, as, mk, c, ds >>= unDerivClause)+unNewtypeInstD :: Dec -> Maybe (Cxt, Maybe [TyVarBndr], Type, Maybe Kind, Con, [Type])+unNewtypeInstD (NewtypeInstD cxt b ty mk c ds) = Just (cxt, b, ty, mk, c, ds >>= unDerivClause) unNewtypeInstD  _                              = Nothing  -- | Compatible interface to destruct 'InstanceD'

@@ -0,0 +1,9 @@+module Language.Haskell.TH.Compat.Data.Util (+  foldAppT_,+  ) where++import Language.Haskell.TH+import Data.List (foldl')++foldAppT_ :: Name -> [Type] -> Type+foldAppT_ n as = foldl' AppT (ConT n) as

@@ -12,7 +12,9 @@    Dec (DataD, NewtypeD, DataInstD, NewtypeInstD, InstanceD),    dataD, newtypeD, dataInstD, newtypeInstD) +import Language.Haskell.TH.Compat.Data.Util (foldAppT_) + -- | Definition against 'dataD', --   compatible with before temaplate-haskell-2.11 dataD' :: CxtQ -> Name -> [TyVarBndr] -> [ConQ] -> [Name]@@ -42,8 +44,8 @@ dataInstD' = dataInstD  -- | Compatible interface to destruct 'DataInstD'-unDataInstD :: Dec -> Maybe (Cxt, Name, [Type], Maybe Kind, [Con], [Type])-unDataInstD (DataInstD cxt n as cs ds) = Just (cxt, n, as, Nothing, cs, map ConT ds)+unDataInstD :: Dec -> Maybe (Cxt, Maybe [TyVarBndr], Type, Maybe Kind, [Con], [Type])+unDataInstD (DataInstD cxt n as cs ds) = Just (cxt, Nothing, foldAppT_ n as, Nothing, cs, map ConT ds) unDataInstD  _                         = Nothing  -- | Definition against 'newtypeInstD',@@ -53,8 +55,8 @@ newtypeInstD' = newtypeInstD  -- | Compatible interface to destruct 'NewtypeInstD'-unNewtypeInstD :: Dec -> Maybe (Cxt, Name, [Type], Maybe Kind, Con, [Type])-unNewtypeInstD (NewtypeInstD cxt n as c ds) = Just (cxt, n, as, Nothing, c, map ConT ds)+unNewtypeInstD :: Dec -> Maybe (Cxt, Maybe [TyVarBndr], Type, Maybe Kind, Con, [Type])+unNewtypeInstD (NewtypeInstD cxt n as c ds) = Just (cxt, Nothing, foldAppT_ n as, Nothing, c, map ConT ds) unNewtypeInstD  _                           = Nothing  -- | Compatible interface to destruct 'InstanceD'.

@@ -12,7 +12,9 @@    Dec (DataD, NewtypeD, DataInstD, NewtypeInstD, InstanceD),    dataD, newtypeD, dataInstD, newtypeInstD, conT) +import Language.Haskell.TH.Compat.Data.Util (foldAppT_) + -- | Definition against 'dataD', --   compatible with before temaplate-haskell-2.11 dataD' :: CxtQ -> Name -> [TyVarBndr] -> [ConQ] -> [Name]@@ -42,8 +44,8 @@ dataInstD' cxt n as cs ds = dataInstD cxt n as Nothing cs $ mapM conT ds  -- | Compatible interface to destruct 'DataInstD'-unDataInstD :: Dec -> Maybe (Cxt, Name, [Type], Maybe Kind, [Con], [Type])-unDataInstD (DataInstD cxt n as mk cs ds) = Just (cxt, n, as, mk, cs, ds)+unDataInstD :: Dec -> Maybe (Cxt, Maybe [TyVarBndr], Type, Maybe Kind, [Con], [Type])+unDataInstD (DataInstD cxt n as mk cs ds) = Just (cxt, Nothing, foldAppT_ n as, mk, cs, ds) unDataInstD  _                            = Nothing  -- | Definition against 'newtypeInstD',@@ -53,8 +55,8 @@ newtypeInstD' cxt n as c ds = newtypeInstD cxt n as Nothing c $ mapM conT ds  -- | Compatible interface to destruct 'NewtypeInstD'-unNewtypeInstD :: Dec -> Maybe (Cxt, Name, [Type], Maybe Kind, Con, [Type])-unNewtypeInstD (NewtypeInstD cxt n as mk c ds) = Just (cxt, n, as, mk, c, ds)+unNewtypeInstD :: Dec -> Maybe (Cxt, Maybe [TyVarBndr], Type, Maybe Kind, Con, [Type])+unNewtypeInstD (NewtypeInstD cxt n as mk c ds) = Just (cxt, Nothing, foldAppT_ n as, mk, c, ds) unNewtypeInstD  _                              = Nothing  -- | Compatible interface to destruct 'InstanceD'

@@ -0,0 +1,73 @@+module Language.Haskell.TH.Compat.Data.V214 (+  dataD', unDataD,+  newtypeD', unNewtypeD,+  dataInstD', unDataInstD,+  newtypeInstD', unNewtypeInstD,+  unInstanceD,+  ) where++import Language.Haskell.TH+  (CxtQ, ConQ, TypeQ, DecQ,+   Cxt, Con, Type, Name, TyVarBndr, Kind,+   Dec (DataD, NewtypeD, DataInstD, NewtypeInstD, InstanceD),+   DerivClauseQ, DerivClause (..), Pred,+   dataD, newtypeD, dataInstD, newtypeInstD, derivClause, conT)++import Language.Haskell.TH.Compat.Data.Util (foldAppT_)+++derivesFromNames :: [Name] -> [DerivClauseQ]+derivesFromNames ns = [derivClause Nothing $ map conT ns]++unDerivClause :: DerivClause -> [Pred]+unDerivClause (DerivClause _ ps) = ps++-- | Definition against 'dataD',+--   compatible with before temaplate-haskell-2.11+dataD' :: CxtQ -> Name -> [TyVarBndr] -> [ConQ] -> [Name]+       -> DecQ+dataD' cxt n bs cs ds = dataD cxt n bs Nothing cs $ derivesFromNames ds++-- | Compatible interface to destruct 'DataD'+unDataD :: Dec -> Maybe (Cxt, Name, [TyVarBndr], Maybe Kind, [Con], [Type])+unDataD (DataD cxt n bs mk cs ds) = Just (cxt, n, bs, mk, cs, ds >>= unDerivClause)+unDataD  _                        = Nothing++-- | Definition against 'newtypeD',+--   compatible with before temaplate-haskell-2.11+newtypeD' :: CxtQ -> Name -> [TyVarBndr] -> ConQ -> [Name]+          -> DecQ+newtypeD' cxt n bs c ds = newtypeD cxt n bs Nothing c $ derivesFromNames ds++-- | Compatible interface to destruct 'NewtypeD'+unNewtypeD :: Dec -> Maybe (Cxt, Name, [TyVarBndr], Maybe Kind, Con, [Type])+unNewtypeD (NewtypeD cxt n bs mk c ds) = Just (cxt, n, bs, mk, c, ds >>= unDerivClause)+unNewtypeD  _                          = Nothing++-- | Definition against 'dataInstD',+--   compatible with before temaplate-haskell-2.11+dataInstD' :: CxtQ -> Name -> [TypeQ] -> [ConQ] -> [Name]+           -> DecQ+dataInstD' cxt n as cs ds = dataInstD cxt n as Nothing cs $ derivesFromNames ds++-- | Compatible interface to destruct 'DataInstD'+unDataInstD :: Dec -> Maybe (Cxt, Maybe [TyVarBndr], Type, Maybe Kind, [Con], [Type])+unDataInstD (DataInstD cxt n as mk cs ds) = Just (cxt, Nothing, foldAppT_ n as, mk, cs, ds >>= unDerivClause)+unDataInstD  _                            = Nothing++-- | Definition against 'newtypeInstD',+--   compatible with before temaplate-haskell-2.11+newtypeInstD' :: CxtQ -> Name -> [TypeQ] -> ConQ -> [Name]+              -> DecQ+newtypeInstD' cxt n as c ds = newtypeInstD cxt n as Nothing c $ derivesFromNames ds++-- | Compatible interface to destruct 'NewtypeInstD'+unNewtypeInstD :: Dec -> Maybe (Cxt, Maybe [TyVarBndr], Type, Maybe Kind, Con, [Type])+unNewtypeInstD (NewtypeInstD cxt n as mk c ds) = Just (cxt, Nothing, foldAppT_ n as, mk, c, ds >>= unDerivClause)+unNewtypeInstD  _                              = Nothing++-- | Compatible interface to destruct 'InstanceD'+--   No Overlap type is defined before template-haskell-2.11.+unInstanceD :: Dec -> Maybe (Cxt, Type, [Dec])+unInstanceD (InstanceD _ cxt ty decs) = Just (cxt, ty, decs)+unInstanceD  _                        = Nothing

@@ -1,6 +1,6 @@  name:                th-data-compat-version:             0.0.2.7+version:             0.1.0.0 synopsis:            Compatibility for data definition template of TH description:         This package contains wrapped name definitions of                      data definition template@@ -8,11 +8,13 @@ license-file:        LICENSE author:              Kei Hibino maintainer:          ex8k.hibino@gmail.com-copyright:           Copyright (c) 2016-2018 Kei Hibino+copyright:           Copyright (c) 2016-2019 Kei Hibino category:            Language build-type:          Simple cabal-version:       >=1.10-tested-with:           GHC == 8.4.1, GHC == 8.4.2, GHC == 8.4.3+tested-with:           GHC == 8.8.1+                     , GHC == 8.6.1, GHC == 8.6.2, GHC == 8.6.3, GHC == 8.6.4, GHC == 8.6.5+                     , GHC == 8.4.1, GHC == 8.4.2, GHC == 8.4.3, GHC == 8.4.4                      , GHC == 8.2.1, GHC == 8.2.2                      , GHC == 8.0.1, GHC == 8.0.2                      , GHC == 7.10.1, GHC == 7.10.2, GHC == 7.10.3@@ -23,20 +25,26 @@ library   exposed-modules:      Language.Haskell.TH.Compat.Data -  if impl(ghc < 8)-    other-modules:-                          Language.Haskell.TH.Compat.Data.V210-    build-depends:        template-haskell >=2.4 && <2.11+  other-modules:        Language.Haskell.TH.Compat.Data.Util++  if impl(ghc >= 8.8)+      other-modules:+                          Language.Haskell.TH.Compat.Data.Current+      build-depends:      template-haskell >=2.15   else     if impl(ghc >= 8.2)       other-modules:-                          Language.Haskell.TH.Compat.Data.Current+                          Language.Haskell.TH.Compat.Data.V214       build-depends:      template-haskell >=2.12     else-      -- 8 <= ghc < 8.2-      other-modules:+      if impl(ghc >= 8.0)+        other-modules:                           Language.Haskell.TH.Compat.Data.V211-      build-depends:      template-haskell ==2.11.*+        build-depends:    template-haskell ==2.11.*+      else+        other-modules:+                          Language.Haskell.TH.Compat.Data.V210+        build-depends:    template-haskell >=2.4 && <2.11    build-depends:         base <5