Returns all the binding names of the decl. The first one is guaranteed to be the name of the decl. The first component represents all binding names except record fields; the second represents field occurrences. For record fields mentioned in multiple constructors, the SrcLoc will be from the first occurrence.

Each returned (Located name) has a SrcSpan for the whole declaration. See Note [SrcSpan for binders]

hsTyClForeignBinders :: [TyClGroup GhcRn] -> [LForeignDecl GhcRn] -> [Name] #

hsGroupBinders :: HsGroup GhcRn -> [Name] #

collectPatsBinders :: forall (p :: Pass). [LPat (GhcPass p)] -> [IdP (GhcPass p)] #

collectPatBinders :: forall (p :: Pass). LPat (GhcPass p) -> [IdP (GhcPass p)] #

collectStmtBinders :: forall (idL :: Pass) (idR :: Pass) body. StmtLR (GhcPass idL) (GhcPass idR) body -> [IdP (GhcPass idL)] #

collectLStmtBinders :: forall (idL :: Pass) (idR :: Pass) body. LStmtLR (GhcPass idL) (GhcPass idR) body -> [IdP (GhcPass idL)] #

collectStmtsBinders :: forall (idL :: Pass) (idR :: Pass) body. [StmtLR (GhcPass idL) (GhcPass idR) body] -> [IdP (GhcPass idL)] #

collectLStmtsBinders :: forall (idL :: Pass) (idR :: Pass) body. [LStmtLR (GhcPass idL) (GhcPass idR) body] -> [IdP (GhcPass idL)] #

collectMethodBinders :: LHsBindsLR idL idR -> [Located (IdP idL)] #

Used exclusively for the bindings of an instance decl which are all FunBinds

collectHsBindListBinders :: forall (p :: Pass) idR. [LHsBindLR (GhcPass p) idR] -> [IdP (GhcPass p)] #

Same as collectHsBindsBinders, but works over a list of bindings

collectHsBindsBinders :: forall (p :: Pass) idR. LHsBindsLR (GhcPass p) idR -> [IdP (GhcPass p)] #

collectHsBindBinders :: (SrcSpanLess (LPat p) ~ Pat p, HasSrcSpan (LPat p)) => HsBindLR p idR -> [IdP p] #

Collect both Ids and pattern-synonym binders

collectHsValBinders :: forall (idL :: Pass) (idR :: Pass). HsValBindsLR (GhcPass idL) (GhcPass idR) -> [IdP (GhcPass idL)] #

Collect Id binders only, or Ids + pattern synonyms, respectively

collectHsIdBinders :: forall (idL :: Pass) (idR :: Pass). HsValBindsLR (GhcPass idL) (GhcPass idR) -> [IdP (GhcPass idL)] #

Collect Id binders only, or Ids + pattern synonyms, respectively

collectLocalBinders :: forall (idL :: Pass) (idR :: Pass). HsLocalBindsLR (GhcPass idL) (GhcPass idR) -> [IdP (GhcPass idL)] #

isBangedHsBind :: HsBind GhcTc -> Bool #

Is a binding a strict variable or pattern bind (e.g. !x = ...)?

isUnliftedHsBind :: HsBind GhcTc -> Bool #

Should we treat this as an unlifted bind? This will be true for any bind that binds an unlifted variable, but we must be careful around AbsBinds. See Note [Unlifted id check in isUnliftedHsBind]. For usage information, see Note [Strict binds check] is DsBinds.

mkMatch :: forall (p :: Pass). HsMatchContext (NameOrRdrName (IdP (GhcPass p))) -> [LPat (GhcPass p)] -> LHsExpr (GhcPass p) -> Located (HsLocalBinds (GhcPass p)) -> LMatch (GhcPass p) (LHsExpr (GhcPass p)) #

mkPrefixFunRhs :: Located id -> HsMatchContext id #

Make a prefix, non-strict function HsMatchContext

mkSimpleGeneratedFunBind :: SrcSpan -> RdrName -> [LPat GhcPs] -> LHsExpr GhcPs -> LHsBind GhcPs #

Convenience function using mkFunBind. This is for generated bindings only, do not use for user-written code.

isInfixFunBind :: HsBindLR id1 id2 -> Bool #

If any of the matches in the FunBind are infix, the FunBind is considered infix.

mkPatSynBind :: Located RdrName -> HsPatSynDetails (Located RdrName) -> LPat GhcPs -> HsPatSynDir GhcPs -> HsBind GhcPs #

mkVarBind :: forall (p :: Pass). IdP (GhcPass p) -> LHsExpr (GhcPass p) -> LHsBind (GhcPass p) #

mkHsVarBind :: SrcSpan -> RdrName -> LHsExpr GhcPs -> LHsBind GhcPs #

mkTopFunBind :: Origin -> Located Name -> [LMatch GhcRn (LHsExpr GhcRn)] -> HsBind GhcRn #

In Name-land, with empty bind_fvs

mkFunBind :: Origin -> Located RdrName -> [LMatch GhcPs (LHsExpr GhcPs)] -> HsBind GhcPs #

Not infix, with place holders for coercion and free vars

mkHsDictLet :: TcEvBinds -> LHsExpr GhcTc -> LHsExpr GhcTc #

mkHsWrapPatCo :: forall (id :: Pass). TcCoercionN -> Pat (GhcPass id) -> Type -> Pat (GhcPass id) #

mkHsWrapPat :: forall (id :: Pass). HsWrapper -> Pat (GhcPass id) -> Type -> Pat (GhcPass id) #

mkLHsCmdWrap :: forall (p :: Pass). HsWrapper -> LHsCmd (GhcPass p) -> LHsCmd (GhcPass p) #

mkHsCmdWrap :: forall (p :: Pass). HsWrapper -> HsCmd (GhcPass p) -> HsCmd (GhcPass p) #

mkLHsWrapCo :: forall (id :: Pass). TcCoercionN -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #

mkHsWrapCoR :: forall (id :: Pass). TcCoercionR -> HsExpr (GhcPass id) -> HsExpr (GhcPass id) #

mkHsWrapCo :: forall (id :: Pass). TcCoercionN -> HsExpr (GhcPass id) -> HsExpr (GhcPass id) #

mkHsWrap :: forall (id :: Pass). HsWrapper -> HsExpr (GhcPass id) -> HsExpr (GhcPass id) #

Avoid (HsWrap co (HsWrap co' _)). See Note [Detecting forced eta expansion] in DsExpr

mkLHsWrap :: forall (id :: Pass). HsWrapper -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #

typeToLHsType :: Type -> LHsType GhcPs #

Converting a Type to an HsType RdrName This is needed to implement GeneralizedNewtypeDeriving.

Note that we use getRdrName extensively, which generates Exact RdrNames rather than strings.

mkClassOpSigs :: [LSig GhcPs] -> [LSig GhcPs] #

Convert TypeSig to ClassOpSig The former is what is parsed, but the latter is what we need in class/instance declarations

mkHsSigEnv :: (LSig GhcRn -> Maybe ([Located Name], a)) -> [LSig GhcRn] -> NameEnv a #

mkLHsSigWcType :: LHsType GhcPs -> LHsSigWcType GhcPs #

mkLHsSigType :: LHsType GhcPs -> LHsSigType GhcPs #

chunkify :: [a] -> [[a]] #

Split a list into lists that are small enough to have a corresponding tuple arity. The sub-lists of the result all have length <= mAX_TUPLE_SIZE But there may be more than mAX_TUPLE_SIZE sub-lists

mkChunkified #

Arguments

:: ([a] -> a)	"Small" constructor function, of maximum input arity `mAX_TUPLE_SIZE`
-> [a]	Possible "big" list of things to construct from
-> a	Constructed thing made possible by recursive decomposition

Lifts a "small" constructor into a "big" constructor by recursive decompositon

mkBigLHsPatTup :: [LPat GhcRn] -> LPat GhcRn #

mkBigLHsVarPatTup :: [IdP GhcRn] -> LPat GhcRn #

The Big equivalents for the source tuple patterns

mkBigLHsTup :: forall (id :: Pass). [LHsExpr (GhcPass id)] -> LHsExpr (GhcPass id) #

mkBigLHsVarTup :: forall (id :: Pass). [IdP (GhcPass id)] -> LHsExpr (GhcPass id) #

The Big equivalents for the source tuple expressions

missingTupArg :: HsTupArg GhcPs #

nlTuplePat :: [LPat GhcPs] -> Boxity -> LPat GhcPs #

mkLHsVarTuple :: forall (a :: Pass). [IdP (GhcPass a)] -> LHsExpr (GhcPass a) #

mkLHsTupleExpr :: forall (a :: Pass). [LHsExpr (GhcPass a)] -> LHsExpr (GhcPass a) #

nlHsAppKindTy :: forall (p :: Pass). LHsType (GhcPass p) -> LHsKind (GhcPass p) -> LHsType (GhcPass p) #

nlHsTyConApp :: forall (p :: Pass). IdP (GhcPass p) -> [LHsType (GhcPass p)] -> LHsType (GhcPass p) #

nlHsParTy :: forall (p :: Pass). LHsType (GhcPass p) -> LHsType (GhcPass p) #

nlHsFunTy :: forall (p :: Pass). LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) #

nlHsTyVar :: forall (p :: Pass). IdP (GhcPass p) -> LHsType (GhcPass p) #

nlHsAppTy :: forall (p :: Pass). LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) #

nlList :: [LHsExpr GhcPs] -> LHsExpr GhcPs #

nlHsCase :: LHsExpr GhcPs -> [LMatch GhcPs (LHsExpr GhcPs)] -> LHsExpr GhcPs #

nlHsIf :: forall (id :: Pass). LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #

Note [Rebindable nlHsIf] nlHsIf should generate if-expressions which are NOT subject to RebindableSyntax, so the first field of HsIf is Nothing. (#12080)

nlHsPar :: forall (id :: Pass). LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #

nlHsLam :: LMatch GhcPs (LHsExpr GhcPs) -> LHsExpr GhcPs #

nlHsOpApp :: LHsExpr GhcPs -> IdP GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs #

nlHsDo :: HsStmtContext Name -> [LStmt GhcPs (LHsExpr GhcPs)] -> LHsExpr GhcPs #

nlWildPatName :: LPat GhcRn #

Wildcard pattern - after renaming

nlWildPat :: LPat GhcPs #

Wildcard pattern - after parsing

nlWildConPat :: DataCon -> LPat GhcPs #

nlNullaryConPat :: forall (p :: Pass). IdP (GhcPass p) -> LPat (GhcPass p) #

nlConPatName :: Name -> [LPat GhcRn] -> LPat GhcRn #

nlConPat :: RdrName -> [LPat GhcPs] -> LPat GhcPs #

nlInfixConPat :: RdrName -> LPat GhcPs -> LPat GhcPs -> LPat GhcPs #

nlConVarPatName :: Name -> [Name] -> LPat GhcRn #

nlConVarPat :: RdrName -> [RdrName] -> LPat GhcPs #

nlHsVarApps :: forall (id :: Pass). IdP (GhcPass id) -> [IdP (GhcPass id)] -> LHsExpr (GhcPass id) #

nlHsApps :: forall (id :: Pass). IdP (GhcPass id) -> [LHsExpr (GhcPass id)] -> LHsExpr (GhcPass id) #

nlHsSyntaxApps :: forall (id :: Pass). SyntaxExpr (GhcPass id) -> [LHsExpr (GhcPass id)] -> LHsExpr (GhcPass id) #

nlHsApp :: forall (id :: Pass). LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #

nlLitPat :: HsLit GhcPs -> LPat GhcPs #

nlVarPat :: forall (id :: Pass). IdP (GhcPass id) -> LPat (GhcPass id) #

nlHsIntLit :: forall (p :: Pass). Integer -> LHsExpr (GhcPass p) #

nlHsLit :: forall (p :: Pass). HsLit (GhcPass p) -> LHsExpr (GhcPass p) #

nlHsDataCon :: DataCon -> LHsExpr GhcTc #

NB: Only for LHsExpr **Id**

nlHsVar :: forall (id :: Pass). IdP (GhcPass id) -> LHsExpr (GhcPass id) #

mkHsStringPrimLit :: forall (p :: Pass). FastString -> HsLit (GhcPass p) #

mkHsString :: forall (p :: Pass). String -> HsLit (GhcPass p) #

unqualQuasiQuote :: RdrName #

mkHsQuasiQuote :: RdrName -> SrcSpan -> FastString -> HsSplice GhcPs #

mkTypedSplice :: SpliceDecoration -> LHsExpr GhcPs -> HsSplice GhcPs #

mkUntypedSplice :: SpliceDecoration -> LHsExpr GhcPs -> HsSplice GhcPs #

mkHsOpApp :: LHsExpr GhcPs -> IdP GhcPs -> LHsExpr GhcPs -> HsExpr GhcPs #

A useful function for building OpApps. The operator is always a variable, and we don't know the fixity yet.

mkRecStmt :: forall (idL :: Pass) bodyR. [LStmtLR (GhcPass idL) GhcPs bodyR] -> StmtLR (GhcPass idL) GhcPs bodyR #

emptyRecStmtId :: StmtLR GhcTc GhcTc bodyR #

emptyRecStmtName :: StmtLR GhcRn GhcRn bodyR #

emptyRecStmt :: forall (idL :: Pass) bodyR. StmtLR (GhcPass idL) GhcPs bodyR #

unitRecStmtTc :: RecStmtTc #

mkTcBindStmt :: LPat GhcTc -> Located (bodyR GhcTc) -> StmtLR GhcTc GhcTc (Located (bodyR GhcTc)) #

mkBindStmt :: forall (idL :: Pass) (idR :: Pass) bodyR. XBindStmt (GhcPass idL) (GhcPass idR) (Located (bodyR (GhcPass idR))) ~ NoExtField => LPat (GhcPass idL) -> Located (bodyR (GhcPass idR)) -> StmtLR (GhcPass idL) (GhcPass idR) (Located (bodyR (GhcPass idR))) #

mkBodyStmt :: forall bodyR (idL :: Pass). Located (bodyR GhcPs) -> StmtLR (GhcPass idL) GhcPs (Located (bodyR GhcPs)) #

mkLastStmt :: forall bodyR (idR :: Pass) (idL :: Pass). Located (bodyR (GhcPass idR)) -> StmtLR (GhcPass idL) (GhcPass idR) (Located (bodyR (GhcPass idR))) #

mkGroupByUsingStmt :: [ExprLStmt GhcPs] -> LHsExpr GhcPs -> LHsExpr GhcPs -> StmtLR GhcPs GhcPs (LHsExpr GhcPs) #

mkGroupUsingStmt :: [ExprLStmt GhcPs] -> LHsExpr GhcPs -> StmtLR GhcPs GhcPs (LHsExpr GhcPs) #

mkTransformByStmt :: [ExprLStmt GhcPs] -> LHsExpr GhcPs -> LHsExpr GhcPs -> StmtLR GhcPs GhcPs (LHsExpr GhcPs) #

mkTransformStmt :: [ExprLStmt GhcPs] -> LHsExpr GhcPs -> StmtLR GhcPs GhcPs (LHsExpr GhcPs) #

emptyTransStmt :: StmtLR GhcPs GhcPs (LHsExpr GhcPs) #

mkNPlusKPat :: Located RdrName -> Located (HsOverLit GhcPs) -> Pat GhcPs #

mkNPat :: Located (HsOverLit GhcPs) -> Maybe (SyntaxExpr GhcPs) -> Pat GhcPs #

mkHsCmdIf :: forall (p :: Pass). LHsExpr (GhcPass p) -> LHsCmd (GhcPass p) -> LHsCmd (GhcPass p) -> HsCmd (GhcPass p) #

mkHsIf :: forall (p :: Pass). LHsExpr (GhcPass p) -> LHsExpr (GhcPass p) -> LHsExpr (GhcPass p) -> HsExpr (GhcPass p) #

mkHsComp :: HsStmtContext Name -> [ExprLStmt GhcPs] -> LHsExpr GhcPs -> HsExpr GhcPs #

mkHsDo :: HsStmtContext Name -> [ExprLStmt GhcPs] -> HsExpr GhcPs #

mkHsIsString :: SourceText -> FastString -> HsOverLit GhcPs #

mkHsFractional :: FractionalLit -> HsOverLit GhcPs #

mkHsIntegral :: IntegralLit -> HsOverLit GhcPs #

nlParPat :: forall (name :: Pass). LPat (GhcPass name) -> LPat (GhcPass name) #

mkParPat :: forall (name :: Pass). LPat (GhcPass name) -> LPat (GhcPass name) #

mkLHsPar :: forall (id :: Pass). LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #

Wrap in parens if (hsExprNeedsParens appPrec) says it needs them So 'f x' becomes '(f x)', but '3' stays as '3'

nlHsTyApps :: forall (id :: Pass). IdP (GhcPass id) -> [Type] -> [LHsExpr (GhcPass id)] -> LHsExpr (GhcPass id) #

nlHsTyApp :: forall (id :: Pass). IdP (GhcPass id) -> [Type] -> LHsExpr (GhcPass id) #

mkHsCaseAlt :: forall (p :: Pass) body. LPat (GhcPass p) -> Located (body (GhcPass p)) -> LMatch (GhcPass p) (Located (body (GhcPass p))) #

A simple case alternative with a single pattern, no binds, no guards; pre-typechecking

mkHsLams :: [TyVar] -> [EvVar] -> LHsExpr GhcTc -> LHsExpr GhcTc #

mkHsLam :: forall (p :: Pass). XMG (GhcPass p) (LHsExpr (GhcPass p)) ~ NoExtField => [LPat (GhcPass p)] -> LHsExpr (GhcPass p) -> LHsExpr (GhcPass p) #

mkHsAppTypes :: LHsExpr GhcRn -> [LHsWcType GhcRn] -> LHsExpr GhcRn #

mkHsAppType :: forall (id :: Pass). NoGhcTc (GhcPass id) ~ GhcRn => LHsExpr (GhcPass id) -> LHsWcType GhcRn -> LHsExpr (GhcPass id) #

mkHsApp :: forall (id :: Pass). LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #

mkMatchGroup :: XMG name (Located (body name)) ~ NoExtField => Origin -> [LMatch name (Located (body name))] -> MatchGroup name (Located (body name)) #

unguardedRHS :: forall body (p :: Pass). SrcSpan -> Located (body (GhcPass p)) -> [LGRHS (GhcPass p) (Located (body (GhcPass p)))] #

unguardedGRHSs :: forall body (p :: Pass). Located (body (GhcPass p)) -> GRHSs (GhcPass p) (Located (body (GhcPass p))) #

mkSimpleMatch :: forall (p :: Pass) body. HsMatchContext (NameOrRdrName (IdP (GhcPass p))) -> [LPat (GhcPass p)] -> Located (body (GhcPass p)) -> LMatch (GhcPass p) (Located (body (GhcPass p))) #

mkHsPar :: forall (id :: Pass). LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #

e => (e)

pprStmtInCtxt :: forall (idL :: Pass) (idR :: Pass) body. (OutputableBndrId idL, OutputableBndrId idR, Outputable body) => HsStmtContext (IdP (GhcPass idL)) -> StmtLR (GhcPass idL) (GhcPass idR) body -> SDoc #

pprMatchInCtxt :: forall (idR :: Pass) body. (OutputableBndrId idR, Outputable (NameOrRdrName (NameOrRdrName (IdP (GhcPass idR)))), Outputable body) => Match (GhcPass idR) body -> SDoc #

matchContextErrString :: Outputable id => HsMatchContext id -> SDoc #

pprStmtContext :: (Outputable id, Outputable (NameOrRdrName id)) => HsStmtContext id -> SDoc #

pprAStmtContext :: (Outputable id, Outputable (NameOrRdrName id)) => HsStmtContext id -> SDoc #

pprMatchContextNoun :: (Outputable (NameOrRdrName id), Outputable id) => HsMatchContext id -> SDoc #

pprMatchContext :: (Outputable (NameOrRdrName id), Outputable id) => HsMatchContext id -> SDoc #

matchSeparator :: HsMatchContext id -> SDoc #

isMonadCompContext :: HsStmtContext id -> Bool #

isMonadFailStmtContext :: HsStmtContext id -> Bool #

Should pattern match failure in a HsStmtContext be desugared using MonadFail?

isComprehensionContext :: HsStmtContext id -> Bool #

isPatSynCtxt :: HsMatchContext id -> Bool #

pp_dotdot :: SDoc #

thTyBrackets :: SDoc -> SDoc #

thBrackets :: SDoc -> SDoc -> SDoc #

pprHsBracket :: forall (p :: Pass). OutputableBndrId p => HsBracket (GhcPass p) -> SDoc #

isTypedBracket :: HsBracket id -> Bool #

ppr_splice :: forall (p :: Pass). OutputableBndrId p => SDoc -> IdP (GhcPass p) -> LHsExpr (GhcPass p) -> SDoc -> SDoc #

ppr_quasi :: OutputableBndr p => p -> p -> FastString -> SDoc #

ppr_splice_decl :: forall (p :: Pass). OutputableBndrId p => HsSplice (GhcPass p) -> SDoc #

pprPendingSplice :: forall (p :: Pass). OutputableBndrId p => SplicePointName -> LHsExpr (GhcPass p) -> SDoc #

isTypedSplice :: HsSplice id -> Bool #

pprQuals :: forall (p :: Pass) body. (OutputableBndrId p, Outputable body) => [LStmt (GhcPass p) body] -> SDoc #

pprComp :: forall (p :: Pass) body. (OutputableBndrId p, Outputable body) => [LStmt (GhcPass p) body] -> SDoc #

ppr_do_stmts :: forall (idL :: Pass) (idR :: Pass) body. (OutputableBndrId idL, OutputableBndrId idR, Outputable body) => [LStmtLR (GhcPass idL) (GhcPass idR) body] -> SDoc #

pprDo :: forall (p :: Pass) body any. (OutputableBndrId p, Outputable body) => HsStmtContext any -> [LStmt (GhcPass p) body] -> SDoc #

pprBy :: Outputable body => Maybe body -> SDoc #

pprTransStmt :: Outputable body => Maybe body -> body -> TransForm -> SDoc #

pprTransformStmt :: forall (p :: Pass). OutputableBndrId p => [IdP (GhcPass p)] -> LHsExpr (GhcPass p) -> Maybe (LHsExpr (GhcPass p)) -> SDoc #

pprArg :: forall (idL :: Pass). OutputableBndrId idL => ApplicativeArg (GhcPass idL) -> SDoc #

pprStmt :: forall (idL :: Pass) (idR :: Pass) body. (OutputableBndrId idL, OutputableBndrId idR, Outputable body) => StmtLR (GhcPass idL) (GhcPass idR) body -> SDoc #

pp_rhs :: Outputable body => HsMatchContext idL -> body -> SDoc #

pprGRHS :: forall (idR :: Pass) body idL. (OutputableBndrId idR, Outputable body) => HsMatchContext idL -> GRHS (GhcPass idR) body -> SDoc #

pprGRHSs :: forall (idR :: Pass) body idL. (OutputableBndrId idR, Outputable body) => HsMatchContext idL -> GRHSs (GhcPass idR) body -> SDoc #

pprMatch :: forall (idR :: Pass) body. (OutputableBndrId idR, Outputable body) => Match (GhcPass idR) body -> SDoc #

pprMatches :: forall (idR :: Pass) body. (OutputableBndrId idR, Outputable body) => MatchGroup (GhcPass idR) body -> SDoc #

hsLMatchPats :: forall (id :: Pass) body. LMatch (GhcPass id) body -> [LPat (GhcPass id)] #

matchGroupArity :: forall (id :: Pass) body. MatchGroup (GhcPass id) body -> Arity #

isSingletonMatchGroup :: [LMatch id body] -> Bool #

Is there only one RHS in this list of matches?

isEmptyMatchGroup :: MatchGroup id body -> Bool #

isInfixMatch :: Match id body -> Bool #

pprCmdArg :: forall (p :: Pass). OutputableBndrId p => HsCmdTop (GhcPass p) -> SDoc #

ppr_cmd :: forall (p :: Pass). OutputableBndrId p => HsCmd (GhcPass p) -> SDoc #

ppr_lcmd :: forall (p :: Pass). OutputableBndrId p => LHsCmd (GhcPass p) -> SDoc #

isQuietHsCmd :: HsCmd id -> Bool #

pprCmd :: forall (p :: Pass). OutputableBndrId p => HsCmd (GhcPass p) -> SDoc #

pprLCmd :: forall (p :: Pass). OutputableBndrId p => LHsCmd (GhcPass p) -> SDoc #

isAtomicHsExpr :: HsExpr id -> Bool #

parenthesizeHsExpr :: forall (p :: Pass). PprPrec -> LHsExpr (GhcPass p) -> LHsExpr (GhcPass p) #

parenthesizeHsExpr p e checks if hsExprNeedsParens p e is true, and if so, surrounds e with an HsPar. Otherwise, it simply returns e.

hsExprNeedsParens :: PprPrec -> HsExpr p -> Bool #

hsExprNeedsParens p e returns True if the expression e needs parentheses under precedence p.

pprParendExpr :: forall (p :: Pass). OutputableBndrId p => PprPrec -> HsExpr (GhcPass p) -> SDoc #

pprParendLExpr :: forall (p :: Pass). OutputableBndrId p => PprPrec -> LHsExpr (GhcPass p) -> SDoc #

pprDebugParendExpr :: forall (p :: Pass). OutputableBndrId p => PprPrec -> LHsExpr (GhcPass p) -> SDoc #

pprExternalSrcLoc :: (StringLiteral, (Int, Int), (Int, Int)) -> SDoc #

ppr_apps :: forall (p :: Pass). OutputableBndrId p => HsExpr (GhcPass p) -> [Either (LHsExpr (GhcPass p)) (LHsWcType (NoGhcTc (GhcPass p)))] -> SDoc #

ppr_infix_expr :: forall (p :: Pass). OutputableBndrId p => HsExpr (GhcPass p) -> Maybe SDoc #

ppr_expr :: forall (p :: Pass). OutputableBndrId p => HsExpr (GhcPass p) -> SDoc #

ppr_lexpr :: forall (p :: Pass). OutputableBndrId p => LHsExpr (GhcPass p) -> SDoc #

pprBinds :: forall (idL :: Pass) (idR :: Pass). (OutputableBndrId idL, OutputableBndrId idR) => HsLocalBindsLR (GhcPass idL) (GhcPass idR) -> SDoc #

isQuietHsExpr :: HsExpr id -> Bool #

tupArgPresent :: LHsTupArg id -> Bool #

unboundVarOcc :: UnboundVar -> OccName #

mkRnSyntaxExpr :: Name -> SyntaxExpr GhcRn #

Make a 'SyntaxExpr Name' (the "rn" is because this is used in the renamer), missing its HsWrappers.

mkSyntaxExpr :: forall (p :: Pass). HsExpr (GhcPass p) -> SyntaxExpr (GhcPass p) #

Make a 'SyntaxExpr (HsExpr _)', missing its HsWrappers.

noSyntaxExpr :: forall (p :: Pass). SyntaxExpr (GhcPass p) #

noExpr :: forall (p :: Pass). HsExpr (GhcPass p) #

This is used for rebindable-syntax pieces that are too polymorphic for tcSyntaxOp (trS_fmap and the mzip in ParStmt)

type PostTcExpr = HsExpr GhcTc #

Post-Type checking Expression

PostTcExpr is an evidence expression attached to the syntax tree by the type checker (c.f. postTcType).

type PostTcTable = [(Name, PostTcExpr)] #

Post-Type checking Table

We use a PostTcTable where there are a bunch of pieces of evidence, more than is convenient to keep individually.

type CmdSyntaxTable p = [(Name, HsExpr p)] #

Command Syntax Table (for Arrow syntax)

data UnboundVar #

An unbound variable; used for treating out-of-scope variables as expression holes

Either "x", "y" Plain OutOfScope or "_", "_x" A TrueExprHole

Both forms indicate an out-of-scope variable, but the latter indicates that the user expects it to be out of scope, and just wants GHC to report its type

Constructors

OutOfScope OccName GlobalRdrEnv	An (unqualified) out-of-scope variable, together with the GlobalRdrEnv with respect to which it is unbound
TrueExprHole OccName	A "true" expression hole (_ or _x)

Instances

Instances details

Data UnboundVar
Instance details Defined in GHC.Hs.Expr Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UnboundVar -> c UnboundVar # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UnboundVar # toConstr :: UnboundVar -> Constr # dataTypeOf :: UnboundVar -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UnboundVar) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnboundVar) # gmapT :: (forall b. Data b => b -> b) -> UnboundVar -> UnboundVar # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UnboundVar -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UnboundVar -> r # gmapQ :: (forall d. Data d => d -> u) -> UnboundVar -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> UnboundVar -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> UnboundVar -> m UnboundVar # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UnboundVar -> m UnboundVar # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UnboundVar -> m UnboundVar #
Outputable UnboundVar
Instance details Defined in GHC.Hs.Expr Methods ppr :: UnboundVar -> SDoc # pprPrec :: Rational -> UnboundVar -> SDoc #

data RecordConTc #

Extra data fields for a RecordCon, added by the type checker

Constructors

RecordConTc
Fields rcon_con_like :: ConLike rcon_con_expr :: PostTcExpr

data RecordUpdTc #

Extra data fields for a RecordUpd, added by the type checker

Constructors

RecordUpdTc
Fields rupd_cons :: [ConLike] rupd_in_tys :: [Type] rupd_out_tys :: [Type] rupd_wrap :: HsWrapper

Instances

Instances details

Data RecordUpdTc

Instance details

Defined in GHC.Hs.Expr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RecordUpdTc -> c RecordUpdTc #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RecordUpdTc #

toConstr :: RecordUpdTc -> Constr #

dataTypeOf :: RecordUpdTc -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RecordUpdTc) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RecordUpdTc) #

gmapT :: (forall b. Data b => b -> b) -> RecordUpdTc -> RecordUpdTc #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RecordUpdTc -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RecordUpdTc -> r #

gmapQ :: (forall d. Data d => d -> u) -> RecordUpdTc -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> RecordUpdTc -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RecordUpdTc -> m RecordUpdTc #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RecordUpdTc -> m RecordUpdTc #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RecordUpdTc -> m RecordUpdTc #

type LHsTupArg id = Located (HsTupArg id) #

Located Haskell Tuple Argument

HsTupArg is used for tuple sections (,a,) is represented by ExplicitTuple [Missing ty1, Present a, Missing ty3] Which in turn stands for (x:ty1 y:ty2. (x,a,y))

data HsTupArg id #

AnnKeywordId : AnnComma

Haskell Tuple Argument

Constructors

Present (XPresent id) (LHsExpr id)	The argument
Missing (XMissing id)	The argument is missing, but this is its type
XTupArg (XXTupArg id)	Note [Trees that Grow] extension point

Instances

Instances details

Annotate (HsTupArg GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsTupArg GhcPs -> Annotated () #

type LHsCmd id = Located (HsCmd id) #

Located Haskell Command (for arrow syntax)

data HsArrAppType #

Haskell Array Application Type

Constructors

HsHigherOrderApp
HsFirstOrderApp

Instances

Instances details

Data HsArrAppType

Instance details

Defined in GHC.Hs.Expr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsArrAppType -> c HsArrAppType #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsArrAppType #

toConstr :: HsArrAppType -> Constr #

dataTypeOf :: HsArrAppType -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsArrAppType) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsArrAppType) #

gmapT :: (forall b. Data b => b -> b) -> HsArrAppType -> HsArrAppType #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsArrAppType -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsArrAppType -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsArrAppType -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsArrAppType -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsArrAppType -> m HsArrAppType #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsArrAppType -> m HsArrAppType #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsArrAppType -> m HsArrAppType #

type LHsCmdTop p = Located (HsCmdTop p) #

Top-level command, introducing a new arrow. This may occur inside a proc (where the stack is empty) or as an argument of a command-forming operator.

Located Haskell Top-level Command

data HsCmdTop p #

Haskell Top-level Command

Constructors

HsCmdTop (XCmdTop p) (LHsCmd p)
XCmdTop (XXCmdTop p)

Instances

Instances details

OutputableBndrId p => Outputable (HsCmdTop (GhcPass p))
Instance details Defined in GHC.Hs.Expr Methods ppr :: HsCmdTop (GhcPass p) -> SDoc # pprPrec :: Rational -> HsCmdTop (GhcPass p) -> SDoc #
Annotate (HsCmdTop GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsCmdTop GhcPs -> Annotated () #

data CmdTopTc #

Constructors

CmdTopTc Type Type (CmdSyntaxTable GhcTc)

type HsRecordBinds p = HsRecFields p (LHsExpr p) #

Haskell Record Bindings

data MatchGroupTc #

Constructors

MatchGroupTc
Fields mg_arg_tys :: [Type] mg_res_ty :: Type

Instances

Instances details

Data MatchGroupTc

Instance details

Defined in GHC.Hs.Expr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MatchGroupTc -> c MatchGroupTc #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c MatchGroupTc #

toConstr :: MatchGroupTc -> Constr #

dataTypeOf :: MatchGroupTc -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c MatchGroupTc) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MatchGroupTc) #

gmapT :: (forall b. Data b => b -> b) -> MatchGroupTc -> MatchGroupTc #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MatchGroupTc -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MatchGroupTc -> r #

gmapQ :: (forall d. Data d => d -> u) -> MatchGroupTc -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> MatchGroupTc -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MatchGroupTc -> m MatchGroupTc #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MatchGroupTc -> m MatchGroupTc #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MatchGroupTc -> m MatchGroupTc #

type LMatch id body = Located (Match id body) #

Located Match

May have AnnKeywordId : AnnSemi when in a list

data Match p body #

Constructors

Match
Fields m_ext :: XCMatch p body m_ctxt :: HsMatchContext (NameOrRdrName (IdP p)) m_pats :: [LPat p] m_grhss :: GRHSs p body
XMatch (XXMatch p body)

Instances

Instances details

Annotate body => Annotate [Located (Match GhcPs (Located body))]
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> [Located (Match GhcPs (Located body))] -> Annotated () #
(OutputableBndrId pr, Outputable body) => Outputable (Match (GhcPass pr) body)
Instance details Defined in GHC.Hs.Expr Methods ppr :: Match (GhcPass pr) body -> SDoc # pprPrec :: Rational -> Match (GhcPass pr) body -> SDoc #
Annotate body => Annotate (Match GhcPs (Located body))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> Match GhcPs (Located body) -> Annotated () #
HasDecls (LMatch GhcPs (LHsExpr GhcPs))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Transform Methods hsDecls :: forall (m :: Type -> Type). Monad m => LMatch GhcPs (LHsExpr GhcPs) -> TransformT m [LHsDecl GhcPs] # replaceDecls :: forall (m :: Type -> Type). Monad m => LMatch GhcPs (LHsExpr GhcPs) -> [LHsDecl GhcPs] -> TransformT m (LMatch GhcPs (LHsExpr GhcPs)) #

type LGRHS id body = Located (GRHS id body) #

Located Guarded Right-Hand Side

data GRHS p body #

Guarded Right Hand Side.

Constructors

GRHS (XCGRHS p body) [GuardLStmt p] body
XGRHS (XXGRHS p body)

Instances

Instances details

Annotate body => Annotate (GRHS GhcPs (Located body))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> GRHS GhcPs (Located body) -> Annotated () #

type LStmt id body = Located (StmtLR id id body) #

Located do block Statement

type LStmtLR idL idR body = Located (StmtLR idL idR body) #

Located Statement with separate Left and Right id's

type Stmt id body = StmtLR id id body #

do block Statement

type CmdLStmt id = LStmt id (LHsCmd id) #

Command Located Statement

type CmdStmt id = Stmt id (LHsCmd id) #

Command Statement

type ExprLStmt id = LStmt id (LHsExpr id) #

Expression Located Statement

type ExprStmt id = Stmt id (LHsExpr id) #

Expression Statement

type GuardLStmt id = LStmt id (LHsExpr id) #

Guard Located Statement

type GuardStmt id = Stmt id (LHsExpr id) #

Guard Statement

type GhciLStmt id = LStmt id (LHsExpr id) #

Ghci Located Statement

type GhciStmt id = Stmt id (LHsExpr id) #

Ghci Statement

data StmtLR idL idR body #

API Annotations when in qualifier lists or guards - AnnKeywordId : AnnVbar, AnnComma,AnnThen, AnnBy,AnnBy, AnnGroup,AnnUsing

Constructors

LastStmt (XLastStmt idL idR body) body Bool (SyntaxExpr idR)
BindStmt (XBindStmt idL idR body) (LPat idL) body (SyntaxExpr idR) (SyntaxExpr idR)
ApplicativeStmt (XApplicativeStmt idL idR body) [(SyntaxExpr idR, ApplicativeArg idL)] (Maybe (SyntaxExpr idR))	`ApplicativeStmt` represents an applicative expression built with `<$>` and `<*>`. It is generated by the renamer, and is desugared into the appropriate applicative expression by the desugarer, but it is intended to be invisible in error messages. For full details, see Note [ApplicativeDo] in RnExpr
BodyStmt (XBodyStmt idL idR body) body (SyntaxExpr idR) (SyntaxExpr idR)
LetStmt (XLetStmt idL idR body) (LHsLocalBindsLR idL idR)	`AnnKeywordId` : `AnnLet` `AnnOpen` `'{'`,`AnnClose` `'}'`,
ParStmt (XParStmt idL idR body) [ParStmtBlock idL idR] (HsExpr idR) (SyntaxExpr idR)
TransStmt
Fields trS_ext :: XTransStmt idL idR body trS_form :: TransForm trS_stmts :: [ExprLStmt idL] trS_bndrs :: [(IdP idR, IdP idR)] trS_using :: LHsExpr idR trS_by :: Maybe (LHsExpr idR) trS_ret :: SyntaxExpr idR trS_bind :: SyntaxExpr idR trS_fmap :: HsExpr idR
RecStmt	`AnnKeywordId` : `AnnRec`
Fields recS_ext :: XRecStmt idL idR body recS_stmts :: [LStmtLR idL idR body] recS_later_ids :: [IdP idR] recS_rec_ids :: [IdP idR] recS_bind_fn :: SyntaxExpr idR recS_ret_fn :: SyntaxExpr idR recS_mfix_fn :: SyntaxExpr idR
XStmtLR (XXStmtLR idL idR body)

Instances

Instances details

Annotate [ExprLStmt GhcPs]	Used for declarations that need to be aligned together, e.g. in a do or let .. in statement/expr
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> [ExprLStmt GhcPs] -> Annotated () #
Annotate [Located (StmtLR GhcPs GhcPs (LHsCmd GhcPs))]
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> [Located (StmtLR GhcPs GhcPs (LHsCmd GhcPs))] -> Annotated () #
Annotate body => Annotate (Stmt GhcPs (Located body))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> Stmt GhcPs (Located body) -> Annotated () #
HasDecls (LStmt GhcPs (LHsExpr GhcPs))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Transform Methods hsDecls :: forall (m :: Type -> Type). Monad m => LStmt GhcPs (LHsExpr GhcPs) -> TransformT m [LHsDecl GhcPs] # replaceDecls :: forall (m :: Type -> Type). Monad m => LStmt GhcPs (LHsExpr GhcPs) -> [LHsDecl GhcPs] -> TransformT m (LStmt GhcPs (LHsExpr GhcPs)) #
Matchable (LStmt GhcPs (LHsExpr GhcPs)) Source #
Instance details Defined in Retrie.Universe Methods inject :: LStmt GhcPs (LHsExpr GhcPs) -> Universe Source # project :: Universe -> LStmt GhcPs (LHsExpr GhcPs) Source # getOrigin :: LStmt GhcPs (LHsExpr GhcPs) -> SrcSpan Source #
(OutputableBndrId pl, OutputableBndrId pr, Outputable body) => Outputable (StmtLR (GhcPass pl) (GhcPass pr) body)
Instance details Defined in GHC.Hs.Expr Methods ppr :: StmtLR (GhcPass pl) (GhcPass pr) body -> SDoc # pprPrec :: Rational -> StmtLR (GhcPass pl) (GhcPass pr) body -> SDoc #

data RecStmtTc #

Constructors

RecStmtTc
Fields recS_bind_ty :: Type recS_later_rets :: [PostTcExpr] recS_rec_rets :: [PostTcExpr] recS_ret_ty :: Type

data TransForm #

Constructors

ThenForm
GroupForm

Instances

Instances details

Data TransForm

Instance details

Defined in GHC.Hs.Expr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TransForm -> c TransForm #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TransForm #

toConstr :: TransForm -> Constr #

dataTypeOf :: TransForm -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TransForm) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TransForm) #

gmapT :: (forall b. Data b => b -> b) -> TransForm -> TransForm #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TransForm -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TransForm -> r #

gmapQ :: (forall d. Data d => d -> u) -> TransForm -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TransForm -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TransForm -> m TransForm #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TransForm -> m TransForm #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TransForm -> m TransForm #

data ParStmtBlock idL idR #

Parenthesised Statement Block

Constructors

ParStmtBlock (XParStmtBlock idL idR) [ExprLStmt idL] [IdP idR] (SyntaxExpr idR)
XParStmtBlock (XXParStmtBlock idL idR)

Instances

Instances details

(Outputable (StmtLR idL idL (LHsExpr idL)), Outputable (XXParStmtBlock idL idR)) => Outputable (ParStmtBlock idL idR)
Instance details Defined in GHC.Hs.Expr Methods ppr :: ParStmtBlock idL idR -> SDoc # pprPrec :: Rational -> ParStmtBlock idL idR -> SDoc #
Annotate (ParStmtBlock GhcPs GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> ParStmtBlock GhcPs GhcPs -> Annotated () #

data ApplicativeArg idL #

Applicative Argument

Constructors

ApplicativeArgOne
Fields xarg_app_arg_one :: XApplicativeArgOne idL app_arg_pattern :: LPat idL arg_expr :: LHsExpr idL is_body_stmt :: Bool fail_operator :: SyntaxExpr idL
ApplicativeArgMany
Fields xarg_app_arg_many :: XApplicativeArgMany idL app_stmts :: [ExprLStmt idL] final_expr :: HsExpr idL bv_pattern :: LPat idL
XApplicativeArg (XXApplicativeArg idL)

Instances

Instances details

OutputableBndrId idL => Outputable (ApplicativeArg (GhcPass idL))
Instance details Defined in GHC.Hs.Expr Methods ppr :: ApplicativeArg (GhcPass idL) -> SDoc # pprPrec :: Rational -> ApplicativeArg (GhcPass idL) -> SDoc #

data SpliceDecoration #

A splice can appear with various decorations wrapped around it. This data type captures explicitly how it was originally written, for use in the pretty printer.

Constructors

HasParens	$( splice ) or $$( splice )
HasDollar	$splice or $$splice
NoParens	bare splice

Instances

Instances details

Eq SpliceDecoration
Instance details Defined in GHC.Hs.Expr Methods (==) :: SpliceDecoration -> SpliceDecoration -> Bool # (/=) :: SpliceDecoration -> SpliceDecoration -> Bool #
Data SpliceDecoration
Instance details Defined in GHC.Hs.Expr Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SpliceDecoration -> c SpliceDecoration # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SpliceDecoration # toConstr :: SpliceDecoration -> Constr # dataTypeOf :: SpliceDecoration -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SpliceDecoration) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SpliceDecoration) # gmapT :: (forall b. Data b => b -> b) -> SpliceDecoration -> SpliceDecoration # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SpliceDecoration -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SpliceDecoration -> r # gmapQ :: (forall d. Data d => d -> u) -> SpliceDecoration -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SpliceDecoration -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SpliceDecoration -> m SpliceDecoration # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceDecoration -> m SpliceDecoration # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceDecoration -> m SpliceDecoration #
Show SpliceDecoration
Instance details Defined in GHC.Hs.Expr Methods showsPrec :: Int -> SpliceDecoration -> ShowS # show :: SpliceDecoration -> String # showList :: [SpliceDecoration] -> ShowS #
Outputable SpliceDecoration
Instance details Defined in GHC.Hs.Expr Methods ppr :: SpliceDecoration -> SDoc # pprPrec :: Rational -> SpliceDecoration -> SDoc #

newtype ThModFinalizers #

Finalizers produced by a splice with addModFinalizer

See Note [Delaying modFinalizers in untyped splices] in RnSplice. For how this is used.

Constructors

ThModFinalizers [ForeignRef (Q ())]

Instances

Instances details

Data ThModFinalizers

Instance details

Defined in GHC.Hs.Expr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ThModFinalizers -> c ThModFinalizers #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ThModFinalizers #

toConstr :: ThModFinalizers -> Constr #

dataTypeOf :: ThModFinalizers -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ThModFinalizers) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ThModFinalizers) #

gmapT :: (forall b. Data b => b -> b) -> ThModFinalizers -> ThModFinalizers #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ThModFinalizers -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ThModFinalizers -> r #

gmapQ :: (forall d. Data d => d -> u) -> ThModFinalizers -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ThModFinalizers -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ThModFinalizers -> m ThModFinalizers #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ThModFinalizers -> m ThModFinalizers #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ThModFinalizers -> m ThModFinalizers #

data DelayedSplice #

Constructors

DelayedSplice TcLclEnv (LHsExpr GhcRn) TcType (LHsExpr GhcTcId)

Instances

Instances details

Data DelayedSplice

Instance details

Defined in GHC.Hs.Expr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DelayedSplice -> c DelayedSplice #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DelayedSplice #

toConstr :: DelayedSplice -> Constr #

dataTypeOf :: DelayedSplice -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DelayedSplice) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DelayedSplice) #

gmapT :: (forall b. Data b => b -> b) -> DelayedSplice -> DelayedSplice #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DelayedSplice -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DelayedSplice -> r #

gmapQ :: (forall d. Data d => d -> u) -> DelayedSplice -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> DelayedSplice -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DelayedSplice -> m DelayedSplice #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DelayedSplice -> m DelayedSplice #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DelayedSplice -> m DelayedSplice #

data HsSplicedThing id #

Haskell Spliced Thing

Values that can result from running a splice.

Constructors

HsSplicedExpr (HsExpr id)	Haskell Spliced Expression
HsSplicedTy (HsType id)	Haskell Spliced Type
HsSplicedPat (Pat id)	Haskell Spliced Pattern

Instances

Instances details

OutputableBndrId p => Outputable (HsSplicedThing (GhcPass p))
Instance details Defined in GHC.Hs.Expr Methods ppr :: HsSplicedThing (GhcPass p) -> SDoc # pprPrec :: Rational -> HsSplicedThing (GhcPass p) -> SDoc #

type SplicePointName = Name #

data PendingRnSplice #

Pending Renamer Splice

Constructors

PendingRnSplice UntypedSpliceFlavour SplicePointName (LHsExpr GhcRn)

Instances

Instances details

Outputable PendingRnSplice
Instance details Defined in GHC.Hs.Expr Methods ppr :: PendingRnSplice -> SDoc # pprPrec :: Rational -> PendingRnSplice -> SDoc #

data UntypedSpliceFlavour #

Constructors

UntypedExpSplice
UntypedPatSplice
UntypedTypeSplice
UntypedDeclSplice

Instances

Instances details

Data UntypedSpliceFlavour

Instance details

Defined in GHC.Hs.Expr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UntypedSpliceFlavour -> c UntypedSpliceFlavour #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UntypedSpliceFlavour #

toConstr :: UntypedSpliceFlavour -> Constr #

dataTypeOf :: UntypedSpliceFlavour -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UntypedSpliceFlavour) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UntypedSpliceFlavour) #

gmapT :: (forall b. Data b => b -> b) -> UntypedSpliceFlavour -> UntypedSpliceFlavour #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UntypedSpliceFlavour -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UntypedSpliceFlavour -> r #

gmapQ :: (forall d. Data d => d -> u) -> UntypedSpliceFlavour -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UntypedSpliceFlavour -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UntypedSpliceFlavour -> m UntypedSpliceFlavour #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UntypedSpliceFlavour -> m UntypedSpliceFlavour #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UntypedSpliceFlavour -> m UntypedSpliceFlavour #

data PendingTcSplice #

Pending Type-checker Splice

Constructors

PendingTcSplice SplicePointName (LHsExpr GhcTc)

Instances

Instances details

Outputable PendingTcSplice
Instance details Defined in GHC.Hs.Expr Methods ppr :: PendingTcSplice -> SDoc # pprPrec :: Rational -> PendingTcSplice -> SDoc #

data HsBracket p #

Haskell Bracket

Constructors

ExpBr (XExpBr p) (LHsExpr p)
PatBr (XPatBr p) (LPat p)
DecBrL (XDecBrL p) [LHsDecl p]
DecBrG (XDecBrG p) (HsGroup p)
TypBr (XTypBr p) (LHsType p)
VarBr (XVarBr p) Bool (IdP p)
TExpBr (XTExpBr p) (LHsExpr p)
XBracket (XXBracket p)

Instances

Instances details

OutputableBndrId p => Outputable (HsBracket (GhcPass p))
Instance details Defined in GHC.Hs.Expr Methods ppr :: HsBracket (GhcPass p) -> SDoc # pprPrec :: Rational -> HsBracket (GhcPass p) -> SDoc #

data ArithSeqInfo id #

Arithmetic Sequence Information

Constructors

From (LHsExpr id)
FromThen (LHsExpr id) (LHsExpr id)
FromTo (LHsExpr id) (LHsExpr id)
FromThenTo (LHsExpr id) (LHsExpr id) (LHsExpr id)

Instances

Instances details

OutputableBndrId p => Outputable (ArithSeqInfo (GhcPass p))
Instance details Defined in GHC.Hs.Expr Methods ppr :: ArithSeqInfo (GhcPass p) -> SDoc # pprPrec :: Rational -> ArithSeqInfo (GhcPass p) -> SDoc #

data HsMatchContext id #

Haskell Match Context

Context of a pattern match. This is more subtle than it would seem. See Note [Varieties of pattern matches].

Constructors

FunRhs	A pattern matching on an argument of a function binding
Fields mc_fun :: Located id function binder of `f` mc_fixity :: LexicalFixity fixing of `f` mc_strictness :: SrcStrictness was `f` banged? See Note [FunBind vs PatBind]
LambdaExpr	Patterns of a lambda
CaseAlt	Patterns and guards on a case alternative
IfAlt	Guards of a multi-way if alternative
ProcExpr	Patterns of a proc
PatBindRhs	A pattern binding eg [y] <- e = e
PatBindGuards	Guards of pattern bindings, e.g., (Just b) \| Just _ <- x = e \| otherwise = e'
RecUpd	Record update [used only in DsExpr to tell matchWrapper what sort of runtime error message to generate]
StmtCtxt (HsStmtContext id)	Pattern of a do-stmt, list comprehension, pattern guard, etc
ThPatSplice	A Template Haskell pattern splice
ThPatQuote	A Template Haskell pattern quotation [p\| (a,b) \|]
PatSyn	A pattern synonym declaration

Instances

Instances details

Functor HsMatchContext
Instance details Defined in GHC.Hs.Expr Methods fmap :: (a -> b) -> HsMatchContext a -> HsMatchContext b # (<$) :: a -> HsMatchContext b -> HsMatchContext a #
Data id => Data (HsMatchContext id)
Instance details Defined in GHC.Hs.Expr Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsMatchContext id -> c (HsMatchContext id) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsMatchContext id) # toConstr :: HsMatchContext id -> Constr # dataTypeOf :: HsMatchContext id -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsMatchContext id)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsMatchContext id)) # gmapT :: (forall b. Data b => b -> b) -> HsMatchContext id -> HsMatchContext id # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsMatchContext id -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsMatchContext id -> r # gmapQ :: (forall d. Data d => d -> u) -> HsMatchContext id -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsMatchContext id -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsMatchContext id -> m (HsMatchContext id) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMatchContext id -> m (HsMatchContext id) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMatchContext id -> m (HsMatchContext id) #
OutputableBndr id => Outputable (HsMatchContext id)
Instance details Defined in GHC.Hs.Expr Methods ppr :: HsMatchContext id -> SDoc # pprPrec :: Rational -> HsMatchContext id -> SDoc #

data HsStmtContext id #

Haskell Statement Context. It expects to be parameterised with one of RdrName, Name or Id

Constructors

ListComp
MonadComp
DoExpr	do { ... }
MDoExpr	mdo { ... } ie recursive do-expression
ArrowExpr	do-notation in an arrow-command context
GhciStmtCtxt	A command-line Stmt in GHCi pat <- rhs
PatGuard (HsMatchContext id)	Pattern guard for specified thing
ParStmtCtxt (HsStmtContext id)	A branch of a parallel stmt
TransStmtCtxt (HsStmtContext id)	A branch of a transform stmt

Instances

Instances details

Functor HsStmtContext
Instance details Defined in GHC.Hs.Expr Methods fmap :: (a -> b) -> HsStmtContext a -> HsStmtContext b # (<$) :: a -> HsStmtContext b -> HsStmtContext a #
Data id => Data (HsStmtContext id)
Instance details Defined in GHC.Hs.Expr Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsStmtContext id -> c (HsStmtContext id) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsStmtContext id) # toConstr :: HsStmtContext id -> Constr # dataTypeOf :: HsStmtContext id -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsStmtContext id)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsStmtContext id)) # gmapT :: (forall b. Data b => b -> b) -> HsStmtContext id -> HsStmtContext id # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsStmtContext id -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsStmtContext id -> r # gmapQ :: (forall d. Data d => d -> u) -> HsStmtContext id -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsStmtContext id -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsStmtContext id -> m (HsStmtContext id) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsStmtContext id -> m (HsStmtContext id) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsStmtContext id -> m (HsStmtContext id) #
(Outputable (GhcPass p), Outputable (NameOrRdrName (GhcPass p))) => Outputable (HsStmtContext (GhcPass p))
Instance details Defined in GHC.Hs.Expr Methods ppr :: HsStmtContext (GhcPass p) -> SDoc # pprPrec :: Rational -> HsStmtContext (GhcPass p) -> SDoc #

roleAnnotDeclName :: forall (p :: Pass). RoleAnnotDecl (GhcPass p) -> IdP (GhcPass p) #

annProvenanceName_maybe :: AnnProvenance name -> Maybe name #

docDeclDoc :: DocDecl -> HsDocString #

pprFullRuleName :: Located (SourceText, RuleName) -> SDoc #

collectRuleBndrSigTys :: [RuleBndr pass] -> [LHsSigWcType pass] #

flattenRuleDecls :: [LRuleDecls pass] -> [LRuleDecl pass] #

mapDerivStrategy :: forall p (pass :: Pass). p ~ GhcPass pass => (XViaStrategy p -> XViaStrategy p) -> DerivStrategy p -> DerivStrategy p #

Map over the via type if dealing with ViaStrategy. Otherwise, return the DerivStrategy unchanged.

foldDerivStrategy :: forall p (pass :: Pass) r. p ~ GhcPass pass => r -> (XViaStrategy p -> r) -> DerivStrategy p -> r #

Eliminate a DerivStrategy.

derivStrategyName :: DerivStrategy a -> SDoc #

A short description of a DerivStrategy'.

instDeclDataFamInsts :: forall (p :: Pass). [LInstDecl (GhcPass p)] -> [DataFamInstDecl (GhcPass p)] #

pprHsFamInstLHS :: forall (p :: Pass). OutputableBndrId p => IdP (GhcPass p) -> Maybe [LHsTyVarBndr (GhcPass p)] -> HsTyPats (GhcPass p) -> LexicalFixity -> LHsContext (GhcPass p) -> SDoc #

pprDataFamInstFlavour :: forall (p :: Pass). DataFamInstDecl (GhcPass p) -> SDoc #

pprTyFamInstDecl :: forall (p :: Pass). OutputableBndrId p => TopLevelFlag -> TyFamInstDecl (GhcPass p) -> SDoc #

hsConDeclTheta :: Maybe (LHsContext pass) -> [LHsType pass] #

hsConDeclArgTys :: HsConDeclDetails pass -> [LBangType pass] #

getConArgs :: ConDecl pass -> HsConDeclDetails pass #

getConNames :: forall (p :: Pass). ConDecl (GhcPass p) -> [Located (IdP (GhcPass p))] #

newOrDataToFlavour :: NewOrData -> TyConFlavour #

Convert a NewOrData to a TyConFlavour

standaloneKindSigName :: forall (p :: Pass). StandaloneKindSig (GhcPass p) -> IdP (GhcPass p) #

resultVariableName :: forall (a :: Pass). FamilyResultSig (GhcPass a) -> Maybe (IdP (GhcPass a)) #

Maybe return name of the result type variable

famResultKindSignature :: forall (p :: Pass). FamilyResultSig (GhcPass p) -> Maybe (LHsKind (GhcPass p)) #

familyDeclName :: forall (p :: Pass). FamilyDecl (GhcPass p) -> IdP (GhcPass p) #

familyDeclLName :: forall (p :: Pass). FamilyDecl (GhcPass p) -> Located (IdP (GhcPass p)) #

tyClGroupKindSigs :: [TyClGroup pass] -> [LStandaloneKindSig pass] #

tyClGroupRoleDecls :: [TyClGroup pass] -> [LRoleAnnotDecl pass] #

tyClGroupInstDecls :: [TyClGroup pass] -> [LInstDecl pass] #

tyClGroupTyClDecls :: [TyClGroup pass] -> [LTyClDecl pass] #

pprTyClDeclFlavour :: forall (p :: Pass). TyClDecl (GhcPass p) -> SDoc #

hsDeclHasCusk :: TyClDecl GhcRn -> Bool #

Does this declaration have a complete, user-supplied kind signature? See Note [CUSKs: complete user-supplied kind signatures]

countTyClDecls :: [TyClDecl pass] -> (Int, Int, Int, Int, Int) #

tyClDeclTyVars :: TyClDecl pass -> LHsQTyVars pass #

tcdName :: forall (p :: Pass). TyClDecl (GhcPass p) -> IdP (GhcPass p) #

tyClDeclLName :: forall (p :: Pass). TyClDecl (GhcPass p) -> Located (IdP (GhcPass p)) #

tyFamInstDeclLName :: forall (p :: Pass). TyFamInstDecl (GhcPass p) -> Located (IdP (GhcPass p)) #

tyFamInstDeclName :: forall (p :: Pass). TyFamInstDecl (GhcPass p) -> IdP (GhcPass p) #

isDataFamilyDecl :: TyClDecl pass -> Bool #

data family declaration

isClosedTypeFamilyInfo :: FamilyInfo pass -> Bool #

closed type family info

isOpenTypeFamilyInfo :: FamilyInfo pass -> Bool #

open type family info

isTypeFamilyDecl :: TyClDecl pass -> Bool #

type family declaration

isFamilyDecl :: TyClDecl pass -> Bool #

type/data family declaration

isClassDecl :: TyClDecl pass -> Bool #

type class

isSynDecl :: TyClDecl pass -> Bool #

type or type instance declaration

isDataDecl :: TyClDecl pass -> Bool #

True = argument is a data/newtype declaration.

appendGroups :: forall (p :: Pass). HsGroup (GhcPass p) -> HsGroup (GhcPass p) -> HsGroup (GhcPass p) #

hsGroupInstDecls :: HsGroup id -> [LInstDecl id] #

emptyRnGroup :: forall (p :: Pass). HsGroup (GhcPass p) #

emptyRdrGroup :: forall (p :: Pass). HsGroup (GhcPass p) #

type LHsDecl p #

Arguments

= Located (HsDecl p)

When in a list this may have

AnnKeywordId : AnnSemi

data HsDecl p #

A Haskell Declaration

Constructors

TyClD (XTyClD p) (TyClDecl p)	Type or Class Declaration
InstD (XInstD p) (InstDecl p)	Instance declaration
DerivD (XDerivD p) (DerivDecl p)	Deriving declaration
ValD (XValD p) (HsBind p)	Value declaration
SigD (XSigD p) (Sig p)	Signature declaration
KindSigD (XKindSigD p) (StandaloneKindSig p)	Standalone kind signature
DefD (XDefD p) (DefaultDecl p)	'default' declaration
ForD (XForD p) (ForeignDecl p)	Foreign declaration
WarningD (XWarningD p) (WarnDecls p)	Warning declaration
AnnD (XAnnD p) (AnnDecl p)	Annotation declaration
RuleD (XRuleD p) (RuleDecls p)	Rule declaration
SpliceD (XSpliceD p) (SpliceDecl p)	Splice declaration (Includes quasi-quotes)
DocD (XDocD p) DocDecl	Documentation comment declaration
RoleAnnotD (XRoleAnnotD p) (RoleAnnotDecl p)	Role annotation declaration
XHsDecl (XXHsDecl p)

Instances

Instances details

OutputableBndrId p => Outputable (HsDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: HsDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> HsDecl (GhcPass p) -> SDoc #
Annotate (HsDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsDecl GhcPs -> Annotated () #

data HsGroup p #

Haskell Group

A HsDecl is categorised into a HsGroup before being fed to the renamer.

Constructors

HsGroup
Fields hs_ext :: XCHsGroup p hs_valds :: HsValBinds p hs_splcds :: [LSpliceDecl p] hs_tyclds :: [TyClGroup p] hs_derivds :: [LDerivDecl p] hs_fixds :: [LFixitySig p] hs_defds :: [LDefaultDecl p] hs_fords :: [LForeignDecl p] hs_warnds :: [LWarnDecls p] hs_annds :: [LAnnDecl p] hs_ruleds :: [LRuleDecls p] hs_docs :: [LDocDecl]
XHsGroup (XXHsGroup p)

Instances

Instances details

OutputableBndrId p => Outputable (HsGroup (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: HsGroup (GhcPass p) -> SDoc # pprPrec :: Rational -> HsGroup (GhcPass p) -> SDoc #

type LSpliceDecl pass = Located (SpliceDecl pass) #

Located Splice Declaration

data SpliceDecl p #

Splice Declaration

Constructors

SpliceDecl (XSpliceDecl p) (Located (HsSplice p)) SpliceExplicitFlag
XSpliceDecl (XXSpliceDecl p)

Instances

Instances details

OutputableBndrId p => Outputable (SpliceDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: SpliceDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> SpliceDecl (GhcPass p) -> SDoc #
Annotate (SpliceDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> SpliceDecl GhcPs -> Annotated () #

type LTyClDecl pass = Located (TyClDecl pass) #

Located Declaration of a Type or Class

data TyClDecl pass #

A type or class declaration.

Constructors

FamDecl	type/data family T :: -> `AnnKeywordId` : `AnnType`, `AnnData`, `AnnFamily`,`AnnDcolon`, `AnnWhere`,`AnnOpenP`, `AnnDcolon`,`AnnCloseP`, `AnnEqual`,`AnnRarrow`, `AnnVbar`
Fields tcdFExt :: XFamDecl pass tcdFam :: FamilyDecl pass
SynDecl	`type` declaration `AnnKeywordId` : `AnnType`, `AnnEqual`,
Fields tcdSExt :: XSynDecl pass Post renameer, FVs tcdLName :: Located (IdP pass) Type constructor tcdTyVars :: LHsQTyVars pass Type variables; for an associated type these include outer binders tcdFixity :: LexicalFixity Fixity used in the declaration tcdRhs :: LHsType pass
DataDecl	`data` declaration `AnnKeywordId` : `AnnData`, `AnnFamily`, `AnnNewType`, `AnnNewType`,`AnnDcolon` `AnnWhere`,
Fields tcdDExt :: XDataDecl pass Post renamer, CUSK flag, FVs tcdLName :: Located (IdP pass) Type constructor tcdTyVars :: LHsQTyVars pass Type variables; for an associated type these include outer binders tcdFixity :: LexicalFixity Fixity used in the declaration tcdDataDefn :: HsDataDefn pass
ClassDecl	`AnnKeywordId` : `AnnClass`, `AnnWhere`,`AnnOpen`, `AnnClose` The tcdFDs will have `AnnVbar`, `AnnComma` `AnnRarrow`
Fields tcdCExt :: XClassDecl pass Post renamer, FVs tcdCtxt :: LHsContext pass Context... tcdLName :: Located (IdP pass) Type constructor tcdTyVars :: LHsQTyVars pass Type variables; for an associated type these include outer binders tcdFixity :: LexicalFixity Fixity used in the declaration tcdFDs :: [LHsFunDep pass] Functional deps tcdSigs :: [LSig pass] Methods' signatures tcdMeths :: LHsBinds pass Default methods tcdATs :: [LFamilyDecl pass] Associated types; tcdATDefs :: [LTyFamDefltDecl pass] Associated type defaults tcdDocs :: [LDocDecl] Haddock docs
XTyClDecl (XXTyClDecl pass)

Instances

Instances details

OutputableBndrId p => Outputable (TyClDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: TyClDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> TyClDecl (GhcPass p) -> SDoc #
Annotate (TyClDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> TyClDecl GhcPs -> Annotated () #

type LHsFunDep pass = Located (FunDep (Located (IdP pass))) #

data DataDeclRn #

Constructors

DataDeclRn
Fields tcdDataCusk :: Bool does this have a CUSK? See Note [CUSKs: complete user-supplied kind signatures] tcdFVs :: NameSet

Instances

Instances details

Data DataDeclRn

Instance details

Defined in GHC.Hs.Decls

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DataDeclRn -> c DataDeclRn #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DataDeclRn #

toConstr :: DataDeclRn -> Constr #

dataTypeOf :: DataDeclRn -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DataDeclRn) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataDeclRn) #

gmapT :: (forall b. Data b => b -> b) -> DataDeclRn -> DataDeclRn #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DataDeclRn -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DataDeclRn -> r #

gmapQ :: (forall d. Data d => d -> u) -> DataDeclRn -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> DataDeclRn -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DataDeclRn -> m DataDeclRn #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DataDeclRn -> m DataDeclRn #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DataDeclRn -> m DataDeclRn #

data TyClGroup pass #

Type or Class Group

Constructors

TyClGroup
Fields group_ext :: XCTyClGroup pass group_tyclds :: [LTyClDecl pass] group_roles :: [LRoleAnnotDecl pass] group_kisigs :: [LStandaloneKindSig pass] group_instds :: [LInstDecl pass]
XTyClGroup (XXTyClGroup pass)

Instances

Instances details

OutputableBndrId p => Outputable (TyClGroup (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: TyClGroup (GhcPass p) -> SDoc # pprPrec :: Rational -> TyClGroup (GhcPass p) -> SDoc #

type LFamilyResultSig pass = Located (FamilyResultSig pass) #

Located type Family Result Signature

data FamilyResultSig pass #

type Family Result Signature

Constructors

NoSig (XNoSig pass)	`AnnKeywordId` :
KindSig (XCKindSig pass) (LHsKind pass)	`AnnKeywordId` : `AnnOpenP`,`AnnDcolon`, `AnnCloseP`
TyVarSig (XTyVarSig pass) (LHsTyVarBndr pass)	`AnnKeywordId` : `AnnOpenP`,`AnnDcolon`, `AnnCloseP`, `AnnEqual`
XFamilyResultSig (XXFamilyResultSig pass)

Instances

Instances details

Annotate (FamilyResultSig GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> FamilyResultSig GhcPs -> Annotated () #

type LFamilyDecl pass = Located (FamilyDecl pass) #

Located type Family Declaration

data FamilyDecl pass #

type Family Declaration

Constructors

FamilyDecl
Fields fdExt :: XCFamilyDecl pass fdInfo :: FamilyInfo pass fdLName :: Located (IdP pass) fdTyVars :: LHsQTyVars pass fdFixity :: LexicalFixity fdResultSig :: LFamilyResultSig pass fdInjectivityAnn :: Maybe (LInjectivityAnn pass)
XFamilyDecl (XXFamilyDecl pass)	`AnnKeywordId` : `AnnType`, `AnnData`, `AnnFamily`, `AnnWhere`, `AnnOpenP`, `AnnDcolon`, `AnnCloseP`, `AnnEqual`, `AnnRarrow`, `AnnVbar`

Instances

Instances details

OutputableBndrId p => Outputable (FamilyDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: FamilyDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> FamilyDecl (GhcPass p) -> SDoc #
Annotate (FamilyDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> FamilyDecl GhcPs -> Annotated () #

type LInjectivityAnn pass = Located (InjectivityAnn pass) #

Located Injectivity Annotation

data InjectivityAnn pass #

If the user supplied an injectivity annotation it is represented using InjectivityAnn. At the moment this is a single injectivity condition - see Note [Injectivity annotation]. `Located name` stores the LHS of injectivity condition. `[Located name]` stores the RHS of injectivity condition. Example:

type family Foo a b c = r | r -> a c where ...

This will be represented as "InjectivityAnn r [a, c]"

Constructors

InjectivityAnn (Located (IdP pass)) [Located (IdP pass)]

AnnKeywordId : AnnRarrow, AnnVbar

Instances

Instances details

Annotate (InjectivityAnn GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> InjectivityAnn GhcPs -> Annotated () #

data FamilyInfo pass #

Constructors

DataFamily
OpenTypeFamily
ClosedTypeFamily (Maybe [LTyFamInstEqn pass])	`Nothing` if we're in an hs-boot file and the user said "type family Foo x where .."

Instances

Instances details

Outputable (FamilyInfo pass)
Instance details Defined in GHC.Hs.Decls Methods ppr :: FamilyInfo pass -> SDoc # pprPrec :: Rational -> FamilyInfo pass -> SDoc #

data HsDataDefn pass #

Haskell Data type Definition

Constructors

HsDataDefn	Declares a data type or newtype, giving its constructors `data/newtype T a = constrs data/newtype instance T [a] = constrs`
Fields dd_ext :: XCHsDataDefn pass dd_ND :: NewOrData dd_ctxt :: LHsContext pass Context dd_cType :: Maybe (Located CType) dd_kindSig :: Maybe (LHsKind pass) Optional kind signature. `(Just k)` for a GADT-style `data`, or `data instance` decl, with explicit kind sig Always `Nothing` for H98-syntax decls dd_cons :: [LConDecl pass] Data constructors For `data T a = T1 \| T2 a` the `LConDecl`s all have `ConDeclH98`. For `data T a where { T1 :: T a }` the `LConDecls` all have `ConDeclGADT`. dd_derivs :: HsDeriving pass Optional 'deriving' claues
XHsDataDefn (XXHsDataDefn pass)

Instances

Instances details

OutputableBndrId p => Outputable (HsDataDefn (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: HsDataDefn (GhcPass p) -> SDoc # pprPrec :: Rational -> HsDataDefn (GhcPass p) -> SDoc #

type HsDeriving pass #

Arguments

= Located [LHsDerivingClause pass]

The optional deriving clauses of a data declaration. Clauses is plural because one can specify multiple deriving clauses using the -XDerivingStrategies language extension.

The list of LHsDerivingClauses corresponds to exactly what the user requested to derive, in order. If no deriving clauses were specified, the list is empty.

Haskell Deriving clause

type LHsDerivingClause pass = Located (HsDerivingClause pass) #

data HsDerivingClause pass #

A single deriving clause of a data declaration.

AnnKeywordId : AnnDeriving, AnnStock, AnnAnyClass, AnnNewtype, AnnOpen,AnnClose

Constructors

HsDerivingClause
Fields deriv_clause_ext :: XCHsDerivingClause pass deriv_clause_strategy :: Maybe (LDerivStrategy pass) The user-specified strategy (if any) to use when deriving `deriv_clause_tys`. deriv_clause_tys :: Located [LHsSigType pass] The types to derive. It uses `LHsSigType`s because, with `-XGeneralizedNewtypeDeriving`, we can mention type variables that aren't bound by the datatype, e.g. data T b = ... deriving (C [a]) should produce a derived instance for `C [a] (T b)`.
XHsDerivingClause (XXHsDerivingClause pass)

Instances

Instances details

OutputableBndrId p => Outputable (HsDerivingClause (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: HsDerivingClause (GhcPass p) -> SDoc # pprPrec :: Rational -> HsDerivingClause (GhcPass p) -> SDoc #
Annotate [LHsDerivingClause GhcPs]
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> [LHsDerivingClause GhcPs] -> Annotated () #
Annotate (HsDerivingClause GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsDerivingClause GhcPs -> Annotated () #

type LStandaloneKindSig pass = Located (StandaloneKindSig pass) #

Located Standalone Kind Signature

data StandaloneKindSig pass #

Constructors

StandaloneKindSig (XStandaloneKindSig pass) (Located (IdP pass)) (LHsSigType pass)
XStandaloneKindSig (XXStandaloneKindSig pass)

Instances

Instances details

OutputableBndrId p => Outputable (StandaloneKindSig (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: StandaloneKindSig (GhcPass p) -> SDoc # pprPrec :: Rational -> StandaloneKindSig (GhcPass p) -> SDoc #
Annotate (StandaloneKindSig GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> StandaloneKindSig GhcPs -> Annotated () #

data NewOrData #

Constructors

NewType	newtype Blah ...
DataType	data Blah ...

Instances

Instances details

Eq NewOrData
Instance details Defined in GHC.Hs.Decls Methods (==) :: NewOrData -> NewOrData -> Bool # (/=) :: NewOrData -> NewOrData -> Bool #
Data NewOrData
Instance details Defined in GHC.Hs.Decls Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NewOrData -> c NewOrData # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NewOrData # toConstr :: NewOrData -> Constr # dataTypeOf :: NewOrData -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NewOrData) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NewOrData) # gmapT :: (forall b. Data b => b -> b) -> NewOrData -> NewOrData # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NewOrData -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NewOrData -> r # gmapQ :: (forall d. Data d => d -> u) -> NewOrData -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NewOrData -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NewOrData -> m NewOrData # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NewOrData -> m NewOrData # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NewOrData -> m NewOrData #
Outputable NewOrData
Instance details Defined in GHC.Hs.Decls Methods ppr :: NewOrData -> SDoc # pprPrec :: Rational -> NewOrData -> SDoc #

type LConDecl pass #

Arguments

= Located (ConDecl pass)

May have AnnKeywordId : AnnSemi when in a GADT constructor list

Located data Constructor Declaration

data ConDecl pass #

data T b = forall a. Eq a => MkT a b
  MkT :: forall b a. Eq a => MkT a b

data T b where
     MkT1 :: Int -> T Int

data T = Int MkT Int
       | MkT2

data T a where
     Int MkT Int :: T Int

AnnKeywordIds : AnnOpen, AnnDotdot,AnnCLose, AnnEqual,AnnVbar, AnnDarrow,AnnDarrow, AnnForall,AnnDot

data Constructor Declaration

Constructors

ConDeclGADT
Fields con_g_ext :: XConDeclGADT pass con_names :: [Located (IdP pass)] con_forall :: Located Bool True = explicit forall False => hsq_explicit is empty con_qvars :: LHsQTyVars pass con_mb_cxt :: Maybe (LHsContext pass) User-written context (if any) con_args :: HsConDeclDetails pass Arguments; never InfixCon con_res_ty :: LHsType pass Result type con_doc :: Maybe LHsDocString A possible Haddock comment.
ConDeclH98
Fields con_ext :: XConDeclH98 pass con_name :: Located (IdP pass) con_forall :: Located Bool True = explicit forall False => hsq_explicit is empty con_ex_tvs :: [LHsTyVarBndr pass] Existentials only con_mb_cxt :: Maybe (LHsContext pass) User-written context (if any) con_args :: HsConDeclDetails pass Arguments; never InfixCon con_doc :: Maybe LHsDocString A possible Haddock comment.
XConDecl (XXConDecl pass)

Instances

Instances details

OutputableBndrId p => Outputable (ConDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: ConDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> ConDecl (GhcPass p) -> SDoc #
Annotate (ConDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> ConDecl GhcPs -> Annotated () #

type HsConDeclDetails pass = HsConDetails (LBangType pass) (Located [LConDeclField pass]) #

Haskell data Constructor Declaration Details

type LTyFamInstEqn pass #

Arguments

= Located (TyFamInstEqn pass)

May have AnnKeywordId : AnnSemi when in a list

Located Type Family Instance Equation

type HsTyPats pass = [LHsTypeArg pass] #

Haskell Type Patterns

type TyFamInstEqn pass = FamInstEqn pass (LHsType pass) #

Type Family Instance Equation

type TyFamDefltDecl = TyFamInstDecl #

Type family default declarations. A convenient synonym for TyFamInstDecl. See Note [Type family instance declarations in HsSyn].

type LTyFamDefltDecl pass = Located (TyFamDefltDecl pass) #

Located type family default declarations.

type LTyFamInstDecl pass = Located (TyFamInstDecl pass) #

Located Type Family Instance Declaration

newtype TyFamInstDecl pass #

Type Family Instance Declaration

Constructors

TyFamInstDecl	`AnnKeywordId` : `AnnType`, `AnnInstance`,
Fields tfid_eqn :: TyFamInstEqn pass

Instances

Instances details

OutputableBndrId p => Outputable (TyFamInstDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: TyFamInstDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> TyFamInstDecl (GhcPass p) -> SDoc #
Annotate (TyFamInstDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> TyFamInstDecl GhcPs -> Annotated () #

type LDataFamInstDecl pass = Located (DataFamInstDecl pass) #

Located Data Family Instance Declaration

newtype DataFamInstDecl pass #

Data Family Instance Declaration

Constructors

DataFamInstDecl	`AnnKeywordId` : `AnnData`, `AnnNewType`,`AnnInstance`, `AnnDcolon` `AnnWhere`,`AnnOpen`, `AnnClose`
Fields dfid_eqn :: FamInstEqn pass (HsDataDefn pass)

Instances

Instances details

OutputableBndrId p => Outputable (DataFamInstDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: DataFamInstDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> DataFamInstDecl (GhcPass p) -> SDoc #
Annotate (DataFamInstDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> DataFamInstDecl GhcPs -> Annotated () #

type LFamInstEqn pass rhs = Located (FamInstEqn pass rhs) #

Located Family Instance Equation

type FamInstEqn pass rhs #

Arguments

= HsImplicitBndrs pass (FamEqn pass rhs)

Here, the pats are type patterns (with kind and type bndrs). See Note [Family instance declaration binders]

Family Instance Equation

data FamEqn pass rhs #

Family Equation

One equation in a type family instance declaration, data family instance declaration, or type family default. See Note [Type family instance declarations in HsSyn] See Note [Family instance declaration binders]

Constructors

FamEqn	`AnnKeywordId` : `AnnEqual`
Fields feqn_ext :: XCFamEqn pass rhs feqn_tycon :: Located (IdP pass) feqn_bndrs :: Maybe [LHsTyVarBndr pass] Optional quantified type vars feqn_pats :: HsTyPats pass feqn_fixity :: LexicalFixity Fixity used in the declaration feqn_rhs :: rhs
XFamEqn (XXFamEqn pass rhs)

Instances

Instances details

Annotate (TyFamInstEqn GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> TyFamInstEqn GhcPs -> Annotated () #

type LClsInstDecl pass = Located (ClsInstDecl pass) #

Located Class Instance Declaration

data ClsInstDecl pass #

Class Instance Declaration

Constructors

ClsInstDecl	`AnnKeywordId` : `AnnInstance`, `AnnWhere`, `AnnOpen`,`AnnClose`,
Fields cid_ext :: XCClsInstDecl pass cid_poly_ty :: LHsSigType pass cid_binds :: LHsBinds pass cid_sigs :: [LSig pass] cid_tyfam_insts :: [LTyFamInstDecl pass] cid_datafam_insts :: [LDataFamInstDecl pass] cid_overlap_mode :: Maybe (Located OverlapMode) `AnnKeywordId` : `AnnOpen`, `AnnClose`,
XClsInstDecl (XXClsInstDecl pass)

Instances

Instances details

OutputableBndrId p => Outputable (ClsInstDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: ClsInstDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> ClsInstDecl (GhcPass p) -> SDoc #
Annotate (ClsInstDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> ClsInstDecl GhcPs -> Annotated () #

type LInstDecl pass = Located (InstDecl pass) #

Located Instance Declaration

data InstDecl pass #

Instance Declaration

Constructors

ClsInstD
Fields cid_d_ext :: XClsInstD pass cid_inst :: ClsInstDecl pass
DataFamInstD
Fields dfid_ext :: XDataFamInstD pass dfid_inst :: DataFamInstDecl pass
TyFamInstD
Fields tfid_ext :: XTyFamInstD pass tfid_inst :: TyFamInstDecl pass
XInstDecl (XXInstDecl pass)

Instances

Instances details

OutputableBndrId p => Outputable (InstDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: InstDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> InstDecl (GhcPass p) -> SDoc #
Annotate (InstDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> InstDecl GhcPs -> Annotated () #

type LDerivDecl pass = Located (DerivDecl pass) #

Located stand-alone 'deriving instance' declaration

data DerivDecl pass #

Stand-alone 'deriving instance' declaration

Constructors

DerivDecl
Fields deriv_ext :: XCDerivDecl pass deriv_type :: LHsSigWcType pass The instance type to derive. It uses an `LHsSigWcType` because the context is allowed to be a single wildcard: deriving instance _ => Eq (Foo a) Which signifies that the context should be inferred. deriv_strategy :: Maybe (LDerivStrategy pass) deriv_overlap_mode :: Maybe (Located OverlapMode) `AnnKeywordId` : `AnnDeriving`, `AnnInstance`, `AnnStock`, `AnnAnyClass`, `AnnNewtype`, `AnnOpen`,`AnnClose`
XDerivDecl (XXDerivDecl pass)

Instances

Instances details

OutputableBndrId p => Outputable (DerivDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: DerivDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> DerivDecl (GhcPass p) -> SDoc #
Annotate (DerivDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> DerivDecl GhcPs -> Annotated () #

type LDerivStrategy pass = Located (DerivStrategy pass) #

A Located DerivStrategy.

data DerivStrategy pass #

Which technique the user explicitly requested when deriving an instance.

Constructors

StockStrategy	GHC's "standard" strategy, which is to implement a custom instance for the data type. This only works for certain types that GHC knows about (e.g., `Eq`, `Show`, `Functor` when `-XDeriveFunctor` is enabled, etc.)
AnyclassStrategy	-XDeriveAnyClass
NewtypeStrategy	-XGeneralizedNewtypeDeriving
ViaStrategy (XViaStrategy pass)	-XDerivingVia

Instances

Instances details

OutputableBndrId p => Outputable (DerivStrategy (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: DerivStrategy (GhcPass p) -> SDoc # pprPrec :: Rational -> DerivStrategy (GhcPass p) -> SDoc #
Annotate (DerivStrategy GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> DerivStrategy GhcPs -> Annotated () #

type LDefaultDecl pass = Located (DefaultDecl pass) #

Located Default Declaration

data DefaultDecl pass #

Default Declaration

Constructors

DefaultDecl (XCDefaultDecl pass) [LHsType pass]	`AnnKeywordId`s : `AnnDefault`, `AnnOpen`,`AnnClose`
XDefaultDecl (XXDefaultDecl pass)

Instances

Instances details

OutputableBndrId p => Outputable (DefaultDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: DefaultDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> DefaultDecl (GhcPass p) -> SDoc #
Annotate (DefaultDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> DefaultDecl GhcPs -> Annotated () #

type LForeignDecl pass = Located (ForeignDecl pass) #

Located Foreign Declaration

data ForeignDecl pass #

Foreign Declaration

Constructors

ForeignImport
Fields fd_i_ext :: XForeignImport pass fd_name :: Located (IdP pass) fd_sig_ty :: LHsSigType pass fd_fi :: ForeignImport
ForeignExport	`AnnKeywordId` : `AnnForeign`, `AnnImport`,`AnnExport`, `AnnDcolon`
Fields fd_e_ext :: XForeignExport pass fd_name :: Located (IdP pass) fd_sig_ty :: LHsSigType pass fd_fe :: ForeignExport
XForeignDecl (XXForeignDecl pass)

Instances

Instances details

OutputableBndrId p => Outputable (ForeignDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: ForeignDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> ForeignDecl (GhcPass p) -> SDoc #
Annotate (ForeignDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> ForeignDecl GhcPs -> Annotated () #

data ForeignImport #

Constructors

CImport (Located CCallConv) (Located Safety) (Maybe Header) CImportSpec (Located SourceText)

Instances

Instances details

Data ForeignImport
Instance details Defined in GHC.Hs.Decls Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForeignImport -> c ForeignImport # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ForeignImport # toConstr :: ForeignImport -> Constr # dataTypeOf :: ForeignImport -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ForeignImport) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ForeignImport) # gmapT :: (forall b. Data b => b -> b) -> ForeignImport -> ForeignImport # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForeignImport -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForeignImport -> r # gmapQ :: (forall d. Data d => d -> u) -> ForeignImport -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ForeignImport -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForeignImport -> m ForeignImport # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignImport -> m ForeignImport # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignImport -> m ForeignImport #
Outputable ForeignImport
Instance details Defined in GHC.Hs.Decls Methods ppr :: ForeignImport -> SDoc # pprPrec :: Rational -> ForeignImport -> SDoc #

data CImportSpec #

Constructors

CLabel CLabelString
CFunction CCallTarget
CWrapper

Instances

Instances details

Data CImportSpec

Instance details

Defined in GHC.Hs.Decls

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CImportSpec -> c CImportSpec #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CImportSpec #

toConstr :: CImportSpec -> Constr #

dataTypeOf :: CImportSpec -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c CImportSpec) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CImportSpec) #

gmapT :: (forall b. Data b => b -> b) -> CImportSpec -> CImportSpec #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CImportSpec -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CImportSpec -> r #

gmapQ :: (forall d. Data d => d -> u) -> CImportSpec -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> CImportSpec -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CImportSpec -> m CImportSpec #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CImportSpec -> m CImportSpec #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CImportSpec -> m CImportSpec #

data ForeignExport #

Constructors

CExport (Located CExportSpec) (Located SourceText)

Instances

Instances details

Data ForeignExport
Instance details Defined in GHC.Hs.Decls Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForeignExport -> c ForeignExport # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ForeignExport # toConstr :: ForeignExport -> Constr # dataTypeOf :: ForeignExport -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ForeignExport) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ForeignExport) # gmapT :: (forall b. Data b => b -> b) -> ForeignExport -> ForeignExport # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForeignExport -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForeignExport -> r # gmapQ :: (forall d. Data d => d -> u) -> ForeignExport -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ForeignExport -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForeignExport -> m ForeignExport # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignExport -> m ForeignExport # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignExport -> m ForeignExport #
Outputable ForeignExport
Instance details Defined in GHC.Hs.Decls Methods ppr :: ForeignExport -> SDoc # pprPrec :: Rational -> ForeignExport -> SDoc #

type LRuleDecls pass = Located (RuleDecls pass) #

Located Rule Declarations

data RuleDecls pass #

Rule Declarations

Constructors

HsRules
Fields rds_ext :: XCRuleDecls pass rds_src :: SourceText rds_rules :: [LRuleDecl pass]
XRuleDecls (XXRuleDecls pass)

Instances

Instances details

OutputableBndrId p => Outputable (RuleDecls (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: RuleDecls (GhcPass p) -> SDoc # pprPrec :: Rational -> RuleDecls (GhcPass p) -> SDoc #
Annotate (RuleDecls GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> RuleDecls GhcPs -> Annotated () #

type LRuleDecl pass = Located (RuleDecl pass) #

Located Rule Declaration

data RuleDecl pass #

Rule Declaration

Constructors

HsRule	`AnnKeywordId` : `AnnOpen`,`AnnTilde`, `AnnVal`, `AnnClose`, `AnnForall`,`AnnDot`, `AnnEqual`,
Fields rd_ext :: XHsRule pass After renamer, free-vars from the LHS and RHS rd_name :: Located (SourceText, RuleName) Note [Pragma source text] in BasicTypes rd_act :: Activation rd_tyvs :: Maybe [LHsTyVarBndr (NoGhcTc pass)] Forall'd type vars rd_tmvs :: [LRuleBndr pass] Forall'd term vars, before typechecking; after typechecking this includes all forall'd vars rd_lhs :: Located (HsExpr pass) rd_rhs :: Located (HsExpr pass)
XRuleDecl (XXRuleDecl pass)

Instances

Instances details

OutputableBndrId p => Outputable (RuleDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: RuleDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> RuleDecl (GhcPass p) -> SDoc #
Annotate (RuleDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> RuleDecl GhcPs -> Annotated () #

data HsRuleRn #

Constructors

HsRuleRn NameSet NameSet

Instances

Instances details

Data HsRuleRn

Instance details

Defined in GHC.Hs.Decls

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsRuleRn -> c HsRuleRn #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsRuleRn #

toConstr :: HsRuleRn -> Constr #

dataTypeOf :: HsRuleRn -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsRuleRn) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsRuleRn) #

gmapT :: (forall b. Data b => b -> b) -> HsRuleRn -> HsRuleRn #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsRuleRn -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsRuleRn -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsRuleRn -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsRuleRn -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsRuleRn -> m HsRuleRn #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsRuleRn -> m HsRuleRn #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsRuleRn -> m HsRuleRn #

type LRuleBndr pass = Located (RuleBndr pass) #

Located Rule Binder

data RuleBndr pass #

Rule Binder

Constructors

RuleBndr (XCRuleBndr pass) (Located (IdP pass))
RuleBndrSig (XRuleBndrSig pass) (Located (IdP pass)) (LHsSigWcType pass)
XRuleBndr (XXRuleBndr pass)	`AnnKeywordId` : `AnnOpen`, `AnnDcolon`,`AnnClose`

Instances

Instances details

OutputableBndrId p => Outputable (RuleBndr (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: RuleBndr (GhcPass p) -> SDoc # pprPrec :: Rational -> RuleBndr (GhcPass p) -> SDoc #
Annotate (RuleBndr GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> RuleBndr GhcPs -> Annotated () #

type LDocDecl = Located DocDecl #

Located Documentation comment Declaration

data DocDecl #

Documentation comment Declaration

Constructors

DocCommentNext HsDocString
DocCommentPrev HsDocString
DocCommentNamed String HsDocString
DocGroup Int HsDocString

Instances

Instances details

Data DocDecl
Instance details Defined in GHC.Hs.Decls Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DocDecl -> c DocDecl # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DocDecl # toConstr :: DocDecl -> Constr # dataTypeOf :: DocDecl -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DocDecl) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DocDecl) # gmapT :: (forall b. Data b => b -> b) -> DocDecl -> DocDecl # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DocDecl -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DocDecl -> r # gmapQ :: (forall d. Data d => d -> u) -> DocDecl -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DocDecl -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DocDecl -> m DocDecl # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DocDecl -> m DocDecl # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DocDecl -> m DocDecl #
Outputable DocDecl
Instance details Defined in GHC.Hs.Decls Methods ppr :: DocDecl -> SDoc # pprPrec :: Rational -> DocDecl -> SDoc #
Annotate DocDecl
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> DocDecl -> Annotated () #

type LWarnDecls pass = Located (WarnDecls pass) #

Located Warning Declarations

data WarnDecls pass #

Warning pragma Declarations

Constructors

Warnings
Fields wd_ext :: XWarnings pass wd_src :: SourceText wd_warnings :: [LWarnDecl pass]
XWarnDecls (XXWarnDecls pass)

Instances

Instances details

OutputableBndr (IdP (GhcPass p)) => Outputable (WarnDecls (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: WarnDecls (GhcPass p) -> SDoc # pprPrec :: Rational -> WarnDecls (GhcPass p) -> SDoc #
Annotate (WarnDecls GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> WarnDecls GhcPs -> Annotated () #

type LWarnDecl pass = Located (WarnDecl pass) #

Located Warning pragma Declaration

data WarnDecl pass #

Warning pragma Declaration

Constructors

Warning (XWarning pass) [Located (IdP pass)] WarningTxt
XWarnDecl (XXWarnDecl pass)

Instances

Instances details

OutputableBndr (IdP (GhcPass p)) => Outputable (WarnDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: WarnDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> WarnDecl (GhcPass p) -> SDoc #
Annotate (WarnDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> WarnDecl GhcPs -> Annotated () #

type LAnnDecl pass = Located (AnnDecl pass) #

Located Annotation Declaration

data AnnDecl pass #

Annotation Declaration

Constructors

HsAnnotation (XHsAnnotation pass) SourceText (AnnProvenance (IdP pass)) (Located (HsExpr pass))	`AnnKeywordId` : `AnnOpen`, `AnnType` `AnnModule` `AnnClose`
XAnnDecl (XXAnnDecl pass)

Instances

Instances details

OutputableBndrId p => Outputable (AnnDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: AnnDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> AnnDecl (GhcPass p) -> SDoc #
Annotate (AnnDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> AnnDecl GhcPs -> Annotated () #

data AnnProvenance name #

Annotation Provenance

Constructors

ValueAnnProvenance (Located name)
TypeAnnProvenance (Located name)
ModuleAnnProvenance

Instances

Instances details

Functor AnnProvenance
Instance details Defined in GHC.Hs.Decls Methods fmap :: (a -> b) -> AnnProvenance a -> AnnProvenance b # (<$) :: a -> AnnProvenance b -> AnnProvenance a #
Foldable AnnProvenance
Instance details Defined in GHC.Hs.Decls Methods fold :: Monoid m => AnnProvenance m -> m # foldMap :: Monoid m => (a -> m) -> AnnProvenance a -> m # foldMap' :: Monoid m => (a -> m) -> AnnProvenance a -> m # foldr :: (a -> b -> b) -> b -> AnnProvenance a -> b # foldr' :: (a -> b -> b) -> b -> AnnProvenance a -> b # foldl :: (b -> a -> b) -> b -> AnnProvenance a -> b # foldl' :: (b -> a -> b) -> b -> AnnProvenance a -> b # foldr1 :: (a -> a -> a) -> AnnProvenance a -> a # foldl1 :: (a -> a -> a) -> AnnProvenance a -> a # toList :: AnnProvenance a -> [a] # null :: AnnProvenance a -> Bool # length :: AnnProvenance a -> Int # elem :: Eq a => a -> AnnProvenance a -> Bool # maximum :: Ord a => AnnProvenance a -> a # minimum :: Ord a => AnnProvenance a -> a # sum :: Num a => AnnProvenance a -> a # product :: Num a => AnnProvenance a -> a #
Traversable AnnProvenance
Instance details Defined in GHC.Hs.Decls Methods traverse :: Applicative f => (a -> f b) -> AnnProvenance a -> f (AnnProvenance b) # sequenceA :: Applicative f => AnnProvenance (f a) -> f (AnnProvenance a) # mapM :: Monad m => (a -> m b) -> AnnProvenance a -> m (AnnProvenance b) # sequence :: Monad m => AnnProvenance (m a) -> m (AnnProvenance a) #
Data pass => Data (AnnProvenance pass)
Instance details Defined in GHC.Hs.Decls Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnProvenance pass -> c (AnnProvenance pass) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnProvenance pass) # toConstr :: AnnProvenance pass -> Constr # dataTypeOf :: AnnProvenance pass -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AnnProvenance pass)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (AnnProvenance pass)) # gmapT :: (forall b. Data b => b -> b) -> AnnProvenance pass -> AnnProvenance pass # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnProvenance pass -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnProvenance pass -> r # gmapQ :: (forall d. Data d => d -> u) -> AnnProvenance pass -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnProvenance pass -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnProvenance pass -> m (AnnProvenance pass) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnProvenance pass -> m (AnnProvenance pass) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnProvenance pass -> m (AnnProvenance pass) #

type LRoleAnnotDecl pass = Located (RoleAnnotDecl pass) #

Located Role Annotation Declaration

data RoleAnnotDecl pass #

Role Annotation Declaration

Constructors

RoleAnnotDecl (XCRoleAnnotDecl pass) (Located (IdP pass)) [Located (Maybe Role)]	`AnnKeywordId` : `AnnType`, `AnnRole`
XRoleAnnotDecl (XXRoleAnnotDecl pass)

Instances

Instances details

OutputableBndr (IdP (GhcPass p)) => Outputable (RoleAnnotDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: RoleAnnotDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> RoleAnnotDecl (GhcPass p) -> SDoc #
Annotate (RoleAnnotDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> RoleAnnotDecl GhcPs -> Annotated () #

collectEvVarsPat :: Pat GhcTc -> Bag EvVar #

collectEvVarsPats :: [Pat GhcTc] -> Bag EvVar #

parenthesizePat :: forall (p :: Pass). PprPrec -> LPat (GhcPass p) -> LPat (GhcPass p) #

parenthesizePat p pat checks if patNeedsParens p pat is true, and if so, surrounds pat with a ParPat. Otherwise, it simply returns pat.

patNeedsParens :: PprPrec -> Pat p -> Bool #

patNeedsParens p pat returns True if the pattern pat needs parentheses under precedence p.

isIrrefutableHsPat :: forall (p :: Pass). OutputableBndrId p => LPat (GhcPass p) -> Bool #

looksLazyPatBind :: forall (p :: Pass). HsBind (GhcPass p) -> Bool #

isBangedLPat :: forall (p :: Pass). LPat (GhcPass p) -> Bool #

mkCharLitPat :: forall (p :: Pass). SourceText -> Char -> OutPat (GhcPass p) #

mkNilPat :: forall (p :: Pass). Type -> OutPat (GhcPass p) #

mkPrefixConPat :: forall (p :: Pass). DataCon -> [OutPat (GhcPass p)] -> [Type] -> OutPat (GhcPass p) #

pprConArgs :: forall (p :: Pass). OutputableBndrId p => HsConPatDetails (GhcPass p) -> SDoc #

pprParendLPat :: forall (p :: Pass). OutputableBndrId p => PprPrec -> LPat (GhcPass p) -> SDoc #

hsRecUpdFieldOcc :: HsRecField' (AmbiguousFieldOcc GhcTc) arg -> LFieldOcc GhcTc #

hsRecUpdFieldId :: HsRecField' (AmbiguousFieldOcc GhcTc) arg -> Located Id #

hsRecUpdFieldRdr :: forall (p :: Pass). HsRecUpdField (GhcPass p) -> Located RdrName #

hsRecFieldId :: HsRecField GhcTc arg -> Located Id #

hsRecFieldSel :: HsRecField pass arg -> Located (XCFieldOcc pass) #

hsRecFieldsArgs :: HsRecFields p arg -> [arg] #

hsRecFields :: HsRecFields p arg -> [XCFieldOcc p] #

hsConPatArgs :: HsConPatDetails p -> [LPat p] #

type InPat p = LPat p #

type OutPat p = LPat p #

data ListPatTc #

Constructors

ListPatTc Type (Maybe (Type, SyntaxExpr GhcTc))

type HsConPatDetails p = HsConDetails (LPat p) (HsRecFields p (LPat p)) #

Haskell Constructor Pattern Details

data HsRecFields p arg #

Haskell Record Fields

HsRecFields is used only for patterns and expressions (not data type declarations)

Constructors

HsRecFields
Fields rec_flds :: [LHsRecField p arg] rec_dotdot :: Maybe (Located Int)

Instances

Instances details

Functor (HsRecFields p)
Instance details Defined in GHC.Hs.Pat Methods fmap :: (a -> b) -> HsRecFields p a -> HsRecFields p b # (<$) :: a -> HsRecFields p b -> HsRecFields p a #
Foldable (HsRecFields p)
Instance details Defined in GHC.Hs.Pat Methods fold :: Monoid m => HsRecFields p m -> m # foldMap :: Monoid m => (a -> m) -> HsRecFields p a -> m # foldMap' :: Monoid m => (a -> m) -> HsRecFields p a -> m # foldr :: (a -> b -> b) -> b -> HsRecFields p a -> b # foldr' :: (a -> b -> b) -> b -> HsRecFields p a -> b # foldl :: (b -> a -> b) -> b -> HsRecFields p a -> b # foldl' :: (b -> a -> b) -> b -> HsRecFields p a -> b # foldr1 :: (a -> a -> a) -> HsRecFields p a -> a # foldl1 :: (a -> a -> a) -> HsRecFields p a -> a # toList :: HsRecFields p a -> [a] # null :: HsRecFields p a -> Bool # length :: HsRecFields p a -> Int # elem :: Eq a => a -> HsRecFields p a -> Bool # maximum :: Ord a => HsRecFields p a -> a # minimum :: Ord a => HsRecFields p a -> a # sum :: Num a => HsRecFields p a -> a # product :: Num a => HsRecFields p a -> a #
Traversable (HsRecFields p)
Instance details Defined in GHC.Hs.Pat Methods traverse :: Applicative f => (a -> f b) -> HsRecFields p a -> f (HsRecFields p b) # sequenceA :: Applicative f => HsRecFields p (f a) -> f (HsRecFields p a) # mapM :: Monad m => (a -> m b) -> HsRecFields p a -> m (HsRecFields p b) # sequence :: Monad m => HsRecFields p (m a) -> m (HsRecFields p a) #
Outputable arg => Outputable (HsRecFields p arg)
Instance details Defined in GHC.Hs.Pat Methods ppr :: HsRecFields p arg -> SDoc # pprPrec :: Rational -> HsRecFields p arg -> SDoc #

type LHsRecField' p arg = Located (HsRecField' p arg) #

Located Haskell Record Field

type LHsRecField p arg = Located (HsRecField p arg) #

Located Haskell Record Field

type LHsRecUpdField p = Located (HsRecUpdField p) #

Located Haskell Record Update Field

type HsRecField p arg = HsRecField' (FieldOcc p) arg #

Haskell Record Field

type HsRecUpdField p = HsRecField' (AmbiguousFieldOcc p) (LHsExpr p) #

Haskell Record Update Field

data HsRecField' id arg #

Haskell Record Field

AnnKeywordId : AnnEqual,

For details on above see note [Api annotations] in ApiAnnotation

Constructors

HsRecField
Fields hsRecFieldLbl :: Located id hsRecFieldArg :: arg Filled in by renamer when punning hsRecPun :: Bool Note [Punning]

Instances

Instances details

Functor (HsRecField' id)
Instance details Defined in GHC.Hs.Pat Methods fmap :: (a -> b) -> HsRecField' id a -> HsRecField' id b # (<$) :: a -> HsRecField' id b -> HsRecField' id a #
Foldable (HsRecField' id)
Instance details Defined in GHC.Hs.Pat Methods fold :: Monoid m => HsRecField' id m -> m # foldMap :: Monoid m => (a -> m) -> HsRecField' id a -> m # foldMap' :: Monoid m => (a -> m) -> HsRecField' id a -> m # foldr :: (a -> b -> b) -> b -> HsRecField' id a -> b # foldr' :: (a -> b -> b) -> b -> HsRecField' id a -> b # foldl :: (b -> a -> b) -> b -> HsRecField' id a -> b # foldl' :: (b -> a -> b) -> b -> HsRecField' id a -> b # foldr1 :: (a -> a -> a) -> HsRecField' id a -> a # foldl1 :: (a -> a -> a) -> HsRecField' id a -> a # toList :: HsRecField' id a -> [a] # null :: HsRecField' id a -> Bool # length :: HsRecField' id a -> Int # elem :: Eq a => a -> HsRecField' id a -> Bool # maximum :: Ord a => HsRecField' id a -> a # minimum :: Ord a => HsRecField' id a -> a # sum :: Num a => HsRecField' id a -> a # product :: Num a => HsRecField' id a -> a #
Traversable (HsRecField' id)
Instance details Defined in GHC.Hs.Pat Methods traverse :: Applicative f => (a -> f b) -> HsRecField' id a -> f (HsRecField' id b) # sequenceA :: Applicative f => HsRecField' id (f a) -> f (HsRecField' id a) # mapM :: Monad m => (a -> m b) -> HsRecField' id a -> m (HsRecField' id b) # sequence :: Monad m => HsRecField' id (m a) -> m (HsRecField' id a) #
Annotate (HsRecUpdField GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsRecUpdField GhcPs -> Annotated () #
(Data id, Data arg) => Data (HsRecField' id arg)
Instance details Defined in GHC.Hs.Pat Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsRecField' id arg -> c (HsRecField' id arg) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsRecField' id arg) # toConstr :: HsRecField' id arg -> Constr # dataTypeOf :: HsRecField' id arg -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsRecField' id arg)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsRecField' id arg)) # gmapT :: (forall b. Data b => b -> b) -> HsRecField' id arg -> HsRecField' id arg # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsRecField' id arg -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsRecField' id arg -> r # gmapQ :: (forall d. Data d => d -> u) -> HsRecField' id arg -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsRecField' id arg -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsRecField' id arg -> m (HsRecField' id arg) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsRecField' id arg -> m (HsRecField' id arg) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsRecField' id arg -> m (HsRecField' id arg) #
(Outputable p, Outputable arg) => Outputable (HsRecField' p arg)
Instance details Defined in GHC.Hs.Pat Methods ppr :: HsRecField' p arg -> SDoc # pprPrec :: Rational -> HsRecField' p arg -> SDoc #
Annotate (HsRecField GhcPs (LHsExpr GhcPs))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsRecField GhcPs (LHsExpr GhcPs) -> Annotated () #
Annotate (HsRecField GhcPs (Located (Pat GhcPs)))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsRecField GhcPs (Located (Pat GhcPs)) -> Annotated () #

pprMinimalSig :: OutputableBndr name => LBooleanFormula (Located name) -> SDoc #

pprTcSpecPrags :: TcSpecPrags -> SDoc #

pprSpec :: OutputableBndr id => id -> SDoc -> InlinePragma -> SDoc #

pprVarSig :: OutputableBndr id => [id] -> SDoc -> SDoc #

pragSrcBrackets :: SourceText -> String -> SDoc -> SDoc #

Using SourceText in case the pragma was spelled differently or used mixed case

pragBrackets :: SDoc -> SDoc #

ppr_sig :: forall (p :: Pass). OutputableBndrId p => Sig (GhcPass p) -> SDoc #

hsSigDoc :: Sig name -> SDoc #

isCompleteMatchSig :: LSig name -> Bool #

isSCCFunSig :: LSig name -> Bool #

isMinimalLSig :: LSig name -> Bool #

isInlineLSig :: LSig name -> Bool #

isPragLSig :: LSig name -> Bool #

isSpecInstLSig :: LSig name -> Bool #

isSpecLSig :: LSig name -> Bool #

isTypeLSig :: LSig name -> Bool #

isFixityLSig :: LSig name -> Bool #

isDefaultMethod :: TcSpecPrags -> Bool #

hasSpecPrags :: TcSpecPrags -> Bool #

noSpecPrags :: TcSpecPrags #

isEmptyIPBindsTc :: HsIPBinds GhcTc -> Bool #

isEmptyIPBindsPR :: forall (p :: Pass). HsIPBinds (GhcPass p) -> Bool #

pprTicks :: SDoc -> SDoc -> SDoc #

ppr_monobind :: forall (idL :: Pass) (idR :: Pass). (OutputableBndrId idL, OutputableBndrId idR) => HsBindLR (GhcPass idL) (GhcPass idR) -> SDoc #

plusHsValBinds :: forall (a :: Pass). HsValBinds (GhcPass a) -> HsValBinds (GhcPass a) -> HsValBinds (GhcPass a) #

isEmptyLHsBinds :: LHsBindsLR idL idR -> Bool #

emptyLHsBinds :: LHsBindsLR idL idR #

emptyValBindsOut :: forall (a :: Pass) (b :: Pass). HsValBindsLR (GhcPass a) (GhcPass b) #

emptyValBindsIn :: forall (a :: Pass) (b :: Pass). HsValBindsLR (GhcPass a) (GhcPass b) #

isEmptyValBinds :: forall (a :: Pass) (b :: Pass). HsValBindsLR (GhcPass a) (GhcPass b) -> Bool #

eqEmptyLocalBinds :: HsLocalBindsLR a b -> Bool #

isEmptyLocalBindsPR :: forall (a :: Pass) (b :: Pass). HsLocalBindsLR (GhcPass a) (GhcPass b) -> Bool #

isEmptyLocalBindsTc :: forall (a :: Pass). HsLocalBindsLR (GhcPass a) GhcTc -> Bool #

emptyLocalBinds :: forall (a :: Pass) (b :: Pass). HsLocalBindsLR (GhcPass a) (GhcPass b) #

pprDeclList :: [SDoc] -> SDoc #

pprLHsBindsForUser :: forall (idL :: Pass) (idR :: Pass) (id2 :: Pass). (OutputableBndrId idL, OutputableBndrId idR, OutputableBndrId id2) => LHsBindsLR (GhcPass idL) (GhcPass idR) -> [LSig (GhcPass id2)] -> [SDoc] #

pprLHsBinds :: forall (idL :: Pass) (idR :: Pass). (OutputableBndrId idL, OutputableBndrId idR) => LHsBindsLR (GhcPass idL) (GhcPass idR) -> SDoc #

type HsLocalBinds id = HsLocalBindsLR id id #

Haskell Local Bindings

type LHsLocalBinds id = Located (HsLocalBinds id) #

Located Haskell local bindings

data HsLocalBindsLR idL idR #

Haskell Local Bindings with separate Left and Right identifier types

Bindings in a 'let' expression or a 'where' clause

Constructors

HsValBinds (XHsValBinds idL idR) (HsValBindsLR idL idR)	Haskell Value Bindings
HsIPBinds (XHsIPBinds idL idR) (HsIPBinds idR)	Haskell Implicit Parameter Bindings
EmptyLocalBinds (XEmptyLocalBinds idL idR)	Empty Local Bindings
XHsLocalBindsLR (XXHsLocalBindsLR idL idR)

Instances

Instances details

Annotate (HsLocalBinds GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsLocalBinds GhcPs -> Annotated () #
(OutputableBndrId pl, OutputableBndrId pr) => Outputable (HsLocalBindsLR (GhcPass pl) (GhcPass pr))
Instance details Defined in GHC.Hs.Binds Methods ppr :: HsLocalBindsLR (GhcPass pl) (GhcPass pr) -> SDoc # pprPrec :: Rational -> HsLocalBindsLR (GhcPass pl) (GhcPass pr) -> SDoc #

type LHsLocalBindsLR idL idR = Located (HsLocalBindsLR idL idR) #

type HsValBinds id = HsValBindsLR id id #

Haskell Value Bindings

data HsValBindsLR idL idR #

Haskell Value bindings with separate Left and Right identifier types (not implicit parameters) Used for both top level and nested bindings May contain pattern synonym bindings

Constructors

ValBinds (XValBinds idL idR) (LHsBindsLR idL idR) [LSig idR]

Value Bindings In

Before renaming RHS; idR is always RdrName Not dependency analysed Recursive by default

XValBindsLR (XXValBindsLR idL idR)

Value Bindings Out

After renaming RHS; idR can be Name or Id Dependency analysed, later bindings in the list may depend on earlier ones.

Instances

Instances details

(OutputableBndrId pl, OutputableBndrId pr) => Outputable (HsValBindsLR (GhcPass pl) (GhcPass pr))
Instance details Defined in GHC.Hs.Binds Methods ppr :: HsValBindsLR (GhcPass pl) (GhcPass pr) -> SDoc # pprPrec :: Rational -> HsValBindsLR (GhcPass pl) (GhcPass pr) -> SDoc #

data NHsValBindsLR idL #

Constructors

NValBinds [(RecFlag, LHsBinds idL)] [LSig GhcRn]

type LHsBind id = LHsBindLR id id #

Located Haskell Binding

type LHsBinds id = LHsBindsLR id id #

Located Haskell Bindings

type HsBind id = HsBindLR id id #

Haskell Binding

type LHsBindsLR idL idR = Bag (LHsBindLR idL idR) #

Located Haskell Bindings with separate Left and Right identifier types

type LHsBindLR idL idR = Located (HsBindLR idL idR) #

Located Haskell Binding with separate Left and Right identifier types

data HsBindLR idL idR #

Haskell Binding with separate Left and Right id's

Constructors

FunBind	Function-like Binding FunBind is used for both functions `f x = e` and variables `f = x -> e` and strict variables `!x = x + 1` Reason 1: Special case for type inference: see `tcMonoBinds`. Reason 2: Instance decls can only have FunBinds, which is convenient. If you change this, you'll need to change e.g. rnMethodBinds But note that the form `f :: a->a = ...` parses as a pattern binding, just like `(f :: a -> a) = ...` Strict bindings have their strictness recorded in the `SrcStrictness` of their `MatchContext`. See Note [FunBind vs PatBind] for details about the relationship between FunBind and PatBind. `AnnKeywordId`s `AnnFunId`, attached to each element of fun_matches `AnnEqual`,`AnnWhere`, `AnnOpen`,`AnnClose`,
Fields fun_ext :: XFunBind idL idR After the renamer, this contains the locally-bound free variables of this defn. See Note [Bind free vars] fun_id :: Located (IdP idL) fun_matches :: MatchGroup idR (LHsExpr idR) The payload fun_co_fn :: HsWrapper Coercion from the type of the MatchGroup to the type of the Id. Example: f :: Int -> forall a. a -> a f x y = y Then the MatchGroup will have type (Int -> a' -> a') (with a free type variable a'). The coercion will take a CoreExpr of this type and convert it to a CoreExpr of type Int -> forall a'. a' -> a' Notice that the coercion captures the free a'. fun_tick :: [Tickish Id] Ticks to put on the rhs, if any
PatBind	Pattern Binding The pattern is never a simple variable; That case is done by FunBind. See Note [FunBind vs PatBind] for details about the relationship between FunBind and PatBind.
Fields pat_ext :: XPatBind idL idR See Note [Bind free vars] pat_lhs :: LPat idL pat_rhs :: GRHSs idR (LHsExpr idR) pat_ticks :: ([Tickish Id], [[Tickish Id]]) Ticks to put on the rhs, if any, and ticks to put on the bound variables.
VarBind	Variable Binding Dictionary binding and suchlike. All VarBinds are introduced by the type checker
Fields var_ext :: XVarBind idL idR var_id :: IdP idL var_rhs :: LHsExpr idR Located only for consistency var_inline :: Bool True = inline this binding regardless (used for implication constraints only)
AbsBinds	Abstraction Bindings
Fields abs_ext :: XAbsBinds idL idR abs_tvs :: [TyVar] abs_ev_vars :: [EvVar] Includes equality constraints abs_exports :: [ABExport idL] AbsBinds only gets used when idL = idR after renaming, but these need to be idL's for the collect... code in HsUtil to have the right type abs_ev_binds :: [TcEvBinds] Evidence bindings Why a list? See TcInstDcls Note [Typechecking plan for instance declarations] abs_binds :: LHsBinds idL Typechecked user bindings abs_sig :: Bool
PatSynBind (XPatSynBind idL idR) (PatSynBind idL idR)	`AnnKeywordId` : `AnnPattern`, `AnnLarrow`,`AnnEqual`, `AnnWhere` `AnnOpen` `'{'`,`AnnClose` `'}'`
XHsBindsLR (XXHsBindsLR idL idR)

Instances

Instances details

Annotate (HsBind GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsBind GhcPs -> Annotated () #
(OutputableBndrId pl, OutputableBndrId pr) => Outputable (HsBindLR (GhcPass pl) (GhcPass pr))
Instance details Defined in GHC.Hs.Binds Methods ppr :: HsBindLR (GhcPass pl) (GhcPass pr) -> SDoc # pprPrec :: Rational -> HsBindLR (GhcPass pl) (GhcPass pr) -> SDoc #

data NPatBindTc #

Constructors

NPatBindTc
Fields pat_fvs :: NameSet Free variables pat_rhs_ty :: Type Type of the GRHSs

Instances

Instances details

Data NPatBindTc

Instance details

Defined in GHC.Hs.Binds

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NPatBindTc -> c NPatBindTc #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NPatBindTc #

toConstr :: NPatBindTc -> Constr #

dataTypeOf :: NPatBindTc -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NPatBindTc) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NPatBindTc) #

gmapT :: (forall b. Data b => b -> b) -> NPatBindTc -> NPatBindTc #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NPatBindTc -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NPatBindTc -> r #

gmapQ :: (forall d. Data d => d -> u) -> NPatBindTc -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> NPatBindTc -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NPatBindTc -> m NPatBindTc #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NPatBindTc -> m NPatBindTc #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NPatBindTc -> m NPatBindTc #

data ABExport p #

Abtraction Bindings Export

Constructors

ABE
Fields abe_ext :: XABE p abe_poly :: IdP p Any INLINE pragma is attached to this Id abe_mono :: IdP p abe_wrap :: HsWrapper See Note [ABExport wrapper] Shape: (forall abs_tvs. abs_ev_vars => abe_mono) ~ abe_poly abe_prags :: TcSpecPrags SPECIALISE pragmas
XABExport (XXABExport p)

Instances

Instances details

OutputableBndrId p => Outputable (ABExport (GhcPass p))
Instance details Defined in GHC.Hs.Binds Methods ppr :: ABExport (GhcPass p) -> SDoc # pprPrec :: Rational -> ABExport (GhcPass p) -> SDoc #

data PatSynBind idL idR #

AnnKeywordId : AnnPattern, AnnEqual,AnnLarrow AnnWhere,AnnOpen '{', AnnClose '}',

Pattern Synonym binding

Constructors

PSB
Fields psb_ext :: XPSB idL idR Post renaming, FVs. See Note [Bind free vars] psb_id :: Located (IdP idL) Name of the pattern synonym psb_args :: HsPatSynDetails (Located (IdP idR)) Formal parameter names psb_def :: LPat idR Right-hand side psb_dir :: HsPatSynDir idR Directionality
XPatSynBind (XXPatSynBind idL idR)

Instances

Instances details

(OutputableBndrId l, OutputableBndrId r, Outputable (XXPatSynBind (GhcPass l) (GhcPass r))) => Outputable (PatSynBind (GhcPass l) (GhcPass r))
Instance details Defined in GHC.Hs.Binds Methods ppr :: PatSynBind (GhcPass l) (GhcPass r) -> SDoc # pprPrec :: Rational -> PatSynBind (GhcPass l) (GhcPass r) -> SDoc #

data HsIPBinds id #

Haskell Implicit Parameter Bindings

Constructors

IPBinds (XIPBinds id) [LIPBind id]
XHsIPBinds (XXHsIPBinds id)

Instances

Instances details

OutputableBndrId p => Outputable (HsIPBinds (GhcPass p))
Instance details Defined in GHC.Hs.Binds Methods ppr :: HsIPBinds (GhcPass p) -> SDoc # pprPrec :: Rational -> HsIPBinds (GhcPass p) -> SDoc #

type LIPBind id = Located (IPBind id) #

Located Implicit Parameter Binding

May have AnnKeywordId : AnnSemi when in a list

data IPBind id #

Implicit parameter bindings.

These bindings start off as (Left "x") in the parser and stay that way until after type-checking when they are replaced with (Right d), where "d" is the name of the dictionary holding the evidence for the implicit parameter.

AnnKeywordId : AnnEqual

Constructors

IPBind (XCIPBind id) (Either (Located HsIPName) (IdP id)) (LHsExpr id)
XIPBind (XXIPBind id)

Instances

Instances details

OutputableBndrId p => Outputable (IPBind (GhcPass p))
Instance details Defined in GHC.Hs.Binds Methods ppr :: IPBind (GhcPass p) -> SDoc # pprPrec :: Rational -> IPBind (GhcPass p) -> SDoc #
Annotate (IPBind GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> IPBind GhcPs -> Annotated () #

type LSig pass = Located (Sig pass) #

Located Signature

data Sig pass #

Signatures and pragmas

Constructors

TypeSig (XTypeSig pass) [Located (IdP pass)] (LHsSigWcType pass)	An ordinary type signature f :: Num a => a -> a After renaming, this list of Names contains the named wildcards brought into scope by this signature. For a signature `_ -> _a -> Bool`, the renamer will leave the unnamed wildcard `_` untouched, and the named wildcard `_a` is then replaced with fresh meta vars in the type. Their names are stored in the type signature that brought them into scope, in this third field to be more specific. `AnnKeywordId` : `AnnDcolon`, `AnnComma`
PatSynSig (XPatSynSig pass) [Located (IdP pass)] (LHsSigType pass)	A pattern synonym type signature pattern Single :: () => (Show a) => a -> [a] `AnnKeywordId` : `AnnPattern`, `AnnDcolon`,`AnnForall` `AnnDot`,`AnnDarrow`
ClassOpSig (XClassOpSig pass) Bool [Located (IdP pass)] (LHsSigType pass)	A signature for a class method False: ordinary class-method signature True: generic-default class method signature e.g. class C a where op :: a -> a -- Ordinary default op :: Eq a => a -> a -- Generic default No wildcards allowed here `AnnKeywordId` : `AnnDefault`, `AnnDcolon`
IdSig (XIdSig pass) Id	A type signature in generated code, notably the code generated for record selectors. We simply record the desired Id itself, replete with its name, type and IdDetails. Otherwise it's just like a type signature: there should be an accompanying binding
FixSig (XFixSig pass) (FixitySig pass)	An ordinary fixity declaration infixl 8 *** `AnnKeywordId` : `AnnInfix`, `AnnVal`
InlineSig (XInlineSig pass) (Located (IdP pass)) InlinePragma	An inline pragma {#- INLINE f #-} `AnnKeywordId` : `AnnOpen` `'{-# INLINE'` and `'['`, `AnnClose`,`AnnOpen`, `AnnVal`,`AnnTilde`, `AnnClose`
SpecSig (XSpecSig pass) (Located (IdP pass)) [LHsSigType pass] InlinePragma	A specialisation pragma {-# SPECIALISE f :: Int -> Int #-} `AnnKeywordId` : `AnnOpen`, `AnnOpen` `'{-# SPECIALISE'` and `'['`, `AnnTilde`, `AnnVal`, `AnnClose` `']'` and `'#-}'`, `AnnDcolon`
SpecInstSig (XSpecInstSig pass) SourceText (LHsSigType pass)	A specialisation pragma for instance declarations only {-# SPECIALISE instance Eq [Int] #-} (Class tys); should be a specialisation of the current instance declaration `AnnKeywordId` : `AnnOpen`, `AnnInstance`,`AnnClose`
MinimalSig (XMinimalSig pass) SourceText (LBooleanFormula (Located (IdP pass)))	A minimal complete definition pragma {-# MINIMAL a \| (b, c \| (d \| e)) #-} `AnnKeywordId` : `AnnOpen`, `AnnVbar`,`AnnComma`, `AnnClose`
SCCFunSig (XSCCFunSig pass) SourceText (Located (IdP pass)) (Maybe (Located StringLiteral))	A "set cost centre" pragma for declarations {-# SCC funName #-} or {-# SCC funName "cost_centre_name" #-}
CompleteMatchSig (XCompleteMatchSig pass) SourceText (Located [Located (IdP pass)]) (Maybe (Located (IdP pass)))	A complete match pragma {-# COMPLETE C, D [:: T] #-} Used to inform the pattern match checker about additional complete matchings which, for example, arise from pattern synonym definitions.
XSig (XXSig pass)

Instances

Instances details

OutputableBndrId p => Outputable (Sig (GhcPass p))
Instance details Defined in GHC.Hs.Binds Methods ppr :: Sig (GhcPass p) -> SDoc # pprPrec :: Rational -> Sig (GhcPass p) -> SDoc #
Annotate (Sig GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> Sig GhcPs -> Annotated () #

type LFixitySig pass = Located (FixitySig pass) #

Located Fixity Signature

data FixitySig pass #

Fixity Signature

Constructors

FixitySig (XFixitySig pass) [Located (IdP pass)] Fixity
XFixitySig (XXFixitySig pass)

Instances

Instances details

OutputableBndrId p => Outputable (FixitySig (GhcPass p))
Instance details Defined in GHC.Hs.Binds Methods ppr :: FixitySig (GhcPass p) -> SDoc # pprPrec :: Rational -> FixitySig (GhcPass p) -> SDoc #

data TcSpecPrags #

Type checker Specialisation Pragmas

TcSpecPrags conveys SPECIALISE pragmas from the type checker to the desugarer

Constructors

IsDefaultMethod	Super-specialised: a default method should be macro-expanded at every call site
SpecPrags [LTcSpecPrag]

Instances

Instances details

Data TcSpecPrags

Instance details

Defined in GHC.Hs.Binds

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TcSpecPrags -> c TcSpecPrags #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TcSpecPrags #

toConstr :: TcSpecPrags -> Constr #

dataTypeOf :: TcSpecPrags -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TcSpecPrags) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TcSpecPrags) #

gmapT :: (forall b. Data b => b -> b) -> TcSpecPrags -> TcSpecPrags #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TcSpecPrags -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TcSpecPrags -> r #

gmapQ :: (forall d. Data d => d -> u) -> TcSpecPrags -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TcSpecPrags -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TcSpecPrags -> m TcSpecPrags #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TcSpecPrags -> m TcSpecPrags #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TcSpecPrags -> m TcSpecPrags #

type LTcSpecPrag = Located TcSpecPrag #

Located Type checker Specification Pragmas

data TcSpecPrag #

Type checker Specification Pragma

Constructors

SpecPrag Id HsWrapper InlinePragma

The Id to be specialised, a wrapper that specialises the polymorphic function, and inlining spec for the specialised function

Instances

Instances details

Data TcSpecPrag
Instance details Defined in GHC.Hs.Binds Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TcSpecPrag -> c TcSpecPrag # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TcSpecPrag # toConstr :: TcSpecPrag -> Constr # dataTypeOf :: TcSpecPrag -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TcSpecPrag) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TcSpecPrag) # gmapT :: (forall b. Data b => b -> b) -> TcSpecPrag -> TcSpecPrag # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TcSpecPrag -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TcSpecPrag -> r # gmapQ :: (forall d. Data d => d -> u) -> TcSpecPrag -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TcSpecPrag -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TcSpecPrag -> m TcSpecPrag # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TcSpecPrag -> m TcSpecPrag # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TcSpecPrag -> m TcSpecPrag #
Outputable TcSpecPrag
Instance details Defined in GHC.Hs.Binds Methods ppr :: TcSpecPrag -> SDoc # pprPrec :: Rational -> TcSpecPrag -> SDoc #

type HsPatSynDetails arg = HsConDetails arg [RecordPatSynField arg] #

Haskell Pattern Synonym Details

data RecordPatSynField a #

Record Pattern Synonym Field

Constructors

RecordPatSynField
Fields recordPatSynSelectorId :: a recordPatSynPatVar :: a

Instances

Instances details

Functor RecordPatSynField
Instance details Defined in GHC.Hs.Binds Methods fmap :: (a -> b) -> RecordPatSynField a -> RecordPatSynField b # (<$) :: a -> RecordPatSynField b -> RecordPatSynField a #
Foldable RecordPatSynField
Instance details Defined in GHC.Hs.Binds Methods fold :: Monoid m => RecordPatSynField m -> m # foldMap :: Monoid m => (a -> m) -> RecordPatSynField a -> m # foldMap' :: Monoid m => (a -> m) -> RecordPatSynField a -> m # foldr :: (a -> b -> b) -> b -> RecordPatSynField a -> b # foldr' :: (a -> b -> b) -> b -> RecordPatSynField a -> b # foldl :: (b -> a -> b) -> b -> RecordPatSynField a -> b # foldl' :: (b -> a -> b) -> b -> RecordPatSynField a -> b # foldr1 :: (a -> a -> a) -> RecordPatSynField a -> a # foldl1 :: (a -> a -> a) -> RecordPatSynField a -> a # toList :: RecordPatSynField a -> [a] # null :: RecordPatSynField a -> Bool # length :: RecordPatSynField a -> Int # elem :: Eq a => a -> RecordPatSynField a -> Bool # maximum :: Ord a => RecordPatSynField a -> a # minimum :: Ord a => RecordPatSynField a -> a # sum :: Num a => RecordPatSynField a -> a # product :: Num a => RecordPatSynField a -> a #
Traversable RecordPatSynField
Instance details Defined in GHC.Hs.Binds Methods traverse :: Applicative f => (a -> f b) -> RecordPatSynField a -> f (RecordPatSynField b) # sequenceA :: Applicative f => RecordPatSynField (f a) -> f (RecordPatSynField a) # mapM :: Monad m => (a -> m b) -> RecordPatSynField a -> m (RecordPatSynField b) # sequence :: Monad m => RecordPatSynField (m a) -> m (RecordPatSynField a) #
Data a => Data (RecordPatSynField a)
Instance details Defined in GHC.Hs.Binds Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RecordPatSynField a -> c (RecordPatSynField a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RecordPatSynField a) # toConstr :: RecordPatSynField a -> Constr # dataTypeOf :: RecordPatSynField a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RecordPatSynField a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RecordPatSynField a)) # gmapT :: (forall b. Data b => b -> b) -> RecordPatSynField a -> RecordPatSynField a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RecordPatSynField a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RecordPatSynField a -> r # gmapQ :: (forall d. Data d => d -> u) -> RecordPatSynField a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RecordPatSynField a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RecordPatSynField a -> m (RecordPatSynField a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RecordPatSynField a -> m (RecordPatSynField a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RecordPatSynField a -> m (RecordPatSynField a) #
Outputable a => Outputable (RecordPatSynField a)
Instance details Defined in GHC.Hs.Binds Methods ppr :: RecordPatSynField a -> SDoc # pprPrec :: Rational -> RecordPatSynField a -> SDoc #

data HsPatSynDir id #

Haskell Pattern Synonym Direction

Constructors

Unidirectional
ImplicitBidirectional
ExplicitBidirectional (MatchGroup id (LHsExpr id))

parenthesizeHsContext :: forall (p :: Pass). PprPrec -> LHsContext (GhcPass p) -> LHsContext (GhcPass p) #

parenthesizeHsContext p ctxt checks if ctxt is a single constraint c such that hsTypeNeedsParens p c is true, and if so, surrounds c with an HsParTy to form a parenthesized ctxt. Otherwise, it simply returns ctxt unchanged.

parenthesizeHsType :: forall (p :: Pass). PprPrec -> LHsType (GhcPass p) -> LHsType (GhcPass p) #

parenthesizeHsType p ty checks if hsTypeNeedsParens p ty is true, and if so, surrounds ty with an HsParTy. Otherwise, it simply returns ty.

hsTypeNeedsParens :: PprPrec -> HsType pass -> Bool #

hsTypeNeedsParens p t returns True if the type t needs parentheses under precedence p.

pprHsType :: forall (p :: Pass). OutputableBndrId p => HsType (GhcPass p) -> SDoc #

pprConDeclFields :: forall (p :: Pass). OutputableBndrId p => [LConDeclField (GhcPass p)] -> SDoc #

pprLHsContext :: forall (p :: Pass). OutputableBndrId p => LHsContext (GhcPass p) -> SDoc #

pprHsExplicitForAll :: forall (p :: Pass). OutputableBndrId p => ForallVisFlag -> Maybe [LHsTyVarBndr (GhcPass p)] -> SDoc #

Version of pprHsForAll or pprHsForAllExtra that will always print forall. when passed Just []. Prints nothing if passed Nothing

pprHsForAllExtra :: forall (p :: Pass). OutputableBndrId p => Maybe SrcSpan -> ForallVisFlag -> [LHsTyVarBndr (GhcPass p)] -> LHsContext (GhcPass p) -> SDoc #

Version of pprHsForAll that can also print an extra-constraints wildcard, e.g. _ => a -> Bool or (Show a, _) => a -> String. This underscore will be printed when the 'Maybe SrcSpan' argument is a Just containing the location of the extra-constraints wildcard. A special function for this is needed, as the extra-constraints wildcard is removed from the actual context and type, and stored in a separate field, thus just printing the type will not print the extra-constraints wildcard.

pprHsForAll :: forall (p :: Pass). OutputableBndrId p => ForallVisFlag -> [LHsTyVarBndr (GhcPass p)] -> LHsContext (GhcPass p) -> SDoc #

Prints a forall; When passed an empty list, prints forall ./forall -> only when -dppr-debug is enabled.

pprAnonWildCard :: SDoc #

ambiguousFieldOcc :: FieldOcc GhcTc -> AmbiguousFieldOcc GhcTc #

unambiguousFieldOcc :: AmbiguousFieldOcc GhcTc -> FieldOcc GhcTc #

selectorAmbiguousFieldOcc :: AmbiguousFieldOcc GhcTc -> Id #

rdrNameAmbiguousFieldOcc :: forall (p :: Pass). AmbiguousFieldOcc (GhcPass p) -> RdrName #

mkAmbiguousFieldOcc :: Located RdrName -> AmbiguousFieldOcc GhcPs #

mkFieldOcc :: Located RdrName -> FieldOcc GhcPs #

getLHsInstDeclClass_maybe :: forall (p :: Pass). LHsSigType (GhcPass p) -> Maybe (Located (IdP (GhcPass p))) #

getLHsInstDeclHead :: forall (p :: Pass). LHsSigType (GhcPass p) -> LHsType (GhcPass p) #

splitLHsInstDeclTy :: LHsSigType GhcRn -> ([Name], LHsContext GhcRn, LHsType GhcRn) #

Decompose a type class instance type (of the form forall tvs. context => instance_head) into its constituent parts.

Note that this function looks through parentheses, so it will work on types such as (forall tvs. ...). The downside to this is that it is not generally possible to take the returned types and reconstruct the original type (parentheses and all) from them.

splitLHsQualTy :: LHsType pass -> (LHsContext pass, LHsType pass) #

Decompose a type of the form context => body into its constituent parts.

Note that this function looks through parentheses, so it will work on types such as (context => ...). The downside to this is that it is not generally possible to take the returned types and reconstruct the original type (parentheses and all) from them.

splitLHsForAllTyInvis :: LHsType pass -> ([LHsTyVarBndr pass], LHsType pass) #

Decompose a type of the form forall tvs. body into its constituent parts. Note that only invisible foralls (i.e., forall a., with a dot) are split apart; visible foralls (i.e., forall a ->, with an arrow) are left untouched.

This function is used to split apart certain types, such as instance declaration types, which disallow visible foralls. For instance, if GHC split apart the forall in instance forall a -> Show (Blah a), then that declaration would mistakenly be accepted!

Note that this function looks through parentheses, so it will work on types such as (forall a. ...). The downside to this is that it is not generally possible to take the returned types and reconstruct the original type (parentheses and all) from them.

splitLHsSigmaTyInvis :: LHsType pass -> ([LHsTyVarBndr pass], LHsContext pass, LHsType pass) #

Decompose a sigma type (of the form forall tvs. context => body) into its constituent parts. Note that only invisible foralls (i.e., forall a., with a dot) are split apart; visible foralls (i.e., forall a ->, with an arrow) are left untouched.

This function is used to split apart certain types, such as instance declaration types, which disallow visible foralls. For instance, if GHC split apart the forall in instance forall a -> Show (Blah a), then that declaration would mistakenly be accepted!

Note that this function looks through parentheses, so it will work on types such as (forall a. ...). The downside to this is that it is not generally possible to take the returned types and reconstruct the original type (parentheses and all) from them.

splitLHsPatSynTy :: LHsType pass -> ([LHsTyVarBndr pass], LHsContext pass, [LHsTyVarBndr pass], LHsContext pass, LHsType pass) #

Decompose a pattern synonym type signature into its constituent parts.

Note that this function looks through parentheses, so it will work on types such as (forall a. ...). The downside to this is that it is not generally possible to take the returned types and reconstruct the original type (parentheses and all) from them.

numVisibleArgs :: [HsArg tm ty] -> Arity #

hsTyGetAppHead_maybe :: forall (p :: Pass). LHsType (GhcPass p) -> Maybe (Located (IdP (GhcPass p))) #

splitHsFunType :: LHsType GhcRn -> ([LHsType GhcRn], LHsType GhcRn) #

mkHsAppKindTy :: forall (p :: Pass). XAppKindTy (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) #

mkHsAppTys :: forall (p :: Pass). LHsType (GhcPass p) -> [LHsType (GhcPass p)] -> LHsType (GhcPass p) #

mkHsAppTy :: forall (p :: Pass). LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) #

mkHsOpTy :: forall (p :: Pass). LHsType (GhcPass p) -> Located (IdP (GhcPass p)) -> LHsType (GhcPass p) -> HsType (GhcPass p) #

mkAnonWildCardTy :: HsType GhcPs #

isLHsForAllTy :: LHsType p -> Bool #

ignoreParens :: LHsType pass -> LHsType pass #

hsTyKindSig :: LHsType pass -> Maybe (LHsKind pass) #

Get the kind signature of a type, ignoring parentheses:

hsTyKindSig `Maybe ` = Nothing hsTyKindSig `Maybe :: Type -> Type ` = Just `Type -> Type` hsTyKindSig `Maybe :: ((Type -> Type))` = Just `Type -> Type`

This is used to extract the result kind of type synonyms with a CUSK:

type S = (F :: res_kind) ^^^^^^^^

hsLTyVarBndrsToTypes :: forall (p :: Pass). LHsQTyVars (GhcPass p) -> [LHsType (GhcPass p)] #

Convert a LHsTyVarBndrs to a list of types. Works on *type* variable only, no kind vars.

hsLTyVarBndrToType :: forall (p :: Pass). LHsTyVarBndr (GhcPass p) -> LHsType (GhcPass p) #

Convert a LHsTyVarBndr to an equivalent LHsType.

hsLTyVarLocNames :: forall (p :: Pass). LHsQTyVars (GhcPass p) -> [Located (IdP (GhcPass p))] #

hsLTyVarLocName :: forall (p :: Pass). LHsTyVarBndr (GhcPass p) -> Located (IdP (GhcPass p)) #

hsAllLTyVarNames :: LHsQTyVars GhcRn -> [Name] #

hsExplicitLTyVarNames :: forall (p :: Pass). LHsQTyVars (GhcPass p) -> [IdP (GhcPass p)] #

hsLTyVarNames :: forall (p :: Pass). [LHsTyVarBndr (GhcPass p)] -> [IdP (GhcPass p)] #

hsLTyVarName :: forall (p :: Pass). LHsTyVarBndr (GhcPass p) -> IdP (GhcPass p) #

hsTyVarName :: forall (p :: Pass). HsTyVarBndr (GhcPass p) -> IdP (GhcPass p) #

hsScopedTvs :: LHsSigType GhcRn -> [Name] #

hsWcScopedTvs :: LHsSigWcType GhcRn -> [Name] #

hsConDetailsArgs :: HsConDetails (LHsType a) (Located [LConDeclField a]) -> [LHsType a] #

hsTvbAllKinded :: LHsQTyVars pass -> Bool #

Do all type variables in this LHsQTyVars come with kind annotations?

isHsKindedTyVar :: HsTyVarBndr pass -> Bool #

Does this HsTyVarBndr come with an explicit kind annotation?

hsIPNameFS :: HsIPName -> FastString #

mkEmptyWildCardBndrs :: thing -> HsWildCardBndrs GhcRn thing #

mkEmptyImplicitBndrs :: thing -> HsImplicitBndrs GhcRn thing #

mkHsWildCardBndrs :: thing -> HsWildCardBndrs GhcPs thing #

mkHsImplicitBndrs :: thing -> HsImplicitBndrs GhcPs thing #

dropWildCards :: LHsSigWcType pass -> LHsSigType pass #

hsSigWcType :: LHsSigWcType pass -> LHsType pass #

hsSigType :: forall (p :: Pass). LHsSigType (GhcPass p) -> LHsType (GhcPass p) #

hsImplicitBody :: forall (p :: Pass) thing. HsImplicitBndrs (GhcPass p) thing -> thing #

isEmptyLHsQTvs :: LHsQTyVars GhcRn -> Bool #

emptyLHsQTvs :: LHsQTyVars GhcRn #

hsQTvExplicit :: LHsQTyVars pass -> [LHsTyVarBndr pass] #

mkHsQTvs :: [LHsTyVarBndr GhcPs] -> LHsQTyVars GhcPs #

noLHsContext :: LHsContext pass #

getBangStrictness :: LHsType a -> HsSrcBang #

getBangType :: LHsType a -> LHsType a #

type LBangType pass = Located (BangType pass) #

Located Bang Type

type BangType pass = HsType pass #

Bang Type

In the parser, strictness and packedness annotations bind more tightly than docstrings. This means that when consuming a BangType (and looking for HsBangTy) we must be ready to peer behind a potential layer of HsDocTy. See #15206 for motivation and getBangType for an example.

type LHsContext pass #

Arguments

= Located (HsContext pass)

AnnKeywordId : AnnUnit For details on above see note [Api annotations] in ApiAnnotation

Located Haskell Context

type HsContext pass = [LHsType pass] #

Haskell Context

type LHsType pass #

Arguments

= Located (HsType pass)

May have AnnKeywordId : AnnComma when in a list

Located Haskell Type

type HsKind pass = HsType pass #

Haskell Kind

type LHsKind pass #

Arguments

= Located (HsKind pass)

AnnKeywordId : AnnDcolon

Located Haskell Kind

type LHsTyVarBndr pass = Located (HsTyVarBndr pass) #

Located Haskell Type Variable Binder

data LHsQTyVars pass #

Located Haskell Quantified Type Variables

Constructors

HsQTvs
Fields hsq_ext :: XHsQTvs pass hsq_explicit :: [LHsTyVarBndr pass]
XLHsQTyVars (XXLHsQTyVars pass)

Instances

Instances details

OutputableBndrId p => Outputable (LHsQTyVars (GhcPass p))
Instance details Defined in GHC.Hs.Types Methods ppr :: LHsQTyVars (GhcPass p) -> SDoc # pprPrec :: Rational -> LHsQTyVars (GhcPass p) -> SDoc #

data HsImplicitBndrs pass thing #

Haskell Implicit Binders

Constructors

HsIB
Fields hsib_ext :: XHsIB pass thing hsib_body :: thing
XHsImplicitBndrs (XXHsImplicitBndrs pass thing)

Instances

Instances details

Annotate [LHsSigType GhcPs]
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> [LHsSigType GhcPs] -> Annotated () #
Annotate (TyFamInstEqn GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> TyFamInstEqn GhcPs -> Annotated () #
Outputable thing => Outputable (HsImplicitBndrs (GhcPass p) thing)
Instance details Defined in GHC.Hs.Types Methods ppr :: HsImplicitBndrs (GhcPass p) thing -> SDoc # pprPrec :: Rational -> HsImplicitBndrs (GhcPass p) thing -> SDoc #
Annotate arg => Annotate (HsImplicitBndrs GhcPs (Located arg))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsImplicitBndrs GhcPs (Located arg) -> Annotated () #

data HsWildCardBndrs pass thing #

Haskell Wildcard Binders

Constructors

HsWC
Fields hswc_ext :: XHsWC pass thing hswc_body :: thing
XHsWildCardBndrs (XXHsWildCardBndrs pass thing)

Instances

Instances details

Outputable thing => Outputable (HsWildCardBndrs (GhcPass p) thing)
Instance details Defined in GHC.Hs.Types Methods ppr :: HsWildCardBndrs (GhcPass p) thing -> SDoc # pprPrec :: Rational -> HsWildCardBndrs (GhcPass p) thing -> SDoc #

type LHsSigType pass = HsImplicitBndrs pass (LHsType pass) #

Located Haskell Signature Type

type LHsWcType pass = HsWildCardBndrs pass (LHsType pass) #

Located Haskell Wildcard Type

type LHsSigWcType pass = HsWildCardBndrs pass (LHsSigType pass) #

Located Haskell Signature Wildcard Type

newtype HsIPName #

These names are used early on to store the names of implicit parameters. They completely disappear after type-checking.

Constructors

HsIPName FastString

Instances

Instances details

Eq HsIPName
Instance details Defined in GHC.Hs.Types Methods (==) :: HsIPName -> HsIPName -> Bool # (/=) :: HsIPName -> HsIPName -> Bool #
Data HsIPName
Instance details Defined in GHC.Hs.Types Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsIPName -> c HsIPName # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsIPName # toConstr :: HsIPName -> Constr # dataTypeOf :: HsIPName -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsIPName) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsIPName) # gmapT :: (forall b. Data b => b -> b) -> HsIPName -> HsIPName # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsIPName -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsIPName -> r # gmapQ :: (forall d. Data d => d -> u) -> HsIPName -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsIPName -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsIPName -> m HsIPName # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsIPName -> m HsIPName # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsIPName -> m HsIPName #
Outputable HsIPName
Instance details Defined in GHC.Hs.Types Methods ppr :: HsIPName -> SDoc # pprPrec :: Rational -> HsIPName -> SDoc #
OutputableBndr HsIPName
Instance details Defined in GHC.Hs.Types Methods pprBndr :: BindingSite -> HsIPName -> SDoc # pprPrefixOcc :: HsIPName -> SDoc # pprInfixOcc :: HsIPName -> SDoc # bndrIsJoin_maybe :: HsIPName -> Maybe Int #
Annotate HsIPName
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsIPName -> Annotated () #

data HsTyVarBndr pass #

Haskell Type Variable Binder

Constructors

UserTyVar (XUserTyVar pass) (Located (IdP pass))
KindedTyVar (XKindedTyVar pass) (Located (IdP pass)) (LHsKind pass)	`AnnKeywordId` : `AnnOpen`, `AnnDcolon`, `AnnClose`
XTyVarBndr (XXTyVarBndr pass)

Instances

Instances details

NamedThing (HsTyVarBndr GhcRn)
Instance details Defined in GHC.Hs.Types Methods getOccName :: HsTyVarBndr GhcRn -> OccName # getName :: HsTyVarBndr GhcRn -> Name #
OutputableBndrId p => Outputable (HsTyVarBndr (GhcPass p))
Instance details Defined in GHC.Hs.Types Methods ppr :: HsTyVarBndr (GhcPass p) -> SDoc # pprPrec :: Rational -> HsTyVarBndr (GhcPass p) -> SDoc #
Annotate (HsTyVarBndr GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsTyVarBndr GhcPs -> Annotated () #

data HsType pass #

Haskell Type

Constructors

HsForAllTy	`AnnKeywordId` : `AnnForall`, `AnnDot`,`AnnDarrow` For details on above see note [Api annotations] in ApiAnnotation
Fields hst_xforall :: XForAllTy pass hst_fvf :: ForallVisFlag hst_bndrs :: [LHsTyVarBndr pass] hst_body :: LHsType pass
HsQualTy
Fields hst_xqual :: XQualTy pass hst_ctxt :: LHsContext pass hst_body :: LHsType pass
HsTyVar (XTyVar pass) PromotionFlag (Located (IdP pass))	`AnnKeywordId` : None
HsAppTy (XAppTy pass) (LHsType pass) (LHsType pass)	`AnnKeywordId` : None
HsAppKindTy (XAppKindTy pass) (LHsType pass) (LHsKind pass)
HsFunTy (XFunTy pass) (LHsType pass) (LHsType pass)	`AnnKeywordId` : `AnnRarrow`,
HsListTy (XListTy pass) (LHsType pass)	`AnnKeywordId` : `AnnOpen` `'['`, `AnnClose` `']'`
HsTupleTy (XTupleTy pass) HsTupleSort [LHsType pass]	`AnnKeywordId` : `AnnOpen` `'(' or '(#'`, `AnnClose` `')' or '#)'`
HsSumTy (XSumTy pass) [LHsType pass]	`AnnKeywordId` : `AnnOpen` `'(#'`, `AnnClose` '#)'@
HsOpTy (XOpTy pass) (LHsType pass) (Located (IdP pass)) (LHsType pass)	`AnnKeywordId` : None
HsParTy (XParTy pass) (LHsType pass)	`AnnKeywordId` : `AnnOpen` `'('`, `AnnClose` `')'`
HsIParamTy (XIParamTy pass) (Located HsIPName) (LHsType pass)	(?x :: ty) `AnnKeywordId` : `AnnDcolon`
HsStarTy (XStarTy pass) Bool	`AnnKeywordId` : None
HsKindSig (XKindSig pass) (LHsType pass) (LHsKind pass)	(ty :: kind) `AnnKeywordId` : `AnnOpen` `'('`, `AnnDcolon`,`AnnClose` `')'`
HsSpliceTy (XSpliceTy pass) (HsSplice pass)	`AnnKeywordId` : `AnnOpen` `'$('`, `AnnClose` `')'`
HsDocTy (XDocTy pass) (LHsType pass) LHsDocString	`AnnKeywordId` : None
HsBangTy (XBangTy pass) HsSrcBang (LHsType pass)	`AnnKeywordId` : `AnnOpen` `'{-# UNPACK' or '{-# NOUNPACK'`, `AnnClose` `'#-}'` `AnnBang` `'!'`
HsRecTy (XRecTy pass) [LConDeclField pass]	`AnnKeywordId` : `AnnOpen` `'{'`, `AnnClose` `'}'`
HsExplicitListTy (XExplicitListTy pass) PromotionFlag [LHsType pass]	`AnnKeywordId` : `AnnOpen` `"'["`, `AnnClose` `']'`
HsExplicitTupleTy (XExplicitTupleTy pass) [LHsType pass]	`AnnKeywordId` : `AnnOpen` `"'("`, `AnnClose` `')'`
HsTyLit (XTyLit pass) HsTyLit	`AnnKeywordId` : None
HsWildCardTy (XWildCardTy pass)	`AnnKeywordId` : None
XHsType (XXType pass)

Instances

Instances details

OutputableBndrId p => Outputable (HsType (GhcPass p))
Instance details Defined in GHC.Hs.Types Methods ppr :: HsType (GhcPass p) -> SDoc # pprPrec :: Rational -> HsType (GhcPass p) -> SDoc #
Annotate [LHsType GhcPs]
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> [LHsType GhcPs] -> Annotated () #
Annotate [LHsSigType GhcPs]
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> [LHsSigType GhcPs] -> Annotated () #
Annotate (TyFamInstEqn GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> TyFamInstEqn GhcPs -> Annotated () #
Annotate (HsType GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsType GhcPs -> Annotated () #
Matchable (LHsType GhcPs) Source #
Instance details Defined in Retrie.Universe Methods inject :: LHsType GhcPs -> Universe Source # project :: Universe -> LHsType GhcPs Source # getOrigin :: LHsType GhcPs -> SrcSpan Source #

data NewHsTypeX #

Constructors

NHsCoreTy Type

Instances

Instances details

Data NewHsTypeX	`AnnKeywordId` : None
Instance details Defined in GHC.Hs.Types Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NewHsTypeX -> c NewHsTypeX # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NewHsTypeX # toConstr :: NewHsTypeX -> Constr # dataTypeOf :: NewHsTypeX -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NewHsTypeX) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NewHsTypeX) # gmapT :: (forall b. Data b => b -> b) -> NewHsTypeX -> NewHsTypeX # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NewHsTypeX -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NewHsTypeX -> r # gmapQ :: (forall d. Data d => d -> u) -> NewHsTypeX -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NewHsTypeX -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NewHsTypeX -> m NewHsTypeX # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NewHsTypeX -> m NewHsTypeX # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NewHsTypeX -> m NewHsTypeX #
Outputable NewHsTypeX
Instance details Defined in GHC.Hs.Types Methods ppr :: NewHsTypeX -> SDoc # pprPrec :: Rational -> NewHsTypeX -> SDoc #

data HsTyLit #

Haskell Type Literal

Constructors

HsNumTy SourceText Integer
HsStrTy SourceText FastString

Instances

Instances details

Data HsTyLit
Instance details Defined in GHC.Hs.Types Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsTyLit -> c HsTyLit # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsTyLit # toConstr :: HsTyLit -> Constr # dataTypeOf :: HsTyLit -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsTyLit) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsTyLit) # gmapT :: (forall b. Data b => b -> b) -> HsTyLit -> HsTyLit # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsTyLit -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsTyLit -> r # gmapQ :: (forall d. Data d => d -> u) -> HsTyLit -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsTyLit -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsTyLit -> m HsTyLit # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyLit -> m HsTyLit # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTyLit -> m HsTyLit #
Outputable HsTyLit
Instance details Defined in GHC.Hs.Types Methods ppr :: HsTyLit -> SDoc # pprPrec :: Rational -> HsTyLit -> SDoc #

data HsTupleSort #

Haskell Tuple Sort

Constructors

HsUnboxedTuple
HsBoxedTuple
HsConstraintTuple
HsBoxedOrConstraintTuple

Instances

Instances details

Data HsTupleSort

Instance details

Defined in GHC.Hs.Types

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsTupleSort -> c HsTupleSort #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsTupleSort #

toConstr :: HsTupleSort -> Constr #

dataTypeOf :: HsTupleSort -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsTupleSort) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsTupleSort) #

gmapT :: (forall b. Data b => b -> b) -> HsTupleSort -> HsTupleSort #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsTupleSort -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsTupleSort -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsTupleSort -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsTupleSort -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsTupleSort -> m HsTupleSort #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTupleSort -> m HsTupleSort #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTupleSort -> m HsTupleSort #

type LConDeclField pass #

Arguments

= Located (ConDeclField pass)

May have AnnKeywordId : AnnComma when in a list

Located Constructor Declaration Field

data ConDeclField pass #

Constructor Declaration Field

Constructors

ConDeclField	`AnnKeywordId` : `AnnDcolon`
Fields cd_fld_ext :: XConDeclField pass cd_fld_names :: [LFieldOcc pass] See Note [ConDeclField passs] cd_fld_type :: LBangType pass cd_fld_doc :: Maybe LHsDocString
XConDeclField (XXConDeclField pass)

Instances

Instances details

OutputableBndrId p => Outputable (ConDeclField (GhcPass p))
Instance details Defined in GHC.Hs.Types Methods ppr :: ConDeclField (GhcPass p) -> SDoc # pprPrec :: Rational -> ConDeclField (GhcPass p) -> SDoc #
Annotate [LConDeclField GhcPs]
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> [LConDeclField GhcPs] -> Annotated () #
Annotate (ConDeclField GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> ConDeclField GhcPs -> Annotated () #

data HsConDetails arg rec #

Haskell Constructor Details

Constructors

PrefixCon [arg]
RecCon rec
InfixCon arg arg

Instances

Instances details

(Data arg, Data rec) => Data (HsConDetails arg rec)
Instance details Defined in GHC.Hs.Types Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsConDetails arg rec -> c (HsConDetails arg rec) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsConDetails arg rec) # toConstr :: HsConDetails arg rec -> Constr # dataTypeOf :: HsConDetails arg rec -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsConDetails arg rec)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsConDetails arg rec)) # gmapT :: (forall b. Data b => b -> b) -> HsConDetails arg rec -> HsConDetails arg rec # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsConDetails arg rec -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsConDetails arg rec -> r # gmapQ :: (forall d. Data d => d -> u) -> HsConDetails arg rec -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsConDetails arg rec -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsConDetails arg rec -> m (HsConDetails arg rec) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDetails arg rec -> m (HsConDetails arg rec) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDetails arg rec -> m (HsConDetails arg rec) #
(Outputable arg, Outputable rec) => Outputable (HsConDetails arg rec)
Instance details Defined in GHC.Hs.Types Methods ppr :: HsConDetails arg rec -> SDoc # pprPrec :: Rational -> HsConDetails arg rec -> SDoc #

data HsArg tm ty #

Constructors

HsValArg tm
HsTypeArg SrcSpan ty
HsArgPar SrcSpan

Instances

Instances details

(Outputable tm, Outputable ty) => Outputable (HsArg tm ty)
Instance details Defined in GHC.Hs.Types Methods ppr :: HsArg tm ty -> SDoc # pprPrec :: Rational -> HsArg tm ty -> SDoc #

type LHsTypeArg p = HsArg (LHsType p) (LHsKind p) #

type LFieldOcc pass = Located (FieldOcc pass) #

Located Field Occurrence

data FieldOcc pass #

Field Occurrence

Represents an *occurrence* of an unambiguous field. We store both the RdrName the user originally wrote, and after the renamer, the selector function.

Constructors

FieldOcc
Fields extFieldOcc :: XCFieldOcc pass rdrNameFieldOcc :: Located RdrName See Note [Located RdrNames] in GHC.Hs.Expr
XFieldOcc (XXFieldOcc pass)

Instances

Instances details

Eq (XCFieldOcc (GhcPass p)) => Eq (FieldOcc (GhcPass p))
Instance details Defined in GHC.Hs.Types Methods (==) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool # (/=) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool #
Ord (XCFieldOcc (GhcPass p)) => Ord (FieldOcc (GhcPass p))
Instance details Defined in GHC.Hs.Types Methods compare :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Ordering # (<) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool # (<=) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool # (>) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool # (>=) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool # max :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) # min :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) #
Outputable (FieldOcc pass)
Instance details Defined in GHC.Hs.Types Methods ppr :: FieldOcc pass -> SDoc # pprPrec :: Rational -> FieldOcc pass -> SDoc #
Annotate (FieldOcc GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> FieldOcc GhcPs -> Annotated () #
RecordFieldToRdrName (FieldOcc p) Source #
Instance details Defined in Retrie.PatternMap.Instances Methods recordFieldToRdrName :: FieldOcc p -> RdrName Source #
Annotate (HsRecField GhcPs (LHsExpr GhcPs))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsRecField GhcPs (LHsExpr GhcPs) -> Annotated () #
Annotate (HsRecField GhcPs (Located (Pat GhcPs)))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsRecField GhcPs (Located (Pat GhcPs)) -> Annotated () #

data AmbiguousFieldOcc pass #

Ambiguous Field Occurrence

Represents an *occurrence* of a field that is potentially ambiguous after the renamer, with the ambiguity resolved by the typechecker. We always store the RdrName that the user originally wrote, and store the selector function after the renamer (for unambiguous occurrences) or the typechecker (for ambiguous occurrences).

See Note [HsRecField and HsRecUpdField] in GHC.Hs.Pat and Note [Disambiguating record fields] in TcExpr. See Note [Located RdrNames] in GHC.Hs.Expr

Constructors

Unambiguous (XUnambiguous pass) (Located RdrName)
Ambiguous (XAmbiguous pass) (Located RdrName)
XAmbiguousFieldOcc (XXAmbiguousFieldOcc pass)

Instances

Instances details

Outputable (AmbiguousFieldOcc (GhcPass p))
Instance details Defined in GHC.Hs.Types Methods ppr :: AmbiguousFieldOcc (GhcPass p) -> SDoc # pprPrec :: Rational -> AmbiguousFieldOcc (GhcPass p) -> SDoc #
OutputableBndr (AmbiguousFieldOcc (GhcPass p))
Instance details Defined in GHC.Hs.Types Methods pprBndr :: BindingSite -> AmbiguousFieldOcc (GhcPass p) -> SDoc # pprPrefixOcc :: AmbiguousFieldOcc (GhcPass p) -> SDoc # pprInfixOcc :: AmbiguousFieldOcc (GhcPass p) -> SDoc # bndrIsJoin_maybe :: AmbiguousFieldOcc (GhcPass p) -> Maybe Int #
Annotate (HsRecUpdField GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsRecUpdField GhcPs -> Annotated () #
Annotate (AmbiguousFieldOcc GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> AmbiguousFieldOcc GhcPs -> Annotated () #
RecordFieldToRdrName (AmbiguousFieldOcc GhcPs) Source #
Instance details Defined in Retrie.PatternMap.Instances Methods recordFieldToRdrName :: AmbiguousFieldOcc GhcPs -> RdrName Source #

data HsSrcBang #

Haskell Source Bang

Bangs on data constructor arguments as the user wrote them in the source code.

(HsSrcBang _ SrcUnpack SrcLazy) and (HsSrcBang _ SrcUnpack NoSrcStrict) (without StrictData) makes no sense, we emit a warning (in checkValidDataCon) and treat it like (HsSrcBang _ NoSrcUnpack SrcLazy)

Constructors

HsSrcBang SourceText SrcUnpackedness SrcStrictness

Instances

Instances details

Data HsSrcBang
Instance details Defined in DataCon Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsSrcBang -> c HsSrcBang # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsSrcBang # toConstr :: HsSrcBang -> Constr # dataTypeOf :: HsSrcBang -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsSrcBang) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsSrcBang) # gmapT :: (forall b. Data b => b -> b) -> HsSrcBang -> HsSrcBang # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsSrcBang -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsSrcBang -> r # gmapQ :: (forall d. Data d => d -> u) -> HsSrcBang -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsSrcBang -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsSrcBang -> m HsSrcBang # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSrcBang -> m HsSrcBang # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSrcBang -> m HsSrcBang #
Outputable HsSrcBang
Instance details Defined in DataCon Methods ppr :: HsSrcBang -> SDoc # pprPrec :: Rational -> HsSrcBang -> SDoc #

data HsImplBang #

Haskell Implementation Bang

Bangs of data constructor arguments as generated by the compiler after consulting HsSrcBang, flags, etc.

Constructors

HsLazy	Lazy field, or one with an unlifted type
HsStrict	Strict but not unpacked field
HsUnpack (Maybe Coercion)	Strict and unpacked field co :: arg-ty ~ product-ty HsBang

Instances

Instances details

Data HsImplBang
Instance details Defined in DataCon Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsImplBang -> c HsImplBang # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsImplBang # toConstr :: HsImplBang -> Constr # dataTypeOf :: HsImplBang -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsImplBang) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsImplBang) # gmapT :: (forall b. Data b => b -> b) -> HsImplBang -> HsImplBang # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsImplBang -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsImplBang -> r # gmapQ :: (forall d. Data d => d -> u) -> HsImplBang -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsImplBang -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsImplBang -> m HsImplBang # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImplBang -> m HsImplBang # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImplBang -> m HsImplBang #
Outputable HsImplBang
Instance details Defined in DataCon Methods ppr :: HsImplBang -> SDoc # pprPrec :: Rational -> HsImplBang -> SDoc #

data SrcStrictness #

Source Strictness

What strictness annotation the user wrote

Constructors

SrcLazy	Lazy, ie '~'
SrcStrict	Strict, ie `!`
NoSrcStrict	no strictness annotation

Instances

Instances details

Eq SrcStrictness
Instance details Defined in DataCon Methods (==) :: SrcStrictness -> SrcStrictness -> Bool # (/=) :: SrcStrictness -> SrcStrictness -> Bool #
Data SrcStrictness
Instance details Defined in DataCon Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcStrictness -> c SrcStrictness # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SrcStrictness # toConstr :: SrcStrictness -> Constr # dataTypeOf :: SrcStrictness -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SrcStrictness) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcStrictness) # gmapT :: (forall b. Data b => b -> b) -> SrcStrictness -> SrcStrictness # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcStrictness -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SrcStrictness -> r # gmapQ :: (forall d. Data d => d -> u) -> SrcStrictness -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcStrictness -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SrcStrictness -> m SrcStrictness # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcStrictness -> m SrcStrictness # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcStrictness -> m SrcStrictness #
Binary SrcStrictness
Instance details Defined in DataCon Methods put_ :: BinHandle -> SrcStrictness -> IO () # put :: BinHandle -> SrcStrictness -> IO (Bin SrcStrictness) # get :: BinHandle -> IO SrcStrictness #
Outputable SrcStrictness
Instance details Defined in DataCon Methods ppr :: SrcStrictness -> SDoc # pprPrec :: Rational -> SrcStrictness -> SDoc #

data SrcUnpackedness #

Source Unpackedness

What unpackedness the user requested

Constructors

SrcUnpack	{--} specified
SrcNoUnpack	{--} specified
NoSrcUnpack	no unpack pragma

Instances

Instances details

Eq SrcUnpackedness
Instance details Defined in DataCon Methods (==) :: SrcUnpackedness -> SrcUnpackedness -> Bool # (/=) :: SrcUnpackedness -> SrcUnpackedness -> Bool #
Data SrcUnpackedness
Instance details Defined in DataCon Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcUnpackedness -> c SrcUnpackedness # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SrcUnpackedness # toConstr :: SrcUnpackedness -> Constr # dataTypeOf :: SrcUnpackedness -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SrcUnpackedness) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcUnpackedness) # gmapT :: (forall b. Data b => b -> b) -> SrcUnpackedness -> SrcUnpackedness # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcUnpackedness -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SrcUnpackedness -> r # gmapQ :: (forall d. Data d => d -> u) -> SrcUnpackedness -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcUnpackedness -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SrcUnpackedness -> m SrcUnpackedness # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcUnpackedness -> m SrcUnpackedness # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcUnpackedness -> m SrcUnpackedness #
Binary SrcUnpackedness
Instance details Defined in DataCon Methods put_ :: BinHandle -> SrcUnpackedness -> IO () # put :: BinHandle -> SrcUnpackedness -> IO (Bin SrcUnpackedness) # get :: BinHandle -> IO SrcUnpackedness #
Outputable SrcUnpackedness
Instance details Defined in DataCon Methods ppr :: SrcUnpackedness -> SDoc # pprPrec :: Rational -> SrcUnpackedness -> SDoc #

hsOverLitNeedsParens :: PprPrec -> HsOverLit x -> Bool #

hsOverLitNeedsParens p ol returns True if an overloaded literal ol needs to be parenthesized under precedence p.

hsLitNeedsParens :: PprPrec -> HsLit x -> Bool #

hsLitNeedsParens p l returns True if a literal l needs to be parenthesized under precedence p.

pmPprHsLit :: forall (x :: Pass). HsLit (GhcPass x) -> SDoc #

pmPprHsLit pretty prints literals and is used when pretty printing pattern match warnings. All are printed the same (i.e., without hashes if they are primitive and not wrapped in constructors if they are boxed). This happens mainly for too reasons: * We do not want to expose their internal representation * The warnings become too messy

pp_st_suffix :: SourceText -> SDoc -> SDoc -> SDoc #

convertLit :: ConvertIdX a b => HsLit a -> HsLit b #

Convert a literal from one index type to another, updating the annotations according to the relevant Convertable instance

overLitType :: HsOverLit GhcTc -> Type #

negateOverLitVal :: OverLitVal -> OverLitVal #

data HsLit x #

Haskell Literal

Constructors

HsChar (XHsChar x) Char	Character
HsCharPrim (XHsCharPrim x) Char	Unboxed character
HsString (XHsString x) FastString	String
HsStringPrim (XHsStringPrim x) ByteString	Packed bytes
HsInt (XHsInt x) IntegralLit	Genuinely an Int; arises from `TcGenDeriv`, and from TRANSLATION
HsIntPrim (XHsIntPrim x) Integer	literal `Int#`
HsWordPrim (XHsWordPrim x) Integer	literal `Word#`
HsInt64Prim (XHsInt64Prim x) Integer	literal `Int64#`
HsWord64Prim (XHsWord64Prim x) Integer	literal `Word64#`
HsInteger (XHsInteger x) Integer Type	Genuinely an integer; arises only from TRANSLATION (overloaded literals are done with HsOverLit)
HsRat (XHsRat x) FractionalLit Type	Genuinely a rational; arises only from TRANSLATION (overloaded literals are done with HsOverLit)
HsFloatPrim (XHsFloatPrim x) FractionalLit	Unboxed Float
HsDoublePrim (XHsDoublePrim x) FractionalLit	Unboxed Double
XLit (XXLit x)

Instances

Instances details

Eq (HsLit x)
Instance details Defined in GHC.Hs.Lit Methods (==) :: HsLit x -> HsLit x -> Bool # (/=) :: HsLit x -> HsLit x -> Bool #
Outputable (HsLit (GhcPass p))
Instance details Defined in GHC.Hs.Lit Methods ppr :: HsLit (GhcPass p) -> SDoc # pprPrec :: Rational -> HsLit (GhcPass p) -> SDoc #
Annotate (HsLit GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsLit GhcPs -> Annotated () #

data HsOverLit p #

Haskell Overloaded Literal

Constructors

OverLit
Fields ol_ext :: XOverLit p ol_val :: OverLitVal ol_witness :: HsExpr p
XOverLit (XXOverLit p)

Instances

Instances details

Eq (XXOverLit p) => Eq (HsOverLit p)
Instance details Defined in GHC.Hs.Lit Methods (==) :: HsOverLit p -> HsOverLit p -> Bool # (/=) :: HsOverLit p -> HsOverLit p -> Bool #
Ord (XXOverLit p) => Ord (HsOverLit p)
Instance details Defined in GHC.Hs.Lit Methods compare :: HsOverLit p -> HsOverLit p -> Ordering # (<) :: HsOverLit p -> HsOverLit p -> Bool # (<=) :: HsOverLit p -> HsOverLit p -> Bool # (>) :: HsOverLit p -> HsOverLit p -> Bool # (>=) :: HsOverLit p -> HsOverLit p -> Bool # max :: HsOverLit p -> HsOverLit p -> HsOverLit p # min :: HsOverLit p -> HsOverLit p -> HsOverLit p #
OutputableBndrId p => Outputable (HsOverLit (GhcPass p))
Instance details Defined in GHC.Hs.Lit Methods ppr :: HsOverLit (GhcPass p) -> SDoc # pprPrec :: Rational -> HsOverLit (GhcPass p) -> SDoc #
Annotate (HsOverLit GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsOverLit GhcPs -> Annotated () #

data OverLitTc #

Constructors

OverLitTc
Fields ol_rebindable :: Bool ol_type :: Type

Instances

Instances details

Data OverLitTc

Instance details

Defined in GHC.Hs.Lit

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OverLitTc -> c OverLitTc #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OverLitTc #

toConstr :: OverLitTc -> Constr #

dataTypeOf :: OverLitTc -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OverLitTc) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OverLitTc) #

gmapT :: (forall b. Data b => b -> b) -> OverLitTc -> OverLitTc #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OverLitTc -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OverLitTc -> r #

gmapQ :: (forall d. Data d => d -> u) -> OverLitTc -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> OverLitTc -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> OverLitTc -> m OverLitTc #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OverLitTc -> m OverLitTc #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OverLitTc -> m OverLitTc #

data OverLitVal #

Overloaded Literal Value

Constructors

HsIntegral !IntegralLit	Integer-looking literals;
HsFractional !FractionalLit	Frac-looking literals
HsIsString !SourceText !FastString	String-looking literals

Instances

Instances details

Eq OverLitVal
Instance details Defined in GHC.Hs.Lit Methods (==) :: OverLitVal -> OverLitVal -> Bool # (/=) :: OverLitVal -> OverLitVal -> Bool #
Data OverLitVal
Instance details Defined in GHC.Hs.Lit Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OverLitVal -> c OverLitVal # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OverLitVal # toConstr :: OverLitVal -> Constr # dataTypeOf :: OverLitVal -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OverLitVal) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OverLitVal) # gmapT :: (forall b. Data b => b -> b) -> OverLitVal -> OverLitVal # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OverLitVal -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OverLitVal -> r # gmapQ :: (forall d. Data d => d -> u) -> OverLitVal -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> OverLitVal -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> OverLitVal -> m OverLitVal # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OverLitVal -> m OverLitVal # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OverLitVal -> m OverLitVal #
Ord OverLitVal
Instance details Defined in GHC.Hs.Lit Methods compare :: OverLitVal -> OverLitVal -> Ordering # (<) :: OverLitVal -> OverLitVal -> Bool # (<=) :: OverLitVal -> OverLitVal -> Bool # (>) :: OverLitVal -> OverLitVal -> Bool # (>=) :: OverLitVal -> OverLitVal -> Bool # max :: OverLitVal -> OverLitVal -> OverLitVal # min :: OverLitVal -> OverLitVal -> OverLitVal #
Outputable OverLitVal
Instance details Defined in GHC.Hs.Lit Methods ppr :: OverLitVal -> SDoc # pprPrec :: Rational -> OverLitVal -> SDoc #

pprLExpr :: forall (p :: Pass). OutputableBndrId p => LHsExpr (GhcPass p) -> SDoc #

pprExpr :: forall (p :: Pass). OutputableBndrId p => HsExpr (GhcPass p) -> SDoc #

pprSplice :: forall (p :: Pass). OutputableBndrId p => HsSplice (GhcPass p) -> SDoc #

pprSpliceDecl :: forall (p :: Pass). OutputableBndrId p => HsSplice (GhcPass p) -> SpliceExplicitFlag -> SDoc #

pprPatBind :: forall (bndr :: Pass) (p :: Pass) body. (OutputableBndrId bndr, OutputableBndrId p, Outputable body) => LPat (GhcPass bndr) -> GRHSs (GhcPass p) body -> SDoc #

pprFunBind :: forall (idR :: Pass) body. (OutputableBndrId idR, Outputable body) => MatchGroup (GhcPass idR) body -> SDoc #

data HsExpr p #

A Haskell expression.

Constructors

HsVar (XVar p) (Located (IdP p))	Variable
HsUnboundVar (XUnboundVar p) UnboundVar	Unbound variable; also used for "holes" (_ or _x). Turned from HsVar to HsUnboundVar by the renamer, when it finds an out-of-scope variable or hole. Turned into HsVar by type checker, to support deferred type errors.
HsConLikeOut (XConLikeOut p) ConLike	After typechecker only; must be different HsVar for pretty printing
HsRecFld (XRecFld p) (AmbiguousFieldOcc p)	Variable pointing to record selector Not in use after typechecking
HsOverLabel (XOverLabel p) (Maybe (IdP p)) FastString	Overloaded label (Note [Overloaded labels] in GHC.OverloadedLabels) `Just id` means `RebindableSyntax` is in use, and gives the id of the in-scope `fromLabel`. NB: Not in use after typechecking
HsIPVar (XIPVar p) HsIPName	Implicit parameter (not in use after typechecking)
HsOverLit (XOverLitE p) (HsOverLit p)	Overloaded literals
HsLit (XLitE p) (HsLit p)	Simple (non-overloaded) literals
HsLam (XLam p) (MatchGroup p (LHsExpr p))	Lambda abstraction. Currently always a single match `AnnKeywordId` : `AnnLam`, `AnnRarrow`,
HsLamCase (XLamCase p) (MatchGroup p (LHsExpr p))	Lambda-case `AnnKeywordId` : `AnnLam`, `AnnCase`,`AnnOpen`, `AnnClose`
HsApp (XApp p) (LHsExpr p) (LHsExpr p)	Application
HsAppType (XAppTypeE p) (LHsExpr p) (LHsWcType (NoGhcTc p))	Visible type application Explicit type argument; e.g f @Int x y NB: Has wildcards, but no implicit quantification `AnnKeywordId` : `AnnAt`,
OpApp (XOpApp p) (LHsExpr p) (LHsExpr p) (LHsExpr p)	Operator applications: NB Bracketed ops such as (+) come out as Vars.
NegApp (XNegApp p) (LHsExpr p) (SyntaxExpr p)	Negation operator. Contains the negated expression and the name of `negate` `AnnKeywordId` : `AnnMinus`
HsPar (XPar p) (LHsExpr p)	Parenthesised expr; see Note [Parens in HsSyn]
SectionL (XSectionL p) (LHsExpr p) (LHsExpr p)
SectionR (XSectionR p) (LHsExpr p) (LHsExpr p)
ExplicitTuple (XExplicitTuple p) [LHsTupArg p] Boxity	Used for explicit tuples and sections thereof `AnnKeywordId` : `AnnOpen`, `AnnClose`
ExplicitSum (XExplicitSum p) ConTag Arity (LHsExpr p)	Used for unboxed sum types `AnnKeywordId` : `AnnOpen` `'(#'`, `AnnVbar`, `AnnClose` `'#)'`, There will be multiple `AnnVbar`, (1 - alternative) before the expression, (arity - alternative) after it
HsCase (XCase p) (LHsExpr p) (MatchGroup p (LHsExpr p))	`AnnKeywordId` : `AnnCase`, `AnnOf`,`AnnOpen` `'{'`, `AnnClose` `'}'`
HsIf (XIf p) (Maybe (SyntaxExpr p)) (LHsExpr p) (LHsExpr p) (LHsExpr p)	`AnnKeywordId` : `AnnIf`, `AnnSemi`, `AnnThen`,`AnnSemi`, `AnnElse`,
HsMultiIf (XMultiIf p) [LGRHS p (LHsExpr p)]	Multi-way if `AnnKeywordId` : `AnnIf` `AnnOpen`,`AnnClose`,
HsLet (XLet p) (LHsLocalBinds p) (LHsExpr p)	let(rec) `AnnKeywordId` : `AnnLet`, `AnnOpen` `'{'`, `AnnClose` `'}'`,`AnnIn`
HsDo (XDo p) (HsStmtContext Name) (Located [ExprLStmt p])	`AnnKeywordId` : `AnnDo`, `AnnOpen`, `AnnSemi`, `AnnVbar`, `AnnClose`
ExplicitList (XExplicitList p) (Maybe (SyntaxExpr p)) [LHsExpr p]	Syntactic list: [a,b,c,...] `AnnKeywordId` : `AnnOpen` `'['`, `AnnClose` `']'`
RecordCon	Record construction `AnnKeywordId` : `AnnOpen` `'{'`, `AnnDotdot`,`AnnClose` `'}'`
Fields rcon_ext :: XRecordCon p rcon_con_name :: Located (IdP p) rcon_flds :: HsRecordBinds p
RecordUpd	Record update `AnnKeywordId` : `AnnOpen` `'{'`, `AnnDotdot`,`AnnClose` `'}'`
Fields rupd_ext :: XRecordUpd p rupd_expr :: LHsExpr p rupd_flds :: [LHsRecUpdField p]
ExprWithTySig (XExprWithTySig p) (LHsExpr p) (LHsSigWcType (NoGhcTc p))	Expression with an explicit type signature. `e :: type` `AnnKeywordId` : `AnnDcolon`
ArithSeq (XArithSeq p) (Maybe (SyntaxExpr p)) (ArithSeqInfo p)	Arithmetic sequence `AnnKeywordId` : `AnnOpen` `'['`, `AnnComma`,`AnnDotdot`, `AnnClose` `']'`
HsSCC (XSCC p) SourceText StringLiteral (LHsExpr p)
HsCoreAnn (XCoreAnn p) SourceText StringLiteral (LHsExpr p)	`AnnKeywordId` : `AnnOpen` `'{-# CORE'`, `AnnVal`, `AnnClose` `'#-}'`
HsBracket (XBracket p) (HsBracket p)	`AnnKeywordId` : `AnnOpen`, `AnnOpenE`,`AnnOpenEQ`, `AnnClose`,`AnnCloseQ`
HsRnBracketOut (XRnBracketOut p) (HsBracket GhcRn) [PendingRnSplice]
HsTcBracketOut (XTcBracketOut p) (HsBracket GhcRn) [PendingTcSplice]
HsSpliceE (XSpliceE p) (HsSplice p)	`AnnKeywordId` : `AnnOpen`, `AnnClose`
HsProc (XProc p) (LPat p) (LHsCmdTop p)	`proc` notation for Arrows `AnnKeywordId` : `AnnProc`, `AnnRarrow`
HsStatic (XStatic p) (LHsExpr p)	`AnnKeywordId` : `AnnStatic`,
HsTick (XTick p) (Tickish (IdP p)) (LHsExpr p)
HsBinTick (XBinTick p) Int Int (LHsExpr p)
HsTickPragma (XTickPragma p) SourceText (StringLiteral, (Int, Int), (Int, Int)) ((SourceText, SourceText), (SourceText, SourceText)) (LHsExpr p)	`AnnKeywordId` : `AnnOpen`, `AnnOpen` `'{-# GENERATED'`, `AnnVal`,`AnnVal`, `AnnColon`,`AnnVal`, `AnnMinus`, `AnnVal`,`AnnColon`, `AnnVal`, `AnnClose` `'#-}'`
HsWrap (XWrap p) HsWrapper (HsExpr p)
XExpr (XXExpr p)

Instances

Instances details

p ~ GhcPs => DisambInfixOp (HsExpr p)
Instance details Defined in RdrHsSyn Methods mkHsVarOpPV :: Located RdrName -> PV (Located (HsExpr p)) # mkHsConOpPV :: Located RdrName -> PV (Located (HsExpr p)) # mkHsInfixHolePV :: SrcSpan -> PV (Located (HsExpr p)) #
p ~ GhcPs => DisambECP (HsExpr p)
Instance details Defined in RdrHsSyn Associated Types type Body (HsExpr p) :: Type -> Type # type InfixOp (HsExpr p) # type FunArg (HsExpr p) # Methods ecpFromCmd' :: LHsCmd GhcPs -> PV (Located (HsExpr p)) # ecpFromExp' :: LHsExpr GhcPs -> PV (Located (HsExpr p)) # mkHsLamPV :: SrcSpan -> MatchGroup GhcPs (Located (HsExpr p)) -> PV (Located (HsExpr p)) # mkHsLetPV :: SrcSpan -> LHsLocalBinds GhcPs -> Located (HsExpr p) -> PV (Located (HsExpr p)) # superInfixOp :: (DisambInfixOp (InfixOp (HsExpr p)) => PV (Located (HsExpr p))) -> PV (Located (HsExpr p)) # mkHsOpAppPV :: SrcSpan -> Located (HsExpr p) -> Located (InfixOp (HsExpr p)) -> Located (HsExpr p) -> PV (Located (HsExpr p)) # mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> MatchGroup GhcPs (Located (HsExpr p)) -> PV (Located (HsExpr p)) # superFunArg :: (DisambECP (FunArg (HsExpr p)) => PV (Located (HsExpr p))) -> PV (Located (HsExpr p)) # mkHsAppPV :: SrcSpan -> Located (HsExpr p) -> Located (FunArg (HsExpr p)) -> PV (Located (HsExpr p)) # mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> Located (HsExpr p) -> Bool -> Located (HsExpr p) -> PV (Located (HsExpr p)) # mkHsDoPV :: SrcSpan -> Located [LStmt GhcPs (Located (HsExpr p))] -> PV (Located (HsExpr p)) # mkHsParPV :: SrcSpan -> Located (HsExpr p) -> PV (Located (HsExpr p)) # mkHsVarPV :: Located RdrName -> PV (Located (HsExpr p)) # mkHsLitPV :: Located (HsLit GhcPs) -> PV (Located (HsExpr p)) # mkHsOverLitPV :: Located (HsOverLit GhcPs) -> PV (Located (HsExpr p)) # mkHsWildCardPV :: SrcSpan -> PV (Located (HsExpr p)) # mkHsTySigPV :: SrcSpan -> Located (HsExpr p) -> LHsType GhcPs -> PV (Located (HsExpr p)) # mkHsExplicitListPV :: SrcSpan -> [Located (HsExpr p)] -> PV (Located (HsExpr p)) # mkHsSplicePV :: Located (HsSplice GhcPs) -> PV (Located (HsExpr p)) # mkHsRecordPV :: SrcSpan -> SrcSpan -> Located (HsExpr p) -> ([LHsRecField GhcPs (Located (HsExpr p))], Maybe SrcSpan) -> PV (Located (HsExpr p)) # mkHsNegAppPV :: SrcSpan -> Located (HsExpr p) -> PV (Located (HsExpr p)) # mkHsSectionR_PV :: SrcSpan -> Located (InfixOp (HsExpr p)) -> Located (HsExpr p) -> PV (Located (HsExpr p)) # mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> Located (HsExpr p) -> PV (Located (HsExpr p)) # mkHsAsPatPV :: SrcSpan -> Located RdrName -> Located (HsExpr p) -> PV (Located (HsExpr p)) # mkHsLazyPatPV :: SrcSpan -> Located (HsExpr p) -> PV (Located (HsExpr p)) # mkSumOrTuplePV :: SrcSpan -> Boxity -> SumOrTuple (HsExpr p) -> PV (Located (HsExpr p)) #
OutputableBndrId p => Outputable (HsExpr (GhcPass p))
Instance details Defined in GHC.Hs.Expr Methods ppr :: HsExpr (GhcPass p) -> SDoc # pprPrec :: Rational -> HsExpr (GhcPass p) -> SDoc #
Annotate [ExprLStmt GhcPs]	Used for declarations that need to be aligned together, e.g. in a do or let .. in statement/expr
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> [ExprLStmt GhcPs] -> Annotated () #
Annotate (HsRecUpdField GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsRecUpdField GhcPs -> Annotated () #
Annotate (HsExpr GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsExpr GhcPs -> Annotated () #
HasDecls (LHsExpr GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Transform Methods hsDecls :: forall (m :: Type -> Type). Monad m => LHsExpr GhcPs -> TransformT m [LHsDecl GhcPs] # replaceDecls :: forall (m :: Type -> Type). Monad m => LHsExpr GhcPs -> [LHsDecl GhcPs] -> TransformT m (LHsExpr GhcPs) #
Matchable (LHsExpr GhcPs) Source #
Instance details Defined in Retrie.Universe Methods inject :: LHsExpr GhcPs -> Universe Source # project :: Universe -> LHsExpr GhcPs Source # getOrigin :: LHsExpr GhcPs -> SrcSpan Source #
Annotate (HsRecField GhcPs (LHsExpr GhcPs))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsRecField GhcPs (LHsExpr GhcPs) -> Annotated () #
HasDecls (LMatch GhcPs (LHsExpr GhcPs))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Transform Methods hsDecls :: forall (m :: Type -> Type). Monad m => LMatch GhcPs (LHsExpr GhcPs) -> TransformT m [LHsDecl GhcPs] # replaceDecls :: forall (m :: Type -> Type). Monad m => LMatch GhcPs (LHsExpr GhcPs) -> [LHsDecl GhcPs] -> TransformT m (LMatch GhcPs (LHsExpr GhcPs)) #
HasDecls (LStmt GhcPs (LHsExpr GhcPs))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Transform Methods hsDecls :: forall (m :: Type -> Type). Monad m => LStmt GhcPs (LHsExpr GhcPs) -> TransformT m [LHsDecl GhcPs] # replaceDecls :: forall (m :: Type -> Type). Monad m => LStmt GhcPs (LHsExpr GhcPs) -> [LHsDecl GhcPs] -> TransformT m (LStmt GhcPs (LHsExpr GhcPs)) #
Matchable (LStmt GhcPs (LHsExpr GhcPs)) Source #
Instance details Defined in Retrie.Universe Methods inject :: LStmt GhcPs (LHsExpr GhcPs) -> Universe Source # project :: Universe -> LStmt GhcPs (LHsExpr GhcPs) Source # getOrigin :: LStmt GhcPs (LHsExpr GhcPs) -> SrcSpan Source #
type FunArg (HsExpr p)
Instance details Defined in RdrHsSyn type FunArg (HsExpr p) = HsExpr p
type InfixOp (HsExpr p)
Instance details Defined in RdrHsSyn type InfixOp (HsExpr p) = HsExpr p
type Body (HsExpr p)
Instance details Defined in RdrHsSyn type Body (HsExpr p) = HsExpr

data HsCmd id #

Haskell Command (e.g. a "statement" in an Arrow proc block)

Constructors

HsCmdArrApp (XCmdArrApp id) (LHsExpr id) (LHsExpr id) HsArrAppType Bool	`AnnKeywordId` : `Annlarrowtail`, `Annrarrowtail`,`AnnLarrowtail`, `AnnRarrowtail`
HsCmdArrForm (XCmdArrForm id) (LHsExpr id) LexicalFixity (Maybe Fixity) [LHsCmdTop id]	`AnnKeywordId` : `AnnOpenB` `'(\|'`, `AnnCloseB` `'\|)'`
HsCmdApp (XCmdApp id) (LHsCmd id) (LHsExpr id)
HsCmdLam (XCmdLam id) (MatchGroup id (LHsCmd id))	`AnnKeywordId` : `AnnLam`, `AnnRarrow`,
HsCmdPar (XCmdPar id) (LHsCmd id)	`AnnKeywordId` : `AnnOpen` `'('`, `AnnClose` `')'`
HsCmdCase (XCmdCase id) (LHsExpr id) (MatchGroup id (LHsCmd id))	`AnnKeywordId` : `AnnCase`, `AnnOf`,`AnnOpen` `'{'`, `AnnClose` `'}'`
HsCmdIf (XCmdIf id) (Maybe (SyntaxExpr id)) (LHsExpr id) (LHsCmd id) (LHsCmd id)	`AnnKeywordId` : `AnnIf`, `AnnSemi`, `AnnThen`,`AnnSemi`, `AnnElse`,
HsCmdLet (XCmdLet id) (LHsLocalBinds id) (LHsCmd id)	`AnnKeywordId` : `AnnLet`, `AnnOpen` `'{'`, `AnnClose` `'}'`,`AnnIn`
HsCmdDo (XCmdDo id) (Located [CmdLStmt id])	`AnnKeywordId` : `AnnDo`, `AnnOpen`, `AnnSemi`, `AnnVbar`, `AnnClose`
HsCmdWrap (XCmdWrap id) HsWrapper (HsCmd id)
XCmd (XXCmd id)

Instances

Instances details

p ~ GhcPs => DisambECP (HsCmd p)
Instance details Defined in RdrHsSyn Associated Types type Body (HsCmd p) :: Type -> Type # type InfixOp (HsCmd p) # type FunArg (HsCmd p) # Methods ecpFromCmd' :: LHsCmd GhcPs -> PV (Located (HsCmd p)) # ecpFromExp' :: LHsExpr GhcPs -> PV (Located (HsCmd p)) # mkHsLamPV :: SrcSpan -> MatchGroup GhcPs (Located (HsCmd p)) -> PV (Located (HsCmd p)) # mkHsLetPV :: SrcSpan -> LHsLocalBinds GhcPs -> Located (HsCmd p) -> PV (Located (HsCmd p)) # superInfixOp :: (DisambInfixOp (InfixOp (HsCmd p)) => PV (Located (HsCmd p))) -> PV (Located (HsCmd p)) # mkHsOpAppPV :: SrcSpan -> Located (HsCmd p) -> Located (InfixOp (HsCmd p)) -> Located (HsCmd p) -> PV (Located (HsCmd p)) # mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> MatchGroup GhcPs (Located (HsCmd p)) -> PV (Located (HsCmd p)) # superFunArg :: (DisambECP (FunArg (HsCmd p)) => PV (Located (HsCmd p))) -> PV (Located (HsCmd p)) # mkHsAppPV :: SrcSpan -> Located (HsCmd p) -> Located (FunArg (HsCmd p)) -> PV (Located (HsCmd p)) # mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> Located (HsCmd p) -> Bool -> Located (HsCmd p) -> PV (Located (HsCmd p)) # mkHsDoPV :: SrcSpan -> Located [LStmt GhcPs (Located (HsCmd p))] -> PV (Located (HsCmd p)) # mkHsParPV :: SrcSpan -> Located (HsCmd p) -> PV (Located (HsCmd p)) # mkHsVarPV :: Located RdrName -> PV (Located (HsCmd p)) # mkHsLitPV :: Located (HsLit GhcPs) -> PV (Located (HsCmd p)) # mkHsOverLitPV :: Located (HsOverLit GhcPs) -> PV (Located (HsCmd p)) # mkHsWildCardPV :: SrcSpan -> PV (Located (HsCmd p)) # mkHsTySigPV :: SrcSpan -> Located (HsCmd p) -> LHsType GhcPs -> PV (Located (HsCmd p)) # mkHsExplicitListPV :: SrcSpan -> [Located (HsCmd p)] -> PV (Located (HsCmd p)) # mkHsSplicePV :: Located (HsSplice GhcPs) -> PV (Located (HsCmd p)) # mkHsRecordPV :: SrcSpan -> SrcSpan -> Located (HsCmd p) -> ([LHsRecField GhcPs (Located (HsCmd p))], Maybe SrcSpan) -> PV (Located (HsCmd p)) # mkHsNegAppPV :: SrcSpan -> Located (HsCmd p) -> PV (Located (HsCmd p)) # mkHsSectionR_PV :: SrcSpan -> Located (InfixOp (HsCmd p)) -> Located (HsCmd p) -> PV (Located (HsCmd p)) # mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> Located (HsCmd p) -> PV (Located (HsCmd p)) # mkHsAsPatPV :: SrcSpan -> Located RdrName -> Located (HsCmd p) -> PV (Located (HsCmd p)) # mkHsLazyPatPV :: SrcSpan -> Located (HsCmd p) -> PV (Located (HsCmd p)) # mkSumOrTuplePV :: SrcSpan -> Boxity -> SumOrTuple (HsCmd p) -> PV (Located (HsCmd p)) #
OutputableBndrId p => Outputable (HsCmd (GhcPass p))
Instance details Defined in GHC.Hs.Expr Methods ppr :: HsCmd (GhcPass p) -> SDoc # pprPrec :: Rational -> HsCmd (GhcPass p) -> SDoc #
Annotate [Located (StmtLR GhcPs GhcPs (LHsCmd GhcPs))]
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> [Located (StmtLR GhcPs GhcPs (LHsCmd GhcPs))] -> Annotated () #
Annotate (HsCmd GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsCmd GhcPs -> Annotated () #
type FunArg (HsCmd p)
Instance details Defined in RdrHsSyn type FunArg (HsCmd p) = HsExpr p
type InfixOp (HsCmd p)
Instance details Defined in RdrHsSyn type InfixOp (HsCmd p) = HsExpr p
type Body (HsCmd p)
Instance details Defined in RdrHsSyn type Body (HsCmd p) = HsCmd

data HsSplice id #

Haskell Splice

Constructors

HsTypedSplice (XTypedSplice id) SpliceDecoration (IdP id) (LHsExpr id)
HsUntypedSplice (XUntypedSplice id) SpliceDecoration (IdP id) (LHsExpr id)
HsQuasiQuote (XQuasiQuote id) (IdP id) (IdP id) SrcSpan FastString
HsSpliced (XSpliced id) ThModFinalizers (HsSplicedThing id)
HsSplicedT DelayedSplice
XSplice (XXSplice id)

Instances

Instances details

OutputableBndrId p => Outputable (HsSplice (GhcPass p))
Instance details Defined in GHC.Hs.Expr Methods ppr :: HsSplice (GhcPass p) -> SDoc # pprPrec :: Rational -> HsSplice (GhcPass p) -> SDoc #
Annotate (HsSplice GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsSplice GhcPs -> Annotated () #

data MatchGroup p body #

Constructors

MG
Fields mg_ext :: XMG p body mg_alts :: Located [LMatch p body] mg_origin :: Origin
XMatchGroup (XXMatchGroup p body)

data GRHSs p body #

Guarded Right-Hand Sides

GRHSs are used both for pattern bindings and for Matches

AnnKeywordId : AnnVbar, AnnEqual,AnnWhere, AnnOpen,AnnClose AnnRarrow,AnnSemi

Constructors

GRHSs
Fields grhssExt :: XCGRHSs p body grhssGRHSs :: [LGRHS p body] Guarded RHSs grhssLocalBinds :: LHsLocalBinds p The where clause
XGRHSs (XXGRHSs p body)

data SyntaxExpr p #

Syntax Expression

SyntaxExpr is like PostTcExpr, but it's filled in a little earlier, by the renamer. It's used for rebindable syntax.

E.g. (>>=) is filled in before the renamer by the appropriate Name for (>>=), and then instantiated by the type checker with its type args etc

This should desugar to

syn_res_wrap $ syn_expr (syn_arg_wraps[0] arg0)
                        (syn_arg_wraps[1] arg1) ...

where the actual arguments come from elsewhere in the AST. This could be defined using GhcPass p and such, but it's harder to get it all to work out that way. (noSyntaxExpr is hard to write, for example.)

Constructors

SyntaxExpr
Fields syn_expr :: HsExpr p syn_arg_wraps :: [HsWrapper] syn_res_wrap :: HsWrapper

Instances

Instances details

OutputableBndrId p => Outputable (SyntaxExpr (GhcPass p))
Instance details Defined in GHC.Hs.Expr Methods ppr :: SyntaxExpr (GhcPass p) -> SDoc # pprPrec :: Rational -> SyntaxExpr (GhcPass p) -> SDoc #

type LHsExpr p #

Arguments

= Located (HsExpr p)

May have AnnKeywordId : AnnComma when in a list

Located Haskell Expression

pprImpExp :: (HasOccName name, OutputableBndr name) => name -> SDoc #

replaceLWrappedName :: LIEWrappedName name1 -> name2 -> LIEWrappedName name2 #

replaceWrappedName :: IEWrappedName name1 -> name2 -> IEWrappedName name2 #

ieLWrappedName :: LIEWrappedName name -> Located name #

lieWrappedName :: LIEWrappedName name -> name #

ieWrappedName :: IEWrappedName name -> name #

ieNames :: forall (p :: Pass). IE (GhcPass p) -> [IdP (GhcPass p)] #

ieName :: forall (p :: Pass). IE (GhcPass p) -> IdP (GhcPass p) #

simpleImportDecl :: forall (p :: Pass). ModuleName -> ImportDecl (GhcPass p) #

isImportDeclQualified :: ImportDeclQualifiedStyle -> Bool #

Convenience function to answer the question if an import decl. is qualified.

importDeclQualifiedStyle :: Maybe (Located a) -> Maybe (Located a) -> ImportDeclQualifiedStyle #

Given two possible located qualified tokens, compute a style (in a conforming Haskell program only one of the two can be not Nothing). This is called from y.

type LImportDecl pass #

Arguments

= Located (ImportDecl pass)

When in a list this may have

AnnKeywordId : AnnSemi

Located Import Declaration

data ImportDeclQualifiedStyle #

If/how an import is qualified.

Constructors

QualifiedPre	`qualified` appears in prepositive position.
QualifiedPost	`qualified` appears in postpositive position.
NotQualified	Not qualified.

Instances

Instances details

Eq ImportDeclQualifiedStyle
Instance details Defined in GHC.Hs.ImpExp Methods (==) :: ImportDeclQualifiedStyle -> ImportDeclQualifiedStyle -> Bool # (/=) :: ImportDeclQualifiedStyle -> ImportDeclQualifiedStyle -> Bool #
Data ImportDeclQualifiedStyle
Instance details Defined in GHC.Hs.ImpExp Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImportDeclQualifiedStyle -> c ImportDeclQualifiedStyle # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ImportDeclQualifiedStyle # toConstr :: ImportDeclQualifiedStyle -> Constr # dataTypeOf :: ImportDeclQualifiedStyle -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ImportDeclQualifiedStyle) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImportDeclQualifiedStyle) # gmapT :: (forall b. Data b => b -> b) -> ImportDeclQualifiedStyle -> ImportDeclQualifiedStyle # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImportDeclQualifiedStyle -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImportDeclQualifiedStyle -> r # gmapQ :: (forall d. Data d => d -> u) -> ImportDeclQualifiedStyle -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ImportDeclQualifiedStyle -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImportDeclQualifiedStyle -> m ImportDeclQualifiedStyle # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportDeclQualifiedStyle -> m ImportDeclQualifiedStyle # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportDeclQualifiedStyle -> m ImportDeclQualifiedStyle #

data ImportDecl pass #

Import Declaration

A single Haskell import declaration.

Constructors

ImportDecl

Fields

ideclExt :: XCImportDecl pass
ideclSourceSrc :: SourceText
ideclName :: Located ModuleName
Module name.
ideclPkgQual :: Maybe StringLiteral
Package qualifier.
ideclSource :: Bool
True = {-# SOURCE #-} import
ideclSafe :: Bool
True => safe import
ideclQualified :: ImportDeclQualifiedStyle
If/how the import is qualified.
ideclImplicit :: Bool
True => implicit import (of Prelude)
ideclAs :: Maybe (Located ModuleName)
as Module
ideclHiding :: Maybe (Bool, Located [LIE pass])
(True => hiding, names)

XImportDecl (XXImportDecl pass)

AnnKeywordIds

AnnImport
AnnOpen, AnnClose for ideclSource
AnnSafe,AnnQualified, AnnPackageName,AnnAs, AnnVal
AnnHiding,AnnOpen, AnnClose attached to location in ideclHiding

Instances

Instances details

OutputableBndrId p => Outputable (ImportDecl (GhcPass p))
Instance details Defined in GHC.Hs.ImpExp Methods ppr :: ImportDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> ImportDecl (GhcPass p) -> SDoc #
Annotate (ImportDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> ImportDecl GhcPs -> Annotated () #

data IEWrappedName name #

A name in an import or export specification which may have adornments. Used primarily for accurate pretty printing of ParsedSource, and API Annotation placement.

Constructors

IEName (Located name)	no extra
IEPattern (Located name)	pattern X
IEType (Located name)	type (:+:)

Instances

Instances details

Eq name => Eq (IEWrappedName name)
Instance details Defined in GHC.Hs.ImpExp Methods (==) :: IEWrappedName name -> IEWrappedName name -> Bool # (/=) :: IEWrappedName name -> IEWrappedName name -> Bool #
Data name => Data (IEWrappedName name)
Instance details Defined in GHC.Hs.ImpExp Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IEWrappedName name -> c (IEWrappedName name) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (IEWrappedName name) # toConstr :: IEWrappedName name -> Constr # dataTypeOf :: IEWrappedName name -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (IEWrappedName name)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IEWrappedName name)) # gmapT :: (forall b. Data b => b -> b) -> IEWrappedName name -> IEWrappedName name # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IEWrappedName name -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IEWrappedName name -> r # gmapQ :: (forall d. Data d => d -> u) -> IEWrappedName name -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> IEWrappedName name -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> IEWrappedName name -> m (IEWrappedName name) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IEWrappedName name -> m (IEWrappedName name) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IEWrappedName name -> m (IEWrappedName name) #
HasOccName name => HasOccName (IEWrappedName name)
Instance details Defined in GHC.Hs.ImpExp Methods occName :: IEWrappedName name -> OccName #
OutputableBndr name => Outputable (IEWrappedName name)
Instance details Defined in GHC.Hs.ImpExp Methods ppr :: IEWrappedName name -> SDoc # pprPrec :: Rational -> IEWrappedName name -> SDoc #
OutputableBndr name => OutputableBndr (IEWrappedName name)
Instance details Defined in GHC.Hs.ImpExp Methods pprBndr :: BindingSite -> IEWrappedName name -> SDoc # pprPrefixOcc :: IEWrappedName name -> SDoc # pprInfixOcc :: IEWrappedName name -> SDoc # bndrIsJoin_maybe :: IEWrappedName name -> Maybe Int #
Annotate (IEWrappedName RdrName)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> IEWrappedName RdrName -> Annotated () #

type LIEWrappedName name = Located (IEWrappedName name) #

Located name with possible adornment - AnnKeywordIds : AnnType, AnnPattern

type LIE pass #

Arguments

= Located (IE pass)

When in a list this may have

AnnKeywordId : AnnComma

Located Import or Export

data IE pass #

Imported or exported entity.

Constructors

IEVar (XIEVar pass) (LIEWrappedName (IdP pass))	Imported or Exported Variable
IEThingAbs (XIEThingAbs pass) (LIEWrappedName (IdP pass))	Imported or exported Thing with Absent list The thing is a Class/Type (can't tell) - `AnnKeywordId`s : `AnnPattern`, `AnnType`,`AnnVal`
IEThingAll (XIEThingAll pass) (LIEWrappedName (IdP pass))	Imported or exported Thing with All imported or exported The thing is a ClassType and the All refers to methodsconstructors `AnnKeywordId`s : `AnnOpen`, `AnnDotdot`,`AnnClose`, `AnnType`
IEThingWith (XIEThingWith pass) (LIEWrappedName (IdP pass)) IEWildcard [LIEWrappedName (IdP pass)] [Located (FieldLbl (IdP pass))]	Imported or exported Thing With given imported or exported The thing is a Class/Type and the imported or exported things are methods/constructors and record fields; see Note [IEThingWith] - `AnnKeywordId`s : `AnnOpen`, `AnnClose`, `AnnComma`, `AnnType`
IEModuleContents (XIEModuleContents pass) (Located ModuleName)	Imported or exported module contents (Export Only) `AnnKeywordId`s : `AnnModule`
IEGroup (XIEGroup pass) Int HsDocString	Doc section heading
IEDoc (XIEDoc pass) HsDocString	Some documentation
IEDocNamed (XIEDocNamed pass) String	Reference to named doc
XIE (XXIE pass)

Instances

Instances details

OutputableBndrId p => Outputable (IE (GhcPass p))
Instance details Defined in GHC.Hs.ImpExp Methods ppr :: IE (GhcPass p) -> SDoc # pprPrec :: Rational -> IE (GhcPass p) -> SDoc #
Annotate [LIE GhcPs]
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> [LIE GhcPs] -> Annotated () #
Annotate (IE GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> IE GhcPs -> Annotated () #

data IEWildcard #

Imported or Exported Wildcard

Constructors

NoIEWildcard
IEWildcard Int

Instances

Instances details

Eq IEWildcard
Instance details Defined in GHC.Hs.ImpExp Methods (==) :: IEWildcard -> IEWildcard -> Bool # (/=) :: IEWildcard -> IEWildcard -> Bool #
Data IEWildcard
Instance details Defined in GHC.Hs.ImpExp Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IEWildcard -> c IEWildcard # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IEWildcard # toConstr :: IEWildcard -> Constr # dataTypeOf :: IEWildcard -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c IEWildcard) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IEWildcard) # gmapT :: (forall b. Data b => b -> b) -> IEWildcard -> IEWildcard # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IEWildcard -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IEWildcard -> r # gmapQ :: (forall d. Data d => d -> u) -> IEWildcard -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> IEWildcard -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> IEWildcard -> m IEWildcard # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IEWildcard -> m IEWildcard # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IEWildcard -> m IEWildcard #

data Pat p #

Pattern

AnnKeywordId : AnnBang

Constructors

WildPat (XWildPat p)	Wildcard Pattern The sole reason for a type on a WildPat is to support hsPatType :: Pat Id -> Type
VarPat (XVarPat p) (Located (IdP p))	Variable Pattern
LazyPat (XLazyPat p) (LPat p)	Lazy Pattern ^ - `AnnKeywordId` : `AnnTilde`
AsPat (XAsPat p) (Located (IdP p)) (LPat p)	As pattern ^ - `AnnKeywordId` : `AnnAt`
ParPat (XParPat p) (LPat p)	Parenthesised pattern See Note [Parens in HsSyn] in GHC.Hs.Expr ^ - `AnnKeywordId` : `AnnOpen` `'('`, `AnnClose` `')'`
BangPat (XBangPat p) (LPat p)	Bang pattern ^ - `AnnKeywordId` : `AnnBang`
ListPat (XListPat p) [LPat p]	Syntactic List `AnnKeywordId` : `AnnOpen` `'['`, `AnnClose` `']'`
TuplePat (XTuplePat p) [LPat p] Boxity	Tuple sub-patterns `AnnKeywordId` : `AnnOpen` `'('` or `'(#'`, `AnnClose` `')'` or `'#)'`
SumPat (XSumPat p) (LPat p) ConTag Arity	Anonymous sum pattern `AnnKeywordId` : `AnnOpen` `'(#'`, `AnnClose` `'#)'`
ConPatIn (Located (IdP p)) (HsConPatDetails p)	Constructor Pattern In
ConPatOut	Constructor Pattern Out
Fields pat_con :: Located ConLike pat_arg_tys :: [Type] pat_tvs :: [TyVar] pat_dicts :: [EvVar] pat_binds :: TcEvBinds pat_args :: HsConPatDetails p pat_wrap :: HsWrapper
ViewPat (XViewPat p) (LHsExpr p) (LPat p)	View Pattern
SplicePat (XSplicePat p) (HsSplice p)	Splice Pattern (Includes quasi-quotes)
LitPat (XLitPat p) (HsLit p)	Literal Pattern Used for non-overloaded literal patterns: Int, Int, Char, String, etc.
NPat (XNPat p) (Located (HsOverLit p)) (Maybe (SyntaxExpr p)) (SyntaxExpr p)	Natural Pattern `AnnKeywordId` : `AnnVal` `+`
NPlusKPat (XNPlusKPat p) (Located (IdP p)) (Located (HsOverLit p)) (HsOverLit p) (SyntaxExpr p) (SyntaxExpr p)	n+k pattern
SigPat (XSigPat p) (LPat p) (LHsSigWcType (NoGhcTc p))	Pattern with a type signature
CoPat (XCoPat p) HsWrapper (Pat p) Type	Coercion Pattern
XPat (XXPat p)	Trees that Grow extension point for new constructors

Instances

Instances details

OutputableBndrId p => Outputable (Pat (GhcPass p))
Instance details Defined in GHC.Hs.Pat Methods ppr :: Pat (GhcPass p) -> SDoc # pprPrec :: Rational -> Pat (GhcPass p) -> SDoc #
Annotate (Pat GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> Pat GhcPs -> Annotated () #
Matchable (Located (Pat GhcPs)) Source #
Instance details Defined in Retrie.Universe Methods inject :: Located (Pat GhcPs) -> Universe Source # project :: Universe -> Located (Pat GhcPs) Source # getOrigin :: Located (Pat GhcPs) -> SrcSpan Source #
Annotate (HsRecField GhcPs (Located (Pat GhcPs)))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsRecField GhcPs (Located (Pat GhcPs)) -> Annotated () #

type LPat p = XRec p Pat #

noExtCon :: NoExtCon -> a #

Eliminate a NoExtCon. Much like absurd.

noExtField :: NoExtField #

Used when constructing a term with an unused extension point.

data NoExtField #

A placeholder type for TTG extension points that are not currently unused to represent any particular value.

This should not be confused with NoExtCon, which are found in unused extension constructors and therefore should never be inhabited. In contrast, NoExtField is used in extension points (e.g., as the field of some constructor), so it must have an inhabitant to construct AST passes that manipulate fields with that extension point as their type.

Constructors

NoExtField

Instances

Instances details

Eq NoExtField
Instance details Defined in GHC.Hs.Extension Methods (==) :: NoExtField -> NoExtField -> Bool # (/=) :: NoExtField -> NoExtField -> Bool #
Data NoExtField
Instance details Defined in GHC.Hs.Extension Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NoExtField -> c NoExtField # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NoExtField # toConstr :: NoExtField -> Constr # dataTypeOf :: NoExtField -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NoExtField) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NoExtField) # gmapT :: (forall b. Data b => b -> b) -> NoExtField -> NoExtField # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NoExtField -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NoExtField -> r # gmapQ :: (forall d. Data d => d -> u) -> NoExtField -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NoExtField -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NoExtField -> m NoExtField # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NoExtField -> m NoExtField # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NoExtField -> m NoExtField #
Ord NoExtField
Instance details Defined in GHC.Hs.Extension Methods compare :: NoExtField -> NoExtField -> Ordering # (<) :: NoExtField -> NoExtField -> Bool # (<=) :: NoExtField -> NoExtField -> Bool # (>) :: NoExtField -> NoExtField -> Bool # (>=) :: NoExtField -> NoExtField -> Bool # max :: NoExtField -> NoExtField -> NoExtField # min :: NoExtField -> NoExtField -> NoExtField #
Outputable NoExtField
Instance details Defined in GHC.Hs.Extension Methods ppr :: NoExtField -> SDoc # pprPrec :: Rational -> NoExtField -> SDoc #

data NoExtCon #

Used in TTG extension constructors that have yet to be extended with anything. If an extension constructor has NoExtCon as its field, it is not intended to ever be constructed anywhere, and any function that consumes the extension constructor can eliminate it by way of noExtCon.

This should not be confused with NoExtField, which are found in unused extension points (not constructors) and therefore can be inhabited.

Instances

Instances details

Eq NoExtCon
Instance details Defined in GHC.Hs.Extension Methods (==) :: NoExtCon -> NoExtCon -> Bool # (/=) :: NoExtCon -> NoExtCon -> Bool #
Data NoExtCon
Instance details Defined in GHC.Hs.Extension Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NoExtCon -> c NoExtCon # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NoExtCon # toConstr :: NoExtCon -> Constr # dataTypeOf :: NoExtCon -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NoExtCon) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NoExtCon) # gmapT :: (forall b. Data b => b -> b) -> NoExtCon -> NoExtCon # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NoExtCon -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NoExtCon -> r # gmapQ :: (forall d. Data d => d -> u) -> NoExtCon -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NoExtCon -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NoExtCon -> m NoExtCon # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NoExtCon -> m NoExtCon # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NoExtCon -> m NoExtCon #
Ord NoExtCon
Instance details Defined in GHC.Hs.Extension Methods compare :: NoExtCon -> NoExtCon -> Ordering # (<) :: NoExtCon -> NoExtCon -> Bool # (<=) :: NoExtCon -> NoExtCon -> Bool # (>) :: NoExtCon -> NoExtCon -> Bool # (>=) :: NoExtCon -> NoExtCon -> Bool # max :: NoExtCon -> NoExtCon -> NoExtCon # min :: NoExtCon -> NoExtCon -> NoExtCon #
Outputable NoExtCon
Instance details Defined in GHC.Hs.Extension Methods ppr :: NoExtCon -> SDoc # pprPrec :: Rational -> NoExtCon -> SDoc #

data GhcPass (c :: Pass) #

Used as a data type index for the hsSyn AST

Instances

Instances details

HasDecls ParsedSource
Instance details Defined in Language.Haskell.GHC.ExactPrint.Transform Methods hsDecls :: forall (m :: Type -> Type). Monad m => ParsedSource -> TransformT m [LHsDecl GhcPs] # replaceDecls :: forall (m :: Type -> Type). Monad m => ParsedSource -> [LHsDecl GhcPs] -> TransformT m ParsedSource #
Eq (XCFieldOcc (GhcPass p)) => Eq (FieldOcc (GhcPass p))
Instance details Defined in GHC.Hs.Types Methods (==) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool # (/=) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool #
Eq (GhcPass c)
Instance details Defined in GHC.Hs.Extension Methods (==) :: GhcPass c -> GhcPass c -> Bool # (/=) :: GhcPass c -> GhcPass c -> Bool #
Data (HsModule GhcPs)
Instance details Defined in GHC.Hs Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsModule GhcPs -> c (HsModule GhcPs) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsModule GhcPs) # toConstr :: HsModule GhcPs -> Constr # dataTypeOf :: HsModule GhcPs -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsModule GhcPs)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsModule GhcPs)) # gmapT :: (forall b. Data b => b -> b) -> HsModule GhcPs -> HsModule GhcPs # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsModule GhcPs -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsModule GhcPs -> r # gmapQ :: (forall d. Data d => d -> u) -> HsModule GhcPs -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsModule GhcPs -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsModule GhcPs -> m (HsModule GhcPs) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsModule GhcPs -> m (HsModule GhcPs) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsModule GhcPs -> m (HsModule GhcPs) #
Data (HsModule GhcRn)
Instance details Defined in GHC.Hs Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsModule GhcRn -> c (HsModule GhcRn) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsModule GhcRn) # toConstr :: HsModule GhcRn -> Constr # dataTypeOf :: HsModule GhcRn -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsModule GhcRn)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsModule GhcRn)) # gmapT :: (forall b. Data b => b -> b) -> HsModule GhcRn -> HsModule GhcRn # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsModule GhcRn -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsModule GhcRn -> r # gmapQ :: (forall d. Data d => d -> u) -> HsModule GhcRn -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsModule GhcRn -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsModule GhcRn -> m (HsModule GhcRn) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsModule GhcRn -> m (HsModule GhcRn) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsModule GhcRn -> m (HsModule GhcRn) #
Data (HsModule GhcTc)
Instance details Defined in GHC.Hs Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsModule GhcTc -> c (HsModule GhcTc) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsModule GhcTc) # toConstr :: HsModule GhcTc -> Constr # dataTypeOf :: HsModule GhcTc -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsModule GhcTc)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsModule GhcTc)) # gmapT :: (forall b. Data b => b -> b) -> HsModule GhcTc -> HsModule GhcTc # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsModule GhcTc -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsModule GhcTc -> r # gmapQ :: (forall d. Data d => d -> u) -> HsModule GhcTc -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsModule GhcTc -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsModule GhcTc -> m (HsModule GhcTc) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsModule GhcTc -> m (HsModule GhcTc) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsModule GhcTc -> m (HsModule GhcTc) #
Typeable c => Data (GhcPass c)
Instance details Defined in GHC.Hs.Extension Methods gfoldl :: (forall d b. Data d => c0 (d -> b) -> d -> c0 b) -> (forall g. g -> c0 g) -> GhcPass c -> c0 (GhcPass c) # gunfold :: (forall b r. Data b => c0 (b -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (GhcPass c) # toConstr :: GhcPass c -> Constr # dataTypeOf :: GhcPass c -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c0 (t d)) -> Maybe (c0 (GhcPass c)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c0 (t d e)) -> Maybe (c0 (GhcPass c)) # gmapT :: (forall b. Data b => b -> b) -> GhcPass c -> GhcPass c # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GhcPass c -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GhcPass c -> r # gmapQ :: (forall d. Data d => d -> u) -> GhcPass c -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> GhcPass c -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> GhcPass c -> m (GhcPass c) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GhcPass c -> m (GhcPass c) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GhcPass c -> m (GhcPass c) #
Ord (XCFieldOcc (GhcPass p)) => Ord (FieldOcc (GhcPass p))
Instance details Defined in GHC.Hs.Types Methods compare :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Ordering # (<) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool # (<=) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool # (>) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool # (>=) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool # max :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) # min :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) #
DisambECP (PatBuilder GhcPs)
Instance details Defined in RdrHsSyn Associated Types type Body (PatBuilder GhcPs) :: Type -> Type # type InfixOp (PatBuilder GhcPs) # type FunArg (PatBuilder GhcPs) # Methods ecpFromCmd' :: LHsCmd GhcPs -> PV (Located (PatBuilder GhcPs)) # ecpFromExp' :: LHsExpr GhcPs -> PV (Located (PatBuilder GhcPs)) # mkHsLamPV :: SrcSpan -> MatchGroup GhcPs (Located (PatBuilder GhcPs)) -> PV (Located (PatBuilder GhcPs)) # mkHsLetPV :: SrcSpan -> LHsLocalBinds GhcPs -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs)) # superInfixOp :: (DisambInfixOp (InfixOp (PatBuilder GhcPs)) => PV (Located (PatBuilder GhcPs))) -> PV (Located (PatBuilder GhcPs)) # mkHsOpAppPV :: SrcSpan -> Located (PatBuilder GhcPs) -> Located (InfixOp (PatBuilder GhcPs)) -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs)) # mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> MatchGroup GhcPs (Located (PatBuilder GhcPs)) -> PV (Located (PatBuilder GhcPs)) # superFunArg :: (DisambECP (FunArg (PatBuilder GhcPs)) => PV (Located (PatBuilder GhcPs))) -> PV (Located (PatBuilder GhcPs)) # mkHsAppPV :: SrcSpan -> Located (PatBuilder GhcPs) -> Located (FunArg (PatBuilder GhcPs)) -> PV (Located (PatBuilder GhcPs)) # mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> Located (PatBuilder GhcPs) -> Bool -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs)) # mkHsDoPV :: SrcSpan -> Located [LStmt GhcPs (Located (PatBuilder GhcPs))] -> PV (Located (PatBuilder GhcPs)) # mkHsParPV :: SrcSpan -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs)) # mkHsVarPV :: Located RdrName -> PV (Located (PatBuilder GhcPs)) # mkHsLitPV :: Located (HsLit GhcPs) -> PV (Located (PatBuilder GhcPs)) # mkHsOverLitPV :: Located (HsOverLit GhcPs) -> PV (Located (PatBuilder GhcPs)) # mkHsWildCardPV :: SrcSpan -> PV (Located (PatBuilder GhcPs)) # mkHsTySigPV :: SrcSpan -> Located (PatBuilder GhcPs) -> LHsType GhcPs -> PV (Located (PatBuilder GhcPs)) # mkHsExplicitListPV :: SrcSpan -> [Located (PatBuilder GhcPs)] -> PV (Located (PatBuilder GhcPs)) # mkHsSplicePV :: Located (HsSplice GhcPs) -> PV (Located (PatBuilder GhcPs)) # mkHsRecordPV :: SrcSpan -> SrcSpan -> Located (PatBuilder GhcPs) -> ([LHsRecField GhcPs (Located (PatBuilder GhcPs))], Maybe SrcSpan) -> PV (Located (PatBuilder GhcPs)) # mkHsNegAppPV :: SrcSpan -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs)) # mkHsSectionR_PV :: SrcSpan -> Located (InfixOp (PatBuilder GhcPs)) -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs)) # mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs)) # mkHsAsPatPV :: SrcSpan -> Located RdrName -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs)) # mkHsLazyPatPV :: SrcSpan -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs)) # mkSumOrTuplePV :: SrcSpan -> Boxity -> SumOrTuple (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs)) #
NamedThing (HsTyVarBndr GhcRn)
Instance details Defined in GHC.Hs.Types Methods getOccName :: HsTyVarBndr GhcRn -> OccName # getName :: HsTyVarBndr GhcRn -> Name #
OutputableBndrId a => Outputable (InstInfo (GhcPass a))
Instance details Defined in TcEnv Methods ppr :: InstInfo (GhcPass a) -> SDoc # pprPrec :: Rational -> InstInfo (GhcPass a) -> SDoc #
Outputable (PatBuilder GhcPs)
Instance details Defined in RdrHsSyn Methods ppr :: PatBuilder GhcPs -> SDoc # pprPrec :: Rational -> PatBuilder GhcPs -> SDoc #
OutputableBndrId p => Outputable (HsModule (GhcPass p))
Instance details Defined in GHC.Hs Methods ppr :: HsModule (GhcPass p) -> SDoc # pprPrec :: Rational -> HsModule (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (HsCmdTop (GhcPass p))
Instance details Defined in GHC.Hs.Expr Methods ppr :: HsCmdTop (GhcPass p) -> SDoc # pprPrec :: Rational -> HsCmdTop (GhcPass p) -> SDoc #
OutputableBndrId idL => Outputable (ApplicativeArg (GhcPass idL))
Instance details Defined in GHC.Hs.Expr Methods ppr :: ApplicativeArg (GhcPass idL) -> SDoc # pprPrec :: Rational -> ApplicativeArg (GhcPass idL) -> SDoc #
OutputableBndrId p => Outputable (HsSplicedThing (GhcPass p))
Instance details Defined in GHC.Hs.Expr Methods ppr :: HsSplicedThing (GhcPass p) -> SDoc # pprPrec :: Rational -> HsSplicedThing (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (HsBracket (GhcPass p))
Instance details Defined in GHC.Hs.Expr Methods ppr :: HsBracket (GhcPass p) -> SDoc # pprPrec :: Rational -> HsBracket (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (ArithSeqInfo (GhcPass p))
Instance details Defined in GHC.Hs.Expr Methods ppr :: ArithSeqInfo (GhcPass p) -> SDoc # pprPrec :: Rational -> ArithSeqInfo (GhcPass p) -> SDoc #
(Outputable (GhcPass p), Outputable (NameOrRdrName (GhcPass p))) => Outputable (HsStmtContext (GhcPass p))
Instance details Defined in GHC.Hs.Expr Methods ppr :: HsStmtContext (GhcPass p) -> SDoc # pprPrec :: Rational -> HsStmtContext (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (HsDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: HsDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> HsDecl (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (HsGroup (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: HsGroup (GhcPass p) -> SDoc # pprPrec :: Rational -> HsGroup (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (SpliceDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: SpliceDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> SpliceDecl (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (TyClDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: TyClDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> TyClDecl (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (TyClGroup (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: TyClGroup (GhcPass p) -> SDoc # pprPrec :: Rational -> TyClGroup (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (FamilyDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: FamilyDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> FamilyDecl (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (HsDataDefn (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: HsDataDefn (GhcPass p) -> SDoc # pprPrec :: Rational -> HsDataDefn (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (HsDerivingClause (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: HsDerivingClause (GhcPass p) -> SDoc # pprPrec :: Rational -> HsDerivingClause (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (StandaloneKindSig (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: StandaloneKindSig (GhcPass p) -> SDoc # pprPrec :: Rational -> StandaloneKindSig (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (ConDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: ConDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> ConDecl (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (TyFamInstDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: TyFamInstDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> TyFamInstDecl (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (DataFamInstDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: DataFamInstDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> DataFamInstDecl (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (ClsInstDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: ClsInstDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> ClsInstDecl (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (InstDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: InstDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> InstDecl (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (DerivDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: DerivDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> DerivDecl (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (DerivStrategy (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: DerivStrategy (GhcPass p) -> SDoc # pprPrec :: Rational -> DerivStrategy (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (DefaultDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: DefaultDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> DefaultDecl (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (ForeignDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: ForeignDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> ForeignDecl (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (RuleDecls (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: RuleDecls (GhcPass p) -> SDoc # pprPrec :: Rational -> RuleDecls (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (RuleDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: RuleDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> RuleDecl (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (RuleBndr (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: RuleBndr (GhcPass p) -> SDoc # pprPrec :: Rational -> RuleBndr (GhcPass p) -> SDoc #
OutputableBndr (IdP (GhcPass p)) => Outputable (WarnDecls (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: WarnDecls (GhcPass p) -> SDoc # pprPrec :: Rational -> WarnDecls (GhcPass p) -> SDoc #
OutputableBndr (IdP (GhcPass p)) => Outputable (WarnDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: WarnDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> WarnDecl (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (AnnDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: AnnDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> AnnDecl (GhcPass p) -> SDoc #
OutputableBndr (IdP (GhcPass p)) => Outputable (RoleAnnotDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls Methods ppr :: RoleAnnotDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> RoleAnnotDecl (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (ABExport (GhcPass p))
Instance details Defined in GHC.Hs.Binds Methods ppr :: ABExport (GhcPass p) -> SDoc # pprPrec :: Rational -> ABExport (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (HsIPBinds (GhcPass p))
Instance details Defined in GHC.Hs.Binds Methods ppr :: HsIPBinds (GhcPass p) -> SDoc # pprPrec :: Rational -> HsIPBinds (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (IPBind (GhcPass p))
Instance details Defined in GHC.Hs.Binds Methods ppr :: IPBind (GhcPass p) -> SDoc # pprPrec :: Rational -> IPBind (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (Sig (GhcPass p))
Instance details Defined in GHC.Hs.Binds Methods ppr :: Sig (GhcPass p) -> SDoc # pprPrec :: Rational -> Sig (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (FixitySig (GhcPass p))
Instance details Defined in GHC.Hs.Binds Methods ppr :: FixitySig (GhcPass p) -> SDoc # pprPrec :: Rational -> FixitySig (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (LHsQTyVars (GhcPass p))
Instance details Defined in GHC.Hs.Types Methods ppr :: LHsQTyVars (GhcPass p) -> SDoc # pprPrec :: Rational -> LHsQTyVars (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (HsTyVarBndr (GhcPass p))
Instance details Defined in GHC.Hs.Types Methods ppr :: HsTyVarBndr (GhcPass p) -> SDoc # pprPrec :: Rational -> HsTyVarBndr (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (HsType (GhcPass p))
Instance details Defined in GHC.Hs.Types Methods ppr :: HsType (GhcPass p) -> SDoc # pprPrec :: Rational -> HsType (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (ConDeclField (GhcPass p))
Instance details Defined in GHC.Hs.Types Methods ppr :: ConDeclField (GhcPass p) -> SDoc # pprPrec :: Rational -> ConDeclField (GhcPass p) -> SDoc #
Outputable (AmbiguousFieldOcc (GhcPass p))
Instance details Defined in GHC.Hs.Types Methods ppr :: AmbiguousFieldOcc (GhcPass p) -> SDoc # pprPrec :: Rational -> AmbiguousFieldOcc (GhcPass p) -> SDoc #
Outputable (HsLit (GhcPass p))
Instance details Defined in GHC.Hs.Lit Methods ppr :: HsLit (GhcPass p) -> SDoc # pprPrec :: Rational -> HsLit (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (HsOverLit (GhcPass p))
Instance details Defined in GHC.Hs.Lit Methods ppr :: HsOverLit (GhcPass p) -> SDoc # pprPrec :: Rational -> HsOverLit (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (HsExpr (GhcPass p))
Instance details Defined in GHC.Hs.Expr Methods ppr :: HsExpr (GhcPass p) -> SDoc # pprPrec :: Rational -> HsExpr (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (HsCmd (GhcPass p))
Instance details Defined in GHC.Hs.Expr Methods ppr :: HsCmd (GhcPass p) -> SDoc # pprPrec :: Rational -> HsCmd (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (HsSplice (GhcPass p))
Instance details Defined in GHC.Hs.Expr Methods ppr :: HsSplice (GhcPass p) -> SDoc # pprPrec :: Rational -> HsSplice (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (SyntaxExpr (GhcPass p))
Instance details Defined in GHC.Hs.Expr Methods ppr :: SyntaxExpr (GhcPass p) -> SDoc # pprPrec :: Rational -> SyntaxExpr (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (ImportDecl (GhcPass p))
Instance details Defined in GHC.Hs.ImpExp Methods ppr :: ImportDecl (GhcPass p) -> SDoc # pprPrec :: Rational -> ImportDecl (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (IE (GhcPass p))
Instance details Defined in GHC.Hs.ImpExp Methods ppr :: IE (GhcPass p) -> SDoc # pprPrec :: Rational -> IE (GhcPass p) -> SDoc #
OutputableBndrId p => Outputable (Pat (GhcPass p))
Instance details Defined in GHC.Hs.Pat Methods ppr :: Pat (GhcPass p) -> SDoc # pprPrec :: Rational -> Pat (GhcPass p) -> SDoc #
OutputableBndr (AmbiguousFieldOcc (GhcPass p))
Instance details Defined in GHC.Hs.Types Methods pprBndr :: BindingSite -> AmbiguousFieldOcc (GhcPass p) -> SDoc # pprPrefixOcc :: AmbiguousFieldOcc (GhcPass p) -> SDoc # pprInfixOcc :: AmbiguousFieldOcc (GhcPass p) -> SDoc # bndrIsJoin_maybe :: AmbiguousFieldOcc (GhcPass p) -> Maybe Int #
Annotate [ExprLStmt GhcPs]	Used for declarations that need to be aligned together, e.g. in a do or let .. in statement/expr
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> [ExprLStmt GhcPs] -> Annotated () #
Annotate [LHsDerivingClause GhcPs]
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> [LHsDerivingClause GhcPs] -> Annotated () #
Annotate [LHsType GhcPs]
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> [LHsType GhcPs] -> Annotated () #
Annotate [LHsSigType GhcPs]
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> [LHsSigType GhcPs] -> Annotated () #
Annotate [LConDeclField GhcPs]
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> [LConDeclField GhcPs] -> Annotated () #
Annotate [LIE GhcPs]
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> [LIE GhcPs] -> Annotated () #
Annotate body => Annotate [Located (Match GhcPs (Located body))]
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> [Located (Match GhcPs (Located body))] -> Annotated () #
Annotate [Located (StmtLR GhcPs GhcPs (LHsCmd GhcPs))]
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> [Located (StmtLR GhcPs GhcPs (LHsCmd GhcPs))] -> Annotated () #
Annotate (HsModule GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsModule GhcPs -> Annotated () #
Annotate (HsTupArg GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsTupArg GhcPs -> Annotated () #
Annotate (HsCmdTop GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsCmdTop GhcPs -> Annotated () #
Annotate (HsDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsDecl GhcPs -> Annotated () #
Annotate (SpliceDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> SpliceDecl GhcPs -> Annotated () #
Annotate (TyClDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> TyClDecl GhcPs -> Annotated () #
Annotate (FamilyResultSig GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> FamilyResultSig GhcPs -> Annotated () #
Annotate (FamilyDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> FamilyDecl GhcPs -> Annotated () #
Annotate (InjectivityAnn GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> InjectivityAnn GhcPs -> Annotated () #
Annotate (HsDerivingClause GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsDerivingClause GhcPs -> Annotated () #
Annotate (StandaloneKindSig GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> StandaloneKindSig GhcPs -> Annotated () #
Annotate (ConDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> ConDecl GhcPs -> Annotated () #
Annotate (TyFamInstEqn GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> TyFamInstEqn GhcPs -> Annotated () #
Annotate (TyFamInstDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> TyFamInstDecl GhcPs -> Annotated () #
Annotate (DataFamInstDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> DataFamInstDecl GhcPs -> Annotated () #
Annotate (ClsInstDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> ClsInstDecl GhcPs -> Annotated () #
Annotate (InstDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> InstDecl GhcPs -> Annotated () #
Annotate (DerivDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> DerivDecl GhcPs -> Annotated () #
Annotate (DerivStrategy GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> DerivStrategy GhcPs -> Annotated () #
Annotate (DefaultDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> DefaultDecl GhcPs -> Annotated () #
Annotate (ForeignDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> ForeignDecl GhcPs -> Annotated () #
Annotate (RuleDecls GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> RuleDecls GhcPs -> Annotated () #
Annotate (RuleDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> RuleDecl GhcPs -> Annotated () #
Annotate (RuleBndr GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> RuleBndr GhcPs -> Annotated () #
Annotate (WarnDecls GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> WarnDecls GhcPs -> Annotated () #
Annotate (WarnDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> WarnDecl GhcPs -> Annotated () #
Annotate (AnnDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> AnnDecl GhcPs -> Annotated () #
Annotate (RoleAnnotDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> RoleAnnotDecl GhcPs -> Annotated () #
Annotate (HsRecUpdField GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsRecUpdField GhcPs -> Annotated () #
Annotate (HsLocalBinds GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsLocalBinds GhcPs -> Annotated () #
Annotate (HsBind GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsBind GhcPs -> Annotated () #
Annotate (IPBind GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> IPBind GhcPs -> Annotated () #
Annotate (Sig GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> Sig GhcPs -> Annotated () #
Annotate (HsTyVarBndr GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsTyVarBndr GhcPs -> Annotated () #
Annotate (HsType GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsType GhcPs -> Annotated () #
Annotate (ConDeclField GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> ConDeclField GhcPs -> Annotated () #
Annotate (FieldOcc GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> FieldOcc GhcPs -> Annotated () #
Annotate (AmbiguousFieldOcc GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> AmbiguousFieldOcc GhcPs -> Annotated () #
Annotate (HsLit GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsLit GhcPs -> Annotated () #
Annotate (HsOverLit GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsOverLit GhcPs -> Annotated () #
Annotate (HsExpr GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsExpr GhcPs -> Annotated () #
Annotate (HsCmd GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsCmd GhcPs -> Annotated () #
Annotate (HsSplice GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsSplice GhcPs -> Annotated () #
Annotate (ImportDecl GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> ImportDecl GhcPs -> Annotated () #
Annotate (IE GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> IE GhcPs -> Annotated () #
Annotate (Pat GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> Pat GhcPs -> Annotated () #
HasDecls (LHsExpr GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Transform Methods hsDecls :: forall (m :: Type -> Type). Monad m => LHsExpr GhcPs -> TransformT m [LHsDecl GhcPs] # replaceDecls :: forall (m :: Type -> Type). Monad m => LHsExpr GhcPs -> [LHsDecl GhcPs] -> TransformT m (LHsExpr GhcPs) #
RecordFieldToRdrName (AmbiguousFieldOcc GhcPs) Source #
Instance details Defined in Retrie.PatternMap.Instances Methods recordFieldToRdrName :: AmbiguousFieldOcc GhcPs -> RdrName Source #
Matchable (LHsType GhcPs) Source #
Instance details Defined in Retrie.Universe Methods inject :: LHsType GhcPs -> Universe Source # project :: Universe -> LHsType GhcPs Source # getOrigin :: LHsType GhcPs -> SrcSpan Source #
Matchable (LHsExpr GhcPs) Source #
Instance details Defined in Retrie.Universe Methods inject :: LHsExpr GhcPs -> Universe Source # project :: Universe -> LHsExpr GhcPs Source # getOrigin :: LHsExpr GhcPs -> SrcSpan Source #
Matchable (Located (Pat GhcPs)) Source #
Instance details Defined in Retrie.Universe Methods inject :: Located (Pat GhcPs) -> Universe Source # project :: Universe -> Located (Pat GhcPs) Source # getOrigin :: Located (Pat GhcPs) -> SrcSpan Source #
(OutputableBndrId pr, Outputable body) => Outputable (Match (GhcPass pr) body)
Instance details Defined in GHC.Hs.Expr Methods ppr :: Match (GhcPass pr) body -> SDoc # pprPrec :: Rational -> Match (GhcPass pr) body -> SDoc #
(OutputableBndrId pl, OutputableBndrId pr) => Outputable (HsLocalBindsLR (GhcPass pl) (GhcPass pr))
Instance details Defined in GHC.Hs.Binds Methods ppr :: HsLocalBindsLR (GhcPass pl) (GhcPass pr) -> SDoc # pprPrec :: Rational -> HsLocalBindsLR (GhcPass pl) (GhcPass pr) -> SDoc #
(OutputableBndrId pl, OutputableBndrId pr) => Outputable (HsValBindsLR (GhcPass pl) (GhcPass pr))
Instance details Defined in GHC.Hs.Binds Methods ppr :: HsValBindsLR (GhcPass pl) (GhcPass pr) -> SDoc # pprPrec :: Rational -> HsValBindsLR (GhcPass pl) (GhcPass pr) -> SDoc #
(OutputableBndrId pl, OutputableBndrId pr) => Outputable (HsBindLR (GhcPass pl) (GhcPass pr))
Instance details Defined in GHC.Hs.Binds Methods ppr :: HsBindLR (GhcPass pl) (GhcPass pr) -> SDoc # pprPrec :: Rational -> HsBindLR (GhcPass pl) (GhcPass pr) -> SDoc #
(OutputableBndrId l, OutputableBndrId r, Outputable (XXPatSynBind (GhcPass l) (GhcPass r))) => Outputable (PatSynBind (GhcPass l) (GhcPass r))
Instance details Defined in GHC.Hs.Binds Methods ppr :: PatSynBind (GhcPass l) (GhcPass r) -> SDoc # pprPrec :: Rational -> PatSynBind (GhcPass l) (GhcPass r) -> SDoc #
Outputable thing => Outputable (HsImplicitBndrs (GhcPass p) thing)
Instance details Defined in GHC.Hs.Types Methods ppr :: HsImplicitBndrs (GhcPass p) thing -> SDoc # pprPrec :: Rational -> HsImplicitBndrs (GhcPass p) thing -> SDoc #
Outputable thing => Outputable (HsWildCardBndrs (GhcPass p) thing)
Instance details Defined in GHC.Hs.Types Methods ppr :: HsWildCardBndrs (GhcPass p) thing -> SDoc # pprPrec :: Rational -> HsWildCardBndrs (GhcPass p) thing -> SDoc #
Annotate body => Annotate (Match GhcPs (Located body))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> Match GhcPs (Located body) -> Annotated () #
Annotate body => Annotate (GRHS GhcPs (Located body))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> GRHS GhcPs (Located body) -> Annotated () #
Annotate body => Annotate (Stmt GhcPs (Located body))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> Stmt GhcPs (Located body) -> Annotated () #
Annotate (ParStmtBlock GhcPs GhcPs)
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> ParStmtBlock GhcPs GhcPs -> Annotated () #
Annotate (HsRecField GhcPs (LHsExpr GhcPs))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsRecField GhcPs (LHsExpr GhcPs) -> Annotated () #
Annotate (HsRecField GhcPs (Located (Pat GhcPs)))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsRecField GhcPs (Located (Pat GhcPs)) -> Annotated () #
Annotate arg => Annotate (HsImplicitBndrs GhcPs (Located arg))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsImplicitBndrs GhcPs (Located arg) -> Annotated () #
HasDecls (LMatch GhcPs (LHsExpr GhcPs))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Transform Methods hsDecls :: forall (m :: Type -> Type). Monad m => LMatch GhcPs (LHsExpr GhcPs) -> TransformT m [LHsDecl GhcPs] # replaceDecls :: forall (m :: Type -> Type). Monad m => LMatch GhcPs (LHsExpr GhcPs) -> [LHsDecl GhcPs] -> TransformT m (LMatch GhcPs (LHsExpr GhcPs)) #
HasDecls (LStmt GhcPs (LHsExpr GhcPs))
Instance details Defined in Language.Haskell.GHC.ExactPrint.Transform Methods hsDecls :: forall (m :: Type -> Type). Monad m => LStmt GhcPs (LHsExpr GhcPs) -> TransformT m [LHsDecl GhcPs] # replaceDecls :: forall (m :: Type -> Type). Monad m => LStmt GhcPs (LHsExpr GhcPs) -> [LHsDecl GhcPs] -> TransformT m (LStmt GhcPs (LHsExpr GhcPs)) #
Matchable (LStmt GhcPs (LHsExpr GhcPs)) Source #
Instance details Defined in Retrie.Universe Methods inject :: LStmt GhcPs (LHsExpr GhcPs) -> Universe Source # project :: Universe -> LStmt GhcPs (LHsExpr GhcPs) Source # getOrigin :: LStmt GhcPs (LHsExpr GhcPs) -> SrcSpan Source #
(OutputableBndrId pl, OutputableBndrId pr, Outputable body) => Outputable (StmtLR (GhcPass pl) (GhcPass pr) body)
Instance details Defined in GHC.Hs.Expr Methods ppr :: StmtLR (GhcPass pl) (GhcPass pr) body -> SDoc # pprPrec :: Rational -> StmtLR (GhcPass pl) (GhcPass pr) body -> SDoc #
type IdP GhcPs
Instance details Defined in GHC.Hs.Extension type IdP GhcPs = RdrName
type IdP GhcRn
Instance details Defined in GHC.Hs.Extension type IdP GhcRn = Name
type IdP GhcTc
Instance details Defined in GHC.Hs.Extension type IdP GhcTc = Id
type XIPBinds GhcPs
Instance details Defined in GHC.Hs.Binds type XIPBinds GhcPs = NoExtField
type XIPBinds GhcRn
Instance details Defined in GHC.Hs.Binds type XIPBinds GhcRn = NoExtField
type XIPBinds GhcTc
Instance details Defined in GHC.Hs.Binds type XIPBinds GhcTc = TcEvBinds
type XSynDecl GhcPs
Instance details Defined in GHC.Hs.Decls type XSynDecl GhcPs = NoExtField
type XSynDecl GhcRn
Instance details Defined in GHC.Hs.Decls type XSynDecl GhcRn = NameSet
type XSynDecl GhcTc
Instance details Defined in GHC.Hs.Decls type XSynDecl GhcTc = NameSet
type XDataDecl GhcPs
Instance details Defined in GHC.Hs.Decls type XDataDecl GhcPs = NoExtField
type XDataDecl GhcRn
Instance details Defined in GHC.Hs.Decls type XDataDecl GhcRn = DataDeclRn
type XDataDecl GhcTc
Instance details Defined in GHC.Hs.Decls type XDataDecl GhcTc = DataDeclRn
type XClassDecl GhcPs
Instance details Defined in GHC.Hs.Decls type XClassDecl GhcPs = NoExtField
type XClassDecl GhcRn
Instance details Defined in GHC.Hs.Decls type XClassDecl GhcRn = NameSet
type XClassDecl GhcTc
Instance details Defined in GHC.Hs.Decls type XClassDecl GhcTc = NameSet
type XViaStrategy GhcPs
Instance details Defined in GHC.Hs.Decls type XViaStrategy GhcPs = LHsSigType GhcPs
type XViaStrategy GhcRn
Instance details Defined in GHC.Hs.Decls type XViaStrategy GhcRn = LHsSigType GhcRn
type XViaStrategy GhcTc
Instance details Defined in GHC.Hs.Decls type XViaStrategy GhcTc = Type
type XForeignImport GhcPs
Instance details Defined in GHC.Hs.Decls type XForeignImport GhcPs = NoExtField
type XForeignImport GhcRn
Instance details Defined in GHC.Hs.Decls type XForeignImport GhcRn = NoExtField
type XForeignImport GhcTc
Instance details Defined in GHC.Hs.Decls type XForeignImport GhcTc = Coercion
type XForeignExport GhcPs
Instance details Defined in GHC.Hs.Decls type XForeignExport GhcPs = NoExtField
type XForeignExport GhcRn
Instance details Defined in GHC.Hs.Decls type XForeignExport GhcRn = NoExtField
type XForeignExport GhcTc
Instance details Defined in GHC.Hs.Decls type XForeignExport GhcTc = Coercion
type XHsRule GhcPs
Instance details Defined in GHC.Hs.Decls type XHsRule GhcPs = NoExtField
type XHsRule GhcRn
Instance details Defined in GHC.Hs.Decls type XHsRule GhcRn = HsRuleRn
type XHsRule GhcTc
Instance details Defined in GHC.Hs.Decls type XHsRule GhcTc = HsRuleRn
type XOpApp GhcPs
Instance details Defined in GHC.Hs.Expr type XOpApp GhcPs = NoExtField
type XOpApp GhcRn
Instance details Defined in GHC.Hs.Expr type XOpApp GhcRn = Fixity
type XOpApp GhcTc
Instance details Defined in GHC.Hs.Expr type XOpApp GhcTc = Fixity
type XExplicitSum GhcPs
Instance details Defined in GHC.Hs.Expr type XExplicitSum GhcPs = NoExtField
type XExplicitSum GhcRn
Instance details Defined in GHC.Hs.Expr type XExplicitSum GhcRn = NoExtField
type XExplicitSum GhcTc
Instance details Defined in GHC.Hs.Expr type XExplicitSum GhcTc = [Type]
type XMultiIf GhcPs
Instance details Defined in GHC.Hs.Expr type XMultiIf GhcPs = NoExtField
type XMultiIf GhcRn
Instance details Defined in GHC.Hs.Expr type XMultiIf GhcRn = NoExtField
type XMultiIf GhcTc
Instance details Defined in GHC.Hs.Expr type XMultiIf GhcTc = Type
type XDo GhcPs
Instance details Defined in GHC.Hs.Expr type XDo GhcPs = NoExtField
type XDo GhcRn
Instance details Defined in GHC.Hs.Expr type XDo GhcRn = NoExtField
type XDo GhcTc
Instance details Defined in GHC.Hs.Expr type XDo GhcTc = Type
type XExplicitList GhcPs
Instance details Defined in GHC.Hs.Expr type XExplicitList GhcPs = NoExtField
type XExplicitList GhcRn
Instance details Defined in GHC.Hs.Expr type XExplicitList GhcRn = NoExtField
type XExplicitList GhcTc
Instance details Defined in GHC.Hs.Expr type XExplicitList GhcTc = Type
type XRecordCon GhcPs
Instance details Defined in GHC.Hs.Expr type XRecordCon GhcPs = NoExtField
type XRecordCon GhcRn
Instance details Defined in GHC.Hs.Expr type XRecordCon GhcRn = NoExtField
type XRecordCon GhcTc
Instance details Defined in GHC.Hs.Expr type XRecordCon GhcTc = RecordConTc
type XRecordUpd GhcPs
Instance details Defined in GHC.Hs.Expr type XRecordUpd GhcPs = NoExtField
type XRecordUpd GhcRn
Instance details Defined in GHC.Hs.Expr type XRecordUpd GhcRn = NoExtField
type XRecordUpd GhcTc
Instance details Defined in GHC.Hs.Expr type XRecordUpd GhcTc = RecordUpdTc
type XArithSeq GhcPs
Instance details Defined in GHC.Hs.Expr type XArithSeq GhcPs = NoExtField
type XArithSeq GhcRn
Instance details Defined in GHC.Hs.Expr type XArithSeq GhcRn = NoExtField
type XArithSeq GhcTc
Instance details Defined in GHC.Hs.Expr type XArithSeq GhcTc = PostTcExpr
type XStatic GhcPs
Instance details Defined in GHC.Hs.Expr type XStatic GhcPs = NoExtField
type XStatic GhcRn
Instance details Defined in GHC.Hs.Expr type XStatic GhcRn = NameSet
type XStatic GhcTc
Instance details Defined in GHC.Hs.Expr type XStatic GhcTc = NameSet
type XUnambiguous GhcPs
Instance details Defined in GHC.Hs.Types type XUnambiguous GhcPs = NoExtField
type XUnambiguous GhcRn
Instance details Defined in GHC.Hs.Types type XUnambiguous GhcRn = Name
type XUnambiguous GhcTc
Instance details Defined in GHC.Hs.Types type XUnambiguous GhcTc = Id
type XAmbiguous GhcPs
Instance details Defined in GHC.Hs.Types type XAmbiguous GhcPs = NoExtField
type XAmbiguous GhcRn
Instance details Defined in GHC.Hs.Types type XAmbiguous GhcRn = NoExtField
type XAmbiguous GhcTc
Instance details Defined in GHC.Hs.Types type XAmbiguous GhcTc = Id
type XMissing GhcPs
Instance details Defined in GHC.Hs.Expr type XMissing GhcPs = NoExtField
type XMissing GhcRn
Instance details Defined in GHC.Hs.Expr type XMissing GhcRn = NoExtField
type XMissing GhcTc
Instance details Defined in GHC.Hs.Expr type XMissing GhcTc = Type
type XCmdTop GhcPs
Instance details Defined in GHC.Hs.Expr type XCmdTop GhcPs = NoExtField
type XCmdTop GhcRn
Instance details Defined in GHC.Hs.Expr type XCmdTop GhcRn = CmdSyntaxTable GhcRn
type XCmdTop GhcTc
Instance details Defined in GHC.Hs.Expr type XCmdTop GhcTc = CmdTopTc
type XCmdArrApp GhcPs
Instance details Defined in GHC.Hs.Expr type XCmdArrApp GhcPs = NoExtField
type XCmdArrApp GhcRn
Instance details Defined in GHC.Hs.Expr type XCmdArrApp GhcRn = NoExtField
type XCmdArrApp GhcTc
Instance details Defined in GHC.Hs.Expr type XCmdArrApp GhcTc = Type
type XCmdDo GhcPs
Instance details Defined in GHC.Hs.Expr type XCmdDo GhcPs = NoExtField
type XCmdDo GhcRn
Instance details Defined in GHC.Hs.Expr type XCmdDo GhcRn = NoExtField
type XCmdDo GhcTc
Instance details Defined in GHC.Hs.Expr type XCmdDo GhcTc = Type
type XOverLit GhcPs
Instance details Defined in GHC.Hs.Lit type XOverLit GhcPs = NoExtField
type XOverLit GhcRn
Instance details Defined in GHC.Hs.Lit type XOverLit GhcRn = Bool
type XOverLit GhcTc
Instance details Defined in GHC.Hs.Lit type XOverLit GhcTc = OverLitTc
type XWildPat GhcPs
Instance details Defined in GHC.Hs.Pat type XWildPat GhcPs = NoExtField
type XWildPat GhcRn
Instance details Defined in GHC.Hs.Pat type XWildPat GhcRn = NoExtField
type XWildPat GhcTc
Instance details Defined in GHC.Hs.Pat type XWildPat GhcTc = Type
type XListPat GhcPs
Instance details Defined in GHC.Hs.Pat type XListPat GhcPs = NoExtField
type XListPat GhcRn
Instance details Defined in GHC.Hs.Pat type XListPat GhcRn = Maybe (SyntaxExpr GhcRn)
type XListPat GhcTc
Instance details Defined in GHC.Hs.Pat type XListPat GhcTc = ListPatTc
type XTuplePat GhcPs
Instance details Defined in GHC.Hs.Pat type XTuplePat GhcPs = NoExtField
type XTuplePat GhcRn
Instance details Defined in GHC.Hs.Pat type XTuplePat GhcRn = NoExtField
type XTuplePat GhcTc
Instance details Defined in GHC.Hs.Pat type XTuplePat GhcTc = [Type]
type XSumPat GhcPs
Instance details Defined in GHC.Hs.Pat type XSumPat GhcPs = NoExtField
type XSumPat GhcRn
Instance details Defined in GHC.Hs.Pat type XSumPat GhcRn = NoExtField
type XSumPat GhcTc
Instance details Defined in GHC.Hs.Pat type XSumPat GhcTc = [Type]
type XViewPat GhcPs
Instance details Defined in GHC.Hs.Pat type XViewPat GhcPs = NoExtField
type XViewPat GhcRn
Instance details Defined in GHC.Hs.Pat type XViewPat GhcRn = NoExtField
type XViewPat GhcTc
Instance details Defined in GHC.Hs.Pat type XViewPat GhcTc = Type
type XNPat GhcPs
Instance details Defined in GHC.Hs.Pat type XNPat GhcPs = NoExtField
type XNPat GhcRn
Instance details Defined in GHC.Hs.Pat type XNPat GhcRn = NoExtField
type XNPat GhcTc
Instance details Defined in GHC.Hs.Pat type XNPat GhcTc = Type
type XNPlusKPat GhcPs
Instance details Defined in GHC.Hs.Pat type XNPlusKPat GhcPs = NoExtField
type XNPlusKPat GhcRn
Instance details Defined in GHC.Hs.Pat type XNPlusKPat GhcRn = NoExtField
type XNPlusKPat GhcTc
Instance details Defined in GHC.Hs.Pat type XNPlusKPat GhcTc = Type
type XSigPat GhcPs
Instance details Defined in GHC.Hs.Pat type XSigPat GhcPs = NoExtField
type XSigPat GhcRn
Instance details Defined in GHC.Hs.Pat type XSigPat GhcRn = NoExtField
type XSigPat GhcTc
Instance details Defined in GHC.Hs.Pat type XSigPat GhcTc = Type
type XHsQTvs GhcPs
Instance details Defined in GHC.Hs.Types type XHsQTvs GhcPs = NoExtField
type XHsQTvs GhcRn
Instance details Defined in GHC.Hs.Types type XHsQTvs GhcRn = HsQTvsRn
type XHsQTvs GhcTc
Instance details Defined in GHC.Hs.Types type XHsQTvs GhcTc = HsQTvsRn
type XSpliceTy GhcPs
Instance details Defined in GHC.Hs.Types type XSpliceTy GhcPs = NoExtField
type XSpliceTy GhcRn
Instance details Defined in GHC.Hs.Types type XSpliceTy GhcRn = NoExtField
type XSpliceTy GhcTc
Instance details Defined in GHC.Hs.Types type XSpliceTy GhcTc = Kind
type XExplicitListTy GhcPs
Instance details Defined in GHC.Hs.Types type XExplicitListTy GhcPs = NoExtField
type XExplicitListTy GhcRn
Instance details Defined in GHC.Hs.Types type XExplicitListTy GhcRn = NoExtField
type XExplicitListTy GhcTc
Instance details Defined in GHC.Hs.Types type XExplicitListTy GhcTc = Kind
type XExplicitTupleTy GhcPs
Instance details Defined in GHC.Hs.Types type XExplicitTupleTy GhcPs = NoExtField
type XExplicitTupleTy GhcRn
Instance details Defined in GHC.Hs.Types type XExplicitTupleTy GhcRn = NoExtField
type XExplicitTupleTy GhcTc
Instance details Defined in GHC.Hs.Types type XExplicitTupleTy GhcTc = [Kind]
type XCFieldOcc GhcPs
Instance details Defined in GHC.Hs.Types type XCFieldOcc GhcPs = NoExtField
type XCFieldOcc GhcRn
Instance details Defined in GHC.Hs.Types type XCFieldOcc GhcRn = Name
type XCFieldOcc GhcTc
Instance details Defined in GHC.Hs.Types type XCFieldOcc GhcTc = Id
type XMG GhcPs b
Instance details Defined in GHC.Hs.Expr type XMG GhcPs b = NoExtField
type XMG GhcRn b
Instance details Defined in GHC.Hs.Expr type XMG GhcRn b = NoExtField
type XMG GhcTc b
Instance details Defined in GHC.Hs.Expr type XMG GhcTc b = MatchGroupTc
type XHsIB GhcPs _1
Instance details Defined in GHC.Hs.Types type XHsIB GhcPs _1 = NoExtField
type XHsIB GhcRn _1
Instance details Defined in GHC.Hs.Types type XHsIB GhcRn _1 = [Name]
type XHsIB GhcTc _1
Instance details Defined in GHC.Hs.Types type XHsIB GhcTc _1 = [Name]
type XHsWC GhcPs b
Instance details Defined in GHC.Hs.Types type XHsWC GhcPs b = NoExtField
type XHsWC GhcRn b
Instance details Defined in GHC.Hs.Types type XHsWC GhcRn b = [Name]
type XHsWC GhcTc b
Instance details Defined in GHC.Hs.Types type XHsWC GhcTc b = [Name]
type XPatBind GhcPs (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XPatBind GhcPs (GhcPass pR) = NoExtField
type XPatBind GhcRn (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XPatBind GhcRn (GhcPass pR) = NameSet
type XPatBind GhcTc (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XPatBind GhcTc (GhcPass pR) = NPatBindTc
type FunArg (PatBuilder GhcPs)
Instance details Defined in RdrHsSyn type FunArg (PatBuilder GhcPs) = PatBuilder GhcPs
type InfixOp (PatBuilder GhcPs)
Instance details Defined in RdrHsSyn type InfixOp (PatBuilder GhcPs) = RdrName
type Body (PatBuilder GhcPs)
Instance details Defined in RdrHsSyn type Body (PatBuilder GhcPs) = PatBuilder
type XABE (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XABE (GhcPass p) = NoExtField
type XXABExport (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XXABExport (GhcPass p) = NoExtCon
type XXHsIPBinds (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XXHsIPBinds (GhcPass p) = NoExtCon
type XCIPBind (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XCIPBind (GhcPass p) = NoExtField
type XXIPBind (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XXIPBind (GhcPass p) = NoExtCon
type XTypeSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XTypeSig (GhcPass p) = NoExtField
type XPatSynSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XPatSynSig (GhcPass p) = NoExtField
type XClassOpSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XClassOpSig (GhcPass p) = NoExtField
type XIdSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XIdSig (GhcPass p) = NoExtField
type XFixSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XFixSig (GhcPass p) = NoExtField
type XInlineSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XInlineSig (GhcPass p) = NoExtField
type XSpecSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XSpecSig (GhcPass p) = NoExtField
type XSpecInstSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XSpecInstSig (GhcPass p) = NoExtField
type XMinimalSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XMinimalSig (GhcPass p) = NoExtField
type XSCCFunSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XSCCFunSig (GhcPass p) = NoExtField
type XCompleteMatchSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XCompleteMatchSig (GhcPass p) = NoExtField
type XXSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XXSig (GhcPass p) = NoExtCon
type XFixitySig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XFixitySig (GhcPass p) = NoExtField
type XXFixitySig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XXFixitySig (GhcPass p) = NoExtCon
type XStandaloneKindSig (GhcPass p)
Instance details Defined in GHC.Hs.Decls type XStandaloneKindSig (GhcPass p) = NoExtField
type XXStandaloneKindSig (GhcPass p)
Instance details Defined in GHC.Hs.Decls type XXStandaloneKindSig (GhcPass p) = NoExtCon
type XTyClD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XTyClD (GhcPass _1) = NoExtField
type XInstD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XInstD (GhcPass _1) = NoExtField
type XDerivD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XDerivD (GhcPass _1) = NoExtField
type XValD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XValD (GhcPass _1) = NoExtField
type XSigD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XSigD (GhcPass _1) = NoExtField
type XKindSigD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XKindSigD (GhcPass _1) = NoExtField
type XDefD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XDefD (GhcPass _1) = NoExtField
type XForD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XForD (GhcPass _1) = NoExtField
type XWarningD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XWarningD (GhcPass _1) = NoExtField
type XAnnD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XAnnD (GhcPass _1) = NoExtField
type XRuleD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XRuleD (GhcPass _1) = NoExtField
type XSpliceD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XSpliceD (GhcPass _1) = NoExtField
type XDocD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XDocD (GhcPass _1) = NoExtField
type XRoleAnnotD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XRoleAnnotD (GhcPass _1) = NoExtField
type XXHsDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXHsDecl (GhcPass _1) = NoExtCon
type XCHsGroup (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCHsGroup (GhcPass _1) = NoExtField
type XXHsGroup (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXHsGroup (GhcPass _1) = NoExtCon
type XSpliceDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XSpliceDecl (GhcPass _1) = NoExtField
type XXSpliceDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXSpliceDecl (GhcPass _1) = NoExtCon
type XFamDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XFamDecl (GhcPass _1) = NoExtField
type XXTyClDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXTyClDecl (GhcPass _1) = NoExtCon
type XCTyClGroup (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCTyClGroup (GhcPass _1) = NoExtField
type XXTyClGroup (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXTyClGroup (GhcPass _1) = NoExtCon
type XNoSig (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XNoSig (GhcPass _1) = NoExtField
type XCKindSig (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCKindSig (GhcPass _1) = NoExtField
type XTyVarSig (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XTyVarSig (GhcPass _1) = NoExtField
type XXFamilyResultSig (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXFamilyResultSig (GhcPass _1) = NoExtCon
type XCFamilyDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCFamilyDecl (GhcPass _1) = NoExtField
type XXFamilyDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXFamilyDecl (GhcPass _1) = NoExtCon
type XCHsDataDefn (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCHsDataDefn (GhcPass _1) = NoExtField
type XXHsDataDefn (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXHsDataDefn (GhcPass _1) = NoExtCon
type XCHsDerivingClause (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCHsDerivingClause (GhcPass _1) = NoExtField
type XXHsDerivingClause (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXHsDerivingClause (GhcPass _1) = NoExtCon
type XConDeclGADT (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XConDeclGADT (GhcPass _1) = NoExtField
type XConDeclH98 (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XConDeclH98 (GhcPass _1) = NoExtField
type XXConDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXConDecl (GhcPass _1) = NoExtCon
type XCClsInstDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCClsInstDecl (GhcPass _1) = NoExtField
type XXClsInstDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXClsInstDecl (GhcPass _1) = NoExtCon
type XClsInstD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XClsInstD (GhcPass _1) = NoExtField
type XDataFamInstD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XDataFamInstD (GhcPass _1) = NoExtField
type XTyFamInstD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XTyFamInstD (GhcPass _1) = NoExtField
type XXInstDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXInstDecl (GhcPass _1) = NoExtCon
type XCDerivDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCDerivDecl (GhcPass _1) = NoExtField
type XXDerivDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXDerivDecl (GhcPass _1) = NoExtCon
type XCDefaultDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCDefaultDecl (GhcPass _1) = NoExtField
type XXDefaultDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXDefaultDecl (GhcPass _1) = NoExtCon
type XXForeignDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXForeignDecl (GhcPass _1) = NoExtCon
type XCRuleDecls (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCRuleDecls (GhcPass _1) = NoExtField
type XXRuleDecls (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXRuleDecls (GhcPass _1) = NoExtCon
type XXRuleDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXRuleDecl (GhcPass _1) = NoExtCon
type XCRuleBndr (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCRuleBndr (GhcPass _1) = NoExtField
type XRuleBndrSig (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XRuleBndrSig (GhcPass _1) = NoExtField
type XXRuleBndr (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXRuleBndr (GhcPass _1) = NoExtCon
type XWarnings (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XWarnings (GhcPass _1) = NoExtField
type XXWarnDecls (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXWarnDecls (GhcPass _1) = NoExtCon
type XWarning (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XWarning (GhcPass _1) = NoExtField
type XXWarnDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXWarnDecl (GhcPass _1) = NoExtCon
type XHsAnnotation (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XHsAnnotation (GhcPass _1) = NoExtField
type XXAnnDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXAnnDecl (GhcPass _1) = NoExtCon
type XCRoleAnnotDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCRoleAnnotDecl (GhcPass _1) = NoExtField
type XXRoleAnnotDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXRoleAnnotDecl (GhcPass _1) = NoExtCon
type XVar (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XVar (GhcPass _1) = NoExtField
type XUnboundVar (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XUnboundVar (GhcPass _1) = NoExtField
type XConLikeOut (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XConLikeOut (GhcPass _1) = NoExtField
type XRecFld (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XRecFld (GhcPass _1) = NoExtField
type XOverLabel (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XOverLabel (GhcPass _1) = NoExtField
type XIPVar (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XIPVar (GhcPass _1) = NoExtField
type XOverLitE (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XOverLitE (GhcPass _1) = NoExtField
type XLitE (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XLitE (GhcPass _1) = NoExtField
type XLam (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XLam (GhcPass _1) = NoExtField
type XLamCase (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XLamCase (GhcPass _1) = NoExtField
type XApp (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XApp (GhcPass _1) = NoExtField
type XAppTypeE (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XAppTypeE (GhcPass _1) = NoExtField
type XNegApp (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XNegApp (GhcPass _1) = NoExtField
type XPar (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XPar (GhcPass _1) = NoExtField
type XSectionL (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XSectionL (GhcPass _1) = NoExtField
type XSectionR (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XSectionR (GhcPass _1) = NoExtField
type XExplicitTuple (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XExplicitTuple (GhcPass _1) = NoExtField
type XCase (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCase (GhcPass _1) = NoExtField
type XIf (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XIf (GhcPass _1) = NoExtField
type XLet (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XLet (GhcPass _1) = NoExtField
type XExprWithTySig (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XExprWithTySig (GhcPass _1) = NoExtField
type XSCC (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XSCC (GhcPass _1) = NoExtField
type XCoreAnn (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCoreAnn (GhcPass _1) = NoExtField
type XBracket (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XBracket (GhcPass _1) = NoExtField
type XRnBracketOut (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XRnBracketOut (GhcPass _1) = NoExtField
type XTcBracketOut (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XTcBracketOut (GhcPass _1) = NoExtField
type XSpliceE (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XSpliceE (GhcPass _1) = NoExtField
type XProc (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XProc (GhcPass _1) = NoExtField
type XTick (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XTick (GhcPass _1) = NoExtField
type XBinTick (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XBinTick (GhcPass _1) = NoExtField
type XTickPragma (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XTickPragma (GhcPass _1) = NoExtField
type XWrap (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XWrap (GhcPass _1) = NoExtField
type XXExpr (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XXExpr (GhcPass _1) = NoExtCon
type XXAmbiguousFieldOcc (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XXAmbiguousFieldOcc (GhcPass _1) = NoExtCon
type XPresent (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XPresent (GhcPass _1) = NoExtField
type XXTupArg (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XXTupArg (GhcPass _1) = NoExtCon
type XTypedSplice (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XTypedSplice (GhcPass _1) = NoExtField
type XUntypedSplice (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XUntypedSplice (GhcPass _1) = NoExtField
type XQuasiQuote (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XQuasiQuote (GhcPass _1) = NoExtField
type XSpliced (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XSpliced (GhcPass _1) = NoExtField
type XXSplice (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XXSplice (GhcPass _1) = NoExtCon
type XExpBr (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XExpBr (GhcPass _1) = NoExtField
type XPatBr (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XPatBr (GhcPass _1) = NoExtField
type XDecBrL (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XDecBrL (GhcPass _1) = NoExtField
type XDecBrG (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XDecBrG (GhcPass _1) = NoExtField
type XTypBr (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XTypBr (GhcPass _1) = NoExtField
type XVarBr (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XVarBr (GhcPass _1) = NoExtField
type XTExpBr (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XTExpBr (GhcPass _1) = NoExtField
type XXBracket (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XXBracket (GhcPass _1) = NoExtCon
type XXCmdTop (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XXCmdTop (GhcPass _1) = NoExtCon
type XCmdArrForm (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCmdArrForm (GhcPass _1) = NoExtField
type XCmdApp (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCmdApp (GhcPass _1) = NoExtField
type XCmdLam (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCmdLam (GhcPass _1) = NoExtField
type XCmdPar (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCmdPar (GhcPass _1) = NoExtField
type XCmdCase (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCmdCase (GhcPass _1) = NoExtField
type XCmdIf (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCmdIf (GhcPass _1) = NoExtField
type XCmdLet (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCmdLet (GhcPass _1) = NoExtField
type XCmdWrap (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCmdWrap (GhcPass _1) = NoExtField
type XXCmd (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XXCmd (GhcPass _1) = NoExtCon
type XApplicativeArgOne (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XApplicativeArgOne (GhcPass _1) = NoExtField
type XApplicativeArgMany (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XApplicativeArgMany (GhcPass _1) = NoExtField
type XXApplicativeArg (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XXApplicativeArg (GhcPass _1) = NoExtCon
type XHsChar (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsChar (GhcPass _1) = SourceText
type XHsCharPrim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsCharPrim (GhcPass _1) = SourceText
type XHsString (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsString (GhcPass _1) = SourceText
type XHsStringPrim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsStringPrim (GhcPass _1) = SourceText
type XHsInt (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsInt (GhcPass _1) = NoExtField
type XHsIntPrim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsIntPrim (GhcPass _1) = SourceText
type XHsWordPrim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsWordPrim (GhcPass _1) = SourceText
type XHsInt64Prim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsInt64Prim (GhcPass _1) = SourceText
type XHsWord64Prim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsWord64Prim (GhcPass _1) = SourceText
type XHsInteger (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsInteger (GhcPass _1) = SourceText
type XHsRat (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsRat (GhcPass _1) = NoExtField
type XHsFloatPrim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsFloatPrim (GhcPass _1) = NoExtField
type XHsDoublePrim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsDoublePrim (GhcPass _1) = NoExtField
type XXLit (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XXLit (GhcPass _1) = NoExtCon
type XXOverLit (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XXOverLit (GhcPass _1) = NoExtCon
type XVarPat (GhcPass _1)
Instance details Defined in GHC.Hs.Pat type XVarPat (GhcPass _1) = NoExtField
type XLazyPat (GhcPass _1)
Instance details Defined in GHC.Hs.Pat type XLazyPat (GhcPass _1) = NoExtField
type XAsPat (GhcPass _1)
Instance details Defined in GHC.Hs.Pat type XAsPat (GhcPass _1) = NoExtField
type XParPat (GhcPass _1)
Instance details Defined in GHC.Hs.Pat type XParPat (GhcPass _1) = NoExtField
type XBangPat (GhcPass _1)
Instance details Defined in GHC.Hs.Pat type XBangPat (GhcPass _1) = NoExtField
type XSplicePat (GhcPass _1)
Instance details Defined in GHC.Hs.Pat type XSplicePat (GhcPass _1) = NoExtField
type XLitPat (GhcPass _1)
Instance details Defined in GHC.Hs.Pat type XLitPat (GhcPass _1) = NoExtField
type XCoPat (GhcPass _1)
Instance details Defined in GHC.Hs.Pat type XCoPat (GhcPass _1) = NoExtField
type XXPat (GhcPass _1)
Instance details Defined in GHC.Hs.Pat type XXPat (GhcPass _1) = NoExtCon
type XXLHsQTyVars (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XXLHsQTyVars (GhcPass _1) = NoExtCon
type XForAllTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XForAllTy (GhcPass _1) = NoExtField
type XQualTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XQualTy (GhcPass _1) = NoExtField
type XTyVar (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XTyVar (GhcPass _1) = NoExtField
type XAppTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XAppTy (GhcPass _1) = NoExtField
type XAppKindTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XAppKindTy (GhcPass _1) = SrcSpan
type XFunTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XFunTy (GhcPass _1) = NoExtField
type XListTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XListTy (GhcPass _1) = NoExtField
type XTupleTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XTupleTy (GhcPass _1) = NoExtField
type XSumTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XSumTy (GhcPass _1) = NoExtField
type XOpTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XOpTy (GhcPass _1) = NoExtField
type XParTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XParTy (GhcPass _1) = NoExtField
type XIParamTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XIParamTy (GhcPass _1) = NoExtField
type XStarTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XStarTy (GhcPass _1) = NoExtField
type XKindSig (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XKindSig (GhcPass _1) = NoExtField
type XDocTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XDocTy (GhcPass _1) = NoExtField
type XBangTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XBangTy (GhcPass _1) = NoExtField
type XRecTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XRecTy (GhcPass _1) = NoExtField
type XTyLit (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XTyLit (GhcPass _1) = NoExtField
type XWildCardTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XWildCardTy (GhcPass _1) = NoExtField
type XXType (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XXType (GhcPass _1) = NewHsTypeX
type XUserTyVar (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XUserTyVar (GhcPass _1) = NoExtField
type XKindedTyVar (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XKindedTyVar (GhcPass _1) = NoExtField
type XXTyVarBndr (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XXTyVarBndr (GhcPass _1) = NoExtCon
type XConDeclField (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XConDeclField (GhcPass _1) = NoExtField
type XXConDeclField (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XXConDeclField (GhcPass _1) = NoExtCon
type XXFieldOcc (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XXFieldOcc (GhcPass _1) = NoExtCon
type XCImportDecl (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XCImportDecl (GhcPass _1) = NoExtField
type XXImportDecl (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XXImportDecl (GhcPass _1) = NoExtCon
type XIEVar (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEVar (GhcPass _1) = NoExtField
type XIEThingAbs (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEThingAbs (GhcPass _1) = NoExtField
type XIEThingAll (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEThingAll (GhcPass _1) = NoExtField
type XIEThingWith (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEThingWith (GhcPass _1) = NoExtField
type XIEModuleContents (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEModuleContents (GhcPass _1) = NoExtField
type XIEGroup (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEGroup (GhcPass _1) = NoExtField
type XIEDoc (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEDoc (GhcPass _1) = NoExtField
type XIEDocNamed (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEDocNamed (GhcPass _1) = NoExtField
type XXIE (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XXIE (GhcPass _1) = NoExtCon
type XRec (GhcPass p) f
Instance details Defined in GHC.Hs.Extension type XRec (GhcPass p) f = Located (f (GhcPass p))
type XFunBind (GhcPass pL) GhcTc
Instance details Defined in GHC.Hs.Binds type XFunBind (GhcPass pL) GhcTc = NameSet
type XFunBind (GhcPass pL) GhcRn
Instance details Defined in GHC.Hs.Binds type XFunBind (GhcPass pL) GhcRn = NameSet
type XFunBind (GhcPass pL) GhcPs
Instance details Defined in GHC.Hs.Binds type XFunBind (GhcPass pL) GhcPs = NoExtField
type XPSB (GhcPass idL) GhcTc
Instance details Defined in GHC.Hs.Binds type XPSB (GhcPass idL) GhcTc = NameSet
type XPSB (GhcPass idL) GhcRn
Instance details Defined in GHC.Hs.Binds type XPSB (GhcPass idL) GhcRn = NameSet
type XPSB (GhcPass idL) GhcPs
Instance details Defined in GHC.Hs.Binds type XPSB (GhcPass idL) GhcPs = NoExtField
type XCFamEqn (GhcPass _1) r
Instance details Defined in GHC.Hs.Decls type XCFamEqn (GhcPass _1) r = NoExtField
type XXFamEqn (GhcPass _1) r
Instance details Defined in GHC.Hs.Decls type XXFamEqn (GhcPass _1) r = NoExtCon
type XXMatchGroup (GhcPass _1) b
Instance details Defined in GHC.Hs.Expr type XXMatchGroup (GhcPass _1) b = NoExtCon
type XCMatch (GhcPass _1) b
Instance details Defined in GHC.Hs.Expr type XCMatch (GhcPass _1) b = NoExtField
type XXMatch (GhcPass _1) b
Instance details Defined in GHC.Hs.Expr type XXMatch (GhcPass _1) b = NoExtCon
type XCGRHSs (GhcPass _1) b
Instance details Defined in GHC.Hs.Expr type XCGRHSs (GhcPass _1) b = NoExtField
type XXGRHSs (GhcPass _1) b
Instance details Defined in GHC.Hs.Expr type XXGRHSs (GhcPass _1) b = NoExtCon
type XCGRHS (GhcPass _1) b
Instance details Defined in GHC.Hs.Expr type XCGRHS (GhcPass _1) b = NoExtField
type XXGRHS (GhcPass _1) b
Instance details Defined in GHC.Hs.Expr type XXGRHS (GhcPass _1) b = NoExtCon
type XXHsImplicitBndrs (GhcPass _1) _2
Instance details Defined in GHC.Hs.Types type XXHsImplicitBndrs (GhcPass _1) _2 = NoExtCon
type XXHsWildCardBndrs (GhcPass _1) b
Instance details Defined in GHC.Hs.Types type XXHsWildCardBndrs (GhcPass _1) b = NoExtCon
type XBindStmt (GhcPass _1) GhcTc b
Instance details Defined in GHC.Hs.Expr type XBindStmt (GhcPass _1) GhcTc b = Type
type XBindStmt (GhcPass _1) GhcRn b
Instance details Defined in GHC.Hs.Expr type XBindStmt (GhcPass _1) GhcRn b = NoExtField
type XBindStmt (GhcPass _1) GhcPs b
Instance details Defined in GHC.Hs.Expr type XBindStmt (GhcPass _1) GhcPs b = NoExtField
type XApplicativeStmt (GhcPass _1) GhcTc b
Instance details Defined in GHC.Hs.Expr type XApplicativeStmt (GhcPass _1) GhcTc b = Type
type XApplicativeStmt (GhcPass _1) GhcRn b
Instance details Defined in GHC.Hs.Expr type XApplicativeStmt (GhcPass _1) GhcRn b = NoExtField
type XApplicativeStmt (GhcPass _1) GhcPs b
Instance details Defined in GHC.Hs.Expr type XApplicativeStmt (GhcPass _1) GhcPs b = NoExtField
type XBodyStmt (GhcPass _1) GhcTc b
Instance details Defined in GHC.Hs.Expr type XBodyStmt (GhcPass _1) GhcTc b = Type
type XBodyStmt (GhcPass _1) GhcRn b
Instance details Defined in GHC.Hs.Expr type XBodyStmt (GhcPass _1) GhcRn b = NoExtField
type XBodyStmt (GhcPass _1) GhcPs b
Instance details Defined in GHC.Hs.Expr type XBodyStmt (GhcPass _1) GhcPs b = NoExtField
type XParStmt (GhcPass _1) GhcTc b
Instance details Defined in GHC.Hs.Expr type XParStmt (GhcPass _1) GhcTc b = Type
type XParStmt (GhcPass _1) GhcRn b
Instance details Defined in GHC.Hs.Expr type XParStmt (GhcPass _1) GhcRn b = NoExtField
type XParStmt (GhcPass _1) GhcPs b
Instance details Defined in GHC.Hs.Expr type XParStmt (GhcPass _1) GhcPs b = NoExtField
type XTransStmt (GhcPass _1) GhcTc b
Instance details Defined in GHC.Hs.Expr type XTransStmt (GhcPass _1) GhcTc b = Type
type XTransStmt (GhcPass _1) GhcRn b
Instance details Defined in GHC.Hs.Expr type XTransStmt (GhcPass _1) GhcRn b = NoExtField
type XTransStmt (GhcPass _1) GhcPs b
Instance details Defined in GHC.Hs.Expr type XTransStmt (GhcPass _1) GhcPs b = NoExtField
type XRecStmt (GhcPass _1) GhcRn b
Instance details Defined in GHC.Hs.Expr type XRecStmt (GhcPass _1) GhcRn b = NoExtField
type XRecStmt (GhcPass _1) GhcPs b
Instance details Defined in GHC.Hs.Expr type XRecStmt (GhcPass _1) GhcPs b = NoExtField
type XRecStmt (GhcPass _1) GhcTc b
Instance details Defined in GHC.Hs.Expr type XRecStmt (GhcPass _1) GhcTc b = RecStmtTc
type XHsValBinds (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XHsValBinds (GhcPass pL) (GhcPass pR) = NoExtField
type XHsIPBinds (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XHsIPBinds (GhcPass pL) (GhcPass pR) = NoExtField
type XEmptyLocalBinds (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XEmptyLocalBinds (GhcPass pL) (GhcPass pR) = NoExtField
type XXHsLocalBindsLR (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XXHsLocalBindsLR (GhcPass pL) (GhcPass pR) = NoExtCon
type XValBinds (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XValBinds (GhcPass pL) (GhcPass pR) = NoExtField
type XXValBindsLR (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XXValBindsLR (GhcPass pL) (GhcPass pR) = NHsValBindsLR (GhcPass pL)
type XVarBind (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XVarBind (GhcPass pL) (GhcPass pR) = NoExtField
type XAbsBinds (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XAbsBinds (GhcPass pL) (GhcPass pR) = NoExtField
type XPatSynBind (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XPatSynBind (GhcPass pL) (GhcPass pR) = NoExtField
type XXHsBindsLR (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XXHsBindsLR (GhcPass pL) (GhcPass pR) = NoExtCon
type XXPatSynBind (GhcPass idL) (GhcPass idR)
Instance details Defined in GHC.Hs.Binds type XXPatSynBind (GhcPass idL) (GhcPass idR) = NoExtCon
type XParStmtBlock (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Expr type XParStmtBlock (GhcPass pL) (GhcPass pR) = NoExtField
type XXParStmtBlock (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Expr type XXParStmtBlock (GhcPass pL) (GhcPass pR) = NoExtCon
type XLastStmt (GhcPass _1) (GhcPass _2) b
Instance details Defined in GHC.Hs.Expr type XLastStmt (GhcPass _1) (GhcPass _2) b = NoExtField
type XLetStmt (GhcPass _1) (GhcPass _2) b
Instance details Defined in GHC.Hs.Expr type XLetStmt (GhcPass _1) (GhcPass _2) b = NoExtField
type XXStmtLR (GhcPass _1) (GhcPass _2) b
Instance details Defined in GHC.Hs.Expr type XXStmtLR (GhcPass _1) (GhcPass _2) b = NoExtCon

data Pass #

Constructors

Parsed
Renamed
Typechecked

Instances

Instances details

Data Pass

Instance details

Defined in GHC.Hs.Extension

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Pass -> c Pass #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Pass #

toConstr :: Pass -> Constr #

dataTypeOf :: Pass -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Pass) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pass) #

gmapT :: (forall b. Data b => b -> b) -> Pass -> Pass #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pass -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pass -> r #

gmapQ :: (forall d. Data d => d -> u) -> Pass -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Pass -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Pass -> m Pass #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Pass -> m Pass #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Pass -> m Pass #

type GhcPs = GhcPass 'Parsed #

type GhcRn = GhcPass 'Renamed #

type GhcTc = GhcPass 'Typechecked #

type GhcTcId = GhcTc #

type family XRec p (f :: Type -> Type) = (r :: Type) | r -> p f #

GHC's L prefixed variants wrap their vanilla variant in this type family, to add SrcLoc info via Located. Other passes than GhcPass not interested in location information can define this instance as f p.

Instances

Instances details

type XRec (GhcPass p) f
Instance details Defined in GHC.Hs.Extension type XRec (GhcPass p) f = Located (f (GhcPass p))

type family IdP p #

Maps the "normal" id type for a given pass

Instances

Instances details

type IdP GhcPs
Instance details Defined in GHC.Hs.Extension type IdP GhcPs = RdrName
type IdP GhcRn
Instance details Defined in GHC.Hs.Extension type IdP GhcRn = Name
type IdP GhcTc
Instance details Defined in GHC.Hs.Extension type IdP GhcTc = Id

type LIdP p = Located (IdP p) #

type family NoGhcTc p where ... #

Marks that a field uses the GhcRn variant even when the pass parameter is GhcTc. Useful for storing HsTypes in GHC.Hs.Exprs, say, because HsType GhcTc should never occur.

Equations

NoGhcTc (GhcPass pass) = GhcPass (NoGhcTcPass pass)
NoGhcTc other = other

type family NoGhcTcPass (p :: Pass) :: Pass where ... #

Equations

NoGhcTcPass 'Typechecked = 'Renamed
NoGhcTcPass other = other

type family XHsValBinds x x' #

Instances

Instances details

type XHsValBinds (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XHsValBinds (GhcPass pL) (GhcPass pR) = NoExtField

type family XHsIPBinds x x' #

Instances

Instances details

type XHsIPBinds (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XHsIPBinds (GhcPass pL) (GhcPass pR) = NoExtField

type family XEmptyLocalBinds x x' #

Instances

Instances details

type XEmptyLocalBinds (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XEmptyLocalBinds (GhcPass pL) (GhcPass pR) = NoExtField

type family XXHsLocalBindsLR x x' #

Instances

Instances details

type XXHsLocalBindsLR (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XXHsLocalBindsLR (GhcPass pL) (GhcPass pR) = NoExtCon

type ForallXHsLocalBindsLR (c :: Type -> Constraint) x x' = (c (XHsValBinds x x'), c (XHsIPBinds x x'), c (XEmptyLocalBinds x x'), c (XXHsLocalBindsLR x x')) #

type family XValBinds x x' #

Instances

Instances details

type XValBinds (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XValBinds (GhcPass pL) (GhcPass pR) = NoExtField

type family XXValBindsLR x x' #

Instances

Instances details

type XXValBindsLR (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XXValBindsLR (GhcPass pL) (GhcPass pR) = NHsValBindsLR (GhcPass pL)

type ForallXValBindsLR (c :: Type -> Constraint) x x' = (c (XValBinds x x'), c (XXValBindsLR x x')) #

type family XFunBind x x' #

Instances

Instances details

type XFunBind (GhcPass pL) GhcTc
Instance details Defined in GHC.Hs.Binds type XFunBind (GhcPass pL) GhcTc = NameSet
type XFunBind (GhcPass pL) GhcRn
Instance details Defined in GHC.Hs.Binds type XFunBind (GhcPass pL) GhcRn = NameSet
type XFunBind (GhcPass pL) GhcPs
Instance details Defined in GHC.Hs.Binds type XFunBind (GhcPass pL) GhcPs = NoExtField

type family XPatBind x x' #

Instances

Instances details

type XPatBind GhcPs (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XPatBind GhcPs (GhcPass pR) = NoExtField
type XPatBind GhcRn (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XPatBind GhcRn (GhcPass pR) = NameSet
type XPatBind GhcTc (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XPatBind GhcTc (GhcPass pR) = NPatBindTc

type family XVarBind x x' #

Instances

Instances details

type XVarBind (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XVarBind (GhcPass pL) (GhcPass pR) = NoExtField

type family XAbsBinds x x' #

Instances

Instances details

type XAbsBinds (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XAbsBinds (GhcPass pL) (GhcPass pR) = NoExtField

type family XPatSynBind x x' #

Instances

Instances details

type XPatSynBind (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XPatSynBind (GhcPass pL) (GhcPass pR) = NoExtField

type family XXHsBindsLR x x' #

Instances

Instances details

type XXHsBindsLR (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XXHsBindsLR (GhcPass pL) (GhcPass pR) = NoExtCon

type ForallXHsBindsLR (c :: Type -> Constraint) x x' = (c (XFunBind x x'), c (XPatBind x x'), c (XVarBind x x'), c (XAbsBinds x x'), c (XPatSynBind x x'), c (XXHsBindsLR x x')) #

type family XABE x #

Instances

Instances details

type XABE (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XABE (GhcPass p) = NoExtField

type family XXABExport x #

Instances

Instances details

type XXABExport (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XXABExport (GhcPass p) = NoExtCon

type ForallXABExport (c :: Type -> Constraint) x = (c (XABE x), c (XXABExport x)) #

type family XPSB x x' #

Instances

Instances details

type XPSB (GhcPass idL) GhcTc
Instance details Defined in GHC.Hs.Binds type XPSB (GhcPass idL) GhcTc = NameSet
type XPSB (GhcPass idL) GhcRn
Instance details Defined in GHC.Hs.Binds type XPSB (GhcPass idL) GhcRn = NameSet
type XPSB (GhcPass idL) GhcPs
Instance details Defined in GHC.Hs.Binds type XPSB (GhcPass idL) GhcPs = NoExtField

type family XXPatSynBind x x' #

Instances

Instances details

type XXPatSynBind (GhcPass idL) (GhcPass idR)
Instance details Defined in GHC.Hs.Binds type XXPatSynBind (GhcPass idL) (GhcPass idR) = NoExtCon

type ForallXPatSynBind (c :: Type -> Constraint) x x' = (c (XPSB x x'), c (XXPatSynBind x x')) #

type family XIPBinds x #

Instances

Instances details

type XIPBinds GhcPs
Instance details Defined in GHC.Hs.Binds type XIPBinds GhcPs = NoExtField
type XIPBinds GhcRn
Instance details Defined in GHC.Hs.Binds type XIPBinds GhcRn = NoExtField
type XIPBinds GhcTc
Instance details Defined in GHC.Hs.Binds type XIPBinds GhcTc = TcEvBinds

type family XXHsIPBinds x #

Instances

Instances details

type XXHsIPBinds (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XXHsIPBinds (GhcPass p) = NoExtCon

type ForallXHsIPBinds (c :: Type -> Constraint) x = (c (XIPBinds x), c (XXHsIPBinds x)) #

type family XCIPBind x #

Instances

Instances details

type XCIPBind (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XCIPBind (GhcPass p) = NoExtField

type family XXIPBind x #

Instances

Instances details

type XXIPBind (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XXIPBind (GhcPass p) = NoExtCon

type ForallXIPBind (c :: Type -> Constraint) x = (c (XCIPBind x), c (XXIPBind x)) #

type family XTypeSig x #

Instances

Instances details

type XTypeSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XTypeSig (GhcPass p) = NoExtField

type family XPatSynSig x #

Instances

Instances details

type XPatSynSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XPatSynSig (GhcPass p) = NoExtField

type family XClassOpSig x #

Instances

Instances details

type XClassOpSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XClassOpSig (GhcPass p) = NoExtField

type family XIdSig x #

Instances

Instances details

type XIdSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XIdSig (GhcPass p) = NoExtField

type family XFixSig x #

Instances

Instances details

type XFixSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XFixSig (GhcPass p) = NoExtField

type family XInlineSig x #

Instances

Instances details

type XInlineSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XInlineSig (GhcPass p) = NoExtField

type family XSpecSig x #

Instances

Instances details

type XSpecSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XSpecSig (GhcPass p) = NoExtField

type family XSpecInstSig x #

Instances

Instances details

type XSpecInstSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XSpecInstSig (GhcPass p) = NoExtField

type family XMinimalSig x #

Instances

Instances details

type XMinimalSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XMinimalSig (GhcPass p) = NoExtField

type family XSCCFunSig x #

Instances

Instances details

type XSCCFunSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XSCCFunSig (GhcPass p) = NoExtField

type family XCompleteMatchSig x #

Instances

Instances details

type XCompleteMatchSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XCompleteMatchSig (GhcPass p) = NoExtField

type family XXSig x #

Instances

Instances details

type XXSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XXSig (GhcPass p) = NoExtCon

type ForallXSig (c :: Type -> Constraint) x = (c (XTypeSig x), c (XPatSynSig x), c (XClassOpSig x), c (XIdSig x), c (XFixSig x), c (XInlineSig x), c (XSpecSig x), c (XSpecInstSig x), c (XMinimalSig x), c (XSCCFunSig x), c (XCompleteMatchSig x), c (XXSig x)) #

type family XFixitySig x #

Instances

Instances details

type XFixitySig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XFixitySig (GhcPass p) = NoExtField

type family XXFixitySig x #

Instances

Instances details

type XXFixitySig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XXFixitySig (GhcPass p) = NoExtCon

type ForallXFixitySig (c :: Type -> Constraint) x = (c (XFixitySig x), c (XXFixitySig x)) #

type family XStandaloneKindSig x #

Instances

Instances details

type XStandaloneKindSig (GhcPass p)
Instance details Defined in GHC.Hs.Decls type XStandaloneKindSig (GhcPass p) = NoExtField

type family XXStandaloneKindSig x #

Instances

Instances details

type XXStandaloneKindSig (GhcPass p)
Instance details Defined in GHC.Hs.Decls type XXStandaloneKindSig (GhcPass p) = NoExtCon

type family XTyClD x #

Instances

Instances details

type XTyClD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XTyClD (GhcPass _1) = NoExtField

type family XInstD x #

Instances

Instances details

type XInstD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XInstD (GhcPass _1) = NoExtField

type family XDerivD x #

Instances

Instances details

type XDerivD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XDerivD (GhcPass _1) = NoExtField

type family XValD x #

Instances

Instances details

type XValD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XValD (GhcPass _1) = NoExtField

type family XSigD x #

Instances

Instances details

type XSigD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XSigD (GhcPass _1) = NoExtField

type family XKindSigD x #

Instances

Instances details

type XKindSigD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XKindSigD (GhcPass _1) = NoExtField

type family XDefD x #

Instances

Instances details

type XDefD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XDefD (GhcPass _1) = NoExtField

type family XForD x #

Instances

Instances details

type XForD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XForD (GhcPass _1) = NoExtField

type family XWarningD x #

Instances

Instances details

type XWarningD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XWarningD (GhcPass _1) = NoExtField

type family XAnnD x #

Instances

Instances details

type XAnnD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XAnnD (GhcPass _1) = NoExtField

type family XRuleD x #

Instances

Instances details

type XRuleD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XRuleD (GhcPass _1) = NoExtField

type family XSpliceD x #

Instances

Instances details

type XSpliceD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XSpliceD (GhcPass _1) = NoExtField

type family XDocD x #

Instances

Instances details

type XDocD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XDocD (GhcPass _1) = NoExtField

type family XRoleAnnotD x #

Instances

Instances details

type XRoleAnnotD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XRoleAnnotD (GhcPass _1) = NoExtField

type family XXHsDecl x #

Instances

Instances details

type XXHsDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXHsDecl (GhcPass _1) = NoExtCon

type ForallXHsDecl (c :: Type -> Constraint) x = (c (XTyClD x), c (XInstD x), c (XDerivD x), c (XValD x), c (XSigD x), c (XKindSigD x), c (XDefD x), c (XForD x), c (XWarningD x), c (XAnnD x), c (XRuleD x), c (XSpliceD x), c (XDocD x), c (XRoleAnnotD x), c (XXHsDecl x)) #

type family XCHsGroup x #

Instances

Instances details

type XCHsGroup (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCHsGroup (GhcPass _1) = NoExtField

type family XXHsGroup x #

Instances

Instances details

type XXHsGroup (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXHsGroup (GhcPass _1) = NoExtCon

type ForallXHsGroup (c :: Type -> Constraint) x = (c (XCHsGroup x), c (XXHsGroup x)) #

type family XSpliceDecl x #

Instances

Instances details

type XSpliceDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XSpliceDecl (GhcPass _1) = NoExtField

type family XXSpliceDecl x #

Instances

Instances details

type XXSpliceDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXSpliceDecl (GhcPass _1) = NoExtCon

type ForallXSpliceDecl (c :: Type -> Constraint) x = (c (XSpliceDecl x), c (XXSpliceDecl x)) #

type family XFamDecl x #

Instances

Instances details

type XFamDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XFamDecl (GhcPass _1) = NoExtField

type family XSynDecl x #

Instances

Instances details

type XSynDecl GhcPs
Instance details Defined in GHC.Hs.Decls type XSynDecl GhcPs = NoExtField
type XSynDecl GhcRn
Instance details Defined in GHC.Hs.Decls type XSynDecl GhcRn = NameSet
type XSynDecl GhcTc
Instance details Defined in GHC.Hs.Decls type XSynDecl GhcTc = NameSet

type family XDataDecl x #

Instances

Instances details

type XDataDecl GhcPs
Instance details Defined in GHC.Hs.Decls type XDataDecl GhcPs = NoExtField
type XDataDecl GhcRn
Instance details Defined in GHC.Hs.Decls type XDataDecl GhcRn = DataDeclRn
type XDataDecl GhcTc
Instance details Defined in GHC.Hs.Decls type XDataDecl GhcTc = DataDeclRn

type family XClassDecl x #

Instances

Instances details

type XClassDecl GhcPs
Instance details Defined in GHC.Hs.Decls type XClassDecl GhcPs = NoExtField
type XClassDecl GhcRn
Instance details Defined in GHC.Hs.Decls type XClassDecl GhcRn = NameSet
type XClassDecl GhcTc
Instance details Defined in GHC.Hs.Decls type XClassDecl GhcTc = NameSet

type family XXTyClDecl x #

Instances

Instances details

type XXTyClDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXTyClDecl (GhcPass _1) = NoExtCon

type ForallXTyClDecl (c :: Type -> Constraint) x = (c (XFamDecl x), c (XSynDecl x), c (XDataDecl x), c (XClassDecl x), c (XXTyClDecl x)) #

type family XCTyClGroup x #

Instances

Instances details

type XCTyClGroup (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCTyClGroup (GhcPass _1) = NoExtField

type family XXTyClGroup x #

Instances

Instances details

type XXTyClGroup (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXTyClGroup (GhcPass _1) = NoExtCon

type ForallXTyClGroup (c :: Type -> Constraint) x = (c (XCTyClGroup x), c (XXTyClGroup x)) #

type family XNoSig x #

Instances

Instances details

type XNoSig (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XNoSig (GhcPass _1) = NoExtField

type family XCKindSig x #

Instances

Instances details

type XCKindSig (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCKindSig (GhcPass _1) = NoExtField

type family XTyVarSig x #

Instances

Instances details

type XTyVarSig (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XTyVarSig (GhcPass _1) = NoExtField

type family XXFamilyResultSig x #

Instances

Instances details

type XXFamilyResultSig (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXFamilyResultSig (GhcPass _1) = NoExtCon

type ForallXFamilyResultSig (c :: Type -> Constraint) x = (c (XNoSig x), c (XCKindSig x), c (XTyVarSig x), c (XXFamilyResultSig x)) #

type family XCFamilyDecl x #

Instances

Instances details

type XCFamilyDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCFamilyDecl (GhcPass _1) = NoExtField

type family XXFamilyDecl x #

Instances

Instances details

type XXFamilyDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXFamilyDecl (GhcPass _1) = NoExtCon

type ForallXFamilyDecl (c :: Type -> Constraint) x = (c (XCFamilyDecl x), c (XXFamilyDecl x)) #

type family XCHsDataDefn x #

Instances

Instances details

type XCHsDataDefn (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCHsDataDefn (GhcPass _1) = NoExtField

type family XXHsDataDefn x #

Instances

Instances details

type XXHsDataDefn (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXHsDataDefn (GhcPass _1) = NoExtCon

type ForallXHsDataDefn (c :: Type -> Constraint) x = (c (XCHsDataDefn x), c (XXHsDataDefn x)) #

type family XCHsDerivingClause x #

Instances

Instances details

type XCHsDerivingClause (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCHsDerivingClause (GhcPass _1) = NoExtField

type family XXHsDerivingClause x #

Instances

Instances details

type XXHsDerivingClause (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXHsDerivingClause (GhcPass _1) = NoExtCon

type ForallXHsDerivingClause (c :: Type -> Constraint) x = (c (XCHsDerivingClause x), c (XXHsDerivingClause x)) #

type family XConDeclGADT x #

Instances

Instances details

type XConDeclGADT (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XConDeclGADT (GhcPass _1) = NoExtField

type family XConDeclH98 x #

Instances

Instances details

type XConDeclH98 (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XConDeclH98 (GhcPass _1) = NoExtField

type family XXConDecl x #

Instances

Instances details

type XXConDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXConDecl (GhcPass _1) = NoExtCon

type ForallXConDecl (c :: Type -> Constraint) x = (c (XConDeclGADT x), c (XConDeclH98 x), c (XXConDecl x)) #

type family XCFamEqn x r #

Instances

Instances details

type XCFamEqn (GhcPass _1) r
Instance details Defined in GHC.Hs.Decls type XCFamEqn (GhcPass _1) r = NoExtField

type family XXFamEqn x r #

Instances

Instances details

type XXFamEqn (GhcPass _1) r
Instance details Defined in GHC.Hs.Decls type XXFamEqn (GhcPass _1) r = NoExtCon

type ForallXFamEqn (c :: Type -> Constraint) x r = (c (XCFamEqn x r), c (XXFamEqn x r)) #

type family XCClsInstDecl x #

Instances

Instances details

type XCClsInstDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCClsInstDecl (GhcPass _1) = NoExtField

type family XXClsInstDecl x #

Instances

Instances details

type XXClsInstDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXClsInstDecl (GhcPass _1) = NoExtCon

type ForallXClsInstDecl (c :: Type -> Constraint) x = (c (XCClsInstDecl x), c (XXClsInstDecl x)) #

type family XClsInstD x #

Instances

Instances details

type XClsInstD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XClsInstD (GhcPass _1) = NoExtField

type family XDataFamInstD x #

Instances

Instances details

type XDataFamInstD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XDataFamInstD (GhcPass _1) = NoExtField

type family XTyFamInstD x #

Instances

Instances details

type XTyFamInstD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XTyFamInstD (GhcPass _1) = NoExtField

type family XXInstDecl x #

Instances

Instances details

type XXInstDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXInstDecl (GhcPass _1) = NoExtCon

type ForallXInstDecl (c :: Type -> Constraint) x = (c (XClsInstD x), c (XDataFamInstD x), c (XTyFamInstD x), c (XXInstDecl x)) #

type family XCDerivDecl x #

Instances

Instances details

type XCDerivDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCDerivDecl (GhcPass _1) = NoExtField

type family XXDerivDecl x #

Instances

Instances details

type XXDerivDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXDerivDecl (GhcPass _1) = NoExtCon

type ForallXDerivDecl (c :: Type -> Constraint) x = (c (XCDerivDecl x), c (XXDerivDecl x)) #

type family XViaStrategy x #

Instances

Instances details

type XViaStrategy GhcPs
Instance details Defined in GHC.Hs.Decls type XViaStrategy GhcPs = LHsSigType GhcPs
type XViaStrategy GhcRn
Instance details Defined in GHC.Hs.Decls type XViaStrategy GhcRn = LHsSigType GhcRn
type XViaStrategy GhcTc
Instance details Defined in GHC.Hs.Decls type XViaStrategy GhcTc = Type

type family XCDefaultDecl x #

Instances

Instances details

type XCDefaultDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCDefaultDecl (GhcPass _1) = NoExtField

type family XXDefaultDecl x #

Instances

Instances details

type XXDefaultDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXDefaultDecl (GhcPass _1) = NoExtCon

type ForallXDefaultDecl (c :: Type -> Constraint) x = (c (XCDefaultDecl x), c (XXDefaultDecl x)) #

type family XForeignImport x #

Instances

Instances details

type XForeignImport GhcPs
Instance details Defined in GHC.Hs.Decls type XForeignImport GhcPs = NoExtField
type XForeignImport GhcRn
Instance details Defined in GHC.Hs.Decls type XForeignImport GhcRn = NoExtField
type XForeignImport GhcTc
Instance details Defined in GHC.Hs.Decls type XForeignImport GhcTc = Coercion

type family XForeignExport x #

Instances

Instances details

type XForeignExport GhcPs
Instance details Defined in GHC.Hs.Decls type XForeignExport GhcPs = NoExtField
type XForeignExport GhcRn
Instance details Defined in GHC.Hs.Decls type XForeignExport GhcRn = NoExtField
type XForeignExport GhcTc
Instance details Defined in GHC.Hs.Decls type XForeignExport GhcTc = Coercion

type family XXForeignDecl x #

Instances

Instances details

type XXForeignDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXForeignDecl (GhcPass _1) = NoExtCon

type ForallXForeignDecl (c :: Type -> Constraint) x = (c (XForeignImport x), c (XForeignExport x), c (XXForeignDecl x)) #

type family XCRuleDecls x #

Instances

Instances details

type XCRuleDecls (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCRuleDecls (GhcPass _1) = NoExtField

type family XXRuleDecls x #

Instances

Instances details

type XXRuleDecls (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXRuleDecls (GhcPass _1) = NoExtCon

type ForallXRuleDecls (c :: Type -> Constraint) x = (c (XCRuleDecls x), c (XXRuleDecls x)) #

type family XHsRule x #

Instances

Instances details

type XHsRule GhcPs
Instance details Defined in GHC.Hs.Decls type XHsRule GhcPs = NoExtField
type XHsRule GhcRn
Instance details Defined in GHC.Hs.Decls type XHsRule GhcRn = HsRuleRn
type XHsRule GhcTc
Instance details Defined in GHC.Hs.Decls type XHsRule GhcTc = HsRuleRn

type family XXRuleDecl x #

Instances

Instances details

type XXRuleDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXRuleDecl (GhcPass _1) = NoExtCon

type ForallXRuleDecl (c :: Type -> Constraint) x = (c (XHsRule x), c (XXRuleDecl x)) #

type family XCRuleBndr x #

Instances

Instances details

type XCRuleBndr (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCRuleBndr (GhcPass _1) = NoExtField

type family XRuleBndrSig x #

Instances

Instances details

type XRuleBndrSig (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XRuleBndrSig (GhcPass _1) = NoExtField

type family XXRuleBndr x #

Instances

Instances details

type XXRuleBndr (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXRuleBndr (GhcPass _1) = NoExtCon

type ForallXRuleBndr (c :: Type -> Constraint) x = (c (XCRuleBndr x), c (XRuleBndrSig x), c (XXRuleBndr x)) #

type family XWarnings x #

Instances

Instances details

type XWarnings (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XWarnings (GhcPass _1) = NoExtField

type family XXWarnDecls x #

Instances

Instances details

type XXWarnDecls (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXWarnDecls (GhcPass _1) = NoExtCon

type ForallXWarnDecls (c :: Type -> Constraint) x = (c (XWarnings x), c (XXWarnDecls x)) #

type family XWarning x #

Instances

Instances details

type XWarning (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XWarning (GhcPass _1) = NoExtField

type family XXWarnDecl x #

Instances

Instances details

type XXWarnDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXWarnDecl (GhcPass _1) = NoExtCon

type ForallXWarnDecl (c :: Type -> Constraint) x = (c (XWarning x), c (XXWarnDecl x)) #

type family XHsAnnotation x #

Instances

Instances details

type XHsAnnotation (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XHsAnnotation (GhcPass _1) = NoExtField

type family XXAnnDecl x #

Instances

Instances details

type XXAnnDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXAnnDecl (GhcPass _1) = NoExtCon

type ForallXAnnDecl (c :: Type -> Constraint) x = (c (XHsAnnotation x), c (XXAnnDecl x)) #

type family XCRoleAnnotDecl x #

Instances

Instances details

type XCRoleAnnotDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCRoleAnnotDecl (GhcPass _1) = NoExtField

type family XXRoleAnnotDecl x #

Instances

Instances details

type XXRoleAnnotDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXRoleAnnotDecl (GhcPass _1) = NoExtCon

type ForallXRoleAnnotDecl (c :: Type -> Constraint) x = (c (XCRoleAnnotDecl x), c (XXRoleAnnotDecl x)) #

type family XVar x #

Instances

Instances details

type XVar (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XVar (GhcPass _1) = NoExtField

type family XUnboundVar x #

Instances

Instances details

type XUnboundVar (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XUnboundVar (GhcPass _1) = NoExtField

type family XConLikeOut x #

Instances

Instances details

type XConLikeOut (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XConLikeOut (GhcPass _1) = NoExtField

type family XRecFld x #

Instances

Instances details

type XRecFld (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XRecFld (GhcPass _1) = NoExtField

type family XOverLabel x #

Instances

Instances details

type XOverLabel (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XOverLabel (GhcPass _1) = NoExtField

type family XIPVar x #

Instances

Instances details

type XIPVar (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XIPVar (GhcPass _1) = NoExtField

type family XOverLitE x #

Instances

Instances details

type XOverLitE (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XOverLitE (GhcPass _1) = NoExtField

type family XLitE x #

Instances

Instances details

type XLitE (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XLitE (GhcPass _1) = NoExtField

type family XLam x #

Instances

Instances details

type XLam (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XLam (GhcPass _1) = NoExtField

type family XLamCase x #

Instances

Instances details

type XLamCase (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XLamCase (GhcPass _1) = NoExtField

type family XApp x #

Instances

Instances details

type XApp (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XApp (GhcPass _1) = NoExtField

type family XAppTypeE x #

Instances

Instances details

type XAppTypeE (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XAppTypeE (GhcPass _1) = NoExtField

type family XOpApp x #

Instances

Instances details

type XOpApp GhcPs
Instance details Defined in GHC.Hs.Expr type XOpApp GhcPs = NoExtField
type XOpApp GhcRn
Instance details Defined in GHC.Hs.Expr type XOpApp GhcRn = Fixity
type XOpApp GhcTc
Instance details Defined in GHC.Hs.Expr type XOpApp GhcTc = Fixity

type family XNegApp x #

Instances

Instances details

type XNegApp (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XNegApp (GhcPass _1) = NoExtField

type family XPar x #

Instances

Instances details

type XPar (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XPar (GhcPass _1) = NoExtField

type family XSectionL x #

Instances

Instances details

type XSectionL (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XSectionL (GhcPass _1) = NoExtField

type family XSectionR x #

Instances

Instances details

type XSectionR (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XSectionR (GhcPass _1) = NoExtField

type family XExplicitTuple x #

Instances

Instances details

type XExplicitTuple (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XExplicitTuple (GhcPass _1) = NoExtField

type family XExplicitSum x #

Instances

Instances details

type XExplicitSum GhcPs
Instance details Defined in GHC.Hs.Expr type XExplicitSum GhcPs = NoExtField
type XExplicitSum GhcRn
Instance details Defined in GHC.Hs.Expr type XExplicitSum GhcRn = NoExtField
type XExplicitSum GhcTc
Instance details Defined in GHC.Hs.Expr type XExplicitSum GhcTc = [Type]

type family XCase x #

Instances

Instances details

type XCase (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCase (GhcPass _1) = NoExtField

type family XIf x #

Instances

Instances details

type XIf (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XIf (GhcPass _1) = NoExtField

type family XMultiIf x #

Instances

Instances details

type XMultiIf GhcPs
Instance details Defined in GHC.Hs.Expr type XMultiIf GhcPs = NoExtField
type XMultiIf GhcRn
Instance details Defined in GHC.Hs.Expr type XMultiIf GhcRn = NoExtField
type XMultiIf GhcTc
Instance details Defined in GHC.Hs.Expr type XMultiIf GhcTc = Type

type family XLet x #

Instances

Instances details

type XLet (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XLet (GhcPass _1) = NoExtField

type family XDo x #

Instances

Instances details

type XDo GhcPs
Instance details Defined in GHC.Hs.Expr type XDo GhcPs = NoExtField
type XDo GhcRn
Instance details Defined in GHC.Hs.Expr type XDo GhcRn = NoExtField
type XDo GhcTc
Instance details Defined in GHC.Hs.Expr type XDo GhcTc = Type

type family XExplicitList x #

Instances

Instances details

type XExplicitList GhcPs
Instance details Defined in GHC.Hs.Expr type XExplicitList GhcPs = NoExtField
type XExplicitList GhcRn
Instance details Defined in GHC.Hs.Expr type XExplicitList GhcRn = NoExtField
type XExplicitList GhcTc
Instance details Defined in GHC.Hs.Expr type XExplicitList GhcTc = Type

type family XRecordCon x #

Instances

Instances details

type XRecordCon GhcPs
Instance details Defined in GHC.Hs.Expr type XRecordCon GhcPs = NoExtField
type XRecordCon GhcRn
Instance details Defined in GHC.Hs.Expr type XRecordCon GhcRn = NoExtField
type XRecordCon GhcTc
Instance details Defined in GHC.Hs.Expr type XRecordCon GhcTc = RecordConTc

type family XRecordUpd x #

Instances

Instances details

type XRecordUpd GhcPs
Instance details Defined in GHC.Hs.Expr type XRecordUpd GhcPs = NoExtField
type XRecordUpd GhcRn
Instance details Defined in GHC.Hs.Expr type XRecordUpd GhcRn = NoExtField
type XRecordUpd GhcTc
Instance details Defined in GHC.Hs.Expr type XRecordUpd GhcTc = RecordUpdTc

type family XExprWithTySig x #

Instances

Instances details

type XExprWithTySig (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XExprWithTySig (GhcPass _1) = NoExtField

type family XArithSeq x #

Instances

Instances details

type XArithSeq GhcPs
Instance details Defined in GHC.Hs.Expr type XArithSeq GhcPs = NoExtField
type XArithSeq GhcRn
Instance details Defined in GHC.Hs.Expr type XArithSeq GhcRn = NoExtField
type XArithSeq GhcTc
Instance details Defined in GHC.Hs.Expr type XArithSeq GhcTc = PostTcExpr

type family XSCC x #

Instances

Instances details

type XSCC (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XSCC (GhcPass _1) = NoExtField

type family XCoreAnn x #

Instances

Instances details

type XCoreAnn (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCoreAnn (GhcPass _1) = NoExtField

type family XBracket x #

Instances

Instances details

type XBracket (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XBracket (GhcPass _1) = NoExtField

type family XRnBracketOut x #

Instances

Instances details

type XRnBracketOut (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XRnBracketOut (GhcPass _1) = NoExtField

type family XTcBracketOut x #

Instances

Instances details

type XTcBracketOut (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XTcBracketOut (GhcPass _1) = NoExtField

type family XSpliceE x #

Instances

Instances details

type XSpliceE (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XSpliceE (GhcPass _1) = NoExtField

type family XProc x #

Instances

Instances details

type XProc (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XProc (GhcPass _1) = NoExtField

type family XStatic x #

Instances

Instances details

type XStatic GhcPs
Instance details Defined in GHC.Hs.Expr type XStatic GhcPs = NoExtField
type XStatic GhcRn
Instance details Defined in GHC.Hs.Expr type XStatic GhcRn = NameSet
type XStatic GhcTc
Instance details Defined in GHC.Hs.Expr type XStatic GhcTc = NameSet

type family XTick x #

Instances

Instances details

type XTick (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XTick (GhcPass _1) = NoExtField

type family XBinTick x #

Instances

Instances details

type XBinTick (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XBinTick (GhcPass _1) = NoExtField

type family XTickPragma x #

Instances

Instances details

type XTickPragma (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XTickPragma (GhcPass _1) = NoExtField

type family XWrap x #

Instances

Instances details

type XWrap (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XWrap (GhcPass _1) = NoExtField

type family XXExpr x #

Instances

Instances details

type XXExpr (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XXExpr (GhcPass _1) = NoExtCon

type ForallXExpr (c :: Type -> Constraint) x = (c (XVar x), c (XUnboundVar x), c (XConLikeOut x), c (XRecFld x), c (XOverLabel x), c (XIPVar x), c (XOverLitE x), c (XLitE x), c (XLam x), c (XLamCase x), c (XApp x), c (XAppTypeE x), c (XOpApp x), c (XNegApp x), c (XPar x), c (XSectionL x), c (XSectionR x), c (XExplicitTuple x), c (XExplicitSum x), c (XCase x), c (XIf x), c (XMultiIf x), c (XLet x), c (XDo x), c (XExplicitList x), c (XRecordCon x), c (XRecordUpd x), c (XExprWithTySig x), c (XArithSeq x), c (XSCC x), c (XCoreAnn x), c (XBracket x), c (XRnBracketOut x), c (XTcBracketOut x), c (XSpliceE x), c (XProc x), c (XStatic x), c (XTick x), c (XBinTick x), c (XTickPragma x), c (XWrap x), c (XXExpr x)) #

type family XUnambiguous x #

Instances

Instances details

type XUnambiguous GhcPs
Instance details Defined in GHC.Hs.Types type XUnambiguous GhcPs = NoExtField
type XUnambiguous GhcRn
Instance details Defined in GHC.Hs.Types type XUnambiguous GhcRn = Name
type XUnambiguous GhcTc
Instance details Defined in GHC.Hs.Types type XUnambiguous GhcTc = Id

type family XAmbiguous x #

Instances

Instances details

type XAmbiguous GhcPs
Instance details Defined in GHC.Hs.Types type XAmbiguous GhcPs = NoExtField
type XAmbiguous GhcRn
Instance details Defined in GHC.Hs.Types type XAmbiguous GhcRn = NoExtField
type XAmbiguous GhcTc
Instance details Defined in GHC.Hs.Types type XAmbiguous GhcTc = Id

type family XXAmbiguousFieldOcc x #

Instances

Instances details

type XXAmbiguousFieldOcc (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XXAmbiguousFieldOcc (GhcPass _1) = NoExtCon

type ForallXAmbiguousFieldOcc (c :: Type -> Constraint) x = (c (XUnambiguous x), c (XAmbiguous x), c (XXAmbiguousFieldOcc x)) #

type family XPresent x #

Instances

Instances details

type XPresent (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XPresent (GhcPass _1) = NoExtField

type family XMissing x #

Instances

Instances details

type XMissing GhcPs
Instance details Defined in GHC.Hs.Expr type XMissing GhcPs = NoExtField
type XMissing GhcRn
Instance details Defined in GHC.Hs.Expr type XMissing GhcRn = NoExtField
type XMissing GhcTc
Instance details Defined in GHC.Hs.Expr type XMissing GhcTc = Type

type family XXTupArg x #

Instances

Instances details

type XXTupArg (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XXTupArg (GhcPass _1) = NoExtCon

type ForallXTupArg (c :: Type -> Constraint) x = (c (XPresent x), c (XMissing x), c (XXTupArg x)) #

type family XTypedSplice x #

Instances

Instances details

type XTypedSplice (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XTypedSplice (GhcPass _1) = NoExtField

type family XUntypedSplice x #

Instances

Instances details

type XUntypedSplice (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XUntypedSplice (GhcPass _1) = NoExtField

type family XQuasiQuote x #

Instances

Instances details

type XQuasiQuote (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XQuasiQuote (GhcPass _1) = NoExtField

type family XSpliced x #

Instances

Instances details

type XSpliced (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XSpliced (GhcPass _1) = NoExtField

type family XXSplice x #

Instances

Instances details

type XXSplice (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XXSplice (GhcPass _1) = NoExtCon

type ForallXSplice (c :: Type -> Constraint) x = (c (XTypedSplice x), c (XUntypedSplice x), c (XQuasiQuote x), c (XSpliced x), c (XXSplice x)) #

type family XExpBr x #

Instances

Instances details

type XExpBr (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XExpBr (GhcPass _1) = NoExtField

type family XPatBr x #

Instances

Instances details

type XPatBr (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XPatBr (GhcPass _1) = NoExtField

type family XDecBrL x #

Instances

Instances details

type XDecBrL (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XDecBrL (GhcPass _1) = NoExtField

type family XDecBrG x #

Instances

Instances details

type XDecBrG (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XDecBrG (GhcPass _1) = NoExtField

type family XTypBr x #

Instances

Instances details

type XTypBr (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XTypBr (GhcPass _1) = NoExtField

type family XVarBr x #

Instances

Instances details

type XVarBr (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XVarBr (GhcPass _1) = NoExtField

type family XTExpBr x #

Instances

Instances details

type XTExpBr (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XTExpBr (GhcPass _1) = NoExtField

type family XXBracket x #

Instances

Instances details

type XXBracket (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XXBracket (GhcPass _1) = NoExtCon

type ForallXBracket (c :: Type -> Constraint) x = (c (XExpBr x), c (XPatBr x), c (XDecBrL x), c (XDecBrG x), c (XTypBr x), c (XVarBr x), c (XTExpBr x), c (XXBracket x)) #

type family XCmdTop x #

Instances

Instances details

type XCmdTop GhcPs
Instance details Defined in GHC.Hs.Expr type XCmdTop GhcPs = NoExtField
type XCmdTop GhcRn
Instance details Defined in GHC.Hs.Expr type XCmdTop GhcRn = CmdSyntaxTable GhcRn
type XCmdTop GhcTc
Instance details Defined in GHC.Hs.Expr type XCmdTop GhcTc = CmdTopTc

type family XXCmdTop x #

Instances

Instances details

type XXCmdTop (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XXCmdTop (GhcPass _1) = NoExtCon

type ForallXCmdTop (c :: Type -> Constraint) x = (c (XCmdTop x), c (XXCmdTop x)) #

type family XMG x b #

Instances

Instances details

type XMG GhcPs b
Instance details Defined in GHC.Hs.Expr type XMG GhcPs b = NoExtField
type XMG GhcRn b
Instance details Defined in GHC.Hs.Expr type XMG GhcRn b = NoExtField
type XMG GhcTc b
Instance details Defined in GHC.Hs.Expr type XMG GhcTc b = MatchGroupTc

type family XXMatchGroup x b #

Instances

Instances details

type XXMatchGroup (GhcPass _1) b
Instance details Defined in GHC.Hs.Expr type XXMatchGroup (GhcPass _1) b = NoExtCon

type ForallXMatchGroup (c :: Type -> Constraint) x b = (c (XMG x b), c (XXMatchGroup x b)) #

type family XCMatch x b #

Instances

Instances details

type XCMatch (GhcPass _1) b
Instance details Defined in GHC.Hs.Expr type XCMatch (GhcPass _1) b = NoExtField

type family XXMatch x b #

Instances

Instances details

type XXMatch (GhcPass _1) b
Instance details Defined in GHC.Hs.Expr type XXMatch (GhcPass _1) b = NoExtCon

type ForallXMatch (c :: Type -> Constraint) x b = (c (XCMatch x b), c (XXMatch x b)) #

type family XCGRHSs x b #

Instances

Instances details

type XCGRHSs (GhcPass _1) b
Instance details Defined in GHC.Hs.Expr type XCGRHSs (GhcPass _1) b = NoExtField

type family XXGRHSs x b #

Instances

Instances details

type XXGRHSs (GhcPass _1) b
Instance details Defined in GHC.Hs.Expr type XXGRHSs (GhcPass _1) b = NoExtCon

type ForallXGRHSs (c :: Type -> Constraint) x b = (c (XCGRHSs x b), c (XXGRHSs x b)) #

type family XCGRHS x b #

Instances

Instances details

type XCGRHS (GhcPass _1) b
Instance details Defined in GHC.Hs.Expr type XCGRHS (GhcPass _1) b = NoExtField

type family XXGRHS x b #

Instances

Instances details

type XXGRHS (GhcPass _1) b
Instance details Defined in GHC.Hs.Expr type XXGRHS (GhcPass _1) b = NoExtCon

type ForallXGRHS (c :: Type -> Constraint) x b = (c (XCGRHS x b), c (XXGRHS x b)) #

type family XLastStmt x x' b #

Instances

Instances details

type XLastStmt (GhcPass _1) (GhcPass _2) b
Instance details Defined in GHC.Hs.Expr type XLastStmt (GhcPass _1) (GhcPass _2) b = NoExtField

type family XBindStmt x x' b #

Instances

Instances details

type XBindStmt (GhcPass _1) GhcTc b
Instance details Defined in GHC.Hs.Expr type XBindStmt (GhcPass _1) GhcTc b = Type
type XBindStmt (GhcPass _1) GhcRn b
Instance details Defined in GHC.Hs.Expr type XBindStmt (GhcPass _1) GhcRn b = NoExtField
type XBindStmt (GhcPass _1) GhcPs b
Instance details Defined in GHC.Hs.Expr type XBindStmt (GhcPass _1) GhcPs b = NoExtField

type family XApplicativeStmt x x' b #

Instances

Instances details

type XApplicativeStmt (GhcPass _1) GhcTc b
Instance details Defined in GHC.Hs.Expr type XApplicativeStmt (GhcPass _1) GhcTc b = Type
type XApplicativeStmt (GhcPass _1) GhcRn b
Instance details Defined in GHC.Hs.Expr type XApplicativeStmt (GhcPass _1) GhcRn b = NoExtField
type XApplicativeStmt (GhcPass _1) GhcPs b
Instance details Defined in GHC.Hs.Expr type XApplicativeStmt (GhcPass _1) GhcPs b = NoExtField

type family XBodyStmt x x' b #

Instances

Instances details

type XBodyStmt (GhcPass _1) GhcTc b
Instance details Defined in GHC.Hs.Expr type XBodyStmt (GhcPass _1) GhcTc b = Type
type XBodyStmt (GhcPass _1) GhcRn b
Instance details Defined in GHC.Hs.Expr type XBodyStmt (GhcPass _1) GhcRn b = NoExtField
type XBodyStmt (GhcPass _1) GhcPs b
Instance details Defined in GHC.Hs.Expr type XBodyStmt (GhcPass _1) GhcPs b = NoExtField

type family XLetStmt x x' b #

Instances

Instances details

type XLetStmt (GhcPass _1) (GhcPass _2) b
Instance details Defined in GHC.Hs.Expr type XLetStmt (GhcPass _1) (GhcPass _2) b = NoExtField

type family XParStmt x x' b #

Instances

Instances details

type XParStmt (GhcPass _1) GhcTc b
Instance details Defined in GHC.Hs.Expr type XParStmt (GhcPass _1) GhcTc b = Type
type XParStmt (GhcPass _1) GhcRn b
Instance details Defined in GHC.Hs.Expr type XParStmt (GhcPass _1) GhcRn b = NoExtField
type XParStmt (GhcPass _1) GhcPs b
Instance details Defined in GHC.Hs.Expr type XParStmt (GhcPass _1) GhcPs b = NoExtField

type family XTransStmt x x' b #

Instances

Instances details

type XTransStmt (GhcPass _1) GhcTc b
Instance details Defined in GHC.Hs.Expr type XTransStmt (GhcPass _1) GhcTc b = Type
type XTransStmt (GhcPass _1) GhcRn b
Instance details Defined in GHC.Hs.Expr type XTransStmt (GhcPass _1) GhcRn b = NoExtField
type XTransStmt (GhcPass _1) GhcPs b
Instance details Defined in GHC.Hs.Expr type XTransStmt (GhcPass _1) GhcPs b = NoExtField

type family XRecStmt x x' b #

Instances

Instances details

type XRecStmt (GhcPass _1) GhcRn b
Instance details Defined in GHC.Hs.Expr type XRecStmt (GhcPass _1) GhcRn b = NoExtField
type XRecStmt (GhcPass _1) GhcPs b
Instance details Defined in GHC.Hs.Expr type XRecStmt (GhcPass _1) GhcPs b = NoExtField
type XRecStmt (GhcPass _1) GhcTc b
Instance details Defined in GHC.Hs.Expr type XRecStmt (GhcPass _1) GhcTc b = RecStmtTc

type family XXStmtLR x x' b #

Instances

Instances details

type XXStmtLR (GhcPass _1) (GhcPass _2) b
Instance details Defined in GHC.Hs.Expr type XXStmtLR (GhcPass _1) (GhcPass _2) b = NoExtCon

type ForallXStmtLR (c :: Type -> Constraint) x x' b = (c (XLastStmt x x' b), c (XBindStmt x x' b), c (XApplicativeStmt x x' b), c (XBodyStmt x x' b), c (XLetStmt x x' b), c (XParStmt x x' b), c (XTransStmt x x' b), c (XRecStmt x x' b), c (XXStmtLR x x' b)) #

type family XCmdArrApp x #

Instances

Instances details

type XCmdArrApp GhcPs
Instance details Defined in GHC.Hs.Expr type XCmdArrApp GhcPs = NoExtField
type XCmdArrApp GhcRn
Instance details Defined in GHC.Hs.Expr type XCmdArrApp GhcRn = NoExtField
type XCmdArrApp GhcTc
Instance details Defined in GHC.Hs.Expr type XCmdArrApp GhcTc = Type

type family XCmdArrForm x #

Instances

Instances details

type XCmdArrForm (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCmdArrForm (GhcPass _1) = NoExtField

type family XCmdApp x #

Instances

Instances details

type XCmdApp (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCmdApp (GhcPass _1) = NoExtField

type family XCmdLam x #

Instances

Instances details

type XCmdLam (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCmdLam (GhcPass _1) = NoExtField

type family XCmdPar x #

Instances

Instances details

type XCmdPar (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCmdPar (GhcPass _1) = NoExtField

type family XCmdCase x #

Instances

Instances details

type XCmdCase (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCmdCase (GhcPass _1) = NoExtField

type family XCmdIf x #

Instances

Instances details

type XCmdIf (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCmdIf (GhcPass _1) = NoExtField

type family XCmdLet x #

Instances

Instances details

type XCmdLet (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCmdLet (GhcPass _1) = NoExtField

type family XCmdDo x #

Instances

Instances details

type XCmdDo GhcPs
Instance details Defined in GHC.Hs.Expr type XCmdDo GhcPs = NoExtField
type XCmdDo GhcRn
Instance details Defined in GHC.Hs.Expr type XCmdDo GhcRn = NoExtField
type XCmdDo GhcTc
Instance details Defined in GHC.Hs.Expr type XCmdDo GhcTc = Type

type family XCmdWrap x #

Instances

Instances details

type XCmdWrap (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCmdWrap (GhcPass _1) = NoExtField

type family XXCmd x #

Instances

Instances details

type XXCmd (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XXCmd (GhcPass _1) = NoExtCon

type ForallXCmd (c :: Type -> Constraint) x = (c (XCmdArrApp x), c (XCmdArrForm x), c (XCmdApp x), c (XCmdLam x), c (XCmdPar x), c (XCmdCase x), c (XCmdIf x), c (XCmdLet x), c (XCmdDo x), c (XCmdWrap x), c (XXCmd x)) #

type family XParStmtBlock x x' #

Instances

Instances details

type XParStmtBlock (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Expr type XParStmtBlock (GhcPass pL) (GhcPass pR) = NoExtField

type family XXParStmtBlock x x' #

Instances

Instances details

type XXParStmtBlock (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Expr type XXParStmtBlock (GhcPass pL) (GhcPass pR) = NoExtCon

type ForallXParStmtBlock (c :: Type -> Constraint) x x' = (c (XParStmtBlock x x'), c (XXParStmtBlock x x')) #

type family XApplicativeArgOne x #

Instances

Instances details

type XApplicativeArgOne (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XApplicativeArgOne (GhcPass _1) = NoExtField

type family XApplicativeArgMany x #

Instances

Instances details

type XApplicativeArgMany (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XApplicativeArgMany (GhcPass _1) = NoExtField

type family XXApplicativeArg x #

Instances

Instances details

type XXApplicativeArg (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XXApplicativeArg (GhcPass _1) = NoExtCon

type ForallXApplicativeArg (c :: Type -> Constraint) x = (c (XApplicativeArgOne x), c (XApplicativeArgMany x), c (XXApplicativeArg x)) #

type family XHsChar x #

Instances

Instances details

type XHsChar (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsChar (GhcPass _1) = SourceText

type family XHsCharPrim x #

Instances

Instances details

type XHsCharPrim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsCharPrim (GhcPass _1) = SourceText

type family XHsString x #

Instances

Instances details

type XHsString (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsString (GhcPass _1) = SourceText

type family XHsStringPrim x #

Instances

Instances details

type XHsStringPrim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsStringPrim (GhcPass _1) = SourceText

type family XHsInt x #

Instances

Instances details

type XHsInt (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsInt (GhcPass _1) = NoExtField

type family XHsIntPrim x #

Instances

Instances details

type XHsIntPrim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsIntPrim (GhcPass _1) = SourceText

type family XHsWordPrim x #

Instances

Instances details

type XHsWordPrim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsWordPrim (GhcPass _1) = SourceText

type family XHsInt64Prim x #

Instances

Instances details

type XHsInt64Prim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsInt64Prim (GhcPass _1) = SourceText

type family XHsWord64Prim x #

Instances

Instances details

type XHsWord64Prim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsWord64Prim (GhcPass _1) = SourceText

type family XHsInteger x #

Instances

Instances details

type XHsInteger (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsInteger (GhcPass _1) = SourceText

type family XHsRat x #

Instances

Instances details

type XHsRat (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsRat (GhcPass _1) = NoExtField

type family XHsFloatPrim x #

Instances

Instances details

type XHsFloatPrim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsFloatPrim (GhcPass _1) = NoExtField

type family XHsDoublePrim x #

Instances

Instances details

type XHsDoublePrim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsDoublePrim (GhcPass _1) = NoExtField

type family XXLit x #

Instances

Instances details

type XXLit (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XXLit (GhcPass _1) = NoExtCon

type ForallXHsLit (c :: Type -> Constraint) x = (c (XHsChar x), c (XHsCharPrim x), c (XHsDoublePrim x), c (XHsFloatPrim x), c (XHsInt x), c (XHsInt64Prim x), c (XHsIntPrim x), c (XHsInteger x), c (XHsRat x), c (XHsString x), c (XHsStringPrim x), c (XHsWord64Prim x), c (XHsWordPrim x), c (XXLit x)) #

Helper to apply a constraint to all extension points. It has one entry per extension point type family.

type family XOverLit x #

Instances

Instances details

type XOverLit GhcPs
Instance details Defined in GHC.Hs.Lit type XOverLit GhcPs = NoExtField
type XOverLit GhcRn
Instance details Defined in GHC.Hs.Lit type XOverLit GhcRn = Bool
type XOverLit GhcTc
Instance details Defined in GHC.Hs.Lit type XOverLit GhcTc = OverLitTc

type family XXOverLit x #

Instances

Instances details

type XXOverLit (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XXOverLit (GhcPass _1) = NoExtCon

type ForallXOverLit (c :: Type -> Constraint) x = (c (XOverLit x), c (XXOverLit x)) #

type family XWildPat x #

Instances

Instances details

type XWildPat GhcPs
Instance details Defined in GHC.Hs.Pat type XWildPat GhcPs = NoExtField
type XWildPat GhcRn
Instance details Defined in GHC.Hs.Pat type XWildPat GhcRn = NoExtField
type XWildPat GhcTc
Instance details Defined in GHC.Hs.Pat type XWildPat GhcTc = Type

type family XVarPat x #

Instances

Instances details

type XVarPat (GhcPass _1)
Instance details Defined in GHC.Hs.Pat type XVarPat (GhcPass _1) = NoExtField

type family XLazyPat x #

Instances

Instances details

type XLazyPat (GhcPass _1)
Instance details Defined in GHC.Hs.Pat type XLazyPat (GhcPass _1) = NoExtField

type family XAsPat x #

Instances

Instances details

type XAsPat (GhcPass _1)
Instance details Defined in GHC.Hs.Pat type XAsPat (GhcPass _1) = NoExtField

type family XParPat x #

Instances

Instances details

type XParPat (GhcPass _1)
Instance details Defined in GHC.Hs.Pat type XParPat (GhcPass _1) = NoExtField

type family XBangPat x #

Instances

Instances details

type XBangPat (GhcPass _1)
Instance details Defined in GHC.Hs.Pat type XBangPat (GhcPass _1) = NoExtField

type family XListPat x #

Instances

Instances details

type XListPat GhcPs
Instance details Defined in GHC.Hs.Pat type XListPat GhcPs = NoExtField
type XListPat GhcRn
Instance details Defined in GHC.Hs.Pat type XListPat GhcRn = Maybe (SyntaxExpr GhcRn)
type XListPat GhcTc
Instance details Defined in GHC.Hs.Pat type XListPat GhcTc = ListPatTc

type family XTuplePat x #

Instances

Instances details

type XTuplePat GhcPs
Instance details Defined in GHC.Hs.Pat type XTuplePat GhcPs = NoExtField
type XTuplePat GhcRn
Instance details Defined in GHC.Hs.Pat type XTuplePat GhcRn = NoExtField
type XTuplePat GhcTc
Instance details Defined in GHC.Hs.Pat type XTuplePat GhcTc = [Type]

type family XSumPat x #

Instances

Instances details

type XSumPat GhcPs
Instance details Defined in GHC.Hs.Pat type XSumPat GhcPs = NoExtField
type XSumPat GhcRn
Instance details Defined in GHC.Hs.Pat type XSumPat GhcRn = NoExtField
type XSumPat GhcTc
Instance details Defined in GHC.Hs.Pat type XSumPat GhcTc = [Type]

type family XConPat x #

type family XViewPat x #

Instances

Instances details

type XViewPat GhcPs
Instance details Defined in GHC.Hs.Pat type XViewPat GhcPs = NoExtField
type XViewPat GhcRn
Instance details Defined in GHC.Hs.Pat type XViewPat GhcRn = NoExtField
type XViewPat GhcTc
Instance details Defined in GHC.Hs.Pat type XViewPat GhcTc = Type

type family XSplicePat x #

Instances

Instances details

type XSplicePat (GhcPass _1)
Instance details Defined in GHC.Hs.Pat type XSplicePat (GhcPass _1) = NoExtField

type family XLitPat x #

Instances

Instances details

type XLitPat (GhcPass _1)
Instance details Defined in GHC.Hs.Pat type XLitPat (GhcPass _1) = NoExtField

type family XNPat x #

Instances

Instances details

type XNPat GhcPs
Instance details Defined in GHC.Hs.Pat type XNPat GhcPs = NoExtField
type XNPat GhcRn
Instance details Defined in GHC.Hs.Pat type XNPat GhcRn = NoExtField
type XNPat GhcTc
Instance details Defined in GHC.Hs.Pat type XNPat GhcTc = Type

type family XNPlusKPat x #

Instances

Instances details

type XNPlusKPat GhcPs
Instance details Defined in GHC.Hs.Pat type XNPlusKPat GhcPs = NoExtField
type XNPlusKPat GhcRn
Instance details Defined in GHC.Hs.Pat type XNPlusKPat GhcRn = NoExtField
type XNPlusKPat GhcTc
Instance details Defined in GHC.Hs.Pat type XNPlusKPat GhcTc = Type

type family XSigPat x #

Instances

Instances details

type XSigPat GhcPs
Instance details Defined in GHC.Hs.Pat type XSigPat GhcPs = NoExtField
type XSigPat GhcRn
Instance details Defined in GHC.Hs.Pat type XSigPat GhcRn = NoExtField
type XSigPat GhcTc
Instance details Defined in GHC.Hs.Pat type XSigPat GhcTc = Type

type family XCoPat x #

Instances

Instances details

type XCoPat (GhcPass _1)
Instance details Defined in GHC.Hs.Pat type XCoPat (GhcPass _1) = NoExtField

type family XXPat x #

Instances

Instances details

type XXPat (GhcPass _1)
Instance details Defined in GHC.Hs.Pat type XXPat (GhcPass _1) = NoExtCon

type ForallXPat (c :: Type -> Constraint) x = (c (XWildPat x), c (XVarPat x), c (XLazyPat x), c (XAsPat x), c (XParPat x), c (XBangPat x), c (XListPat x), c (XTuplePat x), c (XSumPat x), c (XViewPat x), c (XSplicePat x), c (XLitPat x), c (XNPat x), c (XNPlusKPat x), c (XSigPat x), c (XCoPat x), c (XXPat x)) #

type family XHsQTvs x #

Instances

Instances details

type XHsQTvs GhcPs
Instance details Defined in GHC.Hs.Types type XHsQTvs GhcPs = NoExtField
type XHsQTvs GhcRn
Instance details Defined in GHC.Hs.Types type XHsQTvs GhcRn = HsQTvsRn
type XHsQTvs GhcTc
Instance details Defined in GHC.Hs.Types type XHsQTvs GhcTc = HsQTvsRn

type family XXLHsQTyVars x #

Instances

Instances details

type XXLHsQTyVars (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XXLHsQTyVars (GhcPass _1) = NoExtCon

type ForallXLHsQTyVars (c :: Type -> Constraint) x = (c (XHsQTvs x), c (XXLHsQTyVars x)) #

type family XHsIB x b #

Instances

Instances details

type XHsIB GhcPs _1
Instance details Defined in GHC.Hs.Types type XHsIB GhcPs _1 = NoExtField
type XHsIB GhcRn _1
Instance details Defined in GHC.Hs.Types type XHsIB GhcRn _1 = [Name]
type XHsIB GhcTc _1
Instance details Defined in GHC.Hs.Types type XHsIB GhcTc _1 = [Name]

type family XXHsImplicitBndrs x b #

Instances

Instances details

type XXHsImplicitBndrs (GhcPass _1) _2
Instance details Defined in GHC.Hs.Types type XXHsImplicitBndrs (GhcPass _1) _2 = NoExtCon

type ForallXHsImplicitBndrs (c :: Type -> Constraint) x b = (c (XHsIB x b), c (XXHsImplicitBndrs x b)) #

type family XHsWC x b #

Instances

Instances details

type XHsWC GhcPs b
Instance details Defined in GHC.Hs.Types type XHsWC GhcPs b = NoExtField
type XHsWC GhcRn b
Instance details Defined in GHC.Hs.Types type XHsWC GhcRn b = [Name]
type XHsWC GhcTc b
Instance details Defined in GHC.Hs.Types type XHsWC GhcTc b = [Name]

type family XXHsWildCardBndrs x b #

Instances

Instances details

type XXHsWildCardBndrs (GhcPass _1) b
Instance details Defined in GHC.Hs.Types type XXHsWildCardBndrs (GhcPass _1) b = NoExtCon

type ForallXHsWildCardBndrs (c :: Type -> Constraint) x b = (c (XHsWC x b), c (XXHsWildCardBndrs x b)) #

type family XForAllTy x #

Instances

Instances details

type XForAllTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XForAllTy (GhcPass _1) = NoExtField

type family XQualTy x #

Instances

Instances details

type XQualTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XQualTy (GhcPass _1) = NoExtField

type family XTyVar x #

Instances

Instances details

type XTyVar (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XTyVar (GhcPass _1) = NoExtField

type family XAppTy x #

Instances

Instances details

type XAppTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XAppTy (GhcPass _1) = NoExtField

type family XAppKindTy x #

Instances

Instances details

type XAppKindTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XAppKindTy (GhcPass _1) = SrcSpan

type family XFunTy x #

Instances

Instances details

type XFunTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XFunTy (GhcPass _1) = NoExtField

type family XListTy x #

Instances

Instances details

type XListTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XListTy (GhcPass _1) = NoExtField

type family XTupleTy x #

Instances

Instances details

type XTupleTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XTupleTy (GhcPass _1) = NoExtField

type family XSumTy x #

Instances

Instances details

type XSumTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XSumTy (GhcPass _1) = NoExtField

type family XOpTy x #

Instances

Instances details

type XOpTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XOpTy (GhcPass _1) = NoExtField

type family XParTy x #

Instances

Instances details

type XParTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XParTy (GhcPass _1) = NoExtField

type family XIParamTy x #

Instances

Instances details

type XIParamTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XIParamTy (GhcPass _1) = NoExtField

type family XStarTy x #

Instances

Instances details

type XStarTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XStarTy (GhcPass _1) = NoExtField

type family XKindSig x #

Instances

Instances details

type XKindSig (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XKindSig (GhcPass _1) = NoExtField

type family XSpliceTy x #

Instances

Instances details

type XSpliceTy GhcPs
Instance details Defined in GHC.Hs.Types type XSpliceTy GhcPs = NoExtField
type XSpliceTy GhcRn
Instance details Defined in GHC.Hs.Types type XSpliceTy GhcRn = NoExtField
type XSpliceTy GhcTc
Instance details Defined in GHC.Hs.Types type XSpliceTy GhcTc = Kind

type family XDocTy x #

Instances

Instances details

type XDocTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XDocTy (GhcPass _1) = NoExtField

type family XBangTy x #

Instances

Instances details

type XBangTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XBangTy (GhcPass _1) = NoExtField

type family XRecTy x #

Instances

Instances details

type XRecTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XRecTy (GhcPass _1) = NoExtField

type family XExplicitListTy x #

Instances

Instances details

type XExplicitListTy GhcPs
Instance details Defined in GHC.Hs.Types type XExplicitListTy GhcPs = NoExtField
type XExplicitListTy GhcRn
Instance details Defined in GHC.Hs.Types type XExplicitListTy GhcRn = NoExtField
type XExplicitListTy GhcTc
Instance details Defined in GHC.Hs.Types type XExplicitListTy GhcTc = Kind

type family XExplicitTupleTy x #

Instances

Instances details

type XExplicitTupleTy GhcPs
Instance details Defined in GHC.Hs.Types type XExplicitTupleTy GhcPs = NoExtField
type XExplicitTupleTy GhcRn
Instance details Defined in GHC.Hs.Types type XExplicitTupleTy GhcRn = NoExtField
type XExplicitTupleTy GhcTc
Instance details Defined in GHC.Hs.Types type XExplicitTupleTy GhcTc = [Kind]

type family XTyLit x #

Instances

Instances details

type XTyLit (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XTyLit (GhcPass _1) = NoExtField

type family XWildCardTy x #

Instances

Instances details

type XWildCardTy (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XWildCardTy (GhcPass _1) = NoExtField

type family XXType x #

Instances

Instances details

type XXType (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XXType (GhcPass _1) = NewHsTypeX

type ForallXType (c :: Type -> Constraint) x = (c (XForAllTy x), c (XQualTy x), c (XTyVar x), c (XAppTy x), c (XAppKindTy x), c (XFunTy x), c (XListTy x), c (XTupleTy x), c (XSumTy x), c (XOpTy x), c (XParTy x), c (XIParamTy x), c (XStarTy x), c (XKindSig x), c (XSpliceTy x), c (XDocTy x), c (XBangTy x), c (XRecTy x), c (XExplicitListTy x), c (XExplicitTupleTy x), c (XTyLit x), c (XWildCardTy x), c (XXType x)) #

Helper to apply a constraint to all extension points. It has one entry per extension point type family.

type family XUserTyVar x #

Instances

Instances details

type XUserTyVar (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XUserTyVar (GhcPass _1) = NoExtField

type family XKindedTyVar x #

Instances

Instances details

type XKindedTyVar (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XKindedTyVar (GhcPass _1) = NoExtField

type family XXTyVarBndr x #

Instances

Instances details

type XXTyVarBndr (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XXTyVarBndr (GhcPass _1) = NoExtCon

type ForallXTyVarBndr (c :: Type -> Constraint) x = (c (XUserTyVar x), c (XKindedTyVar x), c (XXTyVarBndr x)) #

type family XConDeclField x #

Instances

Instances details

type XConDeclField (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XConDeclField (GhcPass _1) = NoExtField

type family XXConDeclField x #

Instances

Instances details

type XXConDeclField (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XXConDeclField (GhcPass _1) = NoExtCon

type ForallXConDeclField (c :: Type -> Constraint) x = (c (XConDeclField x), c (XXConDeclField x)) #

type family XCFieldOcc x #

Instances

Instances details

type XCFieldOcc GhcPs
Instance details Defined in GHC.Hs.Types type XCFieldOcc GhcPs = NoExtField
type XCFieldOcc GhcRn
Instance details Defined in GHC.Hs.Types type XCFieldOcc GhcRn = Name
type XCFieldOcc GhcTc
Instance details Defined in GHC.Hs.Types type XCFieldOcc GhcTc = Id

type family XXFieldOcc x #

Instances

Instances details

type XXFieldOcc (GhcPass _1)
Instance details Defined in GHC.Hs.Types type XXFieldOcc (GhcPass _1) = NoExtCon

type ForallXFieldOcc (c :: Type -> Constraint) x = (c (XCFieldOcc x), c (XXFieldOcc x)) #

type family XCImportDecl x #

Instances

Instances details

type XCImportDecl (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XCImportDecl (GhcPass _1) = NoExtField

type family XXImportDecl x #

Instances

Instances details

type XXImportDecl (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XXImportDecl (GhcPass _1) = NoExtCon

type ForallXImportDecl (c :: Type -> Constraint) x = (c (XCImportDecl x), c (XXImportDecl x)) #

type family XIEVar x #

Instances

Instances details

type XIEVar (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEVar (GhcPass _1) = NoExtField

type family XIEThingAbs x #

Instances

Instances details

type XIEThingAbs (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEThingAbs (GhcPass _1) = NoExtField

type family XIEThingAll x #

Instances

Instances details

type XIEThingAll (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEThingAll (GhcPass _1) = NoExtField

type family XIEThingWith x #

Instances

Instances details

type XIEThingWith (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEThingWith (GhcPass _1) = NoExtField

type family XIEModuleContents x #

Instances

Instances details

type XIEModuleContents (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEModuleContents (GhcPass _1) = NoExtField

type family XIEGroup x #

Instances

Instances details

type XIEGroup (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEGroup (GhcPass _1) = NoExtField

type family XIEDoc x #

Instances

Instances details

type XIEDoc (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEDoc (GhcPass _1) = NoExtField

type family XIEDocNamed x #

Instances

Instances details

type XIEDocNamed (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEDocNamed (GhcPass _1) = NoExtField

type family XXIE x #

Instances

Instances details

type XXIE (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XXIE (GhcPass _1) = NoExtCon

type ForallXIE (c :: Type -> Constraint) x = (c (XIEVar x), c (XIEThingAbs x), c (XIEThingAll x), c (XIEThingWith x), c (XIEModuleContents x), c (XIEGroup x), c (XIEDoc x), c (XIEDocNamed x), c (XXIE x)) #

class Convertable a b | a -> b where #

Conversion of annotations from one type index to another. This is required where the AST is converted from one pass to another, and the extension values need to be brought along if possible. So for example a SourceText is converted via id, but needs a type signature to keep the type checker happy.

Methods

convert :: a -> b #

Instances

Instances details

Convertable a a
Instance details Defined in GHC.Hs.Extension Methods convert :: a -> a #

type ConvertIdX a b = (XHsDoublePrim a ~ XHsDoublePrim b, XHsFloatPrim a ~ XHsFloatPrim b, XHsRat a ~ XHsRat b, XHsInteger a ~ XHsInteger b, XHsWord64Prim a ~ XHsWord64Prim b, XHsInt64Prim a ~ XHsInt64Prim b, XHsWordPrim a ~ XHsWordPrim b, XHsIntPrim a ~ XHsIntPrim b, XHsInt a ~ XHsInt b, XHsStringPrim a ~ XHsStringPrim b, XHsString a ~ XHsString b, XHsCharPrim a ~ XHsCharPrim b, XHsChar a ~ XHsChar b, XXLit a ~ XXLit b) #

A constraint capturing all the extension points that can be converted via instance Convertable a a

type OutputableX p = (Outputable (XIPBinds p), Outputable (XViaStrategy p), Outputable (XViaStrategy GhcRn)) #

Provide a summary constraint that gives all am Outputable constraint to extension points needing one

type OutputableBndrId (pass :: Pass) = (OutputableBndr (NameOrRdrName (IdP (GhcPass pass))), OutputableBndr (IdP (GhcPass pass)), OutputableBndr (NameOrRdrName (IdP (NoGhcTc (GhcPass pass)))), OutputableBndr (IdP (NoGhcTc (GhcPass pass))), NoGhcTc (GhcPass pass) ~ NoGhcTc (NoGhcTc (GhcPass pass)), OutputableX (GhcPass pass), OutputableX (NoGhcTc (GhcPass pass))) #

Constraint type to bundle up the requirement for OutputableBndr on both the p and the NameOrRdrName type for it

placeHolderNamesTc :: NameSet #

type family NameOrRdrName id where ... #

Follow the id, but never beyond Name. This is used in a HsMatchContext, for printing messages related to a Match

Equations

NameOrRdrName Id = Name
NameOrRdrName Name = Name
NameOrRdrName RdrName = RdrName

data ForallVisFlag #

Is a forall invisible (e.g., forall a b. {...}, with a dot) or visible (e.g., forall a b -> {...}, with an arrow)?

Constructors

ForallVis	A visible `forall` (with an arrow)
ForallInvis	An invisible `forall` (with a dot)

Instances

Instances details

Eq ForallVisFlag
Instance details Defined in Var Methods (==) :: ForallVisFlag -> ForallVisFlag -> Bool # (/=) :: ForallVisFlag -> ForallVisFlag -> Bool #
Data ForallVisFlag
Instance details Defined in Var Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForallVisFlag -> c ForallVisFlag # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ForallVisFlag # toConstr :: ForallVisFlag -> Constr # dataTypeOf :: ForallVisFlag -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ForallVisFlag) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ForallVisFlag) # gmapT :: (forall b. Data b => b -> b) -> ForallVisFlag -> ForallVisFlag # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForallVisFlag -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForallVisFlag -> r # gmapQ :: (forall d. Data d => d -> u) -> ForallVisFlag -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ForallVisFlag -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForallVisFlag -> m ForallVisFlag # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForallVisFlag -> m ForallVisFlag # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForallVisFlag -> m ForallVisFlag #
Ord ForallVisFlag
Instance details Defined in Var Methods compare :: ForallVisFlag -> ForallVisFlag -> Ordering # (<) :: ForallVisFlag -> ForallVisFlag -> Bool # (<=) :: ForallVisFlag -> ForallVisFlag -> Bool # (>) :: ForallVisFlag -> ForallVisFlag -> Bool # (>=) :: ForallVisFlag -> ForallVisFlag -> Bool # max :: ForallVisFlag -> ForallVisFlag -> ForallVisFlag # min :: ForallVisFlag -> ForallVisFlag -> ForallVisFlag #
Outputable ForallVisFlag
Instance details Defined in Var Methods ppr :: ForallVisFlag -> SDoc # pprPrec :: Rational -> ForallVisFlag -> SDoc #

emptyArgDocMap :: ArgDocMap #

emptyDeclDocMap :: DeclDocMap #

concatDocs :: [HsDocString] -> Maybe HsDocString #

Concat docstrings with two newlines in between.

Empty docstrings are skipped.

If all inputs are empty, Nothing is returned.

appendDocs :: HsDocString -> HsDocString -> HsDocString #

Join two docstrings.

Non-empty docstrings are joined with two newlines in between, resulting in separate paragraphs.

ppr_mbDoc :: Maybe LHsDocString -> SDoc #

hsDocStringToByteString :: HsDocString -> ByteString #

Return the contents of a HsDocString as a UTF8-encoded ByteString.

unpackHDS :: HsDocString -> String #

mkHsDocStringUtf8ByteString :: ByteString -> HsDocString #

Create a HsDocString from a UTF8-encoded ByteString.

mkHsDocString :: String -> HsDocString #

data HsDocString #

Haskell Documentation String

Internally this is a UTF8-Encoded ByteString.

Instances

Instances details

Eq HsDocString
Instance details Defined in GHC.Hs.Doc Methods (==) :: HsDocString -> HsDocString -> Bool # (/=) :: HsDocString -> HsDocString -> Bool #
Data HsDocString
Instance details Defined in GHC.Hs.Doc Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsDocString -> c HsDocString # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsDocString # toConstr :: HsDocString -> Constr # dataTypeOf :: HsDocString -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsDocString) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsDocString) # gmapT :: (forall b. Data b => b -> b) -> HsDocString -> HsDocString # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDocString -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDocString -> r # gmapQ :: (forall d. Data d => d -> u) -> HsDocString -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsDocString -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsDocString -> m HsDocString # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDocString -> m HsDocString # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDocString -> m HsDocString #
Show HsDocString
Instance details Defined in GHC.Hs.Doc Methods showsPrec :: Int -> HsDocString -> ShowS # show :: HsDocString -> String # showList :: [HsDocString] -> ShowS #
Binary HsDocString
Instance details Defined in GHC.Hs.Doc Methods put_ :: BinHandle -> HsDocString -> IO () # put :: BinHandle -> HsDocString -> IO (Bin HsDocString) # get :: BinHandle -> IO HsDocString #
Outputable HsDocString
Instance details Defined in GHC.Hs.Doc Methods ppr :: HsDocString -> SDoc # pprPrec :: Rational -> HsDocString -> SDoc #
Annotate HsDocString
Instance details Defined in Language.Haskell.GHC.ExactPrint.Annotater Methods markAST :: SrcSpan -> HsDocString -> Annotated () #

type LHsDocString = Located HsDocString #

Located Haskell Documentation String

newtype DeclDocMap #

Docs for declarations: functions, data types, instances, methods etc.

Constructors

DeclDocMap (Map Name HsDocString)

Instances

Instances details

Binary DeclDocMap
Instance details Defined in GHC.Hs.Doc Methods put_ :: BinHandle -> DeclDocMap -> IO () # put :: BinHandle -> DeclDocMap -> IO (Bin DeclDocMap) # get :: BinHandle -> IO DeclDocMap #
Outputable DeclDocMap
Instance details Defined in GHC.Hs.Doc Methods ppr :: DeclDocMap -> SDoc # pprPrec :: Rational -> DeclDocMap -> SDoc #

newtype ArgDocMap #

Docs for arguments. E.g. function arguments, method arguments.

Constructors

ArgDocMap (Map Name (Map Int HsDocString))

Instances

Instances details

Binary ArgDocMap
Instance details Defined in GHC.Hs.Doc Methods put_ :: BinHandle -> ArgDocMap -> IO () # put :: BinHandle -> ArgDocMap -> IO (Bin ArgDocMap) # get :: BinHandle -> IO ArgDocMap #
Outputable ArgDocMap
Instance details Defined in GHC.Hs.Doc Methods ppr :: ArgDocMap -> SDoc # pprPrec :: Rational -> ArgDocMap -> SDoc #

data Fixity #

Instances

Instances details

Eq Fixity
Instance details Defined in BasicTypes Methods (==) :: Fixity -> Fixity -> Bool # (/=) :: Fixity -> Fixity -> Bool #
Data Fixity
Instance details Defined in BasicTypes Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Fixity -> c Fixity # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Fixity # toConstr :: Fixity -> Constr # dataTypeOf :: Fixity -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Fixity) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity) # gmapT :: (forall b. Data b => b -> b) -> Fixity -> Fixity # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r # gmapQ :: (forall d. Data d => d -> u) -> Fixity -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Fixity -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity #
Outputable Fixity
Instance details Defined in BasicTypes Methods ppr :: Fixity -> SDoc # pprPrec :: Rational -> Fixity -> SDoc #

data SpliceExplicitFlag #

Constructors

ExplicitSplice	= $(f x y)
ImplicitSplice	= f x y, i.e. a naked top level expression

Instances

Instances details

Data SpliceExplicitFlag

Instance details

Defined in BasicTypes

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SpliceExplicitFlag -> c SpliceExplicitFlag #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SpliceExplicitFlag #

toConstr :: SpliceExplicitFlag -> Constr #

dataTypeOf :: SpliceExplicitFlag -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SpliceExplicitFlag) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SpliceExplicitFlag) #

gmapT :: (forall b. Data b => b -> b) -> SpliceExplicitFlag -> SpliceExplicitFlag #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SpliceExplicitFlag -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SpliceExplicitFlag -> r #

gmapQ :: (forall d. Data d => d -> u) -> SpliceExplicitFlag -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SpliceExplicitFlag -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SpliceExplicitFlag -> m SpliceExplicitFlag #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceExplicitFlag -> m SpliceExplicitFlag #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceExplicitFlag -> m SpliceExplicitFlag #

module Module

module Name

module OccName

module RdrName

module SrcLoc

module Unique

module UniqFM

module UniqSet