{-# LANGUAGE CPP #-}
module TemplateHaskell.Compat.V0208 where

import TemplateHaskell.Compat.V0208.Prelude
import Language.Haskell.TH


classP :: Name -> [Type] -> Pred
#if MIN_VERSION_template_haskell(2,10,0)
classP :: Name -> [Type] -> Type
classP n :: Name
n tl :: [Type]
tl =
  (Type -> Type -> Type) -> Type -> [Type] -> Type
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl Type -> Type -> Type
AppT (Name -> Type
ConT Name
n) [Type]
tl
#else
classP =
  ClassP
#endif

instanceD :: Cxt -> Type -> [Dec] -> Dec
#if MIN_VERSION_template_haskell(2,11,0)  
instanceD :: [Type] -> Type -> [Dec] -> Dec
instanceD =
  Maybe Overlap -> [Type] -> Type -> [Dec] -> Dec
InstanceD Maybe Overlap
forall a. Maybe a
Nothing
#else
instanceD =
  InstanceD
#endif

dataD :: Cxt -> Name -> [TyVarBndr] -> [Con] -> [Name] -> Dec
dataD :: [Type] -> Name -> [TyVarBndr] -> [Con] -> [Name] -> Dec
dataD cxt :: [Type]
cxt name :: Name
name varBndrs :: [TyVarBndr]
varBndrs cons :: [Con]
cons derivingNames :: [Name]
derivingNames =
#if MIN_VERSION_template_haskell(2,12,0)
  [Type]
-> Name
-> [TyVarBndr]
-> Maybe Type
-> [Con]
-> [DerivClause]
-> Dec
DataD [Type]
cxt Name
name [TyVarBndr]
varBndrs Maybe Type
forall a. Maybe a
Nothing [Con]
cons (DerivClause -> [DerivClause]
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe DerivStrategy -> [Type] -> DerivClause
DerivClause Maybe DerivStrategy
forall a. Maybe a
Nothing ((Name -> Type) -> [Name] -> [Type]
forall a b. (a -> b) -> [a] -> [b]
map Name -> Type
ConT [Name]
derivingNames)))
#elif MIN_VERSION_template_haskell(2,11,0)
  DataD cxt name varBndrs Nothing cons (map ConT derivingNames)
#else
  DataD cxt name varBndrs cons derivingNames
#endif

notStrict :: Strict
notStrict :: Strict
notStrict =
#if MIN_VERSION_template_haskell(2,11,0)
  IO Strict -> Strict
forall a. IO a -> a
unsafePerformIO (Q Strict -> IO Strict
forall (m :: * -> *) a. Quasi m => Q a -> m a
runQ (SourceUnpackednessQ -> SourceStrictnessQ -> Q Strict
bang SourceUnpackednessQ
noSourceUnpackedness SourceStrictnessQ
noSourceStrictness))
#else
  NotStrict
#endif

tupE :: [Exp] -> Exp
#if MIN_VERSION_template_haskell(2,16,0)
tupE = \ case
  [a] -> a
  a -> TupE (map Just a)
#else
tupE :: [Exp] -> Exp
tupE = [Exp] -> Exp
TupE
#endif