{-# LANGUAGE Safe #-}-- |-- Language.Haskell.TH.Lib contains lots of useful helper functions for-- generating and manipulating Template Haskell terms-- Note: this module mostly re-exports functions from-- Language.Haskell.TH.Lib.Internal, but if a change occurs to Template-- Haskell which requires breaking the API offered in this module, we opt to-- copy the old definition here, and make the changes in-- Language.Haskell.TH.Lib.Internal. This way, we can retain backwards-- compatibility while still allowing GHC to make changes as it needs.moduleLanguage.Haskell.TH.Lib(-- All of the exports from this module should-- be "public" functions. The main module TH-- re-exports them all.-- * Library functions-- ** AbbreviationsInfoQ ,ExpQ ,TExpQ ,CodeQ ,DecQ ,DecsQ ,ConQ ,TypeQ ,KindQ ,TyLitQ ,CxtQ ,PredQ ,DerivClauseQ ,MatchQ ,ClauseQ ,BodyQ ,GuardQ ,StmtQ ,RangeQ ,SourceStrictnessQ ,SourceUnpackednessQ ,BangQ ,BangTypeQ ,VarBangTypeQ ,StrictTypeQ ,VarStrictTypeQ ,FieldExpQ ,PatQ ,FieldPatQ ,RuleBndrQ ,TySynEqnQ ,PatSynDirQ ,PatSynArgsQ ,FamilyResultSigQ ,DerivStrategyQ ,TyVarBndrUnit ,TyVarBndrSpec ,-- ** Constructors lifted to 'Q'-- *** LiteralsintPrimL ,wordPrimL ,floatPrimL ,doublePrimL ,integerL ,rationalL ,charL ,stringL ,stringPrimL ,charPrimL ,bytesPrimL ,mkBytes ,-- *** PatternslitP ,varP ,tupP ,unboxedTupP ,unboxedSumP ,conP ,uInfixP ,parensP ,infixP ,tildeP ,bangP ,asP ,wildP ,recP ,listP ,sigP ,viewP ,fieldPat ,-- *** Pattern GuardsnormalB ,guardedB ,normalG ,normalGE ,patG ,patGE ,match ,clause ,-- *** Expressionsdyn ,varE ,unboundVarE ,labelE ,implicitParamVarE ,conE ,litE ,staticE ,appE ,appTypeE ,uInfixE ,parensE ,infixE ,infixApp ,sectionL ,sectionR ,lamE ,lam1E ,lamCaseE ,lamCasesE ,tupE ,unboxedTupE ,unboxedSumE ,condE ,multiIfE ,letE ,caseE ,appsE ,listE ,sigE ,recConE ,recUpdE ,stringE ,fieldExp ,getFieldE ,projectionE ,-- **** RangesfromE ,fromThenE ,fromToE ,fromThenToE ,-- ***** Ranges with more indirectionarithSeqE ,fromR ,fromThenR ,fromToR ,fromThenToR ,-- **** StatementsdoE ,mdoE ,compE ,bindS ,letS ,noBindS ,parS ,recS ,-- *** TypesforallT ,forallVisT ,varT ,conT ,appT ,appKindT ,arrowT ,mulArrowT ,infixT ,uInfixT ,promotedInfixT ,promotedUInfixT ,parensT ,equalityT ,listT ,tupleT ,unboxedTupleT ,unboxedSumT ,sigT ,litT ,wildCardT ,promotedT ,promotedTupleT ,promotedNilT ,promotedConsT ,implicitParamT ,-- **** Type literalsnumTyLit ,strTyLit ,charTyLit ,-- **** StrictnessnoSourceUnpackedness ,sourceNoUnpack ,sourceUnpack ,noSourceStrictness ,sourceLazy ,sourceStrict ,isStrict ,notStrict ,unpacked ,bang ,bangType ,varBangType ,strictType ,varStrictType ,-- **** Class Contextscxt ,classP ,equalP ,-- **** ConstructorsnormalC ,recC ,infixC ,forallC ,gadtC ,recGadtC ,-- *** KindsvarK ,conK ,tupleK ,arrowK ,listK ,appK ,starK ,constraintK ,-- *** Type variable bindersplainTV ,kindedTV ,plainInvisTV ,kindedInvisTV ,specifiedSpec ,inferredSpec ,-- *** RolesnominalR ,representationalR ,phantomR ,inferR ,-- *** Top Level Declarations-- **** DatavalD ,funD ,tySynD ,dataD ,newtypeD ,typeDataD ,derivClause ,DerivClause (..),stockStrategy ,anyclassStrategy ,newtypeStrategy ,viaStrategy ,DerivStrategy (..),-- **** ClassclassD ,instanceD ,instanceWithOverlapD ,Overlap (..),sigD ,kiSigD ,standaloneDerivD ,standaloneDerivWithStrategyD ,defaultSigD ,-- **** Role annotationsroleAnnotD ,-- **** Type Family / Data FamilydataFamilyD ,openTypeFamilyD ,closedTypeFamilyD ,dataInstD ,newtypeInstD ,tySynInstD ,tySynEqn ,injectivityAnn ,noSig ,kindSig ,tyVarSig ,-- **** FixityinfixLD ,infixRD ,infixND ,-- **** Default declarationdefaultD ,-- **** Foreign Function Interface (FFI)cCall ,stdCall ,cApi ,prim ,javaScript ,unsafe ,safe ,interruptible ,forImpD ,-- **** Functional dependenciesfunDep ,-- **** PragmasruleVar ,typedRuleVar ,valueAnnotation ,typeAnnotation ,moduleAnnotation ,pragInlD ,pragSpecD ,pragSpecInlD ,pragSpecInstD ,pragRuleD ,pragAnnD ,pragLineD ,pragCompleteD ,-- **** Pattern SynonymspatSynD ,patSynSigD ,unidir ,implBidir ,explBidir ,prefixPatSyn ,infixPatSyn ,recordPatSyn ,-- **** Implicit ParametersimplicitParamBindD ,-- ** ReifythisModule ,-- ** DocumentationwithDecDoc ,withDecsDoc ,funD_doc ,dataD_doc ,newtypeD_doc ,typeDataD_doc ,dataInstD_doc ,newtypeInstD_doc ,patSynD_doc )whereimportLanguage.Haskell.TH.Lib.Internal hiding(tySynD ,dataD ,newtypeD ,typeDataD ,classD ,pragRuleD ,dataInstD ,newtypeInstD ,dataFamilyD ,openTypeFamilyD ,closedTypeFamilyD ,tySynEqn ,forallC ,forallT ,sigT ,plainTV ,kindedTV ,starK ,constraintK ,noSig ,kindSig ,tyVarSig ,derivClause ,standaloneDerivWithStrategyD ,doE ,mdoE ,tupE ,unboxedTupE ,conP ,Role ,InjectivityAnn )importqualifiedLanguage.Haskell.TH.Lib.Internal asInternalimportLanguage.Haskell.TH.Syntax importControl.Applicative (Applicative (..))importForeign.ForeignPtr importData.Word importPrelude hiding(Applicative (..))-- All definitions below represent the "old" API, since their definitions are-- different in Language.Haskell.TH.Lib.Internal. Please think carefully before-- deciding to change the APIs of the functions below, as they represent the-- public API (as opposed to the Internal module, which has no API promises.)--------------------------------------------------------------------------------- * DectySynD ::Quote m =>Name ->[TyVarBndr ()]->m Type ->m Dec tySynD :: forall (m :: * -> *).
Quote m =>
Name -> [TyVarBndr ()] -> m Type -> m Dec
tySynD Name
tc [TyVarBndr ()]
tvs m Type
rhs =do{Type
rhs1 <-m Type
rhs ;Dec -> m Dec
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Name -> [TyVarBndr ()] -> Type -> Dec
TySynD Name
tc [TyVarBndr ()]
tvs Type
rhs1 )}dataD ::Quote m =>m Cxt ->Name ->[TyVarBndr ()]->Maybe Kind ->[m Con ]->[m DerivClause ]->m Dec dataD :: forall (m :: * -> *).
Quote m =>
m Cxt
-> Name
-> [TyVarBndr ()]
-> Maybe Type
-> [m Con]
-> [m DerivClause]
-> m Dec
dataD m Cxt
ctxt Name
tc [TyVarBndr ()]
tvs Maybe Type
ksig [m Con]
cons [m DerivClause]
derivs =doCxt
ctxt1 <-m Cxt
ctxt [Con]
cons1 <-[m Con] -> m [Con]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
sequenceA [m Con]
cons [DerivClause]
derivs1 <-[m DerivClause] -> m [DerivClause]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
sequenceA [m DerivClause]
derivs Dec -> m Dec
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Cxt
-> Name
-> [TyVarBndr ()]
-> Maybe Type
-> [Con]
-> [DerivClause]
-> Dec
DataD Cxt
ctxt1 Name
tc [TyVarBndr ()]
tvs Maybe Type
ksig [Con]
cons1 [DerivClause]
derivs1 )newtypeD ::Quote m =>m Cxt ->Name ->[TyVarBndr ()]->Maybe Kind ->m Con ->[m DerivClause ]->m Dec newtypeD :: forall (m :: * -> *).
Quote m =>
m Cxt
-> Name
-> [TyVarBndr ()]
-> Maybe Type
-> m Con
-> [m DerivClause]
-> m Dec
newtypeD m Cxt
ctxt Name
tc [TyVarBndr ()]
tvs Maybe Type
ksig m Con
con [m DerivClause]
derivs =doCxt
ctxt1 <-m Cxt
ctxt Con
con1 <-m Con
con [DerivClause]
derivs1 <-[m DerivClause] -> m [DerivClause]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
sequenceA [m DerivClause]
derivs Dec -> m Dec
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Cxt
-> Name
-> [TyVarBndr ()]
-> Maybe Type
-> Con
-> [DerivClause]
-> Dec
NewtypeD Cxt
ctxt1 Name
tc [TyVarBndr ()]
tvs Maybe Type
ksig Con
con1 [DerivClause]
derivs1 )typeDataD ::Quote m =>Name ->[TyVarBndr ()]->Maybe Kind ->[m Con ]->m Dec typeDataD :: forall (m :: * -> *).
Quote m =>
Name -> [TyVarBndr ()] -> Maybe Type -> [m Con] -> m Dec
typeDataD Name
tc [TyVarBndr ()]
tvs Maybe Type
ksig [m Con]
cons =do[Con]
cons1 <-[m Con] -> m [Con]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
sequenceA [m Con]
cons Dec -> m Dec
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Name -> [TyVarBndr ()] -> Maybe Type -> [Con] -> Dec
TypeDataD Name
tc [TyVarBndr ()]
tvs Maybe Type
ksig [Con]
cons1 )classD ::Quote m =>m Cxt ->Name ->[TyVarBndr ()]->[FunDep ]->[m Dec ]->m Dec classD :: forall (m :: * -> *).
Quote m =>
m Cxt -> Name -> [TyVarBndr ()] -> [FunDep] -> [m Dec] -> m Dec
classD m Cxt
ctxt Name
cls [TyVarBndr ()]
tvs [FunDep]
fds [m Dec]
decs =do[Dec]
decs1 <-[m Dec] -> m [Dec]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
sequenceA [m Dec]
decs Cxt
ctxt1 <-m Cxt
ctxt Dec -> m Dec
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Dec -> m Dec) -> Dec -> m Dec
forall a b. (a -> b) -> a -> b
$ Cxt -> Name -> [TyVarBndr ()] -> [FunDep] -> [Dec] -> Dec
ClassD Cxt
ctxt1 Name
cls [TyVarBndr ()]
tvs [FunDep]
fds [Dec]
decs1 pragRuleD ::Quote m =>String ->[m RuleBndr ]->m Exp ->m Exp ->Phases ->m Dec pragRuleD :: forall (m :: * -> *).
Quote m =>
String -> [m RuleBndr] -> m Exp -> m Exp -> Phases -> m Dec
pragRuleD String
n [m RuleBndr]
bndrs m Exp
lhs m Exp
rhs Phases
phases =do[RuleBndr]
bndrs1 <-[m RuleBndr] -> m [RuleBndr]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
sequenceA [m RuleBndr]
bndrs Exp
lhs1 <-m Exp
lhs Exp
rhs1 <-m Exp
rhs Dec -> m Dec
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Dec -> m Dec) -> Dec -> m Dec
forall a b. (a -> b) -> a -> b
$ Pragma -> Dec
PragmaD (Pragma -> Dec) -> Pragma -> Dec
forall a b. (a -> b) -> a -> b
$ String
-> Maybe [TyVarBndr ()]
-> [RuleBndr]
-> Exp
-> Exp
-> Phases
-> Pragma
RuleP String
n Maybe [TyVarBndr ()]
forall a. Maybe a
Nothing [RuleBndr]
bndrs1 Exp
lhs1 Exp
rhs1 Phases
phases dataInstD ::Quote m =>m Cxt ->Name ->[m Type ]->Maybe Kind ->[m Con ]->[m DerivClause ]->m Dec dataInstD :: forall (m :: * -> *).
Quote m =>
m Cxt
-> Name
-> [m Type]
-> Maybe Type
-> [m Con]
-> [m DerivClause]
-> m Dec
dataInstD m Cxt
ctxt Name
tc [m Type]
tys Maybe Type
ksig [m Con]
cons [m DerivClause]
derivs =doCxt
ctxt1 <-m Cxt
ctxt Type
ty1 <-(m Type -> m Type -> m Type) -> m Type -> [m Type] -> m Type
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl m Type -> m Type -> m Type
forall (m :: * -> *). Quote m => m Type -> m Type -> m Type
appT (Name -> m Type
forall (m :: * -> *). Quote m => Name -> m Type
conT Name
tc )[m Type]
tys [Con]
cons1 <-[m Con] -> m [Con]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
sequenceA [m Con]
cons [DerivClause]
derivs1 <-[m DerivClause] -> m [DerivClause]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
sequenceA [m DerivClause]
derivs Dec -> m Dec
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Cxt
-> Maybe [TyVarBndr ()]
-> Type
-> Maybe Type
-> [Con]
-> [DerivClause]
-> Dec
DataInstD Cxt
ctxt1 Maybe [TyVarBndr ()]
forall a. Maybe a
Nothing Type
ty1 Maybe Type
ksig [Con]
cons1 [DerivClause]
derivs1 )newtypeInstD ::Quote m =>m Cxt ->Name ->[m Type ]->Maybe Kind ->m Con ->[m DerivClause ]->m Dec newtypeInstD :: forall (m :: * -> *).
Quote m =>
m Cxt
-> Name
-> [m Type]
-> Maybe Type
-> m Con
-> [m DerivClause]
-> m Dec
newtypeInstD m Cxt
ctxt Name
tc [m Type]
tys Maybe Type
ksig m Con
con [m DerivClause]
derivs =doCxt
ctxt1 <-m Cxt
ctxt Type
ty1 <-(m Type -> m Type -> m Type) -> m Type -> [m Type] -> m Type
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl m Type -> m Type -> m Type
forall (m :: * -> *). Quote m => m Type -> m Type -> m Type
appT (Name -> m Type
forall (m :: * -> *). Quote m => Name -> m Type
conT Name
tc )[m Type]
tys Con
con1 <-m Con
con [DerivClause]
derivs1 <-[m DerivClause] -> m [DerivClause]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
sequenceA [m DerivClause]
derivs Dec -> m Dec
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Cxt
-> Maybe [TyVarBndr ()]
-> Type
-> Maybe Type
-> Con
-> [DerivClause]
-> Dec
NewtypeInstD Cxt
ctxt1 Maybe [TyVarBndr ()]
forall a. Maybe a
Nothing Type
ty1 Maybe Type
ksig Con
con1 [DerivClause]
derivs1 )dataFamilyD ::Quote m =>Name ->[TyVarBndr ()]->Maybe Kind ->m Dec dataFamilyD :: forall (m :: * -> *).
Quote m =>
Name -> [TyVarBndr ()] -> Maybe Type -> m Dec
dataFamilyD Name
tc [TyVarBndr ()]
tvs Maybe Type
kind =Dec -> m Dec
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Dec -> m Dec) -> Dec -> m Dec
forall a b. (a -> b) -> a -> b
$ Name -> [TyVarBndr ()] -> Maybe Type -> Dec
DataFamilyD Name
tc [TyVarBndr ()]
tvs Maybe Type
kind openTypeFamilyD ::Quote m =>Name ->[TyVarBndr ()]->FamilyResultSig ->Maybe InjectivityAnn ->m Dec openTypeFamilyD :: forall (m :: * -> *).
Quote m =>
Name
-> [TyVarBndr ()]
-> FamilyResultSig
-> Maybe InjectivityAnn
-> m Dec
openTypeFamilyD Name
tc [TyVarBndr ()]
tvs FamilyResultSig
res Maybe InjectivityAnn
inj =Dec -> m Dec
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Dec -> m Dec) -> Dec -> m Dec
forall a b. (a -> b) -> a -> b
$ TypeFamilyHead -> Dec
OpenTypeFamilyD (Name
-> [TyVarBndr ()]
-> FamilyResultSig
-> Maybe InjectivityAnn
-> TypeFamilyHead
TypeFamilyHead Name
tc [TyVarBndr ()]
tvs FamilyResultSig
res Maybe InjectivityAnn
inj )closedTypeFamilyD ::Quote m =>Name ->[TyVarBndr ()]->FamilyResultSig ->Maybe InjectivityAnn ->[m TySynEqn ]->m Dec closedTypeFamilyD :: forall (m :: * -> *).
Quote m =>
Name
-> [TyVarBndr ()]
-> FamilyResultSig
-> Maybe InjectivityAnn
-> [m TySynEqn]
-> m Dec
closedTypeFamilyD Name
tc [TyVarBndr ()]
tvs FamilyResultSig
result Maybe InjectivityAnn
injectivity [m TySynEqn]
eqns =do[TySynEqn]
eqns1 <-[m TySynEqn] -> m [TySynEqn]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
sequenceA [m TySynEqn]
eqns Dec -> m Dec
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (TypeFamilyHead -> [TySynEqn] -> Dec
ClosedTypeFamilyD (Name
-> [TyVarBndr ()]
-> FamilyResultSig
-> Maybe InjectivityAnn
-> TypeFamilyHead
TypeFamilyHead Name
tc [TyVarBndr ()]
tvs FamilyResultSig
result Maybe InjectivityAnn
injectivity )[TySynEqn]
eqns1 )tySynEqn ::Quote m =>(Maybe [TyVarBndr ()])->m Type ->m Type ->m TySynEqn tySynEqn :: forall (m :: * -> *).
Quote m =>
Maybe [TyVarBndr ()] -> m Type -> m Type -> m TySynEqn
tySynEqn Maybe [TyVarBndr ()]
tvs m Type
lhs m Type
rhs =doType
lhs1 <-m Type
lhs Type
rhs1 <-m Type
rhs TySynEqn -> m TySynEqn
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe [TyVarBndr ()] -> Type -> Type -> TySynEqn
TySynEqn Maybe [TyVarBndr ()]
tvs Type
lhs1 Type
rhs1 )forallC ::Quote m =>[TyVarBndr Specificity ]->m Cxt ->m Con ->m Con forallC :: forall (m :: * -> *).
Quote m =>
[TyVarBndr Specificity] -> m Cxt -> m Con -> m Con
forallC [TyVarBndr Specificity]
ns m Cxt
ctxt m Con
con =(Cxt -> Con -> Con) -> m Cxt -> m Con -> m Con
forall a b c. (a -> b -> c) -> m a -> m b -> m c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 ([TyVarBndr Specificity] -> Cxt -> Con -> Con
ForallC [TyVarBndr Specificity]
ns )m Cxt
ctxt m Con
con --------------------------------------------------------------------------------- * TypeforallT ::Quote m =>[TyVarBndr Specificity ]->m Cxt ->m Type ->m Type forallT :: forall (m :: * -> *).
Quote m =>
[TyVarBndr Specificity] -> m Cxt -> m Type -> m Type
forallT [TyVarBndr Specificity]
tvars m Cxt
ctxt m Type
ty =doCxt
ctxt1 <-m Cxt
ctxt Type
ty1 <-m Type
ty Type -> m Type
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Type -> m Type) -> Type -> m Type
forall a b. (a -> b) -> a -> b
$ [TyVarBndr Specificity] -> Cxt -> Type -> Type
ForallT [TyVarBndr Specificity]
tvars Cxt
ctxt1 Type
ty1 sigT ::Quote m =>m Type ->Kind ->m Type sigT :: forall (m :: * -> *). Quote m => m Type -> Type -> m Type
sigT m Type
t Type
k =doType
t' <-m Type
t Type -> m Type
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Type -> m Type) -> Type -> m Type
forall a b. (a -> b) -> a -> b
$ Type -> Type -> Type
SigT Type
t' Type
k --------------------------------------------------------------------------------- * KindplainTV ::Name ->TyVarBndr ()plainTV :: Name -> TyVarBndr ()
plainTV Name
n =Name -> () -> TyVarBndr ()
forall flag. Name -> flag -> TyVarBndr flag
PlainTV Name
n ()kindedTV ::Name ->Kind ->TyVarBndr ()kindedTV :: Name -> Type -> TyVarBndr ()
kindedTV Name
n Type
k =Name -> () -> Type -> TyVarBndr ()
forall flag. Name -> flag -> Type -> TyVarBndr flag
KindedTV Name
n ()Type
k starK ::Kind starK :: Type
starK =Type
StarT constraintK ::Kind constraintK :: Type
constraintK =Type
ConstraintT --------------------------------------------------------------------------------- * Type family resultnoSig ::FamilyResultSig noSig :: FamilyResultSig
noSig =FamilyResultSig
NoSig kindSig ::Kind ->FamilyResultSig kindSig :: Type -> FamilyResultSig
kindSig =Type -> FamilyResultSig
KindSig tyVarSig ::TyVarBndr ()->FamilyResultSig tyVarSig :: TyVarBndr () -> FamilyResultSig
tyVarSig =TyVarBndr () -> FamilyResultSig
TyVarSig --------------------------------------------------------------------------------- * Top Level DeclarationsderivClause ::Quote m =>Maybe DerivStrategy ->[m Pred ]->m DerivClause derivClause :: forall (m :: * -> *).
Quote m =>
Maybe DerivStrategy -> [m Type] -> m DerivClause
derivClause Maybe DerivStrategy
mds [m Type]
p =doCxt
p' <-[m Type] -> m Cxt
forall (m :: * -> *). Quote m => [m Type] -> m Cxt
cxt [m Type]
p DerivClause -> m DerivClause
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (DerivClause -> m DerivClause) -> DerivClause -> m DerivClause
forall a b. (a -> b) -> a -> b
$ Maybe DerivStrategy -> Cxt -> DerivClause
DerivClause Maybe DerivStrategy
mds Cxt
p' standaloneDerivWithStrategyD ::Quote m =>Maybe DerivStrategy ->m Cxt ->m Type ->m Dec standaloneDerivWithStrategyD :: forall (m :: * -> *).
Quote m =>
Maybe DerivStrategy -> m Cxt -> m Type -> m Dec
standaloneDerivWithStrategyD Maybe DerivStrategy
mds m Cxt
ctxt m Type
ty =doCxt
ctxt' <-m Cxt
ctxt Type
ty' <-m Type
ty Dec -> m Dec
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (Dec -> m Dec) -> Dec -> m Dec
forall a b. (a -> b) -> a -> b
$ Maybe DerivStrategy -> Cxt -> Type -> Dec
StandaloneDerivD Maybe DerivStrategy
mds Cxt
ctxt' Type
ty' --------------------------------------------------------------------------------- * Bytes literals-- | Create a Bytes datatype representing raw bytes to be embedded into the-- program/library binary.---- @since 2.16.0.0mkBytes ::ForeignPtr Word8 -- ^ Pointer to the data->Word -- ^ Offset from the pointer->Word -- ^ Number of bytes->Bytes mkBytes :: ForeignPtr Word8 -> Word -> Word -> Bytes
mkBytes =ForeignPtr Word8 -> Word -> Word -> Bytes
Bytes --------------------------------------------------------------------------------- * Tuple expressionstupE ::Quote m =>[m Exp ]->m Exp tupE :: forall (m :: * -> *). Quote m => [m Exp] -> m Exp
tupE [m Exp]
es =do{[Exp]
es1 <-[m Exp] -> m [Exp]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
sequenceA [m Exp]
es ;Exp -> m Exp
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Maybe Exp] -> Exp
TupE ([Maybe Exp] -> Exp) -> [Maybe Exp] -> Exp
forall a b. (a -> b) -> a -> b
$ (Exp -> Maybe Exp) -> [Exp] -> [Maybe Exp]
forall a b. (a -> b) -> [a] -> [b]
map Exp -> Maybe Exp
forall a. a -> Maybe a
Just [Exp]
es1 )}unboxedTupE ::Quote m =>[m Exp ]->m Exp unboxedTupE :: forall (m :: * -> *). Quote m => [m Exp] -> m Exp
unboxedTupE [m Exp]
es =do{[Exp]
es1 <-[m Exp] -> m [Exp]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => [f a] -> f [a]
sequenceA [m Exp]
es ;Exp -> m Exp
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Maybe Exp] -> Exp
UnboxedTupE ([Maybe Exp] -> Exp) -> [Maybe Exp] -> Exp
forall a b. (a -> b) -> a -> b
$ (Exp -> Maybe Exp) -> [Exp] -> [Maybe Exp]
forall a b. (a -> b) -> [a] -> [b]
map Exp -> Maybe Exp
forall a. a -> Maybe a
Just [Exp]
es1 )}--------------------------------------------------------------------------------- * Do expressionsdoE ::Quote m =>[m Stmt ]->m Exp doE :: forall (m :: * -> *). Quote m => [m Stmt] -> m Exp
doE =Maybe ModName -> [m Stmt] -> m Exp
forall (m :: * -> *). Quote m => Maybe ModName -> [m Stmt] -> m Exp
Internal.doE Maybe ModName
forall a. Maybe a
Nothing mdoE ::Quote m =>[m Stmt ]->m Exp mdoE :: forall (m :: * -> *). Quote m => [m Stmt] -> m Exp
mdoE =Maybe ModName -> [m Stmt] -> m Exp
forall (m :: * -> *). Quote m => Maybe ModName -> [m Stmt] -> m Exp
Internal.mdoE Maybe ModName
forall a. Maybe a
Nothing --------------------------------------------------------------------------------- * PatternsconP ::Quote m =>Name ->[m Pat ]->m Pat conP :: forall (m :: * -> *). Quote m => Name -> [m Pat] -> m Pat
conP Name
n [m Pat]
xs =Name -> [m Type] -> [m Pat] -> m Pat
forall (m :: * -> *).
Quote m =>
Name -> [m Type] -> [m Pat] -> m Pat
Internal.conP Name
n [][m Pat]
xs