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
dataD' :: CxtQ -> Name -> [TyVarBndr] -> [ConQ] -> [Name]
-> DecQ
dataD' cxt n bs cs ds = dataD cxt n bs Nothing cs $ derivesFromNames ds
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
newtypeD' :: CxtQ -> Name -> [TyVarBndr] -> ConQ -> [Name]
-> DecQ
newtypeD' cxt n bs c ds = newtypeD cxt n bs Nothing c $ derivesFromNames ds
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
dataInstD' :: CxtQ -> Name -> [TypeQ] -> [ConQ] -> [Name]
-> DecQ
dataInstD' cxt n as cs ds = dataInstD cxt n as Nothing cs $ derivesFromNames 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 >>= unDerivClause)
unDataInstD _ = Nothing
newtypeInstD' :: CxtQ -> Name -> [TypeQ] -> ConQ -> [Name]
-> DecQ
newtypeInstD' cxt n as c ds = newtypeInstD cxt n as Nothing c $ derivesFromNames 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 >>= unDerivClause)
unNewtypeInstD _ = Nothing
unInstanceD :: Dec -> Maybe (Cxt, Type, [Dec])
unInstanceD (InstanceD _ cxt ty decs) = Just (cxt, ty, decs)
unInstanceD _ = Nothing