Safe Haskell	None
Language	Haskell2010

Development.IDE.GHC.Compat

Description

Attempt at hiding the GHC version differences we can.

Synopsis

getHeaderImports :: DynFlags -> StringBuffer -> FilePath -> FilePath -> IO (Either ErrorMessages ([(Maybe FastString, Located ModuleName)], [(Maybe FastString, Located ModuleName)], Located ModuleName))
data HieFileResult = HieFileResult {
- hie_file_result_version :: Integer
- hie_file_result_ghc_version :: ByteString
- hie_file_result :: HieFile
}
data HieFile = HieFile {
- hie_hs_file :: FilePath
- hie_module :: Module
- hie_types :: Array TypeIndex HieTypeFlat
- hie_asts :: HieASTs TypeIndex
- hie_exports :: [AvailInfo]
- hie_hs_src :: ByteString
}
newtype NameCacheUpdater = NCU {
- updateNameCache :: forall c. (NameCache -> (NameCache, c)) -> IO c
}
hieExportNames :: HieFile -> [(SrcSpan, Name)]
mkHieFile :: ModSummary -> TcGblEnv -> RenamedSource -> ByteString -> Hsc HieFile
writeHieFile :: FilePath -> HieFile -> IO ()
readHieFile :: NameCacheUpdater -> FilePath -> IO HieFileResult
supportsHieFiles :: Bool
setHieDir :: FilePath -> DynFlags -> DynFlags
dontWriteHieFiles :: DynFlags -> DynFlags
ml_hie_file :: ModLocation -> FilePath
hPutStringBuffer :: Handle -> StringBuffer -> IO ()
includePathsGlobal :: IncludeSpecs -> [String]
includePathsQuote :: IncludeSpecs -> [String]
addIncludePathsQuote :: FilePath -> DynFlags -> DynFlags
getModuleHash :: ModIface -> Fingerprint
getPackageName :: DynFlags -> InstalledUnitId -> Maybe PackageName
pattern DerivD :: DerivDecl p -> HsDecl p
pattern ForD :: ForeignDecl p -> HsDecl p
pattern InstD :: InstDecl p -> HsDecl p
pattern TyClD :: TyClDecl p -> HsDecl p
pattern ValD :: HsBind p -> HsDecl p
pattern SigD :: Sig p -> HsDecl p
pattern TypeSig :: [Located (IdP p)] -> LHsSigWcType p -> Sig p
pattern ClassOpSig :: Bool -> [Located (IdP pass)] -> LHsSigType pass -> Sig pass
pattern IEThingAll :: LIEWrappedName (IdP pass) -> IE pass
pattern IEThingWith :: LIEWrappedName (IdP pass) -> IEWildcard -> [LIEWrappedName (IdP pass)] -> [Located (FieldLbl (IdP pass))] -> IE pass
pattern VarPat :: Located (IdP p) -> Pat p
pattern PatSynBind :: PatSynBind p p -> HsBind p
data ModLocation
addBootSuffix :: FilePath -> FilePath
pattern ModLocation :: Maybe FilePath -> FilePath -> FilePath -> ModLocation
getConArgs :: ConDecl pass -> HsConDeclDetails pass
class HasSrcSpan a
getLoc :: HasSrcSpan a => a -> SrcSpan
upNameCache :: IORef NameCache -> (NameCache -> (NameCache, c)) -> IO c
parser :: String -> DynFlags -> FilePath -> (WarningMessages, Either ErrorMessages (Located (HsModule GhcPs)))
obtainTermFromId :: GhcMonad m => Int -> Bool -> Id -> m Term
obtainTermFromVal :: GhcMonad m => Int -> Bool -> Type -> a -> m Term
getHistorySpan :: GhcMonad m => History -> m SrcSpan
getGHCiMonad :: GhcMonad m => m Name
setGHCiMonad :: GhcMonad m => String -> m ()
moduleTrustReqs :: GhcMonad m => Module -> m (Bool, Set InstalledUnitId)
isModuleTrusted :: GhcMonad m => Module -> m Bool
lookupModule :: GhcMonad m => ModuleName -> Maybe FastString -> m Module
findModule :: GhcMonad m => ModuleName -> Maybe FastString -> m Module
showRichTokenStream :: [(Located Token, String)] -> String
addSourceToTokens :: RealSrcLoc -> StringBuffer -> [Located Token] -> [(Located Token, String)]
getRichTokenStream :: GhcMonad m => Module -> m [(Located Token, String)]
getTokenStream :: GhcMonad m => Module -> m [Located Token]
pprParenSymName :: NamedThing a => a -> SDoc
dataConType :: DataCon -> Type
getNameToInstancesIndex :: GhcMonad m => [Module] -> Maybe [Module] -> m (Messages, Maybe (NameEnv ([ClsInst], [FamInst])))
getGRE :: GhcMonad m => m GlobalRdrEnv
findGlobalAnns :: (GhcMonad m, Typeable a) => ([Word8] -> a) -> AnnTarget Name -> m [a]
lookupGlobalName :: GhcMonad m => Name -> m (Maybe TyThing)
isDictonaryId :: Id -> Bool
modInfoModBreaks :: ModuleInfo -> ModBreaks
modInfoSafe :: ModuleInfo -> SafeHaskellMode
modInfoIface :: ModuleInfo -> Maybe ModIface
modInfoLookupName :: GhcMonad m => ModuleInfo -> Name -> m (Maybe TyThing)
mkPrintUnqualifiedForModule :: GhcMonad m => ModuleInfo -> m (Maybe PrintUnqualified)
modInfoIsExportedName :: ModuleInfo -> Name -> Bool
modInfoInstances :: ModuleInfo -> [ClsInst]
modInfoExportsWithSelectors :: ModuleInfo -> [Name]
modInfoExports :: ModuleInfo -> [Name]
modInfoTopLevelScope :: ModuleInfo -> Maybe [Name]
modInfoTyThings :: ModuleInfo -> [TyThing]
getModuleInfo :: GhcMonad m => Module -> m (Maybe ModuleInfo)
getPrintUnqual :: GhcMonad m => m PrintUnqualified
getInsts :: GhcMonad m => m ([ClsInst], [FamInst])
getBindings :: GhcMonad m => m [TyThing]
isLoaded :: GhcMonad m => ModuleName -> m Bool
getModuleGraph :: GhcMonad m => m ModuleGraph
compileToCoreSimplified :: GhcMonad m => FilePath -> m CoreModule
compileToCoreModule :: GhcMonad m => FilePath -> m CoreModule
loadModule :: (TypecheckedMod mod, GhcMonad m) => mod -> m mod
desugarModule :: GhcMonad m => TypecheckedModule -> m DesugaredModule
typecheckModule :: GhcMonad m => ParsedModule -> m TypecheckedModule
parseModule :: GhcMonad m => ModSummary -> m ParsedModule
getModSummary :: GhcMonad m => ModuleName -> m ModSummary
workingDirectoryChanged :: GhcMonad m => m ()
guessTarget :: GhcMonad m => String -> Maybe Phase -> m Target
removeTarget :: GhcMonad m => TargetId -> m ()
addTarget :: GhcMonad m => Target -> m ()
getTargets :: GhcMonad m => m [Target]
setTargets :: GhcMonad m => [Target] -> m ()
parseDynamicFlags :: MonadIO m => DynFlags -> [Located String] -> m (DynFlags, [Located String], [Warn])
getInteractiveDynFlags :: GhcMonad m => m DynFlags
setInteractiveDynFlags :: GhcMonad m => DynFlags -> m ()
getProgramDynFlags :: GhcMonad m => m DynFlags
setLogAction :: GhcMonad m => LogAction -> m ()
setProgramDynFlags :: GhcMonad m => DynFlags -> m [InstalledUnitId]
setSessionDynFlags :: GhcMonad m => DynFlags -> m [InstalledUnitId]
initGhcMonad :: GhcMonad m => Maybe FilePath -> m ()
withCleanupSession :: GhcMonad m => m a -> m a
runGhcT :: ExceptionMonad m => Maybe FilePath -> GhcT m a -> m a
runGhc :: Maybe FilePath -> Ghc a -> IO a
defaultCleanupHandler :: ExceptionMonad m => DynFlags -> m a -> m a
defaultErrorHandler :: ExceptionMonad m => FatalMessager -> FlushOut -> m a -> m a
class ParsedMod m where
- parsedSource :: m -> ParsedSource
class ParsedMod m => TypecheckedMod m where
- renamedSource :: m -> Maybe RenamedSource
- typecheckedSource :: m -> TypecheckedSource
- moduleInfo :: m -> ModuleInfo
data ParsedModule = ParsedModule {
- pm_mod_summary :: ModSummary
- pm_parsed_source :: ParsedSource
- pm_extra_src_files :: [FilePath]
- pm_annotations :: ApiAnns
}
data TypecheckedModule = TypecheckedModule {
- tm_parsed_module :: ParsedModule
- tm_renamed_source :: Maybe RenamedSource
- tm_typechecked_source :: TypecheckedSource
- tm_checked_module_info :: ModuleInfo
- tm_internals_ :: (TcGblEnv, ModDetails)
}
data DesugaredModule = DesugaredModule {
- dm_typechecked_module :: TypecheckedModule
- dm_core_module :: ModGuts
}
type ParsedSource = Located (HsModule GhcPs)
type RenamedSource = (HsGroup GhcRn, [LImportDecl GhcRn], Maybe [(LIE GhcRn, Avails)], Maybe LHsDocString)
type TypecheckedSource = LHsBinds GhcTc
data CoreModule = CoreModule {
- cm_module :: !Module
- cm_types :: !TypeEnv
- cm_binds :: CoreProgram
- cm_safe :: SafeHaskellMode
}
data ModuleInfo
cyclicModuleErr :: [ModSummary] -> SDoc
topSortModuleGraph :: Bool -> ModuleGraph -> Maybe ModuleName -> [SCC ModSummary]
load :: GhcMonad m => LoadHowMuch -> m SuccessFlag
depanal :: GhcMonad m => [ModuleName] -> Bool -> m ModuleGraph
data LoadHowMuch
- = LoadAllTargets
- | LoadUpTo ModuleName
- | LoadDependenciesOf ModuleName
reconstructType :: HscEnv -> Int -> Id -> IO (Maybe Type)
moduleIsBootOrNotObjectLinkable :: GhcMonad m => ModSummary -> m Bool
showModule :: GhcMonad m => ModSummary -> m String
dynCompileExpr :: GhcMonad m => String -> m Dynamic
compileParsedExpr :: GhcMonad m => LHsExpr GhcPs -> m HValue
compileParsedExprRemote :: GhcMonad m => LHsExpr GhcPs -> m ForeignHValue
compileExprRemote :: GhcMonad m => String -> m ForeignHValue
compileExpr :: GhcMonad m => String -> m HValue
parseExpr :: GhcMonad m => String -> m (LHsExpr GhcPs)
typeKind :: GhcMonad m => Bool -> String -> m (Type, Kind)
exprType :: GhcMonad m => TcRnExprMode -> String -> m Type
getDocs :: GhcMonad m => Name -> m (Either GetDocsFailure (Maybe HsDocString, Map Int HsDocString))
isDecl :: DynFlags -> String -> Bool
isImport :: DynFlags -> String -> Bool
hasImport :: DynFlags -> String -> Bool
isStmt :: DynFlags -> String -> Bool
parseName :: GhcMonad m => String -> m [Name]
getRdrNamesInScope :: GhcMonad m => m [RdrName]
getNamesInScope :: GhcMonad m => m [Name]
getInfo :: GhcMonad m => Bool -> Name -> m (Maybe (TyThing, Fixity, [ClsInst], [FamInst], SDoc))
moduleIsInterpreted :: GhcMonad m => Module -> m Bool
getContext :: GhcMonad m => m [InteractiveImport]
setContext :: GhcMonad m => [InteractiveImport] -> m ()
abandonAll :: GhcMonad m => m Bool
abandon :: GhcMonad m => m Bool
forward :: GhcMonad m => Int -> m ([Name], Int, SrcSpan, String)
back :: GhcMonad m => Int -> m ([Name], Int, SrcSpan, String)
resumeExec :: GhcMonad m => (SrcSpan -> Bool) -> SingleStep -> m ExecResult
parseImportDecl :: GhcMonad m => String -> m (ImportDecl GhcPs)
runDeclsWithLocation :: GhcMonad m => String -> Int -> String -> m [Name]
runDecls :: GhcMonad m => String -> m [Name]
execStmt :: GhcMonad m => String -> ExecOptions -> m ExecResult
execOptions :: ExecOptions
getHistoryModule :: History -> Module
getResumeContext :: GhcMonad m => m [Resume]
data GetDocsFailure
- = NameHasNoModule Name
- | NoDocsInIface Module Bool
- | InteractiveName
runTcInteractive :: HscEnv -> TcRn a -> IO (Messages, Maybe a)
data TcRnExprMode
- = TM_Inst
- | TM_NoInst
- | TM_Default
pprFamInst :: FamInst -> SDoc
defaultWarnErrLogger :: WarnErrLogger
printException :: GhcMonad m => SourceError -> m ()
getSessionDynFlags :: GhcMonad m => m DynFlags
class (Functor m, MonadIO m, ExceptionMonad m, HasDynFlags m) => GhcMonad (m :: Type -> Type) where
- getSession :: m HscEnv
- setSession :: HscEnv -> m ()
data Ghc a
data GhcT (m :: Type -> Type) a
type WarnErrLogger = forall (m :: Type -> Type). GhcMonad m => Maybe SourceError -> m ()
ms_mod_name :: ModSummary -> ModuleName
mkModuleGraph :: [ModSummary] -> ModuleGraph
emptyMG :: ModuleGraph
mgLookupModule :: ModuleGraph -> Module -> Maybe ModSummary
mgModSummaries :: ModuleGraph -> [ModSummary]
mapMG :: (ModSummary -> ModSummary) -> ModuleGraph -> ModuleGraph
needsTemplateHaskellOrQQ :: ModuleGraph -> Bool
handleSourceError :: ExceptionMonad m => (SourceError -> m a) -> m a -> m a
data HscEnv
data Target = Target {
- targetId :: TargetId
- targetAllowObjCode :: Bool
- targetContents :: Maybe (StringBuffer, UTCTime)
}
data TargetId
- = TargetModule ModuleName
- | TargetFile FilePath (Maybe Phase)
data ModIface = ModIface {
- mi_module :: !Module
- mi_sig_of :: !(Maybe Module)
- mi_iface_hash :: !Fingerprint
- mi_mod_hash :: !Fingerprint
- mi_flag_hash :: !Fingerprint
- mi_opt_hash :: !Fingerprint
- mi_hpc_hash :: !Fingerprint
- mi_plugin_hash :: !Fingerprint
- mi_orphan :: !WhetherHasOrphans
- mi_finsts :: !WhetherHasFamInst
- mi_hsc_src :: !HscSource
- mi_deps :: Dependencies
- mi_usages :: [Usage]
- mi_exports :: ![IfaceExport]
- mi_exp_hash :: !Fingerprint
- mi_used_th :: !Bool
- mi_fixities :: [(OccName, Fixity)]
- mi_warns :: Warnings
- mi_anns :: [IfaceAnnotation]
- mi_decls :: [(Fingerprint, IfaceDecl)]
- mi_globals :: !(Maybe GlobalRdrEnv)
- mi_insts :: [IfaceClsInst]
- mi_fam_insts :: [IfaceFamInst]
- mi_rules :: [IfaceRule]
- mi_orphan_hash :: !Fingerprint
- mi_warn_fn :: OccName -> Maybe WarningTxt
- mi_fix_fn :: OccName -> Maybe Fixity
- mi_hash_fn :: OccName -> Maybe (OccName, Fingerprint)
- mi_hpc :: !AnyHpcUsage
- mi_trust :: !IfaceTrustInfo
- mi_trust_pkg :: !Bool
- mi_complete_sigs :: [IfaceCompleteMatch]
- mi_doc_hdr :: Maybe HsDocString
- mi_decl_docs :: DeclDocMap
- mi_arg_docs :: ArgDocMap
}
data InteractiveImport
- = IIDecl (ImportDecl GhcPs)
- | IIModule ModuleName
data ModuleGraph
data ModSummary = ModSummary {
- ms_mod :: Module
- ms_hsc_src :: HscSource
- ms_location :: ModLocation
- ms_hs_date :: UTCTime
- ms_obj_date :: Maybe UTCTime
- ms_iface_date :: Maybe UTCTime
- ms_srcimps :: [(Maybe FastString, Located ModuleName)]
- ms_textual_imps :: [(Maybe FastString, Located ModuleName)]
- ms_parsed_mod :: Maybe HsParsedModule
- ms_hspp_file :: FilePath
- ms_hspp_opts :: DynFlags
- ms_hspp_buf :: Maybe StringBuffer
}
data HsModule pass = HsModule {
- hsmodName :: Maybe (Located ModuleName)
- hsmodExports :: Maybe (Located [LIE pass])
- hsmodImports :: [LImportDecl pass]
- hsmodDecls :: [LHsDecl pass]
- hsmodDeprecMessage :: Maybe (Located WarningTxt)
- hsmodHaddockModHeader :: Maybe LHsDocString
}
lPatImplicits :: LPat GhcRn -> NameSet
hsValBindsImplicits :: HsValBindsLR GhcRn (GhcPass idR) -> NameSet
lStmtsImplicits :: [LStmtLR GhcRn (GhcPass idR) (Located (body (GhcPass idR)))] -> NameSet
hsDataFamInstBinders :: DataFamInstDecl pass -> ([Located (IdP pass)], [LFieldOcc pass])
getPatSynBinds :: [(RecFlag, LHsBinds id)] -> [PatSynBind id id]
hsPatSynSelectors :: HsValBinds (GhcPass p) -> [IdP (GhcPass p)]
hsForeignDeclsBinders :: [LForeignDecl pass] -> [Located (IdP pass)]
hsLTyClDeclBinders :: Located (TyClDecl pass) -> ([Located (IdP pass)], [LFieldOcc pass])
hsTyClForeignBinders :: [TyClGroup GhcRn] -> [LForeignDecl GhcRn] -> [Name]
hsGroupBinders :: HsGroup GhcRn -> [Name]
collectPatsBinders :: [LPat a] -> [IdP a]
collectPatBinders :: LPat a -> [IdP a]
collectStmtBinders :: StmtLR (GhcPass idL) (GhcPass idR) body -> [IdP (GhcPass idL)]
collectLStmtBinders :: LStmtLR (GhcPass idL) (GhcPass idR) body -> [IdP (GhcPass idL)]
collectStmtsBinders :: [StmtLR (GhcPass idL) (GhcPass idR) body] -> [IdP (GhcPass idL)]
collectLStmtsBinders :: [LStmtLR (GhcPass idL) (GhcPass idR) body] -> [IdP (GhcPass idL)]
collectMethodBinders :: LHsBindsLR idL idR -> [Located (IdP idL)]
collectHsBindListBinders :: [LHsBindLR idL idR] -> [IdP idL]
collectHsBindsBinders :: LHsBindsLR idL idR -> [IdP idL]
collectHsBindBinders :: HsBindLR idL idR -> [IdP idL]
collectHsValBinders :: HsValBindsLR (GhcPass idL) (GhcPass idR) -> [IdP (GhcPass idL)]
collectHsIdBinders :: HsValBindsLR (GhcPass idL) (GhcPass idR) -> [IdP (GhcPass idL)]
collectLocalBinders :: HsLocalBindsLR (GhcPass idL) (GhcPass idR) -> [IdP (GhcPass idL)]
isBangedHsBind :: HsBind GhcTc -> Bool
isUnliftedHsBind :: HsBind GhcTc -> Bool
mkMatch :: 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
mk_easy_FunBind :: SrcSpan -> RdrName -> [LPat GhcPs] -> LHsExpr GhcPs -> LHsBind GhcPs
isInfixFunBind :: HsBindLR id1 id2 -> Bool
mkPatSynBind :: Located RdrName -> HsPatSynDetails (Located RdrName) -> LPat GhcPs -> HsPatSynDir GhcPs -> HsBind GhcPs
mkVarBind :: 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
mkFunBind :: Located RdrName -> [LMatch GhcPs (LHsExpr GhcPs)] -> HsBind GhcPs
mkHsDictLet :: TcEvBinds -> LHsExpr GhcTc -> LHsExpr GhcTc
mkHsWrapPatCo :: TcCoercionN -> Pat (GhcPass id) -> Type -> Pat (GhcPass id)
mkHsWrapPat :: HsWrapper -> Pat (GhcPass id) -> Type -> Pat (GhcPass id)
mkLHsCmdWrap :: HsWrapper -> LHsCmd (GhcPass p) -> LHsCmd (GhcPass p)
mkHsCmdWrap :: HsWrapper -> HsCmd (GhcPass p) -> HsCmd (GhcPass p)
mkLHsWrapCo :: TcCoercionN -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)
mkHsWrapCoR :: TcCoercionR -> HsExpr (GhcPass id) -> HsExpr (GhcPass id)
mkHsWrapCo :: TcCoercionN -> HsExpr (GhcPass id) -> HsExpr (GhcPass id)
mkHsWrap :: HsWrapper -> HsExpr (GhcPass id) -> HsExpr (GhcPass id)
mkLHsWrap :: HsWrapper -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)
typeToLHsType :: Type -> LHsType GhcPs
mkClassOpSigs :: [LSig GhcPs] -> [LSig GhcPs]
mkHsSigEnv :: (LSig GhcRn -> Maybe ([Located Name], a)) -> [LSig GhcRn] -> NameEnv a
mkLHsSigWcType :: LHsType GhcPs -> LHsSigWcType GhcPs
mkLHsSigType :: LHsType GhcPs -> LHsSigType GhcPs
chunkify :: [a] -> [[a]]
mkChunkified :: ([a] -> a) -> [a] -> a
mkBigLHsPatTup :: [LPat GhcRn] -> LPat GhcRn
mkBigLHsVarPatTup :: [IdP GhcRn] -> LPat GhcRn
mkBigLHsTup :: [LHsExpr (GhcPass id)] -> LHsExpr (GhcPass id)
mkBigLHsVarTup :: [IdP (GhcPass id)] -> LHsExpr (GhcPass id)
missingTupArg :: HsTupArg GhcPs
nlTuplePat :: [LPat GhcPs] -> Boxity -> LPat GhcPs
mkLHsVarTuple :: [IdP (GhcPass a)] -> LHsExpr (GhcPass a)
mkLHsTupleExpr :: [LHsExpr (GhcPass a)] -> LHsExpr (GhcPass a)
nlHsTyConApp :: IdP (GhcPass p) -> [LHsType (GhcPass p)] -> LHsType (GhcPass p)
nlHsParTy :: LHsType (GhcPass p) -> LHsType (GhcPass p)
nlHsFunTy :: LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p)
nlHsTyVar :: IdP (GhcPass p) -> LHsType (GhcPass p)
nlHsAppTy :: LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p)
nlList :: [LHsExpr GhcPs] -> LHsExpr GhcPs
nlHsCase :: LHsExpr GhcPs -> [LMatch GhcPs (LHsExpr GhcPs)] -> LHsExpr GhcPs
nlHsIf :: LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)
nlHsPar :: 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
nlWildPat :: LPat GhcPs
nlWildConPat :: DataCon -> LPat GhcPs
nlNullaryConPat :: IdP id -> LPat id
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 :: IdP (GhcPass id) -> [IdP (GhcPass id)] -> LHsExpr (GhcPass id)
nlHsApps :: IdP (GhcPass id) -> [LHsExpr (GhcPass id)] -> LHsExpr (GhcPass id)
nlHsSyntaxApps :: SyntaxExpr (GhcPass id) -> [LHsExpr (GhcPass id)] -> LHsExpr (GhcPass id)
nlHsApp :: LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)
nlLitPat :: HsLit GhcPs -> LPat GhcPs
nlVarPat :: IdP (GhcPass id) -> LPat (GhcPass id)
nlHsIntLit :: Integer -> LHsExpr (GhcPass p)
nlHsLit :: HsLit (GhcPass p) -> LHsExpr (GhcPass p)
nlHsDataCon :: DataCon -> LHsExpr GhcTc
nlHsVar :: IdP (GhcPass id) -> LHsExpr (GhcPass id)
userHsTyVarBndrs :: SrcSpan -> [IdP (GhcPass p)] -> [LHsTyVarBndr (GhcPass p)]
userHsLTyVarBndrs :: SrcSpan -> [Located (IdP (GhcPass p))] -> [LHsTyVarBndr (GhcPass p)]
mkHsStringPrimLit :: FastString -> HsLit (GhcPass p)
mkHsString :: String -> HsLit (GhcPass p)
unqualQuasiQuote :: RdrName
mkHsQuasiQuote :: RdrName -> SrcSpan -> FastString -> HsSplice GhcPs
mkHsSpliceTy :: SpliceDecoration -> LHsExpr GhcPs -> HsType GhcPs
mkHsSpliceTE :: SpliceDecoration -> LHsExpr GhcPs -> HsExpr GhcPs
mkHsSpliceE :: SpliceDecoration -> LHsExpr GhcPs -> HsExpr GhcPs
mkUntypedSplice :: SpliceDecoration -> LHsExpr GhcPs -> HsSplice GhcPs
mkHsOpApp :: LHsExpr GhcPs -> IdP GhcPs -> LHsExpr GhcPs -> HsExpr GhcPs
mkRecStmt :: [LStmtLR (GhcPass idL) GhcPs bodyR] -> StmtLR (GhcPass idL) GhcPs bodyR
emptyRecStmtId :: StmtLR GhcTc GhcTc bodyR
emptyRecStmtName :: StmtLR GhcRn GhcRn bodyR
emptyRecStmt :: StmtLR (GhcPass idL) GhcPs bodyR
unitRecStmtTc :: RecStmtTc
mkTcBindStmt :: LPat GhcTc -> Located (bodyR GhcTc) -> StmtLR GhcTc GhcTc (Located (bodyR GhcTc))
mkBindStmt :: XBindStmt (GhcPass idL) (GhcPass idR) (Located (bodyR (GhcPass idR))) ~ NoExt => LPat (GhcPass idL) -> Located (bodyR (GhcPass idR)) -> StmtLR (GhcPass idL) (GhcPass idR) (Located (bodyR (GhcPass idR)))
mkBodyStmt :: Located (bodyR GhcPs) -> StmtLR (GhcPass idL) GhcPs (Located (bodyR GhcPs))
mkLastStmt :: 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
mkHsIf :: 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 :: LPat (GhcPass name) -> LPat (GhcPass name)
mkParPat :: LPat (GhcPass name) -> LPat (GhcPass name)
mkLHsPar :: LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)
nlHsTyApps :: IdP (GhcPass id) -> [Type] -> [LHsExpr (GhcPass id)] -> LHsExpr (GhcPass id)
nlHsTyApp :: IdP (GhcPass id) -> [Type] -> LHsExpr (GhcPass id)
mkHsCaseAlt :: LPat (GhcPass p) -> Located (body (GhcPass p)) -> LMatch (GhcPass p) (Located (body (GhcPass p)))
mkHsLams :: [TyVar] -> [EvVar] -> LHsExpr GhcTc -> LHsExpr GhcTc
mkHsLam :: [LPat GhcPs] -> LHsExpr GhcPs -> LHsExpr GhcPs
mkHsAppTypes :: LHsExpr GhcRn -> [LHsWcType GhcRn] -> LHsExpr GhcRn
mkHsAppType :: XAppTypeE (GhcPass id) ~ LHsWcType GhcRn => LHsExpr (GhcPass id) -> LHsWcType GhcRn -> LHsExpr (GhcPass id)
mkHsApp :: LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)
mkMatchGroup :: XMG name (Located (body name)) ~ NoExt => Origin -> [LMatch name (Located (body name))] -> MatchGroup name (Located (body name))
unguardedRHS :: SrcSpan -> Located (body (GhcPass p)) -> [LGRHS (GhcPass p) (Located (body (GhcPass p)))]
unguardedGRHSs :: Located (body (GhcPass p)) -> GRHSs (GhcPass p) (Located (body (GhcPass p)))
mkSimpleMatch :: HsMatchContext (NameOrRdrName (IdP (GhcPass p))) -> [LPat (GhcPass p)] -> Located (body (GhcPass p)) -> LMatch (GhcPass p) (Located (body (GhcPass p)))
mkHsPar :: LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)
pprStmtInCtxt :: (OutputableBndrId (GhcPass idL), OutputableBndrId (GhcPass idR), Outputable body) => HsStmtContext (IdP (GhcPass idL)) -> StmtLR (GhcPass idL) (GhcPass idR) body -> SDoc
pprMatchInCtxt :: (OutputableBndrId (GhcPass 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
isMonadFailStmtContext :: HsStmtContext id -> Bool
isListCompExpr :: HsStmtContext id -> Bool
isPatSynCtxt :: HsMatchContext id -> Bool
pp_dotdot :: SDoc
thTyBrackets :: SDoc -> SDoc
thBrackets :: SDoc -> SDoc -> SDoc
pprHsBracket :: OutputableBndrId (GhcPass p) => HsBracket (GhcPass p) -> SDoc
isTypedBracket :: HsBracket id -> Bool
ppr_splice :: OutputableBndrId (GhcPass p) => SDoc -> IdP (GhcPass p) -> LHsExpr (GhcPass p) -> SDoc -> SDoc
ppr_quasi :: OutputableBndr p => p -> p -> FastString -> SDoc
ppr_splice_decl :: OutputableBndrId (GhcPass p) => HsSplice (GhcPass p) -> SDoc
pprPendingSplice :: OutputableBndrId (GhcPass p) => SplicePointName -> LHsExpr (GhcPass p) -> SDoc
isTypedSplice :: HsSplice id -> Bool
pprQuals :: (OutputableBndrId (GhcPass p), Outputable body) => [LStmt (GhcPass p) body] -> SDoc
pprComp :: (OutputableBndrId (GhcPass p), Outputable body) => [LStmt (GhcPass p) body] -> SDoc
ppr_do_stmts :: (OutputableBndrId (GhcPass idL), OutputableBndrId (GhcPass idR), Outputable body) => [LStmtLR (GhcPass idL) (GhcPass idR) body] -> SDoc
pprDo :: (OutputableBndrId (GhcPass 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 :: OutputableBndrId (GhcPass p) => [IdP (GhcPass p)] -> LHsExpr (GhcPass p) -> Maybe (LHsExpr (GhcPass p)) -> SDoc
pprStmt :: (OutputableBndrId (GhcPass idL), OutputableBndrId (GhcPass idR), Outputable body) => StmtLR (GhcPass idL) (GhcPass idR) body -> SDoc
pp_rhs :: Outputable body => HsMatchContext idL -> body -> SDoc
pprGRHS :: (OutputableBndrId (GhcPass idR), Outputable body) => HsMatchContext idL -> GRHS (GhcPass idR) body -> SDoc
pprGRHSs :: (OutputableBndrId (GhcPass idR), Outputable body) => HsMatchContext idL -> GRHSs (GhcPass idR) body -> SDoc
pprMatch :: (OutputableBndrId (GhcPass idR), Outputable body) => Match (GhcPass idR) body -> SDoc
pprMatches :: (OutputableBndrId (GhcPass idR), Outputable body) => MatchGroup (GhcPass idR) body -> SDoc
hsLMatchPats :: LMatch id body -> [LPat id]
matchGroupArity :: MatchGroup id body -> Arity
isSingletonMatchGroup :: [LMatch id body] -> Bool
isEmptyMatchGroup :: MatchGroup id body -> Bool
isInfixMatch :: Match id body -> Bool
pprCmdArg :: OutputableBndrId (GhcPass p) => HsCmdTop (GhcPass p) -> SDoc
ppr_cmd :: OutputableBndrId (GhcPass p) => HsCmd (GhcPass p) -> SDoc
ppr_lcmd :: OutputableBndrId (GhcPass p) => LHsCmd (GhcPass p) -> SDoc
isQuietHsCmd :: HsCmd id -> Bool
pprCmd :: OutputableBndrId (GhcPass p) => HsCmd (GhcPass p) -> SDoc
pprLCmd :: OutputableBndrId (GhcPass p) => LHsCmd (GhcPass p) -> SDoc
isAtomicHsExpr :: HsExpr id -> Bool
parenthesizeHsExpr :: PprPrec -> LHsExpr (GhcPass p) -> LHsExpr (GhcPass p)
hsExprNeedsParens :: PprPrec -> HsExpr p -> Bool
pprParendExpr :: OutputableBndrId (GhcPass p) => PprPrec -> HsExpr (GhcPass p) -> SDoc
pprParendLExpr :: OutputableBndrId (GhcPass p) => PprPrec -> LHsExpr (GhcPass p) -> SDoc
pprDebugParendExpr :: OutputableBndrId (GhcPass p) => PprPrec -> LHsExpr (GhcPass p) -> SDoc
pprExternalSrcLoc :: (StringLiteral, (Int, Int), (Int, Int)) -> SDoc
ppr_apps :: OutputableBndrId (GhcPass p) => HsExpr (GhcPass p) -> [Either (LHsExpr (GhcPass p)) (XAppTypeE (GhcPass p))] -> SDoc
ppr_expr :: OutputableBndrId (GhcPass p) => HsExpr (GhcPass p) -> SDoc
ppr_lexpr :: OutputableBndrId (GhcPass p) => LHsExpr (GhcPass p) -> SDoc
pprBinds :: (OutputableBndrId (GhcPass idL), OutputableBndrId (GhcPass idR)) => HsLocalBindsLR (GhcPass idL) (GhcPass idR) -> SDoc
isQuietHsExpr :: HsExpr id -> Bool
tupArgPresent :: LHsTupArg id -> Bool
unboundVarOcc :: UnboundVar -> OccName
mkRnSyntaxExpr :: Name -> SyntaxExpr GhcRn
noSyntaxExpr :: SyntaxExpr (GhcPass p)
noExpr :: HsExpr (GhcPass p)
type PostTcExpr = HsExpr GhcTc
type PostTcTable = [(Name, PostTcExpr)]
type CmdSyntaxTable p = [(Name, HsExpr p)]
data UnboundVar
- = OutOfScope OccName GlobalRdrEnv
- | TrueExprHole OccName
data RecordConTc = RecordConTc {
- rcon_con_like :: ConLike
- rcon_con_expr :: PostTcExpr
}
data RecordUpdTc = RecordUpdTc {
- rupd_cons :: [ConLike]
- rupd_in_tys :: [Type]
- rupd_out_tys :: [Type]
- rupd_wrap :: HsWrapper
}
type LHsTupArg id = Located (HsTupArg id)
data HsTupArg id
- = Present (XPresent id) (LHsExpr id)
- | Missing (XMissing id)
- | XTupArg (XXTupArg id)
type LHsCmd id = Located (HsCmd id)
data HsArrAppType
- = HsHigherOrderApp
- | HsFirstOrderApp
type LHsCmdTop p = Located (HsCmdTop p)
data HsCmdTop p
- = HsCmdTop (XCmdTop p) (LHsCmd p)
- | XCmdTop (XXCmdTop p)
data CmdTopTc = CmdTopTc Type Type (CmdSyntaxTable GhcTc)
type HsRecordBinds p = HsRecFields p (LHsExpr p)
data MatchGroupTc = MatchGroupTc {
- mg_arg_tys :: [Type]
- mg_res_ty :: Type
}
type LMatch id body = Located (Match id body)
data Match p body
- = Match {
  - m_ext :: XCMatch p body
  - m_ctxt :: HsMatchContext (NameOrRdrName (IdP p))
  - m_pats :: [LPat p]
  - m_grhss :: GRHSs p body
  }
- | XMatch (XXMatch p body)
type LGRHS id body = Located (GRHS id body)
data GRHS p body
- = GRHS (XCGRHS p body) [GuardLStmt p] body
- | XGRHS (XXGRHS p body)
type LStmt id body = Located (StmtLR id id body)
type LStmtLR idL idR body = Located (StmtLR idL idR body)
type Stmt id body = StmtLR id id body
type CmdLStmt id = LStmt id (LHsCmd id)
type CmdStmt id = Stmt id (LHsCmd id)
type ExprLStmt id = LStmt id (LHsExpr id)
type ExprStmt id = Stmt id (LHsExpr id)
type GuardLStmt id = LStmt id (LHsExpr id)
type GuardStmt id = Stmt id (LHsExpr id)
type GhciLStmt id = LStmt id (LHsExpr id)
type GhciStmt id = Stmt id (LHsExpr id)
data StmtLR idL idR body
- = 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))
- | BodyStmt (XBodyStmt idL idR body) body (SyntaxExpr idR) (SyntaxExpr idR)
- | LetStmt (XLetStmt idL idR body) (LHsLocalBindsLR idL idR)
- | ParStmt (XParStmt idL idR body) [ParStmtBlock idL idR] (HsExpr idR) (SyntaxExpr idR)
- | TransStmt {
  - 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 {
  - 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)
data RecStmtTc = RecStmtTc {
- recS_bind_ty :: Type
- recS_later_rets :: [PostTcExpr]
- recS_rec_rets :: [PostTcExpr]
- recS_ret_ty :: Type
}
data TransForm
- = ThenForm
- | GroupForm
data ParStmtBlock idL idR
- = ParStmtBlock (XParStmtBlock idL idR) [ExprLStmt idL] [IdP idR] (SyntaxExpr idR)
- | XParStmtBlock (XXParStmtBlock idL idR)
data ApplicativeArg idL
- = ApplicativeArgOne (XApplicativeArgOne idL) (LPat idL) (LHsExpr idL) Bool
- | ApplicativeArgMany (XApplicativeArgMany idL) [ExprLStmt idL] (HsExpr idL) (LPat idL)
- | XApplicativeArg (XXApplicativeArg idL)
data SpliceDecoration
- = HasParens
- | HasDollar
- | NoParens
newtype ThModFinalizers = ThModFinalizers [ForeignRef (Q ())]
data HsSplicedThing id
- = HsSplicedExpr (HsExpr id)
- | HsSplicedTy (HsType id)
- | HsSplicedPat (Pat id)
type SplicePointName = Name
data PendingRnSplice = PendingRnSplice UntypedSpliceFlavour SplicePointName (LHsExpr GhcRn)
data UntypedSpliceFlavour
- = UntypedExpSplice
- | UntypedPatSplice
- | UntypedTypeSplice
- | UntypedDeclSplice
data PendingTcSplice = PendingTcSplice SplicePointName (LHsExpr GhcTc)
data HsBracket p
- = 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)
data ArithSeqInfo id
- = From (LHsExpr id)
- | FromThen (LHsExpr id) (LHsExpr id)
- | FromTo (LHsExpr id) (LHsExpr id)
- | FromThenTo (LHsExpr id) (LHsExpr id) (LHsExpr id)
data HsMatchContext id
- = FunRhs {
  - mc_fun :: Located id
  - mc_fixity :: LexicalFixity
  - mc_strictness :: SrcStrictness
  }
- | LambdaExpr
- | CaseAlt
- | IfAlt
- | ProcExpr
- | PatBindRhs
- | PatBindGuards
- | RecUpd
- | StmtCtxt (HsStmtContext id)
- | ThPatSplice
- | ThPatQuote
- | PatSyn
data HsStmtContext id
- = ListComp
- | MonadComp
- | DoExpr
- | MDoExpr
- | ArrowExpr
- | GhciStmtCtxt
- | PatGuard (HsMatchContext id)
- | ParStmtCtxt (HsStmtContext id)
- | TransStmtCtxt (HsStmtContext id)
roleAnnotDeclName :: RoleAnnotDecl pass -> IdP pass
annProvenanceName_maybe :: AnnProvenance name -> Maybe name
docDeclDoc :: DocDecl -> HsDocString
pprFullRuleName :: Located (SourceText, RuleName) -> SDoc
collectRuleBndrSigTys :: [RuleBndr pass] -> [LHsSigWcType pass]
flattenRuleDecls :: [LRuleDecls pass] -> [LRuleDecl pass]
derivStrategyName :: DerivStrategy a -> SDoc
instDeclDataFamInsts :: [LInstDecl pass] -> [DataFamInstDecl pass]
pprFamInstLHS :: OutputableBndrId (GhcPass p) => Located (IdP (GhcPass p)) -> HsTyPats (GhcPass p) -> LexicalFixity -> HsContext (GhcPass p) -> Maybe (LHsKind (GhcPass p)) -> SDoc
pprDataFamInstFlavour :: DataFamInstDecl (GhcPass p) -> SDoc
hsConDeclTheta :: Maybe (LHsContext pass) -> [LHsType pass]
hsConDeclArgTys :: HsConDeclDetails pass -> [LBangType pass]
getConNames :: ConDecl pass -> [Located (IdP pass)]
newOrDataToFlavour :: NewOrData -> TyConFlavour
resultVariableName :: FamilyResultSig a -> Maybe (IdP a)
famDeclHasCusk :: Maybe Bool -> FamilyDecl pass -> Bool
mkTyClGroup :: [LTyClDecl (GhcPass p)] -> [LInstDecl (GhcPass p)] -> TyClGroup (GhcPass p)
tyClGroupRoleDecls :: [TyClGroup pass] -> [LRoleAnnotDecl pass]
tyClGroupInstDecls :: [TyClGroup pass] -> [LInstDecl pass]
tyClGroupTyClDecls :: [TyClGroup pass] -> [LTyClDecl pass]
emptyTyClGroup :: TyClGroup (GhcPass p)
pprTyClDeclFlavour :: TyClDecl (GhcPass p) -> SDoc
hsDeclHasCusk :: TyClDecl GhcRn -> Bool
countTyClDecls :: [TyClDecl pass] -> (Int, Int, Int, Int, Int)
tyClDeclTyVars :: TyClDecl pass -> LHsQTyVars pass
tcdName :: TyClDecl pass -> IdP pass
tyClDeclLName :: TyClDecl pass -> Located (IdP pass)
tyFamInstDeclLName :: TyFamInstDecl pass -> Located (IdP pass)
tyFamInstDeclName :: TyFamInstDecl pass -> IdP pass
isDataFamilyDecl :: TyClDecl pass -> Bool
isClosedTypeFamilyInfo :: FamilyInfo pass -> Bool
isOpenTypeFamilyInfo :: FamilyInfo pass -> Bool
isTypeFamilyDecl :: TyClDecl pass -> Bool
isFamilyDecl :: TyClDecl pass -> Bool
isClassDecl :: TyClDecl pass -> Bool
isSynDecl :: TyClDecl pass -> Bool
isDataDecl :: TyClDecl pass -> Bool
appendGroups :: HsGroup (GhcPass p) -> HsGroup (GhcPass p) -> HsGroup (GhcPass p)
hsGroupInstDecls :: HsGroup id -> [LInstDecl id]
emptyRnGroup :: HsGroup (GhcPass p)
emptyRdrGroup :: HsGroup (GhcPass p)
type LHsDecl p = Located (HsDecl p)
data HsDecl p
- = DefD (XDefD p) (DefaultDecl p)
- | WarningD (XWarningD p) (WarnDecls p)
- | AnnD (XAnnD p) (AnnDecl p)
- | RuleD (XRuleD p) (RuleDecls p)
- | SpliceD (XSpliceD p) (SpliceDecl p)
- | DocD (XDocD p) DocDecl
- | RoleAnnotD (XRoleAnnotD p) (RoleAnnotDecl p)
- | XHsDecl (XXHsDecl p)
data HsGroup p
- = HsGroup {
  - 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)
type LSpliceDecl pass = Located (SpliceDecl pass)
data SpliceDecl p
- = SpliceDecl (XSpliceDecl p) (Located (HsSplice p)) SpliceExplicitFlag
- | XSpliceDecl (XXSpliceDecl p)
type LTyClDecl pass = Located (TyClDecl pass)
data TyClDecl pass
- = FamDecl {
  - tcdFExt :: XFamDecl pass
  - tcdFam :: FamilyDecl pass
  }
- | SynDecl {
  - tcdSExt :: XSynDecl pass
  - tcdLName :: Located (IdP pass)
  - tcdTyVars :: LHsQTyVars pass
  - tcdFixity :: LexicalFixity
  - tcdRhs :: LHsType pass
  }
- | DataDecl {
  - tcdDExt :: XDataDecl pass
  - tcdLName :: Located (IdP pass)
  - tcdTyVars :: LHsQTyVars pass
  - tcdFixity :: LexicalFixity
  - tcdDataDefn :: HsDataDefn pass
  }
- | ClassDecl {
  - tcdCExt :: XClassDecl pass
  - tcdCtxt :: LHsContext pass
  - tcdLName :: Located (IdP pass)
  - tcdTyVars :: LHsQTyVars pass
  - tcdFixity :: LexicalFixity
  - tcdFDs :: [Located (FunDep (Located (IdP pass)))]
  - tcdSigs :: [LSig pass]
  - tcdMeths :: LHsBinds pass
  - tcdATs :: [LFamilyDecl pass]
  - tcdATDefs :: [LTyFamDefltEqn pass]
  - tcdDocs :: [LDocDecl]
  }
- | XTyClDecl (XXTyClDecl pass)
data DataDeclRn = DataDeclRn {
- tcdDataCusk :: Bool
- tcdFVs :: NameSet
}
data TyClGroup pass
- = TyClGroup {
  - group_ext :: XCTyClGroup pass
  - group_tyclds :: [LTyClDecl pass]
  - group_roles :: [LRoleAnnotDecl pass]
  - group_instds :: [LInstDecl pass]
  }
- | XTyClGroup (XXTyClGroup pass)
type LFamilyResultSig pass = Located (FamilyResultSig pass)
data FamilyResultSig pass
- = NoSig (XNoSig pass)
- | KindSig (XCKindSig pass) (LHsKind pass)
- | TyVarSig (XTyVarSig pass) (LHsTyVarBndr pass)
- | XFamilyResultSig (XXFamilyResultSig pass)
type LFamilyDecl pass = Located (FamilyDecl pass)
data FamilyDecl pass
- = FamilyDecl {
  - 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)
type LInjectivityAnn pass = Located (InjectivityAnn pass)
data InjectivityAnn pass = InjectivityAnn (Located (IdP pass)) [Located (IdP pass)]
data FamilyInfo pass
- = DataFamily
- | OpenTypeFamily
- | ClosedTypeFamily (Maybe [LTyFamInstEqn pass])
data HsDataDefn pass
- = HsDataDefn {
  - dd_ext :: XCHsDataDefn pass
  - dd_ND :: NewOrData
  - dd_ctxt :: LHsContext pass
  - dd_cType :: Maybe (Located CType)
  - dd_kindSig :: Maybe (LHsKind pass)
  - dd_cons :: [LConDecl pass]
  - dd_derivs :: HsDeriving pass
  }
- | XHsDataDefn (XXHsDataDefn pass)
type HsDeriving pass = Located [LHsDerivingClause pass]
type LHsDerivingClause pass = Located (HsDerivingClause pass)
data HsDerivingClause pass
- = HsDerivingClause {
  - deriv_clause_ext :: XCHsDerivingClause pass
  - deriv_clause_strategy :: Maybe (LDerivStrategy pass)
  - deriv_clause_tys :: Located [LHsSigType pass]
  }
- | XHsDerivingClause (XXHsDerivingClause pass)
data NewOrData
- = NewType
- | DataType
type LConDecl pass = Located (ConDecl pass)
data ConDecl pass
- = ConDeclGADT {
  - con_g_ext :: XConDeclGADT pass
  - con_names :: [Located (IdP pass)]
  - con_forall :: Located Bool
  - con_qvars :: LHsQTyVars pass
  - con_mb_cxt :: Maybe (LHsContext pass)
  - con_args :: HsConDeclDetails pass
  - con_res_ty :: LHsType pass
  - con_doc :: Maybe LHsDocString
  }
- | ConDeclH98 {
  - con_ext :: XConDeclH98 pass
  - con_name :: Located (IdP pass)
  - con_forall :: Located Bool
  - con_ex_tvs :: [LHsTyVarBndr pass]
  - con_mb_cxt :: Maybe (LHsContext pass)
  - con_args :: HsConDeclDetails pass
  - con_doc :: Maybe LHsDocString
  }
- | XConDecl (XXConDecl pass)
type HsConDeclDetails pass = HsConDetails (LBangType pass) (Located [LConDeclField pass])
type LTyFamInstEqn pass = Located (TyFamInstEqn pass)
type LTyFamDefltEqn pass = Located (TyFamDefltEqn pass)
type HsTyPats pass = [LHsType pass]
type TyFamInstEqn pass = FamInstEqn pass (LHsType pass)
type TyFamDefltEqn pass = FamEqn pass (LHsQTyVars pass) (LHsType pass)
type LTyFamInstDecl pass = Located (TyFamInstDecl pass)
newtype TyFamInstDecl pass = TyFamInstDecl {
- tfid_eqn :: TyFamInstEqn pass
}
type LDataFamInstDecl pass = Located (DataFamInstDecl pass)
newtype DataFamInstDecl pass = DataFamInstDecl {
- dfid_eqn :: FamInstEqn pass (HsDataDefn pass)
}
type LFamInstEqn pass rhs = Located (FamInstEqn pass rhs)
type FamInstEqn pass rhs = HsImplicitBndrs pass (FamEqn pass (HsTyPats pass) rhs)
data FamEqn pass pats rhs
- = FamEqn {
  - feqn_ext :: XCFamEqn pass pats rhs
  - feqn_tycon :: Located (IdP pass)
  - feqn_pats :: pats
  - feqn_fixity :: LexicalFixity
  - feqn_rhs :: rhs
  }
- | XFamEqn (XXFamEqn pass pats rhs)
type LClsInstDecl pass = Located (ClsInstDecl pass)
data ClsInstDecl pass
- = ClsInstDecl {
  - 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)
  }
- | XClsInstDecl (XXClsInstDecl pass)
type LInstDecl pass = Located (InstDecl pass)
data InstDecl pass
- = ClsInstD {
  - cid_d_ext :: XClsInstD pass
  - cid_inst :: ClsInstDecl pass
  }
- | DataFamInstD {
  - dfid_ext :: XDataFamInstD pass
  - dfid_inst :: DataFamInstDecl pass
  }
- | TyFamInstD {
  - tfid_ext :: XTyFamInstD pass
  - tfid_inst :: TyFamInstDecl pass
  }
- | XInstDecl (XXInstDecl pass)
type LDerivDecl pass = Located (DerivDecl pass)
data DerivDecl pass
- = DerivDecl {
  - deriv_ext :: XCDerivDecl pass
  - deriv_type :: LHsSigWcType pass
  - deriv_strategy :: Maybe (LDerivStrategy pass)
  - deriv_overlap_mode :: Maybe (Located OverlapMode)
  }
- | XDerivDecl (XXDerivDecl pass)
type LDerivStrategy pass = Located (DerivStrategy pass)
data DerivStrategy pass
- = StockStrategy
- | AnyclassStrategy
- | NewtypeStrategy
- | ViaStrategy (XViaStrategy pass)
type LDefaultDecl pass = Located (DefaultDecl pass)
data DefaultDecl pass
- = DefaultDecl (XCDefaultDecl pass) [LHsType pass]
- | XDefaultDecl (XXDefaultDecl pass)
type LForeignDecl pass = Located (ForeignDecl pass)
data ForeignDecl pass
- = ForeignImport {
  - fd_i_ext :: XForeignImport pass
  - fd_name :: Located (IdP pass)
  - fd_sig_ty :: LHsSigType pass
  - fd_fi :: ForeignImport
  }
- | ForeignExport {
  - fd_e_ext :: XForeignExport pass
  - fd_name :: Located (IdP pass)
  - fd_sig_ty :: LHsSigType pass
  - fd_fe :: ForeignExport
  }
- | XForeignDecl (XXForeignDecl pass)
data ForeignImport = CImport (Located CCallConv) (Located Safety) (Maybe Header) CImportSpec (Located SourceText)
data CImportSpec
- = CLabel CLabelString
- | CFunction CCallTarget
- | CWrapper
data ForeignExport = CExport (Located CExportSpec) (Located SourceText)
type LRuleDecls pass = Located (RuleDecls pass)
data RuleDecls pass
- = HsRules {
  - rds_ext :: XCRuleDecls pass
  - rds_src :: SourceText
  - rds_rules :: [LRuleDecl pass]
  }
- | XRuleDecls (XXRuleDecls pass)
type LRuleDecl pass = Located (RuleDecl pass)
data RuleDecl pass
- = HsRule (XHsRule pass) (Located (SourceText, RuleName)) Activation [LRuleBndr pass] (Located (HsExpr pass)) (Located (HsExpr pass))
- | XRuleDecl (XXRuleDecl pass)
data HsRuleRn = HsRuleRn NameSet NameSet
type LRuleBndr pass = Located (RuleBndr pass)
data RuleBndr pass
- = RuleBndr (XCRuleBndr pass) (Located (IdP pass))
- | RuleBndrSig (XRuleBndrSig pass) (Located (IdP pass)) (LHsSigWcType pass)
- | XRuleBndr (XXRuleBndr pass)
type LDocDecl = Located DocDecl
data DocDecl
- = DocCommentNext HsDocString
- | DocCommentPrev HsDocString
- | DocCommentNamed String HsDocString
- | DocGroup Int HsDocString
type LWarnDecls pass = Located (WarnDecls pass)
data WarnDecls pass
- = Warnings {
  - wd_ext :: XWarnings pass
  - wd_src :: SourceText
  - wd_warnings :: [LWarnDecl pass]
  }
- | XWarnDecls (XXWarnDecls pass)
type LWarnDecl pass = Located (WarnDecl pass)
data WarnDecl pass
- = Warning (XWarning pass) [Located (IdP pass)] WarningTxt
- | XWarnDecl (XXWarnDecl pass)
type LAnnDecl pass = Located (AnnDecl pass)
data AnnDecl pass
- = HsAnnotation (XHsAnnotation pass) SourceText (AnnProvenance (IdP pass)) (Located (HsExpr pass))
- | XAnnDecl (XXAnnDecl pass)
data AnnProvenance name
- = ValueAnnProvenance (Located name)
- | TypeAnnProvenance (Located name)
- | ModuleAnnProvenance
type LRoleAnnotDecl pass = Located (RoleAnnotDecl pass)
data RoleAnnotDecl pass
- = RoleAnnotDecl (XCRoleAnnotDecl pass) (Located (IdP pass)) [Located (Maybe Role)]
- | XRoleAnnotDecl (XXRoleAnnotDecl pass)
collectEvVarsPat :: Pat GhcTc -> Bag EvVar
collectEvVarsPats :: [Pat GhcTc] -> Bag EvVar
parenthesizePat :: PprPrec -> LPat (GhcPass p) -> LPat (GhcPass p)
patNeedsParens :: PprPrec -> Pat p -> Bool
isIrrefutableHsPat :: OutputableBndrId p => LPat p -> Bool
looksLazyPatBind :: HsBind p -> Bool
isBangedLPat :: LPat p -> Bool
mkCharLitPat :: SourceText -> Char -> OutPat (GhcPass p)
mkNilPat :: Type -> OutPat p
mkPrefixConPat :: DataCon -> [OutPat p] -> [Type] -> OutPat p
pprConArgs :: OutputableBndrId (GhcPass p) => HsConPatDetails (GhcPass p) -> SDoc
pprParendLPat :: OutputableBndrId (GhcPass p) => PprPrec -> LPat (GhcPass p) -> SDoc
hsRecUpdFieldOcc :: HsRecField' (AmbiguousFieldOcc GhcTc) arg -> LFieldOcc GhcTc
hsRecUpdFieldId :: HsRecField' (AmbiguousFieldOcc GhcTc) arg -> Located Id
hsRecUpdFieldRdr :: 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 = ListPatTc Type (Maybe (Type, SyntaxExpr GhcTc))
type HsConPatDetails p = HsConDetails (LPat p) (HsRecFields p (LPat p))
data HsRecFields p arg = HsRecFields {
- rec_flds :: [LHsRecField p arg]
- rec_dotdot :: Maybe Int
}
type LHsRecField' p arg = Located (HsRecField' p arg)
type LHsRecField p arg = Located (HsRecField p arg)
type LHsRecUpdField p = Located (HsRecUpdField p)
type HsRecField p arg = HsRecField' (FieldOcc p) arg
type HsRecUpdField p = HsRecField' (AmbiguousFieldOcc p) (LHsExpr p)
data HsRecField' id arg = HsRecField {
- hsRecFieldLbl :: Located id
- hsRecFieldArg :: arg
- hsRecPun :: Bool
}
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
pragBrackets :: SDoc -> SDoc
ppr_sig :: OutputableBndrId (GhcPass 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 :: HsIPBinds (GhcPass p) -> Bool
pprTicks :: SDoc -> SDoc -> SDoc
ppr_monobind :: (OutputableBndrId (GhcPass idL), OutputableBndrId (GhcPass idR)) => HsBindLR (GhcPass idL) (GhcPass idR) -> SDoc
plusHsValBinds :: HsValBinds (GhcPass a) -> HsValBinds (GhcPass a) -> HsValBinds (GhcPass a)
isEmptyLHsBinds :: LHsBindsLR idL idR -> Bool
emptyLHsBinds :: LHsBindsLR idL idR
emptyValBindsOut :: HsValBindsLR (GhcPass a) (GhcPass b)
emptyValBindsIn :: HsValBindsLR (GhcPass a) (GhcPass b)
isEmptyValBinds :: HsValBindsLR (GhcPass a) (GhcPass b) -> Bool
eqEmptyLocalBinds :: HsLocalBindsLR a b -> Bool
isEmptyLocalBindsPR :: HsLocalBindsLR (GhcPass a) (GhcPass b) -> Bool
isEmptyLocalBindsTc :: HsLocalBindsLR (GhcPass a) GhcTc -> Bool
emptyLocalBinds :: HsLocalBindsLR (GhcPass a) (GhcPass b)
pprDeclList :: [SDoc] -> SDoc
pprLHsBindsForUser :: (OutputableBndrId (GhcPass idL), OutputableBndrId (GhcPass idR), OutputableBndrId (GhcPass id2)) => LHsBindsLR (GhcPass idL) (GhcPass idR) -> [LSig (GhcPass id2)] -> [SDoc]
pprLHsBinds :: (OutputableBndrId (GhcPass idL), OutputableBndrId (GhcPass idR)) => LHsBindsLR (GhcPass idL) (GhcPass idR) -> SDoc
type HsLocalBinds id = HsLocalBindsLR id id
type LHsLocalBinds id = Located (HsLocalBinds id)
data HsLocalBindsLR idL idR
- = HsValBinds (XHsValBinds idL idR) (HsValBindsLR idL idR)
- | HsIPBinds (XHsIPBinds idL idR) (HsIPBinds idR)
- | EmptyLocalBinds (XEmptyLocalBinds idL idR)
- | XHsLocalBindsLR (XXHsLocalBindsLR idL idR)
type LHsLocalBindsLR idL idR = Located (HsLocalBindsLR idL idR)
type HsValBinds id = HsValBindsLR id id
data HsValBindsLR idL idR
- = ValBinds (XValBinds idL idR) (LHsBindsLR idL idR) [LSig idR]
- | XValBindsLR (XXValBindsLR idL idR)
data NHsValBindsLR idL = NValBinds [(RecFlag, LHsBinds idL)] [LSig GhcRn]
type LHsBind id = LHsBindLR id id
type LHsBinds id = LHsBindsLR id id
type HsBind id = HsBindLR id id
type LHsBindsLR idL idR = Bag (LHsBindLR idL idR)
type LHsBindLR idL idR = Located (HsBindLR idL idR)
data HsBindLR idL idR
- = FunBind {
  - fun_ext :: XFunBind idL idR
  - fun_id :: Located (IdP idL)
  - fun_matches :: MatchGroup idR (LHsExpr idR)
  - fun_co_fn :: HsWrapper
  - fun_tick :: [Tickish Id]
  }
- | PatBind {
  - pat_ext :: XPatBind idL idR
  - pat_lhs :: LPat idL
  - pat_rhs :: GRHSs idR (LHsExpr idR)
  - pat_ticks :: ([Tickish Id], [[Tickish Id]])
  }
- | VarBind {
  - var_ext :: XVarBind idL idR
  - var_id :: IdP idL
  - var_rhs :: LHsExpr idR
  - var_inline :: Bool
  }
- | AbsBinds {
  - abs_ext :: XAbsBinds idL idR
  - abs_tvs :: [TyVar]
  - abs_ev_vars :: [EvVar]
  - abs_exports :: [ABExport idL]
  - abs_ev_binds :: [TcEvBinds]
  - abs_binds :: LHsBinds idL
  - abs_sig :: Bool
  }
- | XHsBindsLR (XXHsBindsLR idL idR)
data NPatBindTc = NPatBindTc {
- pat_fvs :: NameSet
- pat_rhs_ty :: Type
}
data ABExport p
- = ABE {
  - abe_ext :: XABE p
  - abe_poly :: IdP p
  - abe_mono :: IdP p
  - abe_wrap :: HsWrapper
  - abe_prags :: TcSpecPrags
  }
- | XABExport (XXABExport p)
pattern XPatSynBind :: XXPatSynBind idL idR -> PatSynBind idL idR
pattern PSB :: XPSB idL idR -> Located (IdP idL) -> HsPatSynDetails (Located (IdP idR)) -> LPat idR -> HsPatSynDir idR -> PatSynBind idL idR
psb_ext :: PatSynBind idL idR -> XPSB idL idR
psb_id :: PatSynBind idL idR -> Located (IdP idL)
psb_args :: PatSynBind idL idR -> HsPatSynDetails (Located (IdP idR))
psb_def :: PatSynBind idL idR -> LPat idR
psb_dir :: PatSynBind idL idR -> HsPatSynDir idR
data HsIPBinds id
- = IPBinds (XIPBinds id) [LIPBind id]
- | XHsIPBinds (XXHsIPBinds id)
type LIPBind id = Located (IPBind id)
data IPBind id
- = IPBind (XCIPBind id) (Either (Located HsIPName) (IdP id)) (LHsExpr id)
- | XIPBind (XXIPBind id)
type LSig pass = Located (Sig pass)
data Sig pass
- = PatSynSig (XPatSynSig pass) [Located (IdP pass)] (LHsSigType pass)
- | IdSig (XIdSig pass) Id
- | FixSig (XFixSig pass) (FixitySig pass)
- | InlineSig (XInlineSig pass) (Located (IdP pass)) InlinePragma
- | SpecSig (XSpecSig pass) (Located (IdP pass)) [LHsSigType pass] InlinePragma
- | SpecInstSig (XSpecInstSig pass) SourceText (LHsSigType pass)
- | MinimalSig (XMinimalSig pass) SourceText (LBooleanFormula (Located (IdP pass)))
- | SCCFunSig (XSCCFunSig pass) SourceText (Located (IdP pass)) (Maybe (Located StringLiteral))
- | CompleteMatchSig (XCompleteMatchSig pass) SourceText (Located [Located (IdP pass)]) (Maybe (Located (IdP pass)))
- | XSig (XXSig pass)
type LFixitySig pass = Located (FixitySig pass)
data FixitySig pass
- = FixitySig (XFixitySig pass) [Located (IdP pass)] Fixity
- | XFixitySig (XXFixitySig pass)
data TcSpecPrags
- = IsDefaultMethod
- | SpecPrags [LTcSpecPrag]
type LTcSpecPrag = Located TcSpecPrag
data TcSpecPrag = SpecPrag Id HsWrapper InlinePragma
type HsPatSynDetails arg = HsConDetails arg [RecordPatSynField arg]
data RecordPatSynField a = RecordPatSynField {
- recordPatSynSelectorId :: a
- recordPatSynPatVar :: a
}
data HsPatSynDir id
- = Unidirectional
- | ImplicitBidirectional
- | ExplicitBidirectional (MatchGroup id (LHsExpr id))
pprInstanceHdr :: ClsInst -> SDoc
pprInstance :: ClsInst -> SDoc
instanceDFunId :: ClsInst -> DFunId
data ClsInst
data FamInst
type BreakIndex = Int
data ModBreaks = ModBreaks {
- modBreaks_flags :: ForeignRef BreakArray
- modBreaks_locs :: !(Array BreakIndex SrcSpan)
- modBreaks_vars :: !(Array BreakIndex [OccName])
- modBreaks_decls :: !(Array BreakIndex [String])
- modBreaks_ccs :: !(Array BreakIndex (RemotePtr CostCentre))
- modBreaks_breakInfo :: IntMap CgBreakInfo
}
parenthesizeHsType :: PprPrec -> LHsType (GhcPass p) -> LHsType (GhcPass p)
hsTypeNeedsParens :: PprPrec -> HsType pass -> Bool
pprHsType :: OutputableBndrId (GhcPass p) => HsType (GhcPass p) -> SDoc
pprConDeclFields :: OutputableBndrId (GhcPass p) => [LConDeclField (GhcPass p)] -> SDoc
pprHsContextMaybe :: OutputableBndrId (GhcPass p) => HsContext (GhcPass p) -> Maybe SDoc
pprHsContextNoArrow :: OutputableBndrId (GhcPass p) => HsContext (GhcPass p) -> SDoc
pprHsContext :: OutputableBndrId (GhcPass p) => HsContext (GhcPass p) -> SDoc
pprHsForAllTvs :: OutputableBndrId (GhcPass p) => [LHsTyVarBndr (GhcPass p)] -> SDoc
pprHsForAllExtra :: OutputableBndrId (GhcPass p) => Maybe SrcSpan -> [LHsTyVarBndr (GhcPass p)] -> LHsContext (GhcPass p) -> SDoc
pprHsForAll :: OutputableBndrId (GhcPass p) => [LHsTyVarBndr (GhcPass p)] -> LHsContext (GhcPass p) -> SDoc
pprAnonWildCard :: SDoc
ambiguousFieldOcc :: FieldOcc GhcTc -> AmbiguousFieldOcc GhcTc
unambiguousFieldOcc :: AmbiguousFieldOcc GhcTc -> FieldOcc GhcTc
selectorAmbiguousFieldOcc :: AmbiguousFieldOcc GhcTc -> Id
rdrNameAmbiguousFieldOcc :: AmbiguousFieldOcc (GhcPass p) -> RdrName
mkAmbiguousFieldOcc :: Located RdrName -> AmbiguousFieldOcc GhcPs
mkFieldOcc :: Located RdrName -> FieldOcc GhcPs
getLHsInstDeclClass_maybe :: LHsSigType (GhcPass p) -> Maybe (Located (IdP (GhcPass p)))
getLHsInstDeclHead :: LHsSigType pass -> LHsType pass
splitLHsInstDeclTy :: LHsSigType GhcRn -> ([Name], LHsContext GhcRn, LHsType GhcRn)
splitLHsQualTy :: LHsType pass -> (LHsContext pass, LHsType pass)
splitLHsForAllTy :: LHsType pass -> ([LHsTyVarBndr pass], LHsType pass)
splitLHsSigmaTy :: LHsType pass -> ([LHsTyVarBndr pass], LHsContext pass, LHsType pass)
splitLHsPatSynTy :: LHsType pass -> ([LHsTyVarBndr pass], LHsContext pass, [LHsTyVarBndr pass], LHsContext pass, LHsType pass)
splitHsAppTys :: LHsType GhcRn -> [LHsType GhcRn] -> (LHsType GhcRn, [LHsType GhcRn])
hsTyGetAppHead_maybe :: LHsType (GhcPass p) -> Maybe (Located (IdP (GhcPass p)), [LHsType (GhcPass p)])
splitHsFunType :: LHsType GhcRn -> ([LHsType GhcRn], LHsType GhcRn)
mkHsAppTys :: LHsType (GhcPass p) -> [LHsType (GhcPass p)] -> LHsType (GhcPass p)
mkHsAppTy :: LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p)
mkHsOpTy :: 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
sameWildCard :: Located HsWildCardInfo -> Located HsWildCardInfo -> Bool
wildCardName :: HsWildCardInfo -> Name
hsLTyVarBndrsToTypes :: LHsQTyVars (GhcPass p) -> [LHsType (GhcPass p)]
hsLTyVarBndrToType :: LHsTyVarBndr (GhcPass p) -> LHsType (GhcPass p)
hsLTyVarLocNames :: LHsQTyVars pass -> [Located (IdP pass)]
hsLTyVarLocName :: LHsTyVarBndr pass -> Located (IdP pass)
hsAllLTyVarNames :: LHsQTyVars GhcRn -> [Name]
hsExplicitLTyVarNames :: LHsQTyVars pass -> [IdP pass]
hsLTyVarName :: LHsTyVarBndr pass -> IdP pass
hsTyVarName :: HsTyVarBndr pass -> IdP pass
hsScopedTvs :: LHsSigType GhcRn -> [Name]
hsWcScopedTvs :: LHsSigWcType GhcRn -> [Name]
hsTvbAllKinded :: LHsQTyVars pass -> Bool
isHsKindedTyVar :: HsTyVarBndr pass -> Bool
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 :: LHsSigType pass -> LHsType pass
hsImplicitBody :: HsImplicitBndrs pass thing -> thing
isEmptyLHsQTvs :: LHsQTyVars GhcRn -> Bool
emptyLHsQTvs :: LHsQTyVars GhcRn
hsQTvExplicit :: LHsQTyVars pass -> [LHsTyVarBndr pass]
mkHsQTvs :: [LHsTyVarBndr GhcPs] -> LHsQTyVars GhcPs
getBangStrictness :: LHsType a -> HsSrcBang
getBangType :: LHsType a -> LHsType a
type LBangType pass = Located (BangType pass)
type BangType pass = HsType pass
type LHsContext pass = Located (HsContext pass)
type HsContext pass = [LHsType pass]
type LHsType pass = Located (HsType pass)
type HsKind pass = HsType pass
type LHsKind pass = Located (HsKind pass)
type LHsTyVarBndr pass = Located (HsTyVarBndr pass)
data LHsQTyVars pass
- = HsQTvs {
  - hsq_ext :: XHsQTvs pass
  - hsq_explicit :: [LHsTyVarBndr pass]
  }
- | XLHsQTyVars (XXLHsQTyVars pass)
data HsQTvsRn = HsQTvsRn {
- hsq_implicit :: [Name]
- hsq_dependent :: NameSet
}
data HsImplicitBndrs pass thing
- = HsIB {
  - hsib_ext :: XHsIB pass thing
  - hsib_body :: thing
  }
- | XHsImplicitBndrs (XXHsImplicitBndrs pass thing)
data HsIBRn = HsIBRn {
- hsib_vars :: [Name]
- hsib_closed :: Bool
}
data HsWildCardBndrs pass thing
- = HsWC {
  - hswc_ext :: XHsWC pass thing
  - hswc_body :: thing
  }
- | XHsWildCardBndrs (XXHsWildCardBndrs pass thing)
type LHsSigType pass = HsImplicitBndrs pass (LHsType pass)
type LHsWcType pass = HsWildCardBndrs pass (LHsType pass)
type LHsSigWcType pass = HsWildCardBndrs pass (LHsSigType pass)
newtype HsIPName = HsIPName FastString
data HsTyVarBndr pass
- = UserTyVar (XUserTyVar pass) (Located (IdP pass))
- | KindedTyVar (XKindedTyVar pass) (Located (IdP pass)) (LHsKind pass)
- | XTyVarBndr (XXTyVarBndr pass)
data HsType pass
- = HsForAllTy {
  - hst_xforall :: XForAllTy pass
  - hst_bndrs :: [LHsTyVarBndr pass]
  - hst_body :: LHsType pass
  }
- | HsQualTy {
  - hst_xqual :: XQualTy pass
  - hst_ctxt :: LHsContext pass
  - hst_body :: LHsType pass
  }
- | HsTyVar (XTyVar pass) Promoted (Located (IdP pass))
- | HsAppTy (XAppTy pass) (LHsType pass) (LHsType pass)
- | HsFunTy (XFunTy pass) (LHsType pass) (LHsType pass)
- | HsListTy (XListTy pass) (LHsType pass)
- | HsTupleTy (XTupleTy pass) HsTupleSort [LHsType pass]
- | HsSumTy (XSumTy pass) [LHsType pass]
- | HsOpTy (XOpTy pass) (LHsType pass) (Located (IdP pass)) (LHsType pass)
- | HsParTy (XParTy pass) (LHsType pass)
- | HsIParamTy (XIParamTy pass) (Located HsIPName) (LHsType pass)
- | HsStarTy (XStarTy pass) Bool
- | HsKindSig (XKindSig pass) (LHsType pass) (LHsKind pass)
- | HsSpliceTy (XSpliceTy pass) (HsSplice pass)
- | HsDocTy (XDocTy pass) (LHsType pass) LHsDocString
- | HsBangTy (XBangTy pass) HsSrcBang (LHsType pass)
- | HsRecTy (XRecTy pass) [LConDeclField pass]
- | HsExplicitListTy (XExplicitListTy pass) Promoted [LHsType pass]
- | HsExplicitTupleTy (XExplicitTupleTy pass) [LHsType pass]
- | HsTyLit (XTyLit pass) HsTyLit
- | HsWildCardTy (XWildCardTy pass)
- | XHsType (XXType pass)
data NewHsTypeX = NHsCoreTy Type
data HsTyLit
- = HsNumTy SourceText Integer
- | HsStrTy SourceText FastString
newtype HsWildCardInfo = AnonWildCard (Located Name)
data HsTupleSort
- = HsUnboxedTuple
- | HsBoxedTuple
- | HsConstraintTuple
- | HsBoxedOrConstraintTuple
data Promoted
- = Promoted
- | NotPromoted
type LConDeclField pass = Located (ConDeclField pass)
data ConDeclField pass
- = ConDeclField {
  - cd_fld_ext :: XConDeclField pass
  - cd_fld_names :: [LFieldOcc pass]
  - cd_fld_type :: LBangType pass
  - cd_fld_doc :: Maybe LHsDocString
  }
- | XConDeclField (XXConDeclField pass)
data HsConDetails arg rec
- = PrefixCon [arg]
- | RecCon rec
- | InfixCon arg arg
type LFieldOcc pass = Located (FieldOcc pass)
data FieldOcc pass
- = FieldOcc {
  - extFieldOcc :: XCFieldOcc pass
  - rdrNameFieldOcc :: Located RdrName
  }
- | XFieldOcc (XXFieldOcc pass)
data AmbiguousFieldOcc pass
- = Unambiguous (XUnambiguous pass) (Located RdrName)
- | Ambiguous (XAmbiguous pass) (Located RdrName)
- | XAmbiguousFieldOcc (XXAmbiguousFieldOcc pass)
data ExecOptions = ExecOptions {
- execSingleStep :: SingleStep
- execSourceFile :: String
- execLineNumber :: Int
- execWrap :: ForeignHValue -> EvalExpr ForeignHValue
}
data SingleStep
- = RunToCompletion
- | SingleStep
- | RunAndLogSteps
data ExecResult
- = ExecComplete {
  - execResult :: Either SomeException [Name]
  - execAllocation :: Word64
  }
- | ExecBreak {
  - breakNames :: [Name]
  - breakInfo :: Maybe BreakInfo
  }
data BreakInfo
data Resume = Resume {
- resumeStmt :: String
- resumeContext :: ForeignRef (ResumeContext [HValueRef])
- resumeBindings :: ([TyThing], GlobalRdrEnv)
- resumeFinalIds :: [Id]
- resumeApStack :: ForeignHValue
- resumeBreakInfo :: Maybe BreakInfo
- resumeSpan :: SrcSpan
- resumeDecl :: String
- resumeCCS :: RemotePtr CostCentreStack
- resumeHistory :: [History]
- resumeHistoryIx :: Int
}
data History
isBottomingId :: Var -> Bool
isDeadBinder :: Id -> Bool
isImplicitId :: Id -> Bool
idDataCon :: Id -> DataCon
isDataConWorkId :: Id -> Bool
isFCallId :: Id -> Bool
isPrimOpId :: Id -> Bool
isClassOpId_maybe :: Id -> Maybe Class
isRecordSelector :: Id -> Bool
recordSelectorTyCon :: Id -> RecSelParent
idType :: Id -> Kind
isVanillaDataCon :: DataCon -> Bool
dataConUserType :: DataCon -> Type
dataConSig :: DataCon -> ([TyVar], ThetaType, [Type], Type)
dataConSrcBangs :: DataCon -> [HsSrcBang]
dataConIsInfix :: DataCon -> Bool
isMarkedStrict :: StrictnessMark -> Bool
data HsSrcBang = HsSrcBang SourceText SrcUnpackedness SrcStrictness
data HsImplBang
- = HsLazy
- | HsStrict
- | HsUnpack (Maybe Coercion)
data SrcStrictness
- = SrcLazy
- | SrcStrict
- | NoSrcStrict
data SrcUnpackedness
- = SrcUnpack
- | SrcNoUnpack
- | NoSrcUnpack
data StrictnessMark
- = MarkedStrict
- | NotMarkedStrict
hsOverLitNeedsParens :: PprPrec -> HsOverLit x -> Bool
hsLitNeedsParens :: PprPrec -> HsLit x -> Bool
pmPprHsLit :: HsLit (GhcPass x) -> SDoc
pp_st_suffix :: SourceText -> SDoc -> SDoc -> SDoc
convertLit :: ConvertIdX a b => HsLit a -> HsLit b
overLitType :: HsOverLit GhcTc -> Type
negateOverLitVal :: OverLitVal -> OverLitVal
data HsLit x
- = HsChar (XHsChar x) Char
- | HsCharPrim (XHsCharPrim x) Char
- | HsString (XHsString x) FastString
- | HsStringPrim (XHsStringPrim x) ByteString
- | HsInt (XHsInt x) IntegralLit
- | HsIntPrim (XHsIntPrim x) Integer
- | HsWordPrim (XHsWordPrim x) Integer
- | HsInt64Prim (XHsInt64Prim x) Integer
- | HsWord64Prim (XHsWord64Prim x) Integer
- | HsInteger (XHsInteger x) Integer Type
- | HsRat (XHsRat x) FractionalLit Type
- | HsFloatPrim (XHsFloatPrim x) FractionalLit
- | HsDoublePrim (XHsDoublePrim x) FractionalLit
- | XLit (XXLit x)
data HsOverLit p
- = OverLit {
  - ol_ext :: XOverLit p
  - ol_val :: OverLitVal
  - ol_witness :: HsExpr p
  }
- | XOverLit (XXOverLit p)
data OverLitTc = OverLitTc {
- ol_rebindable :: Bool
- ol_type :: Type
}
data OverLitVal
- = HsIntegral !IntegralLit
- | HsFractional !FractionalLit
- | HsIsString !SourceText !FastString
splitForAllTys :: Type -> ([TyVar], Type)
funResultTy :: Type -> Type
alphaTyVars :: [TyVar]
pprTypeApp :: TyCon -> [Type] -> SDoc
pprForAll :: [TyVarBinder] -> SDoc
pprThetaArrowTy :: ThetaType -> SDoc
pprParendType :: Type -> SDoc
tyConClass_maybe :: TyCon -> Maybe Class
isClassTyCon :: TyCon -> Bool
synTyConRhs_maybe :: TyCon -> Maybe Type
synTyConDefn_maybe :: TyCon -> Maybe ([TyVar], Type)
tyConDataCons :: TyCon -> [DataCon]
isOpenTypeFamilyTyCon :: TyCon -> Bool
isTypeFamilyTyCon :: TyCon -> Bool
isOpenFamilyTyCon :: TyCon -> Bool
isFamilyTyCon :: TyCon -> Bool
isTypeSynonymTyCon :: TyCon -> Bool
isNewTyCon :: TyCon -> Bool
isPrimTyCon :: TyCon -> Bool
pprFundeps :: Outputable a => [FunDep a] -> SDoc
classTvsFds :: Class -> ([TyVar], [FunDep TyVar])
classSCTheta :: Class -> [PredType]
classATs :: Class -> [TyCon]
classMethods :: Class -> [Id]
data Class
dataConTyCon :: DataCon -> TyCon
dataConFieldLabels :: DataCon -> [FieldLabel]
data DataCon
pprLExpr :: OutputableBndrId (GhcPass p) => LHsExpr (GhcPass p) -> SDoc
pprExpr :: OutputableBndrId (GhcPass p) => HsExpr (GhcPass p) -> SDoc
pprSplice :: OutputableBndrId (GhcPass p) => HsSplice (GhcPass p) -> SDoc
pprSpliceDecl :: OutputableBndrId (GhcPass p) => HsSplice (GhcPass p) -> SpliceExplicitFlag -> SDoc
pprPatBind :: (OutputableBndrId (GhcPass bndr), OutputableBndrId (GhcPass p), Outputable body) => LPat (GhcPass bndr) -> GRHSs (GhcPass p) body -> SDoc
pprFunBind :: (OutputableBndrId (GhcPass idR), Outputable body) => MatchGroup (GhcPass idR) body -> SDoc
data HsExpr p
- = HsVar (XVar p) (Located (IdP p))
- | HsUnboundVar (XUnboundVar p) UnboundVar
- | HsConLikeOut (XConLikeOut p) ConLike
- | HsRecFld (XRecFld p) (AmbiguousFieldOcc p)
- | HsOverLabel (XOverLabel p) (Maybe (IdP p)) FastString
- | HsIPVar (XIPVar p) HsIPName
- | HsOverLit (XOverLitE p) (HsOverLit p)
- | HsLit (XLitE p) (HsLit p)
- | HsLam (XLam p) (MatchGroup p (LHsExpr p))
- | HsLamCase (XLamCase p) (MatchGroup p (LHsExpr p))
- | HsApp (XApp p) (LHsExpr p) (LHsExpr p)
- | HsAppType (XAppTypeE p) (LHsExpr p)
- | OpApp (XOpApp p) (LHsExpr p) (LHsExpr p) (LHsExpr p)
- | NegApp (XNegApp p) (LHsExpr p) (SyntaxExpr p)
- | HsPar (XPar p) (LHsExpr p)
- | SectionL (XSectionL p) (LHsExpr p) (LHsExpr p)
- | SectionR (XSectionR p) (LHsExpr p) (LHsExpr p)
- | ExplicitTuple (XExplicitTuple p) [LHsTupArg p] Boxity
- | ExplicitSum (XExplicitSum p) ConTag Arity (LHsExpr p)
- | HsCase (XCase p) (LHsExpr p) (MatchGroup p (LHsExpr p))
- | HsIf (XIf p) (Maybe (SyntaxExpr p)) (LHsExpr p) (LHsExpr p) (LHsExpr p)
- | HsMultiIf (XMultiIf p) [LGRHS p (LHsExpr p)]
- | HsLet (XLet p) (LHsLocalBinds p) (LHsExpr p)
- | HsDo (XDo p) (HsStmtContext Name) (Located [ExprLStmt p])
- | ExplicitList (XExplicitList p) (Maybe (SyntaxExpr p)) [LHsExpr p]
- | RecordCon {
  - rcon_ext :: XRecordCon p
  - rcon_con_name :: Located (IdP p)
  - rcon_flds :: HsRecordBinds p
  }
- | RecordUpd {
  - rupd_ext :: XRecordUpd p
  - rupd_expr :: LHsExpr p
  - rupd_flds :: [LHsRecUpdField p]
  }
- | ExprWithTySig (XExprWithTySig p) (LHsExpr p)
- | ArithSeq (XArithSeq p) (Maybe (SyntaxExpr p)) (ArithSeqInfo p)
- | HsSCC (XSCC p) SourceText StringLiteral (LHsExpr p)
- | HsCoreAnn (XCoreAnn p) SourceText StringLiteral (LHsExpr p)
- | HsBracket (XBracket p) (HsBracket p)
- | HsRnBracketOut (XRnBracketOut p) (HsBracket GhcRn) [PendingRnSplice]
- | HsTcBracketOut (XTcBracketOut p) (HsBracket GhcRn) [PendingTcSplice]
- | HsSpliceE (XSpliceE p) (HsSplice p)
- | HsProc (XProc p) (LPat p) (LHsCmdTop p)
- | HsStatic (XStatic p) (LHsExpr p)
- | HsArrApp (XArrApp p) (LHsExpr p) (LHsExpr p) HsArrAppType Bool
- | HsArrForm (XArrForm p) (LHsExpr p) (Maybe Fixity) [LHsCmdTop p]
- | 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)
- | EWildPat (XEWildPat p)
- | EAsPat (XEAsPat p) (Located (IdP p)) (LHsExpr p)
- | EViewPat (XEViewPat p) (LHsExpr p) (LHsExpr p)
- | ELazyPat (XELazyPat p) (LHsExpr p)
- | HsWrap (XWrap p) HsWrapper (HsExpr p)
- | XExpr (XXExpr p)
data HsCmd id
- = HsCmdArrApp (XCmdArrApp id) (LHsExpr id) (LHsExpr id) HsArrAppType Bool
- | HsCmdArrForm (XCmdArrForm id) (LHsExpr id) LexicalFixity (Maybe Fixity) [LHsCmdTop id]
- | HsCmdApp (XCmdApp id) (LHsCmd id) (LHsExpr id)
- | HsCmdLam (XCmdLam id) (MatchGroup id (LHsCmd id))
- | HsCmdPar (XCmdPar id) (LHsCmd id)
- | HsCmdCase (XCmdCase id) (LHsExpr id) (MatchGroup id (LHsCmd id))
- | HsCmdIf (XCmdIf id) (Maybe (SyntaxExpr id)) (LHsExpr id) (LHsCmd id) (LHsCmd id)
- | HsCmdLet (XCmdLet id) (LHsLocalBinds id) (LHsCmd id)
- | HsCmdDo (XCmdDo id) (Located [CmdLStmt id])
- | HsCmdWrap (XCmdWrap id) HsWrapper (HsCmd id)
- | XCmd (XXCmd id)
data HsSplice id
- = 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)
- | XSplice (XXSplice id)
data MatchGroup p body
- = MG {
  - mg_ext :: XMG p body
  - mg_alts :: Located [LMatch p body]
  - mg_origin :: Origin
  }
- | XMatchGroup (XXMatchGroup p body)
data GRHSs p body
- = GRHSs {
  - grhssExt :: XCGRHSs p body
  - grhssGRHSs :: [LGRHS p body]
  - grhssLocalBinds :: LHsLocalBinds p
  }
- | XGRHSs (XXGRHSs p body)
data SyntaxExpr p = SyntaxExpr {
- syn_expr :: HsExpr p
- syn_arg_wraps :: [HsWrapper]
- syn_res_wrap :: HsWrapper
}
type LHsExpr p = Located (HsExpr p)
pprImpExp :: (HasOccName name, OutputableBndr name) => name -> SDoc
replaceLWrappedName :: LIEWrappedName name1 -> name2 -> LIEWrappedName name2
replaceWrappedName :: IEWrappedName name1 -> name2 -> IEWrappedName name2
ieLWrappedName :: LIEWrappedName name -> Located name
ieWrappedName :: IEWrappedName name -> name
ieNames :: IE pass -> [IdP pass]
ieName :: IE pass -> IdP pass
simpleImportDecl :: ModuleName -> ImportDecl (GhcPass p)
type LImportDecl pass = Located (ImportDecl pass)
data ImportDecl pass
- = ImportDecl {
  - ideclExt :: XCImportDecl pass
  - ideclSourceSrc :: SourceText
  - ideclName :: Located ModuleName
  - ideclPkgQual :: Maybe StringLiteral
  - ideclSource :: Bool
  - ideclSafe :: Bool
  - ideclQualified :: Bool
  - ideclImplicit :: Bool
  - ideclAs :: Maybe (Located ModuleName)
  - ideclHiding :: Maybe (Bool, Located [LIE pass])
  }
- | XImportDecl (XXImportDecl pass)
data IEWrappedName name
- = IEName (Located name)
- | IEPattern (Located name)
- | IEType (Located name)
type LIEWrappedName name = Located (IEWrappedName name)
type LIE pass = Located (IE pass)
data IE pass
- = IEVar (XIEVar pass) (LIEWrappedName (IdP pass))
- | IEThingAbs (XIEThingAbs pass) (LIEWrappedName (IdP pass))
- | IEModuleContents (XIEModuleContents pass) (Located ModuleName)
- | IEGroup (XIEGroup pass) Int HsDocString
- | IEDoc (XIEDoc pass) HsDocString
- | IEDocNamed (XIEDocNamed pass) String
- | XIE (XXIE pass)
data IEWildcard
- = NoIEWildcard
- | IEWildcard Int
data Pat p
- = WildPat (XWildPat p)
- | LazyPat (XLazyPat p) (LPat p)
- | AsPat (XAsPat p) (Located (IdP p)) (LPat p)
- | ParPat (XParPat p) (LPat p)
- | BangPat (XBangPat p) (LPat p)
- | ListPat (XListPat p) [LPat p]
- | TuplePat (XTuplePat p) [LPat p] Boxity
- | SumPat (XSumPat p) (LPat p) ConTag Arity
- | ConPatIn (Located (IdP p)) (HsConPatDetails p)
- | ConPatOut {
  - 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)
- | SplicePat (XSplicePat p) (HsSplice p)
- | LitPat (XLitPat p) (HsLit p)
- | NPat (XNPat p) (Located (HsOverLit p)) (Maybe (SyntaxExpr p)) (SyntaxExpr p)
- | NPlusKPat (XNPlusKPat p) (Located (IdP p)) (Located (HsOverLit p)) (HsOverLit p) (SyntaxExpr p) (SyntaxExpr p)
- | SigPat (XSigPat p) (LPat p)
- | CoPat (XCoPat p) HsWrapper (Pat p) Type
- | XPat (XXPat p)
type LPat p = Located (Pat p)
noExt :: NoExt
data NoExt = NoExt
data GhcPass (c :: Pass)
data Pass
- = Parsed
- | Renamed
- | Typechecked
type GhcPs = GhcPass Parsed
type GhcRn = GhcPass Renamed
type GhcTc = GhcPass Typechecked
type GhcTcId = GhcTc
type family IdP p :: Type
type LIdP p = Located (IdP p)
type family XHsValBinds x x' :: Type
type family XHsIPBinds x x' :: Type
type family XEmptyLocalBinds x x' :: Type
type family XXHsLocalBindsLR x x' :: Type
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' :: Type
type family XXValBindsLR x x' :: Type
type ForallXValBindsLR (c :: Type -> Constraint) x x' = (c (XValBinds x x'), c (XXValBindsLR x x'))
type family XFunBind x x' :: Type
type family XPatBind x x' :: Type
type family XVarBind x x' :: Type
type family XAbsBinds x x' :: Type
type family XPatSynBind x x' :: Type
type family XXHsBindsLR x x' :: Type
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 :: Type
type family XXABExport x :: Type
type ForallXABExport (c :: Type -> Constraint) x = (c (XABE x), c (XXABExport x))
type family XPSB x x' :: Type
type family XXPatSynBind x x' :: Type
type ForallXPatSynBind (c :: Type -> Constraint) x x' = (c (XPSB x x'), c (XXPatSynBind x x'))
type family XIPBinds x :: Type
type family XXHsIPBinds x :: Type
type ForallXHsIPBinds (c :: Type -> Constraint) x = (c (XIPBinds x), c (XXHsIPBinds x))
type family XCIPBind x :: Type
type family XXIPBind x :: Type
type ForallXIPBind (c :: Type -> Constraint) x = (c (XCIPBind x), c (XXIPBind x))
type family XTypeSig x :: Type
type family XPatSynSig x :: Type
type family XClassOpSig x :: Type
type family XIdSig x :: Type
type family XFixSig x :: Type
type family XInlineSig x :: Type
type family XSpecSig x :: Type
type family XSpecInstSig x :: Type
type family XMinimalSig x :: Type
type family XSCCFunSig x :: Type
type family XCompleteMatchSig x :: Type
type family XXSig x :: Type
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 :: Type
type family XXFixitySig x :: Type
type ForallXFixitySig (c :: Type -> Constraint) x = (c (XFixitySig x), c (XXFixitySig x))
type family XTyClD x :: Type
type family XInstD x :: Type
type family XDerivD x :: Type
type family XValD x :: Type
type family XSigD x :: Type
type family XDefD x :: Type
type family XForD x :: Type
type family XWarningD x :: Type
type family XAnnD x :: Type
type family XRuleD x :: Type
type family XSpliceD x :: Type
type family XDocD x :: Type
type family XRoleAnnotD x :: Type
type family XXHsDecl x :: Type
type ForallXHsDecl (c :: Type -> Constraint) x = (c (XTyClD x), c (XInstD x), c (XDerivD x), c (XValD x), c (XSigD 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 :: Type
type family XXHsGroup x :: Type
type ForallXHsGroup (c :: Type -> Constraint) x = (c (XCHsGroup x), c (XXHsGroup x))
type family XSpliceDecl x :: Type
type family XXSpliceDecl x :: Type
type ForallXSpliceDecl (c :: Type -> Constraint) x = (c (XSpliceDecl x), c (XXSpliceDecl x))
type family XFamDecl x :: Type
type family XSynDecl x :: Type
type family XDataDecl x :: Type
type family XClassDecl x :: Type
type family XXTyClDecl x :: Type
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 :: Type
type family XXTyClGroup x :: Type
type ForallXTyClGroup (c :: Type -> Constraint) x = (c (XCTyClGroup x), c (XXTyClGroup x))
type family XNoSig x :: Type
type family XCKindSig x :: Type
type family XTyVarSig x :: Type
type family XXFamilyResultSig x :: Type
type ForallXFamilyResultSig (c :: Type -> Constraint) x = (c (XNoSig x), c (XCKindSig x), c (XTyVarSig x), c (XXFamilyResultSig x))
type family XCFamilyDecl x :: Type
type family XXFamilyDecl x :: Type
type ForallXFamilyDecl (c :: Type -> Constraint) x = (c (XCFamilyDecl x), c (XXFamilyDecl x))
type family XCHsDataDefn x :: Type
type family XXHsDataDefn x :: Type
type ForallXHsDataDefn (c :: Type -> Constraint) x = (c (XCHsDataDefn x), c (XXHsDataDefn x))
type family XCHsDerivingClause x :: Type
type family XXHsDerivingClause x :: Type
type ForallXHsDerivingClause (c :: Type -> Constraint) x = (c (XCHsDerivingClause x), c (XXHsDerivingClause x))
type family XConDeclGADT x :: Type
type family XConDeclH98 x :: Type
type family XXConDecl x :: Type
type ForallXConDecl (c :: Type -> Constraint) x = (c (XConDeclGADT x), c (XConDeclH98 x), c (XXConDecl x))
type family XCFamEqn x p r :: Type
type family XXFamEqn x p r :: Type
type ForallXFamEqn (c :: Type -> Constraint) x p r = (c (XCFamEqn x p r), c (XXFamEqn x p r))
type family XCClsInstDecl x :: Type
type family XXClsInstDecl x :: Type
type ForallXClsInstDecl (c :: Type -> Constraint) x = (c (XCClsInstDecl x), c (XXClsInstDecl x))
type family XClsInstD x :: Type
type family XDataFamInstD x :: Type
type family XTyFamInstD x :: Type
type family XXInstDecl x :: Type
type ForallXInstDecl (c :: Type -> Constraint) x = (c (XClsInstD x), c (XDataFamInstD x), c (XTyFamInstD x), c (XXInstDecl x))
type family XCDerivDecl x :: Type
type family XXDerivDecl x :: Type
type ForallXDerivDecl (c :: Type -> Constraint) x = (c (XCDerivDecl x), c (XXDerivDecl x))
type family XViaStrategy x :: Type
type family XCDefaultDecl x :: Type
type family XXDefaultDecl x :: Type
type ForallXDefaultDecl (c :: Type -> Constraint) x = (c (XCDefaultDecl x), c (XXDefaultDecl x))
type family XForeignImport x :: Type
type family XForeignExport x :: Type
type family XXForeignDecl x :: Type
type ForallXForeignDecl (c :: Type -> Constraint) x = (c (XForeignImport x), c (XForeignExport x), c (XXForeignDecl x))
type family XCRuleDecls x :: Type
type family XXRuleDecls x :: Type
type ForallXRuleDecls (c :: Type -> Constraint) x = (c (XCRuleDecls x), c (XXRuleDecls x))
type family XHsRule x :: Type
type family XXRuleDecl x :: Type
type ForallXRuleDecl (c :: Type -> Constraint) x = (c (XHsRule x), c (XXRuleDecl x))
type family XCRuleBndr x :: Type
type family XRuleBndrSig x :: Type
type family XXRuleBndr x :: Type
type ForallXRuleBndr (c :: Type -> Constraint) x = (c (XCRuleBndr x), c (XRuleBndrSig x), c (XXRuleBndr x))
type family XWarnings x :: Type
type family XXWarnDecls x :: Type
type ForallXWarnDecls (c :: Type -> Constraint) x = (c (XWarnings x), c (XXWarnDecls x))
type family XWarning x :: Type
type family XXWarnDecl x :: Type
type ForallXWarnDecl (c :: Type -> Constraint) x = (c (XWarning x), c (XXWarnDecl x))
type family XHsAnnotation x :: Type
type family XXAnnDecl x :: Type
type ForallXAnnDecl (c :: Type -> Constraint) x = (c (XHsAnnotation x), c (XXAnnDecl x))
type family XCRoleAnnotDecl x :: Type
type family XXRoleAnnotDecl x :: Type
type ForallXRoleAnnotDecl (c :: Type -> Constraint) x = (c (XCRoleAnnotDecl x), c (XXRoleAnnotDecl x))
type family XVar x :: Type
type family XUnboundVar x :: Type
type family XConLikeOut x :: Type
type family XRecFld x :: Type
type family XOverLabel x :: Type
type family XIPVar x :: Type
type family XOverLitE x :: Type
type family XLitE x :: Type
type family XLam x :: Type
type family XLamCase x :: Type
type family XApp x :: Type
type family XAppTypeE x :: Type
type family XOpApp x :: Type
type family XNegApp x :: Type
type family XPar x :: Type
type family XSectionL x :: Type
type family XSectionR x :: Type
type family XExplicitTuple x :: Type
type family XExplicitSum x :: Type
type family XCase x :: Type
type family XIf x :: Type
type family XMultiIf x :: Type
type family XLet x :: Type
type family XDo x :: Type
type family XExplicitList x :: Type
type family XRecordCon x :: Type
type family XRecordUpd x :: Type
type family XExprWithTySig x :: Type
type family XArithSeq x :: Type
type family XSCC x :: Type
type family XCoreAnn x :: Type
type family XBracket x :: Type
type family XRnBracketOut x :: Type
type family XTcBracketOut x :: Type
type family XSpliceE x :: Type
type family XProc x :: Type
type family XStatic x :: Type
type family XArrApp x :: Type
type family XArrForm x :: Type
type family XTick x :: Type
type family XBinTick x :: Type
type family XTickPragma x :: Type
type family XEWildPat x :: Type
type family XEAsPat x :: Type
type family XEViewPat x :: Type
type family XELazyPat x :: Type
type family XWrap x :: Type
type family XXExpr x :: Type
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 (XArrApp x), c (XArrForm x), c (XTick x), c (XBinTick x), c (XTickPragma x), c (XEWildPat x), c (XEAsPat x), c (XEViewPat x), c (XELazyPat x), c (XWrap x), c (XXExpr x))
type family XUnambiguous x :: Type
type family XAmbiguous x :: Type
type family XXAmbiguousFieldOcc x :: Type
type ForallXAmbiguousFieldOcc (c :: Type -> Constraint) x = (c (XUnambiguous x), c (XAmbiguous x), c (XXAmbiguousFieldOcc x))
type family XPresent x :: Type
type family XMissing x :: Type
type family XXTupArg x :: Type
type ForallXTupArg (c :: Type -> Constraint) x = (c (XPresent x), c (XMissing x), c (XXTupArg x))
type family XTypedSplice x :: Type
type family XUntypedSplice x :: Type
type family XQuasiQuote x :: Type
type family XSpliced x :: Type
type family XXSplice x :: Type
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 :: Type
type family XPatBr x :: Type
type family XDecBrL x :: Type
type family XDecBrG x :: Type
type family XTypBr x :: Type
type family XVarBr x :: Type
type family XTExpBr x :: Type
type family XXBracket x :: Type
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 :: Type
type family XXCmdTop x :: Type
type ForallXCmdTop (c :: Type -> Constraint) x = (c (XCmdTop x), c (XXCmdTop x))
type family XMG x b :: Type
type family XXMatchGroup x b :: Type
type ForallXMatchGroup (c :: Type -> Constraint) x b = (c (XMG x b), c (XXMatchGroup x b))
type family XCMatch x b :: Type
type family XXMatch x b :: Type
type ForallXMatch (c :: Type -> Constraint) x b = (c (XCMatch x b), c (XXMatch x b))
type family XCGRHSs x b :: Type
type family XXGRHSs x b :: Type
type ForallXGRHSs (c :: Type -> Constraint) x b = (c (XCGRHSs x b), c (XXGRHSs x b))
type family XCGRHS x b :: Type
type family XXGRHS x b :: Type
type ForallXGRHS (c :: Type -> Constraint) x b = (c (XCGRHS x b), c (XXGRHS x b))
type family XLastStmt x x' b :: Type
type family XBindStmt x x' b :: Type
type family XApplicativeStmt x x' b :: Type
type family XBodyStmt x x' b :: Type
type family XLetStmt x x' b :: Type
type family XParStmt x x' b :: Type
type family XTransStmt x x' b :: Type
type family XRecStmt x x' b :: Type
type family XXStmtLR x x' b :: Type
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 :: Type
type family XCmdArrForm x :: Type
type family XCmdApp x :: Type
type family XCmdLam x :: Type
type family XCmdPar x :: Type
type family XCmdCase x :: Type
type family XCmdIf x :: Type
type family XCmdLet x :: Type
type family XCmdDo x :: Type
type family XCmdWrap x :: Type
type family XXCmd x :: Type
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' :: Type
type family XXParStmtBlock x x' :: Type
type ForallXParStmtBlock (c :: Type -> Constraint) x x' = (c (XParStmtBlock x x'), c (XXParStmtBlock x x'))
type family XApplicativeArgOne x :: Type
type family XApplicativeArgMany x :: Type
type family XXApplicativeArg x :: Type
type ForallXApplicativeArg (c :: Type -> Constraint) x = (c (XApplicativeArgOne x), c (XApplicativeArgMany x), c (XXApplicativeArg x))
type family XHsChar x :: Type
type family XHsCharPrim x :: Type
type family XHsString x :: Type
type family XHsStringPrim x :: Type
type family XHsInt x :: Type
type family XHsIntPrim x :: Type
type family XHsWordPrim x :: Type
type family XHsInt64Prim x :: Type
type family XHsWord64Prim x :: Type
type family XHsInteger x :: Type
type family XHsRat x :: Type
type family XHsFloatPrim x :: Type
type family XHsDoublePrim x :: Type
type family XXLit x :: Type
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))
type family XOverLit x :: Type
type family XXOverLit x :: Type
type ForallXOverLit (c :: Type -> Constraint) x = (c (XOverLit x), c (XXOverLit x))
type family XWildPat x :: Type
type family XVarPat x :: Type
type family XLazyPat x :: Type
type family XAsPat x :: Type
type family XParPat x :: Type
type family XBangPat x :: Type
type family XListPat x :: Type
type family XTuplePat x :: Type
type family XSumPat x :: Type
type family XConPat x :: Type
type family XViewPat x :: Type
type family XSplicePat x :: Type
type family XLitPat x :: Type
type family XNPat x :: Type
type family XNPlusKPat x :: Type
type family XSigPat x :: Type
type family XCoPat x :: Type
type family XXPat x :: Type
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 :: Type
type family XXLHsQTyVars x :: Type
type ForallXLHsQTyVars (c :: Type -> Constraint) x = (c (XHsQTvs x), c (XXLHsQTyVars x))
type family XHsIB x b :: Type
type family XXHsImplicitBndrs x b :: Type
type ForallXHsImplicitBndrs (c :: Type -> Constraint) x b = (c (XHsIB x b), c (XXHsImplicitBndrs x b))
type family XHsWC x b :: Type
type family XXHsWildCardBndrs x b :: Type
type ForallXHsWildCardBndrs (c :: Type -> Constraint) x b = (c (XHsWC x b), c (XXHsWildCardBndrs x b))
type family XForAllTy x :: Type
type family XQualTy x :: Type
type family XTyVar x :: Type
type family XAppTy x :: Type
type family XFunTy x :: Type
type family XListTy x :: Type
type family XTupleTy x :: Type
type family XSumTy x :: Type
type family XOpTy x :: Type
type family XParTy x :: Type
type family XIParamTy x :: Type
type family XStarTy x :: Type
type family XKindSig x :: Type
type family XSpliceTy x :: Type
type family XDocTy x :: Type
type family XBangTy x :: Type
type family XRecTy x :: Type
type family XExplicitListTy x :: Type
type family XExplicitTupleTy x :: Type
type family XTyLit x :: Type
type family XWildCardTy x :: Type
type family XXType x :: Type
type ForallXType (c :: Type -> Constraint) x = (c (XForAllTy x), c (XQualTy x), c (XTyVar x), c (XAppTy 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))
type family XUserTyVar x :: Type
type family XKindedTyVar x :: Type
type family XXTyVarBndr x :: Type
type ForallXTyVarBndr (c :: Type -> Constraint) x = (c (XUserTyVar x), c (XKindedTyVar x), c (XXTyVarBndr x))
type family XConDeclField x :: Type
type family XXConDeclField x :: Type
type ForallXConDeclField (c :: Type -> Constraint) x = (c (XConDeclField x), c (XXConDeclField x))
type family XCFieldOcc x :: Type
type family XXFieldOcc x :: Type
type ForallXFieldOcc (c :: Type -> Constraint) x = (c (XCFieldOcc x), c (XXFieldOcc x))
type family XCImportDecl x :: Type
type family XXImportDecl x :: Type
type ForallXImportDecl (c :: Type -> Constraint) x = (c (XCImportDecl x), c (XXImportDecl x))
type family XIEVar x :: Type
type family XIEThingAbs x :: Type
type family XIEThingAll x :: Type
type family XIEThingWith x :: Type
type family XIEModuleContents x :: Type
type family XIEGroup x :: Type
type family XIEDoc x :: Type
type family XIEDocNamed x :: Type
type family XXIE x :: Type
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
- convert :: a -> b
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)
type OutputableX p = (Outputable (XSigPat p), Outputable (XSigPat GhcRn), Outputable (XIPBinds p), Outputable (XExprWithTySig p), Outputable (XExprWithTySig GhcRn), Outputable (XAppTypeE p), Outputable (XAppTypeE GhcRn), Outputable (XViaStrategy p), Outputable (XViaStrategy GhcRn))
type OutputableBndrId id = (OutputableBndr (NameOrRdrName (IdP id)), OutputableBndr (IdP id), OutputableX id)
placeHolderNamesTc :: NameSet
type family NameOrRdrName id :: Type where ...
isExportedId :: Var -> Bool
isGlobalId :: Var -> Bool
isLocalId :: Var -> Bool
type Id = Var
type TyVar = Var
data Token
unicodeAnn :: AnnKeywordId -> AnnKeywordId
getAndRemoveAnnotationComments :: ApiAnns -> SrcSpan -> ([Located AnnotationComment], ApiAnns)
getAnnotationComments :: ApiAnns -> SrcSpan -> [Located AnnotationComment]
getAndRemoveAnnotation :: ApiAnns -> SrcSpan -> AnnKeywordId -> ([SrcSpan], ApiAnns)
getAnnotation :: ApiAnns -> SrcSpan -> AnnKeywordId -> [SrcSpan]
type ApiAnns = (Map ApiAnnKey [SrcSpan], Map SrcSpan [Located AnnotationComment])
data AnnKeywordId
- = AnnAnyclass
- | AnnAs
- | AnnAt
- | AnnBang
- | AnnBackquote
- | AnnBy
- | AnnCase
- | AnnClass
- | AnnClose
- | AnnCloseB
- | AnnCloseBU
- | AnnCloseC
- | AnnCloseQ
- | AnnCloseQU
- | AnnCloseP
- | AnnCloseS
- | AnnColon
- | AnnComma
- | AnnCommaTuple
- | AnnDarrow
- | AnnDarrowU
- | AnnData
- | AnnDcolon
- | AnnDcolonU
- | AnnDefault
- | AnnDeriving
- | AnnDo
- | AnnDot
- | AnnDotdot
- | AnnElse
- | AnnEqual
- | AnnExport
- | AnnFamily
- | AnnForall
- | AnnForallU
- | AnnForeign
- | AnnFunId
- | AnnGroup
- | AnnHeader
- | AnnHiding
- | AnnIf
- | AnnImport
- | AnnIn
- | AnnInfix
- | AnnInstance
- | AnnLam
- | AnnLarrow
- | AnnLarrowU
- | AnnLet
- | AnnMdo
- | AnnMinus
- | AnnModule
- | AnnNewtype
- | AnnName
- | AnnOf
- | AnnOpen
- | AnnOpenB
- | AnnOpenBU
- | AnnOpenC
- | AnnOpenE
- | AnnOpenEQ
- | AnnOpenEQU
- | AnnOpenP
- | AnnOpenPE
- | AnnOpenPTE
- | AnnOpenS
- | AnnPackageName
- | AnnPattern
- | AnnProc
- | AnnQualified
- | AnnRarrow
- | AnnRarrowU
- | AnnRec
- | AnnRole
- | AnnSafe
- | AnnSemi
- | AnnSimpleQuote
- | AnnSignature
- | AnnStatic
- | AnnStock
- | AnnThen
- | AnnThIdSplice
- | AnnThIdTySplice
- | AnnThTyQuote
- | AnnTilde
- | AnnType
- | AnnUnit
- | AnnUsing
- | AnnVal
- | AnnValStr
- | AnnVbar
- | AnnVia
- | AnnWhere
- | Annlarrowtail
- | AnnlarrowtailU
- | Annrarrowtail
- | AnnrarrowtailU
- | AnnLarrowtail
- | AnnLarrowtailU
- | AnnRarrowtail
- | AnnRarrowtailU
- | AnnEofPos
data AnnotationComment
- = AnnDocCommentNext String
- | AnnDocCommentPrev String
- | AnnDocCommentNamed String
- | AnnDocSection Int String
- | AnnDocOptions String
- | AnnLineComment String
- | AnnBlockComment String
data RdrName
- = Unqual OccName
- | Qual ModuleName OccName
prettyPrintGhcErrors :: ExceptionMonad m => DynFlags -> m a -> m a
emptyArgDocMap :: ArgDocMap
emptyDeclDocMap :: DeclDocMap
concatDocs :: [HsDocString] -> Maybe HsDocString
appendDocs :: HsDocString -> HsDocString -> HsDocString
ppr_mbDoc :: Maybe LHsDocString -> SDoc
hsDocStringToByteString :: HsDocString -> ByteString
unpackHDS :: HsDocString -> String
mkHsDocStringUtf8ByteString :: ByteString -> HsDocString
mkHsDocString :: String -> HsDocString
data HsDocString
type LHsDocString = Located HsDocString
newtype DeclDocMap = DeclDocMap (Map Name HsDocString)
newtype ArgDocMap = ArgDocMap (Map Name (Map Int HsDocString))
nameModule :: HasDebugCallStack -> Name -> Module
isExternalName :: Name -> Bool
nameSrcSpan :: Name -> SrcSpan
class NamedThing a where
- getOccName :: a -> OccName
- getName :: a -> Name
gopt :: GeneralFlag -> DynFlags -> Bool
defaultObjectTarget :: Platform -> HscTarget
data SafeHaskellMode
- = Sf_None
- | Sf_Unsafe
- | Sf_Trustworthy
- | Sf_Safe
data HscTarget
- = HscC
- | HscAsm
- | HscLlvm
- | HscInterpreted
- | HscNothing
data GhcMode
- = CompManager
- | OneShot
- | MkDepend
data GhcLink
- = NoLink
- | LinkBinary
- | LinkInMemory
- | LinkDynLib
- | LinkStaticLib
data Phase
pprModule :: Module -> SDoc
mkModule :: UnitId -> ModuleName -> Module
mkModuleName :: String -> ModuleName
moduleNameString :: ModuleName -> String
ml_hs_file :: ModLocation -> Maybe FilePath
ml_hi_file :: ModLocation -> FilePath
ml_obj_file :: ModLocation -> FilePath
failed :: SuccessFlag -> Bool
succeeded :: SuccessFlag -> Bool
compareFixity :: Fixity -> Fixity -> (Bool, Bool)
negateFixity :: Fixity
defaultFixity :: Fixity
maxPrecedence :: Int
data Fixity
data FixityDirection
- = InfixL
- | InfixR
- | InfixN
data LexicalFixity
- = Prefix
- | Infix
data SuccessFlag
- = Succeeded
- | Failed
data SpliceExplicitFlag
- = ExplicitSplice
- | ImplicitSplice
data Severity
- = SevOutput
- | SevFatal
- | SevInteractive
- | SevDump
- | SevInfo
- | SevWarning
- | SevError
isSubspanOf :: SrcSpan -> SrcSpan -> Bool
spans :: SrcSpan -> (Int, Int) -> Bool
leftmost_largest :: SrcSpan -> SrcSpan -> Ordering
leftmost_smallest :: SrcSpan -> SrcSpan -> Ordering
rightmost :: SrcSpan -> SrcSpan -> Ordering
cmpLocated :: Ord a => Located a -> Located a -> Ordering
eqLocated :: Eq a => Located a -> Located a -> Bool
addCLoc :: Located a -> Located b -> c -> Located c
combineLocs :: Located a -> Located b -> SrcSpan
mkGeneralLocated :: String -> e -> Located e
noLoc :: e -> Located e
unLoc :: GenLocated l e -> e
srcSpanEnd :: SrcSpan -> SrcLoc
srcSpanStart :: SrcSpan -> SrcLoc
srcSpanEndCol :: RealSrcSpan -> Int
srcSpanStartCol :: RealSrcSpan -> Int
srcSpanEndLine :: RealSrcSpan -> Int
srcSpanStartLine :: RealSrcSpan -> Int
isGoodSrcSpan :: SrcSpan -> Bool
mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan
srcLocSpan :: SrcLoc -> SrcSpan
noSrcSpan :: SrcSpan
srcLocCol :: RealSrcLoc -> Int
srcLocLine :: RealSrcLoc -> Int
srcLocFile :: RealSrcLoc -> FastString
noSrcLoc :: SrcLoc
mkSrcLoc :: FastString -> Int -> Int -> SrcLoc
data RealSrcLoc
data SrcLoc
- = RealSrcLoc !RealSrcLoc
- | UnhelpfulLoc FastString
data RealSrcSpan
data SrcSpan
- = RealSrcSpan !RealSrcSpan
- | UnhelpfulSpan !FastString
data GenLocated l e = L l e
type Located = GenLocated SrcSpan
data Type
data TyThing
- = AnId Id
- | AConLike ConLike
- | ATyCon TyCon
- | ACoAxiom (CoAxiom Branched)
type PredType = Type
type Kind = Type
type ThetaType = [PredType]
alwaysQualify :: PrintUnqualified
data PrintUnqualified
data Module
data ModuleName
data UnitId
isFunTyCon :: TyCon -> Bool
data TyCon
data DynFlags = DynFlags {
- ghcMode :: GhcMode
- ghcLink :: GhcLink
- hscTarget :: HscTarget
- settings :: Settings
- llvmTargets :: LlvmTargets
- llvmPasses :: LlvmPasses
- verbosity :: Int
- optLevel :: Int
- debugLevel :: Int
- simplPhases :: Int
- maxSimplIterations :: Int
- maxPmCheckIterations :: Int
- ruleCheck :: Maybe String
- inlineCheck :: Maybe String
- strictnessBefore :: [Int]
- parMakeCount :: Maybe Int
- enableTimeStats :: Bool
- ghcHeapSize :: Maybe Int
- maxRelevantBinds :: Maybe Int
- maxValidHoleFits :: Maybe Int
- maxRefHoleFits :: Maybe Int
- refLevelHoleFits :: Maybe Int
- maxUncoveredPatterns :: Int
- simplTickFactor :: Int
- specConstrThreshold :: Maybe Int
- specConstrCount :: Maybe Int
- specConstrRecursive :: Int
- liberateCaseThreshold :: Maybe Int
- floatLamArgs :: Maybe Int
- cmmProcAlignment :: Maybe Int
- historySize :: Int
- importPaths :: [FilePath]
- mainModIs :: Module
- mainFunIs :: Maybe String
- reductionDepth :: IntWithInf
- solverIterations :: IntWithInf
- thisInstalledUnitId :: InstalledUnitId
- thisComponentId_ :: Maybe ComponentId
- thisUnitIdInsts_ :: Maybe [(ModuleName, Module)]
- ways :: [Way]
- buildTag :: String
- splitInfo :: Maybe (String, Int)
- objectDir :: Maybe String
- dylibInstallName :: Maybe String
- hiDir :: Maybe String
- stubDir :: Maybe String
- dumpDir :: Maybe String
- objectSuf :: String
- hcSuf :: String
- hiSuf :: String
- canGenerateDynamicToo :: IORef Bool
- dynObjectSuf :: String
- dynHiSuf :: String
- outputFile :: Maybe String
- dynOutputFile :: Maybe String
- outputHi :: Maybe String
- dynLibLoader :: DynLibLoader
- dumpPrefix :: Maybe FilePath
- dumpPrefixForce :: Maybe FilePath
- ldInputs :: [Option]
- includePaths :: IncludeSpecs
- libraryPaths :: [String]
- frameworkPaths :: [String]
- cmdlineFrameworks :: [String]
- rtsOpts :: Maybe String
- rtsOptsEnabled :: RtsOptsEnabled
- rtsOptsSuggestions :: Bool
- hpcDir :: String
- pluginModNames :: [ModuleName]
- pluginModNameOpts :: [(ModuleName, String)]
- frontendPluginOpts :: [String]
- plugins :: [LoadedPlugin]
- hooks :: Hooks
- depMakefile :: FilePath
- depIncludePkgDeps :: Bool
- depExcludeMods :: [ModuleName]
- depSuffixes :: [String]
- packageDBFlags :: [PackageDBFlag]
- ignorePackageFlags :: [IgnorePackageFlag]
- packageFlags :: [PackageFlag]
- pluginPackageFlags :: [PackageFlag]
- trustFlags :: [TrustFlag]
- packageEnv :: Maybe FilePath
- pkgDatabase :: Maybe [(FilePath, [PackageConfig])]
- pkgState :: PackageState
- filesToClean :: IORef FilesToClean
- dirsToClean :: IORef (Map FilePath FilePath)
- nextTempSuffix :: IORef Int
- generatedDumps :: IORef (Set FilePath)
- dumpFlags :: EnumSet DumpFlag
- generalFlags :: EnumSet GeneralFlag
- warningFlags :: EnumSet WarningFlag
- fatalWarningFlags :: EnumSet WarningFlag
- language :: Maybe Language
- safeHaskell :: SafeHaskellMode
- safeInfer :: Bool
- safeInferred :: Bool
- thOnLoc :: SrcSpan
- newDerivOnLoc :: SrcSpan
- overlapInstLoc :: SrcSpan
- incoherentOnLoc :: SrcSpan
- pkgTrustOnLoc :: SrcSpan
- warnSafeOnLoc :: SrcSpan
- warnUnsafeOnLoc :: SrcSpan
- trustworthyOnLoc :: SrcSpan
- extensions :: [OnOff Extension]
- extensionFlags :: EnumSet Extension
- ufCreationThreshold :: Int
- ufUseThreshold :: Int
- ufFunAppDiscount :: Int
- ufDictDiscount :: Int
- ufKeenessFactor :: Float
- ufDearOp :: Int
- ufVeryAggressive :: Bool
- maxWorkerArgs :: Int
- ghciHistSize :: Int
- log_action :: LogAction
- flushOut :: FlushOut
- flushErr :: FlushErr
- ghcVersionFile :: Maybe FilePath
- haddockOptions :: Maybe String
- ghciScripts :: [String]
- pprUserLength :: Int
- pprCols :: Int
- useUnicode :: Bool
- useColor :: OverridingBool
- canUseColor :: Bool
- colScheme :: Scheme
- profAuto :: ProfAuto
- interactivePrint :: Maybe String
- nextWrapperNum :: IORef (ModuleEnv Int)
- sseVersion :: Maybe SseVersion
- bmiVersion :: Maybe BmiVersion
- avx :: Bool
- avx2 :: Bool
- avx512cd :: Bool
- avx512er :: Bool
- avx512f :: Bool
- avx512pf :: Bool
- rtldInfo :: IORef (Maybe LinkerInfo)
- rtccInfo :: IORef (Maybe CompilerInfo)
- maxInlineAllocSize :: Int
- maxInlineMemcpyInsns :: Int
- maxInlineMemsetInsns :: Int
- reverseErrors :: Bool
- maxErrors :: Maybe Int
- initialUnique :: Int
- uniqueIncrement :: Int
}
data GeneralFlag
- = Opt_DumpToFile
- | Opt_D_faststring_stats
- | Opt_D_dump_minimal_imports
- | Opt_DoCoreLinting
- | Opt_DoStgLinting
- | Opt_DoCmmLinting
- | Opt_DoAsmLinting
- | Opt_DoAnnotationLinting
- | Opt_NoLlvmMangler
- | Opt_FastLlvm
- | Opt_WarnIsError
- | Opt_ShowWarnGroups
- | Opt_HideSourcePaths
- | Opt_PrintExplicitForalls
- | Opt_PrintExplicitKinds
- | Opt_PrintExplicitCoercions
- | Opt_PrintExplicitRuntimeReps
- | Opt_PrintEqualityRelations
- | Opt_PrintUnicodeSyntax
- | Opt_PrintExpandedSynonyms
- | Opt_PrintPotentialInstances
- | Opt_PrintTypecheckerElaboration
- | Opt_CallArity
- | Opt_Exitification
- | Opt_Strictness
- | Opt_LateDmdAnal
- | Opt_KillAbsence
- | Opt_KillOneShot
- | Opt_FullLaziness
- | Opt_FloatIn
- | Opt_LateSpecialise
- | Opt_Specialise
- | Opt_SpecialiseAggressively
- | Opt_CrossModuleSpecialise
- | Opt_StaticArgumentTransformation
- | Opt_CSE
- | Opt_StgCSE
- | Opt_LiberateCase
- | Opt_SpecConstr
- | Opt_SpecConstrKeen
- | Opt_DoLambdaEtaExpansion
- | Opt_IgnoreAsserts
- | Opt_DoEtaReduction
- | Opt_CaseMerge
- | Opt_CaseFolding
- | Opt_UnboxStrictFields
- | Opt_UnboxSmallStrictFields
- | Opt_DictsCheap
- | Opt_EnableRewriteRules
- | Opt_RegsGraph
- | Opt_RegsIterative
- | Opt_PedanticBottoms
- | Opt_LlvmTBAA
- | Opt_LlvmPassVectorsInRegisters
- | Opt_LlvmFillUndefWithGarbage
- | Opt_IrrefutableTuples
- | Opt_CmmSink
- | Opt_CmmElimCommonBlocks
- | Opt_AsmShortcutting
- | Opt_OmitYields
- | Opt_FunToThunk
- | Opt_DictsStrict
- | Opt_DmdTxDictSel
- | Opt_Loopification
- | Opt_CprAnal
- | Opt_WorkerWrapper
- | Opt_SolveConstantDicts
- | Opt_AlignmentSanitisation
- | Opt_CatchBottoms
- | Opt_NumConstantFolding
- | Opt_SimplPreInlining
- | Opt_IgnoreInterfacePragmas
- | Opt_OmitInterfacePragmas
- | Opt_ExposeAllUnfoldings
- | Opt_WriteInterface
- | Opt_AutoSccsOnIndividualCafs
- | Opt_ProfCountEntries
- | Opt_Pp
- | Opt_ForceRecomp
- | Opt_IgnoreOptimChanges
- | Opt_IgnoreHpcChanges
- | Opt_ExcessPrecision
- | Opt_EagerBlackHoling
- | Opt_NoHsMain
- | Opt_SplitObjs
- | Opt_SplitSections
- | Opt_StgStats
- | Opt_HideAllPackages
- | Opt_HideAllPluginPackages
- | Opt_PrintBindResult
- | Opt_Haddock
- | Opt_HaddockOptions
- | Opt_BreakOnException
- | Opt_BreakOnError
- | Opt_PrintEvldWithShow
- | Opt_PrintBindContents
- | Opt_GenManifest
- | Opt_EmbedManifest
- | Opt_SharedImplib
- | Opt_BuildingCabalPackage
- | Opt_IgnoreDotGhci
- | Opt_GhciSandbox
- | Opt_GhciHistory
- | Opt_GhciLeakCheck
- | Opt_LocalGhciHistory
- | Opt_NoIt
- | Opt_HelpfulErrors
- | Opt_DeferTypeErrors
- | Opt_DeferTypedHoles
- | Opt_DeferOutOfScopeVariables
- | Opt_PIC
- | Opt_PIE
- | Opt_PICExecutable
- | Opt_ExternalDynamicRefs
- | Opt_SccProfilingOn
- | Opt_Ticky
- | Opt_Ticky_Allocd
- | Opt_Ticky_LNE
- | Opt_Ticky_Dyn_Thunk
- | Opt_RPath
- | Opt_RelativeDynlibPaths
- | Opt_Hpc
- | Opt_FlatCache
- | Opt_ExternalInterpreter
- | Opt_OptimalApplicativeDo
- | Opt_VersionMacros
- | Opt_WholeArchiveHsLibs
- | Opt_SingleLibFolder
- | Opt_ErrorSpans
- | Opt_DiagnosticsShowCaret
- | Opt_PprCaseAsLet
- | Opt_PprShowTicks
- | Opt_ShowHoleConstraints
- | Opt_ShowValidHoleFits
- | Opt_SortValidHoleFits
- | Opt_SortBySizeHoleFits
- | Opt_SortBySubsumHoleFits
- | Opt_AbstractRefHoleFits
- | Opt_UnclutterValidHoleFits
- | Opt_ShowTypeAppOfHoleFits
- | Opt_ShowTypeAppVarsOfHoleFits
- | Opt_ShowTypeOfHoleFits
- | Opt_ShowProvOfHoleFits
- | Opt_ShowMatchesOfHoleFits
- | Opt_ShowLoadedModules
- | Opt_HexWordLiterals
- | Opt_SuppressCoercions
- | Opt_SuppressVarKinds
- | Opt_SuppressModulePrefixes
- | Opt_SuppressTypeApplications
- | Opt_SuppressIdInfo
- | Opt_SuppressUnfoldings
- | Opt_SuppressTypeSignatures
- | Opt_SuppressUniques
- | Opt_SuppressStgFreeVars
- | Opt_SuppressTicks
- | Opt_SuppressTimestamps
- | Opt_AutoLinkPackages
- | Opt_ImplicitImportQualified
- | Opt_KeepHiDiffs
- | Opt_KeepHcFiles
- | Opt_KeepSFiles
- | Opt_KeepTmpFiles
- | Opt_KeepRawTokenStream
- | Opt_KeepLlvmFiles
- | Opt_KeepHiFiles
- | Opt_KeepOFiles
- | Opt_BuildDynamicToo
- | Opt_DistrustAllPackages
- | Opt_PackageTrust
- | Opt_G_NoStateHack
- | Opt_G_NoOptCoercion
withSignalHandlers :: (ExceptionMonad m, MonadIO m) => m a -> m a
showGhcException :: GhcException -> ShowS
data GhcException
- = Signal Int
- | UsageError String
- | CmdLineError String
- | Panic String
- | PprPanic String SDoc
- | Sorry String
- | PprSorry String SDoc
- | InstallationError String
- | ProgramError String
- | PprProgramError String SDoc
data Name
gcatch :: (ExceptionMonad m, Exception e) => m a -> (e -> m a) -> m a
gbracket :: ExceptionMonad m => m a -> (a -> m b) -> (a -> m c) -> m c
gfinally :: ExceptionMonad m => m a -> m b -> m a
type ForeignHValue = ForeignRef HValue
data HValue
coreModule :: DesugaredMod m => m -> ModGuts
type Span = RealSrcSpan
hieVersion :: Integer
data HieFile = HieFile {
- hie_hs_file :: FilePath
- hie_module :: Module
- hie_types :: Array TypeIndex HieTypeFlat
- hie_asts :: HieASTs TypeIndex
- hie_exports :: [AvailInfo]
- hie_hs_src :: ByteString
}
type TypeIndex = Int
data HieType a
- = HTyVarTy Name
- | HAppTy a a
- | HTyConApp IfaceTyCon (HieArgs a)
- | HForAllTy ((Name, a), ArgFlag) a
- | HFunTy a a
- | HQualTy a a
- | HLitTy IfaceTyLit
- | HCastTy a
- | HCoercionTy
type HieTypeFlat = HieType TypeIndex
newtype HieTypeFix = Roll (HieType HieTypeFix)
newtype HieArgs a = HieArgs [(Bool, a)]
newtype HieASTs a = HieASTs {
- getAsts :: Map FastString (HieAST a)
}
data HieAST a = Node {
- nodeInfo :: NodeInfo a
- nodeSpan :: Span
- nodeChildren :: [HieAST a]
}
data NodeInfo a = NodeInfo {
- nodeAnnotations :: Set (FastString, FastString)
- nodeType :: [a]
- nodeIdentifiers :: NodeIdentifiers a
}
type Identifier = Either ModuleName Name
type NodeIdentifiers a = Map Identifier (IdentifierDetails a)
data IdentifierDetails a = IdentifierDetails {
- identType :: Maybe a
- identInfo :: Set ContextInfo
}
data ContextInfo
- = Use
- | MatchBind
- | IEThing IEType
- | TyDecl
- | ValBind BindType Scope (Maybe Span)
- | PatternBind Scope Scope (Maybe Span)
- | ClassTyDecl (Maybe Span)
- | Decl DeclType (Maybe Span)
- | TyVarBind Scope TyVarScope
- | RecField RecFieldContext (Maybe Span)
data IEType
- = Import
- | ImportAs
- | ImportHiding
- | Export
data RecFieldContext
- = RecFieldDecl
- | RecFieldAssign
- | RecFieldMatch
- | RecFieldOcc
data BindType
- = RegularBind
- | InstanceBind
data DeclType
- = FamDec
- | SynDec
- | DataDec
- | ConDec
- | PatSynDec
- | ClassDec
- | InstDec
data Scope
- = NoScope
- | LocalScope Span
- | ModuleScope
data TyVarScope
- = ResolvedScopes [Scope]
- | UnresolvedScope [Name] (Maybe Span)
generateReferencesMap :: Foldable f => f (HieAST a) -> Map Identifier [(Span, IdentifierDetails a)]
renderHieType :: DynFlags -> HieTypeFix -> String
resolveVisibility :: Type -> [Type] -> [(Bool, Type)]
foldType :: (HieType a -> a) -> HieTypeFix -> a
hieTypeToIface :: HieTypeFix -> IfaceType
data HieTypeState = HTS {
- tyMap :: !(TypeMap TypeIndex)
- htyTable :: !(IntMap HieTypeFlat)
- freshIndex :: !TypeIndex
}
initialHTS :: HieTypeState
freshTypeIndex :: State HieTypeState TypeIndex
compressTypes :: HieASTs Type -> (HieASTs TypeIndex, Array TypeIndex HieTypeFlat)
recoverFullType :: TypeIndex -> Array TypeIndex HieTypeFlat -> HieTypeFix
getTypeIndex :: Type -> State HieTypeState TypeIndex
resolveTyVarScopes :: Map FastString (HieAST a) -> Map FastString (HieAST a)
resolveTyVarScopeLocal :: HieAST a -> Map FastString (HieAST a) -> HieAST a
getNameBinding :: Name -> Map FastString (HieAST a) -> Maybe Span
getNameScope :: Name -> Map FastString (HieAST a) -> Maybe [Scope]
getNameBindingInClass :: Name -> Span -> Map FastString (HieAST a) -> Maybe Span
getNameScopeAndBinding :: Name -> Map FastString (HieAST a) -> Maybe ([Scope], Maybe Span)
getScopeFromContext :: ContextInfo -> Maybe [Scope]
getBindSiteFromContext :: ContextInfo -> Maybe Span
flattenAst :: HieAST a -> [HieAST a]
smallestContainingSatisfying :: Span -> (HieAST a -> Bool) -> HieAST a -> Maybe (HieAST a)
selectLargestContainedBy :: Span -> HieAST a -> Maybe (HieAST a)
selectSmallestContaining :: Span -> HieAST a -> Maybe (HieAST a)
definedInAsts :: Map FastString (HieAST a) -> Name -> Bool
isOccurrence :: ContextInfo -> Bool
scopeContainsSpan :: Scope -> Span -> Bool
combineAst :: HieAST Type -> HieAST Type -> HieAST Type
insertAst :: HieAST Type -> [HieAST Type] -> [HieAST Type]
combineNodeInfo :: NodeInfo Type -> NodeInfo Type -> NodeInfo Type
mergeAsts :: [HieAST Type] -> [HieAST Type] -> [HieAST Type]
rightOf :: Span -> Span -> Bool
leftOf :: Span -> Span -> Bool
startsRightOf :: Span -> Span -> Bool
mergeSortAsts :: [HieAST Type] -> [HieAST Type]
simpleNodeInfo :: FastString -> FastString -> NodeInfo a
locOnly :: SrcSpan -> [HieAST a]
mkScope :: SrcSpan -> Scope
mkLScope :: Located a -> Scope
combineScopes :: Scope -> Scope -> Scope
makeNode :: (Applicative m, Data a) => a -> SrcSpan -> m [HieAST b]
makeTypeNode :: (Applicative m, Data a) => a -> SrcSpan -> Type -> m [HieAST Type]

Documentation

getHeaderImports :: DynFlags -> StringBuffer -> FilePath -> FilePath -> IO (Either ErrorMessages ([(Maybe FastString, Located ModuleName)], [(Maybe FastString, Located ModuleName)], Located ModuleName)) Source #

data HieFileResult Source #

Constructors

HieFileResult
Fields hie_file_result_version :: Integer hie_file_result_ghc_version :: ByteString hie_file_result :: HieFile

data HieFile Source #

GHC builds up a wealth of information about Haskell source as it compiles it. .hie files are a way of persisting some of this information to disk so that external tools that need to work with haskell source don't need to parse, typecheck, and rename all over again. These files contain:

a simplified AST
- nodes are annotated with source positions and types
- identifiers are annotated with scope information
the raw bytes of the initial Haskell source

Besides saving compilation cycles, .hie files also offer a more stable interface than the GHC API.

Constructors

HieFile

Fields

hie_hs_file :: FilePath
Initial Haskell source file path
hie_module :: Module
The module this HIE file is for
hie_types :: Array TypeIndex HieTypeFlat
Types referenced in the hie_asts.
See Note [Efficient serialization of redundant type info]
hie_asts :: HieASTs TypeIndex
Type-annotated abstract syntax trees
hie_exports :: [AvailInfo]
The names that this module exports
hie_hs_src :: ByteString
Raw bytes of the initial Haskell source

Instances

Show HieFile Source #
Instance details Defined in Development.IDE.GHC.Orphans Methods showsPrec :: Int -> HieFile -> ShowS # show :: HieFile -> String # showList :: [HieFile] -> ShowS #
NFData HieFile Source #
Instance details Defined in Development.IDE.GHC.Orphans Methods rnf :: HieFile -> () #
Binary HieFile Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods put_ :: BinHandle -> HieFile -> IO () # put :: BinHandle -> HieFile -> IO (Bin HieFile) # get :: BinHandle -> IO HieFile #

newtype NameCacheUpdater #

A function that atomically updates the name cache given a modifier function. The second result of the modifier function will be the result of the IO action.

Constructors

NCU
Fields updateNameCache :: forall c. (NameCache -> (NameCache, c)) -> IO c

hieExportNames :: HieFile -> [(SrcSpan, Name)] Source #

mkHieFile :: ModSummary -> TcGblEnv -> RenamedSource -> ByteString -> Hsc HieFile Source #

Construct an HieFile from the outputs of the typechecker.

writeHieFile :: FilePath -> HieFile -> IO () Source #

Write a HieFile to the given FilePath, with a proper header and symbol tables for Names and FastStrings

readHieFile :: NameCacheUpdater -> FilePath -> IO HieFileResult Source #

Read a HieFile from a FilePath. Can use an existing NameCache.

supportsHieFiles :: Bool Source #

setHieDir :: FilePath -> DynFlags -> DynFlags Source #

dontWriteHieFiles :: DynFlags -> DynFlags Source #

ml_hie_file :: ModLocation -> FilePath Source #

hPutStringBuffer :: Handle -> StringBuffer -> IO () Source #

includePathsGlobal :: IncludeSpecs -> [String] #

includePathsQuote :: IncludeSpecs -> [String] #

addIncludePathsQuote :: FilePath -> DynFlags -> DynFlags Source #

getModuleHash :: ModIface -> Fingerprint Source #

getPackageName :: DynFlags -> InstalledUnitId -> Maybe PackageName Source #

pattern DerivD :: DerivDecl p -> HsDecl p Source #

pattern ForD :: ForeignDecl p -> HsDecl p Source #

pattern InstD :: InstDecl p -> HsDecl p Source #

pattern TyClD :: TyClDecl p -> HsDecl p Source #

pattern ValD :: HsBind p -> HsDecl p Source #

pattern SigD :: Sig p -> HsDecl p Source #

pattern TypeSig :: [Located (IdP p)] -> LHsSigWcType p -> Sig p Source #

pattern ClassOpSig :: Bool -> [Located (IdP pass)] -> LHsSigType pass -> Sig pass Source #

pattern IEThingAll :: LIEWrappedName (IdP pass) -> IE pass Source #

pattern IEThingWith :: LIEWrappedName (IdP pass) -> IEWildcard -> [LIEWrappedName (IdP pass)] -> [Located (FieldLbl (IdP pass))] -> IE pass Source #

pattern VarPat :: Located (IdP p) -> Pat p Source #

pattern PatSynBind :: PatSynBind p p -> HsBind p Source #

data ModLocation #

Module Location

Where a module lives on the file system: the actual locations of the .hs, .hi and .o files, if we have them

Instances

Show ModLocation
Instance details Defined in Module Methods showsPrec :: Int -> ModLocation -> ShowS # show :: ModLocation -> String # showList :: [ModLocation] -> ShowS #
Outputable ModLocation
Instance details Defined in Module Methods ppr :: ModLocation -> SDoc # pprPrec :: Rational -> ModLocation -> SDoc #

addBootSuffix :: FilePath -> FilePath #

Add the -boot suffix to .hs, .hi and .o files

pattern ModLocation :: Maybe FilePath -> FilePath -> FilePath -> ModLocation Source #

getConArgs :: ConDecl pass -> HsConDeclDetails pass Source #

class HasSrcSpan a Source #

Minimal complete definition

getLoc

Instances

HasSrcSpan Name Source #
Instance details Defined in Development.IDE.GHC.Compat Methods getLoc :: Name -> SrcSpan Source #
HasSrcSpan (GenLocated SrcSpan a) Source #
Instance details Defined in Development.IDE.GHC.Compat Methods getLoc :: GenLocated SrcSpan a -> SrcSpan Source #

getLoc :: HasSrcSpan a => a -> SrcSpan Source #

upNameCache :: IORef NameCache -> (NameCache -> (NameCache, c)) -> IO c Source #

parser #

Arguments

:: String	Haskell module source text (full Unicode is supported)
-> DynFlags	the flags
-> FilePath	the filename (for source locations)
-> (WarningMessages, Either ErrorMessages (Located (HsModule GhcPs)))

A pure interface to the module parser.

obtainTermFromId :: GhcMonad m => Int -> Bool -> Id -> m Term #

obtainTermFromVal :: GhcMonad m => Int -> Bool -> Type -> a -> m Term #

getHistorySpan :: GhcMonad m => History -> m SrcSpan #

getGHCiMonad :: GhcMonad m => m Name #

Get the monad GHCi lifts user statements into.

setGHCiMonad :: GhcMonad m => String -> m () #

Set the monad GHCi lifts user statements into.

Checks that a type (in string form) is an instance of the GHC.GHCi.GHCiSandboxIO type class. Sets it to be the GHCi monad if it is, throws an error otherwise.

moduleTrustReqs :: GhcMonad m => Module -> m (Bool, Set InstalledUnitId) #

Return if a module is trusted and the pkgs it depends on to be trusted.

isModuleTrusted :: GhcMonad m => Module -> m Bool #

Check that a module is safe to import (according to Safe Haskell).

We return True to indicate the import is safe and False otherwise although in the False case an error may be thrown first.

lookupModule :: GhcMonad m => ModuleName -> Maybe FastString -> m Module #

Like findModule, but differs slightly when the module refers to a source file, and the file has not been loaded via load. In this case, findModule will throw an error (module not loaded), but lookupModule will check to see whether the module can also be found in a package, and if so, that package Module will be returned. If not, the usual module-not-found error will be thrown.

findModule :: GhcMonad m => ModuleName -> Maybe FastString -> m Module #

Takes a ModuleName and possibly a UnitId, and consults the filesystem and package database to find the corresponding Module, using the algorithm that is used for an import declaration.

showRichTokenStream :: [(Located Token, String)] -> String #

Take a rich token stream such as produced from getRichTokenStream and return source code almost identical to the original code (except for insignificant whitespace.)

addSourceToTokens :: RealSrcLoc -> StringBuffer -> [Located Token] -> [(Located Token, String)] #

Given a source location and a StringBuffer corresponding to this location, return a rich token stream with the source associated to the tokens.

getRichTokenStream :: GhcMonad m => Module -> m [(Located Token, String)] #

Give even more information on the source than getTokenStream This function allows reconstructing the source completely with showRichTokenStream.

getTokenStream :: GhcMonad m => Module -> m [Located Token] #

Return module source as token stream, including comments.

The module must be in the module graph and its source must be available. Throws a SourceError on parse error.

pprParenSymName :: NamedThing a => a -> SDoc #

print a NamedThing, adding parentheses if the name is an operator.

dataConType :: DataCon -> Type #

getNameToInstancesIndex #

Arguments

:: GhcMonad m
=> [Module]	visible modules. An orphan instance will be returned if it is visible from at least one module in the list.
-> Maybe [Module]	modules to load. If this is not specified, we load modules for everything that is in scope unqualified.
-> m (Messages, Maybe (NameEnv ([ClsInst], [FamInst])))

Retrieve all type and family instances in the environment, indexed by Name. Each name's lists will contain every instance in which that name is mentioned in the instance head.

getGRE :: GhcMonad m => m GlobalRdrEnv #

get the GlobalRdrEnv for a session

findGlobalAnns :: (GhcMonad m, Typeable a) => ([Word8] -> a) -> AnnTarget Name -> m [a] #

lookupGlobalName :: GhcMonad m => Name -> m (Maybe TyThing) #

Looks up a global name: that is, any top-level name in any visible module. Unlike lookupName, lookupGlobalName does not use the interactive context, and therefore does not require a preceding setContext.

isDictonaryId :: Id -> Bool #

modInfoModBreaks :: ModuleInfo -> ModBreaks #

modInfoSafe :: ModuleInfo -> SafeHaskellMode #

Retrieve module safe haskell mode

modInfoIface :: ModuleInfo -> Maybe ModIface #

modInfoLookupName :: GhcMonad m => ModuleInfo -> Name -> m (Maybe TyThing) #

mkPrintUnqualifiedForModule :: GhcMonad m => ModuleInfo -> m (Maybe PrintUnqualified) #

modInfoIsExportedName :: ModuleInfo -> Name -> Bool #

modInfoInstances :: ModuleInfo -> [ClsInst] #

Returns the instances defined by the specified module. Warning: currently unimplemented for package modules.

modInfoExportsWithSelectors :: ModuleInfo -> [Name] #

modInfoExports :: ModuleInfo -> [Name] #

modInfoTopLevelScope :: ModuleInfo -> Maybe [Name] #

modInfoTyThings :: ModuleInfo -> [TyThing] #

The list of top-level entities defined in a module

getModuleInfo :: GhcMonad m => Module -> m (Maybe ModuleInfo) #

Request information about a loaded Module

getPrintUnqual :: GhcMonad m => m PrintUnqualified #

getInsts :: GhcMonad m => m ([ClsInst], [FamInst]) #

Return the instances for the current interactive session.

getBindings :: GhcMonad m => m [TyThing] #

Return the bindings for the current interactive session.

isLoaded :: GhcMonad m => ModuleName -> m Bool #

Return True == module is loaded.

getModuleGraph :: GhcMonad m => m ModuleGraph #

Get the module dependency graph.

compileToCoreSimplified :: GhcMonad m => FilePath -> m CoreModule #

Like compileToCoreModule, but invokes the simplifier, so as to return simplified and tidied Core.

compileToCoreModule :: GhcMonad m => FilePath -> m CoreModule #

This is the way to get access to the Core bindings corresponding to a module. compileToCore parses, typechecks, and desugars the module, then returns the resulting Core module (consisting of the module name, type declarations, and function declarations) if successful.

loadModule :: (TypecheckedMod mod, GhcMonad m) => mod -> m mod #

Load a module. Input doesn't need to be desugared.

A module must be loaded before dependent modules can be typechecked. This always includes generating a ModIface and, depending on the hscTarget, may also include code generation.

This function will always cause recompilation and will always overwrite previous compilation results (potentially files on disk).

desugarModule :: GhcMonad m => TypecheckedModule -> m DesugaredModule #

Desugar a typechecked module.

typecheckModule :: GhcMonad m => ParsedModule -> m TypecheckedModule #

Typecheck and rename a parsed module.

Throws a SourceError if either fails.

parseModule :: GhcMonad m => ModSummary -> m ParsedModule #

Parse a module.

Throws a SourceError on parse error.

getModSummary :: GhcMonad m => ModuleName -> m ModSummary #

Return the ModSummary of a module with the given name.

The module must be part of the module graph (see hsc_mod_graph and ModuleGraph). If this is not the case, this function will throw a GhcApiError.

This function ignores boot modules and requires that there is only one non-boot module with the given name.

workingDirectoryChanged :: GhcMonad m => m () #

Inform GHC that the working directory has changed. GHC will flush its cache of module locations, since it may no longer be valid.

Note: Before changing the working directory make sure all threads running in the same session have stopped. If you change the working directory, you should also unload the current program (set targets to empty, followed by load).

guessTarget :: GhcMonad m => String -> Maybe Phase -> m Target #

Attempts to guess what Target a string refers to. This function implements the --make/GHCi command-line syntax for filenames:

if the string looks like a Haskell source filename, then interpret it as such
if adding a .hs or .lhs suffix yields the name of an existing file, then use that
otherwise interpret the string as a module name

removeTarget :: GhcMonad m => TargetId -> m () #

Remove a target

addTarget :: GhcMonad m => Target -> m () #

Add another target.

getTargets :: GhcMonad m => m [Target] #

Returns the current set of targets

setTargets :: GhcMonad m => [Target] -> m () #

Sets the targets for this session. Each target may be a module name or a filename. The targets correspond to the set of root modules for the program/library. Unloading the current program is achieved by setting the current set of targets to be empty, followed by load.

parseDynamicFlags :: MonadIO m => DynFlags -> [Located String] -> m (DynFlags, [Located String], [Warn]) #

getInteractiveDynFlags :: GhcMonad m => m DynFlags #

Get the DynFlags used to evaluate interactive expressions.

setInteractiveDynFlags :: GhcMonad m => DynFlags -> m () #

Set the DynFlags used to evaluate interactive expressions. Note: this cannot be used for changes to packages. Use setSessionDynFlags, or setProgramDynFlags and then copy the pkgState into the interactive DynFlags.

getProgramDynFlags :: GhcMonad m => m DynFlags #

Returns the program DynFlags.

setLogAction :: GhcMonad m => LogAction -> m () #

Set the action taken when the compiler produces a message. This can also be accomplished using setProgramDynFlags, but using setLogAction avoids invalidating the cached module graph.

setProgramDynFlags :: GhcMonad m => DynFlags -> m [InstalledUnitId] #

Sets the program DynFlags. Note: this invalidates the internal cached module graph, causing more work to be done the next time load is called.

setSessionDynFlags :: GhcMonad m => DynFlags -> m [InstalledUnitId] #

Updates both the interactive and program DynFlags in a Session. This also reads the package database (unless it has already been read), and prepares the compilers knowledge about packages. It can be called again to load new packages: just add new package flags to (packageFlags dflags).

Returns a list of new packages that may need to be linked in using the dynamic linker (see linkPackages) as a result of new package flags. If you are not doing linking or doing static linking, you can ignore the list of packages returned.

initGhcMonad :: GhcMonad m => Maybe FilePath -> m () #

Initialise a GHC session.

If you implement a custom GhcMonad you must call this function in the monad run function. It will initialise the session variable and clear all warnings.

The first argument should point to the directory where GHC's library files reside. More precisely, this should be the output of ghc --print-libdir of the version of GHC the module using this API is compiled with. For portability, you should use the ghc-paths package, available at http://hackage.haskell.org/package/ghc-paths.

withCleanupSession :: GhcMonad m => m a -> m a #

runGhcT #

Arguments

:: ExceptionMonad m
=> Maybe FilePath	See argument to `initGhcMonad`.
-> GhcT m a	The action to perform.
-> m a

Run function for GhcT monad transformer.

It initialises the GHC session and warnings via initGhcMonad. Each call to this function will create a new session which should not be shared among several threads.

runGhc #

Arguments

:: Maybe FilePath	See argument to `initGhcMonad`.
-> Ghc a	The action to perform.
-> IO a

Run function for the Ghc monad.

It initialises the GHC session and warnings via initGhcMonad. Each call to this function will create a new session which should not be shared among several threads.

Any errors not handled inside the Ghc action are propagated as IO exceptions.

defaultCleanupHandler :: ExceptionMonad m => DynFlags -> m a -> m a #

This function is no longer necessary, cleanup is now done by runGhc/runGhcT.

defaultErrorHandler :: ExceptionMonad m => FatalMessager -> FlushOut -> m a -> m a #

Install some default exception handlers and run the inner computation. Unless you want to handle exceptions yourself, you should wrap this around the top level of your program. The default handlers output the error message(s) to stderr and exit cleanly.

class ParsedMod m where #

Minimal complete definition

modSummary, parsedSource

Methods

parsedSource :: m -> ParsedSource #

Instances

ParsedMod ParsedModule
Instance details Defined in GHC Methods modSummary :: ParsedModule -> ModSummary parsedSource :: ParsedModule -> ParsedSource #
ParsedMod TypecheckedModule
Instance details Defined in GHC Methods modSummary :: TypecheckedModule -> ModSummary parsedSource :: TypecheckedModule -> ParsedSource #
ParsedMod DesugaredModule
Instance details Defined in GHC Methods modSummary :: DesugaredModule -> ModSummary parsedSource :: DesugaredModule -> ParsedSource #

class ParsedMod m => TypecheckedMod m where #

Minimal complete definition

renamedSource, typecheckedSource, moduleInfo, tm_internals

Methods

renamedSource :: m -> Maybe RenamedSource #

typecheckedSource :: m -> TypecheckedSource #

moduleInfo :: m -> ModuleInfo #

Instances

TypecheckedMod TypecheckedModule
Instance details Defined in GHC Methods renamedSource :: TypecheckedModule -> Maybe RenamedSource # typecheckedSource :: TypecheckedModule -> TypecheckedSource # moduleInfo :: TypecheckedModule -> ModuleInfo # tm_internals :: TypecheckedModule -> (TcGblEnv, ModDetails)
TypecheckedMod DesugaredModule
Instance details Defined in GHC Methods renamedSource :: DesugaredModule -> Maybe RenamedSource # typecheckedSource :: DesugaredModule -> TypecheckedSource # moduleInfo :: DesugaredModule -> ModuleInfo # tm_internals :: DesugaredModule -> (TcGblEnv, ModDetails)

data ParsedModule #

The result of successful parsing.

Constructors

ParsedModule
Fields pm_mod_summary :: ModSummary pm_parsed_source :: ParsedSource pm_extra_src_files :: [FilePath] pm_annotations :: ApiAnns

Instances

Show ParsedModule Source #
Instance details Defined in Development.IDE.GHC.Orphans Methods showsPrec :: Int -> ParsedModule -> ShowS # show :: ParsedModule -> String # showList :: [ParsedModule] -> ShowS #
NFData ParsedModule Source #
Instance details Defined in Development.IDE.GHC.Orphans Methods rnf :: ParsedModule -> () #
ParsedMod ParsedModule
Instance details Defined in GHC Methods modSummary :: ParsedModule -> ModSummary parsedSource :: ParsedModule -> ParsedSource #

data TypecheckedModule #

The result of successful typechecking. It also contains the parser result.

Constructors

TypecheckedModule
Fields tm_parsed_module :: ParsedModule tm_renamed_source :: Maybe RenamedSource tm_typechecked_source :: TypecheckedSource tm_checked_module_info :: ModuleInfo tm_internals_ :: (TcGblEnv, ModDetails)

Instances

ParsedMod TypecheckedModule
Instance details Defined in GHC Methods modSummary :: TypecheckedModule -> ModSummary parsedSource :: TypecheckedModule -> ParsedSource #
TypecheckedMod TypecheckedModule
Instance details Defined in GHC Methods renamedSource :: TypecheckedModule -> Maybe RenamedSource # typecheckedSource :: TypecheckedModule -> TypecheckedSource # moduleInfo :: TypecheckedModule -> ModuleInfo # tm_internals :: TypecheckedModule -> (TcGblEnv, ModDetails)

data DesugaredModule #

The result of successful desugaring (i.e., translation to core). Also contains all the information of a typechecked module.

Constructors

DesugaredModule
Fields dm_typechecked_module :: TypecheckedModule dm_core_module :: ModGuts

Instances

ParsedMod DesugaredModule
Instance details Defined in GHC Methods modSummary :: DesugaredModule -> ModSummary parsedSource :: DesugaredModule -> ParsedSource #
TypecheckedMod DesugaredModule
Instance details Defined in GHC Methods renamedSource :: DesugaredModule -> Maybe RenamedSource # typecheckedSource :: DesugaredModule -> TypecheckedSource # moduleInfo :: DesugaredModule -> ModuleInfo # tm_internals :: DesugaredModule -> (TcGblEnv, ModDetails)
DesugaredMod DesugaredModule
Instance details Defined in GHC Methods coreModule :: DesugaredModule -> ModGuts #

type ParsedSource = Located (HsModule GhcPs) #

type RenamedSource = (HsGroup GhcRn, [LImportDecl GhcRn], Maybe [(LIE GhcRn, Avails)], Maybe LHsDocString) #

type TypecheckedSource = LHsBinds GhcTc #

data CoreModule #

A CoreModule consists of just the fields of a ModGuts that are needed for the compileToCoreModule interface.

Constructors

CoreModule
Fields cm_module :: !Module Module name cm_types :: !TypeEnv Type environment for types declared in this module cm_binds :: CoreProgram Declarations cm_safe :: SafeHaskellMode Safe Haskell mode

Instances

Show CoreModule Source #
Instance details Defined in Development.IDE.GHC.Orphans Methods showsPrec :: Int -> CoreModule -> ShowS # show :: CoreModule -> String # showList :: [CoreModule] -> ShowS #
NFData CoreModule Source #
Instance details Defined in Development.IDE.GHC.Orphans Methods rnf :: CoreModule -> () #
Outputable CoreModule
Instance details Defined in GHC Methods ppr :: CoreModule -> SDoc # pprPrec :: Rational -> CoreModule -> SDoc #

data ModuleInfo #

Container for information about a Module.

cyclicModuleErr :: [ModSummary] -> SDoc #

topSortModuleGraph #

Arguments

:: Bool	Drop hi-boot nodes? (see below)
-> ModuleGraph
-> Maybe ModuleName	Root module name. If `Nothing`, use the full graph.
-> [SCC ModSummary]

Topological sort of the module graph

Calculate SCCs of the module graph, possibly dropping the hi-boot nodes The resulting list of strongly-connected-components is in topologically sorted order, starting with the module(s) at the bottom of the dependency graph (ie compile them first) and ending with the ones at the top.

Drop hi-boot nodes (first boolean arg)?

False: treat the hi-boot summaries as nodes of the graph, so the graph must be acyclic
True: eliminate the hi-boot nodes, and instead pretend the a source-import of Foo is an import of Foo The resulting graph has no hi-boot nodes, but can be cyclic

load :: GhcMonad m => LoadHowMuch -> m SuccessFlag #

Try to load the program. See LoadHowMuch for the different modes.

This function implements the core of GHC's --make mode. It preprocesses, compiles and loads the specified modules, avoiding re-compilation wherever possible. Depending on the target (see hscTarget) compiling and loading may result in files being created on disk.

Calls the defaultWarnErrLogger after each compiling each module, whether successful or not.

Throw a SourceError if errors are encountered before the actual compilation starts (e.g., during dependency analysis). All other errors are reported using the defaultWarnErrLogger.

depanal #

Arguments

:: GhcMonad m
=> [ModuleName]	excluded modules
-> Bool	allow duplicate roots
-> m ModuleGraph

Perform a dependency analysis starting from the current targets and update the session with the new module graph.

Dependency analysis entails parsing the import directives and may therefore require running certain preprocessors.

Note that each ModSummary in the module graph caches its DynFlags. These DynFlags are determined by the current session DynFlags and the OPTIONS and LANGUAGE pragmas of the parsed module. Thus if you want changes to the DynFlags to take effect you need to call this function again.

data LoadHowMuch #

Describes which modules of the module graph need to be loaded.

Constructors

LoadAllTargets	Load all targets and its dependencies.
LoadUpTo ModuleName	Load only the given module and its dependencies.
LoadDependenciesOf ModuleName	Load only the dependencies of the given module, but not the module itself.

reconstructType :: HscEnv -> Int -> Id -> IO (Maybe Type) #

moduleIsBootOrNotObjectLinkable :: GhcMonad m => ModSummary -> m Bool #

showModule :: GhcMonad m => ModSummary -> m String #

dynCompileExpr :: GhcMonad m => String -> m Dynamic #

Compile an expression, run it and return the result as a Dynamic.

compileParsedExpr :: GhcMonad m => LHsExpr GhcPs -> m HValue #

compileParsedExprRemote :: GhcMonad m => LHsExpr GhcPs -> m ForeignHValue #

Compile a parsed expression (before renaming), run it, and deliver the resulting HValue.

compileExprRemote :: GhcMonad m => String -> m ForeignHValue #

Compile an expression, run it, and deliver the resulting HValue.

compileExpr :: GhcMonad m => String -> m HValue #

Compile an expression, run it, and deliver the resulting HValue.

parseExpr :: GhcMonad m => String -> m (LHsExpr GhcPs) #

Parse an expression, the parsed expression can be further processed and passed to compileParsedExpr.

typeKind :: GhcMonad m => Bool -> String -> m (Type, Kind) #

Get the kind of a type

exprType :: GhcMonad m => TcRnExprMode -> String -> m Type #

Get the type of an expression Returns the type as described by TcRnExprMode

getDocs :: GhcMonad m => Name -> m (Either GetDocsFailure (Maybe HsDocString, Map Int HsDocString)) #

isDecl :: DynFlags -> String -> Bool #

Returns True if passed string is a declaration but not a splice.

isImport :: DynFlags -> String -> Bool #

Returns True if passed string is an import declaration.

hasImport :: DynFlags -> String -> Bool #

Returns True if passed string has an import declaration.

isStmt :: DynFlags -> String -> Bool #

Returns True if passed string is a statement.

parseName :: GhcMonad m => String -> m [Name] #

Parses a string as an identifier, and returns the list of Names that the identifier can refer to in the current interactive context.

getRdrNamesInScope :: GhcMonad m => m [RdrName] #

Returns all RdrNames in scope in the current interactive context, excluding any that are internally-generated.

getNamesInScope :: GhcMonad m => m [Name] #

Returns all names in scope in the current interactive context

getInfo :: GhcMonad m => Bool -> Name -> m (Maybe (TyThing, Fixity, [ClsInst], [FamInst], SDoc)) #

Looks up an identifier in the current interactive context (for :info) Filter the instances by the ones whose tycons (or clases resp) are in scope (qualified or otherwise). Otherwise we list a whole lot too many! The exact choice of which ones to show, and which to hide, is a judgement call. (see Trac #1581)

moduleIsInterpreted :: GhcMonad m => Module -> m Bool #

Returns True if the specified module is interpreted, and hence has its full top-level scope available.

getContext :: GhcMonad m => m [InteractiveImport] #

Get the interactive evaluation context, consisting of a pair of the set of modules from which we take the full top-level scope, and the set of modules from which we take just the exports respectively.

setContext :: GhcMonad m => [InteractiveImport] -> m () #

Set the interactive evaluation context.

(setContext imports) sets the ic_imports field (which in turn determines what is in scope at the prompt) to imports, and constructs the ic_rn_glb_env environment to reflect it.

We retain in scope all the things defined at the prompt, and kept in ic_tythings. (Indeed, they shadow stuff from ic_imports.)

abandonAll :: GhcMonad m => m Bool #

abandon :: GhcMonad m => m Bool #

forward :: GhcMonad m => Int -> m ([Name], Int, SrcSpan, String) #

back :: GhcMonad m => Int -> m ([Name], Int, SrcSpan, String) #

resumeExec :: GhcMonad m => (SrcSpan -> Bool) -> SingleStep -> m ExecResult #

parseImportDecl :: GhcMonad m => String -> m (ImportDecl GhcPs) #

runDeclsWithLocation :: GhcMonad m => String -> Int -> String -> m [Name] #

Run some declarations and return any user-visible names that were brought into scope.

runDecls :: GhcMonad m => String -> m [Name] #

execStmt #

Arguments

:: GhcMonad m
=> String	a statement (bind or expression)
-> ExecOptions
-> m ExecResult

Run a statement in the current interactive context.

execOptions :: ExecOptions #

default ExecOptions

getHistoryModule :: History -> Module #

getResumeContext :: GhcMonad m => m [Resume] #

data GetDocsFailure #

Failure modes for getDocs.

Constructors

NameHasNoModule Name	`nameModule_maybe` returned `Nothing`.
NoDocsInIface Module Bool	`True`: The module was compiled. `False`: The module was :loaded.
InteractiveName	The `Name` was defined interactively.

Instances

Outputable GetDocsFailure
Instance details Defined in InteractiveEval Methods ppr :: GetDocsFailure -> SDoc # pprPrec :: Rational -> GetDocsFailure -> SDoc #

runTcInteractive :: HscEnv -> TcRn a -> IO (Messages, Maybe a) #

data TcRnExprMode #

How should we infer a type? See Note [TcRnExprMode]

Constructors

TM_Inst	Instantiate the type fully (:type)
TM_NoInst	Do not instantiate the type (:type +v)
TM_Default	Default the type eagerly (:type +d)

pprFamInst :: FamInst -> SDoc #

Pretty-prints a FamInst (type/data family instance) with its defining location.

defaultWarnErrLogger :: WarnErrLogger #

printException :: GhcMonad m => SourceError -> m () #

Print the error message and all warnings. Useful inside exception handlers. Clears warnings after printing.

getSessionDynFlags :: GhcMonad m => m DynFlags #

Grabs the DynFlags from the Session

class (Functor m, MonadIO m, ExceptionMonad m, HasDynFlags m) => GhcMonad (m :: Type -> Type) where #

A monad that has all the features needed by GHC API calls.

In short, a GHC monad

allows embedding of IO actions,
can log warnings,
allows handling of (extensible) exceptions, and
maintains a current session.

If you do not use Ghc or GhcT, make sure to call initGhcMonad before any call to the GHC API functions can occur.

Methods

getSession :: m HscEnv #

setSession :: HscEnv -> m () #

Instances

GhcMonad Ghc
Instance details Defined in GhcMonad Methods getSession :: Ghc HscEnv # setSession :: HscEnv -> Ghc () #
ExceptionMonad m => GhcMonad (GhcT m)
Instance details Defined in GhcMonad Methods getSession :: GhcT m HscEnv # setSession :: HscEnv -> GhcT m () #

data Ghc a #

A minimal implementation of a GhcMonad. If you need a custom monad, e.g., to maintain additional state consider wrapping this monad or using GhcT.

Instances

Monad Ghc
Instance details Defined in GhcMonad Methods (>>=) :: Ghc a -> (a -> Ghc b) -> Ghc b # (>>) :: Ghc a -> Ghc b -> Ghc b # return :: a -> Ghc a # fail :: String -> Ghc a #
Functor Ghc
Instance details Defined in GhcMonad Methods fmap :: (a -> b) -> Ghc a -> Ghc b # (<$) :: a -> Ghc b -> Ghc a #
MonadFix Ghc
Instance details Defined in GhcMonad Methods mfix :: (a -> Ghc a) -> Ghc a #
Applicative Ghc
Instance details Defined in GhcMonad Methods pure :: a -> Ghc a # (<>) :: Ghc (a -> b) -> Ghc a -> Ghc b # liftA2 :: (a -> b -> c) -> Ghc a -> Ghc b -> Ghc c # (>) :: Ghc a -> Ghc b -> Ghc b # (<*) :: Ghc a -> Ghc b -> Ghc a #
MonadIO Ghc
Instance details Defined in GhcMonad Methods liftIO :: IO a -> Ghc a #
GhcMonad Ghc
Instance details Defined in GhcMonad Methods getSession :: Ghc HscEnv # setSession :: HscEnv -> Ghc () #
HasDynFlags Ghc
Instance details Defined in GhcMonad Methods getDynFlags :: Ghc DynFlags #
ExceptionMonad Ghc
Instance details Defined in GhcMonad Methods gcatch :: Exception e => Ghc a -> (e -> Ghc a) -> Ghc a # gmask :: ((Ghc a -> Ghc a) -> Ghc b) -> Ghc b # gbracket :: Ghc a -> (a -> Ghc b) -> (a -> Ghc c) -> Ghc c # gfinally :: Ghc a -> Ghc b -> Ghc a #

data GhcT (m :: Type -> Type) a #

A monad transformer to add GHC specific features to another monad.

Note that the wrapped monad must support IO and handling of exceptions.

Instances

Monad m => Monad (GhcT m)
Instance details Defined in GhcMonad Methods (>>=) :: GhcT m a -> (a -> GhcT m b) -> GhcT m b # (>>) :: GhcT m a -> GhcT m b -> GhcT m b # return :: a -> GhcT m a # fail :: String -> GhcT m a #
Functor m => Functor (GhcT m)
Instance details Defined in GhcMonad Methods fmap :: (a -> b) -> GhcT m a -> GhcT m b # (<$) :: a -> GhcT m b -> GhcT m a #
Applicative m => Applicative (GhcT m)
Instance details Defined in GhcMonad Methods pure :: a -> GhcT m a # (<>) :: GhcT m (a -> b) -> GhcT m a -> GhcT m b # liftA2 :: (a -> b -> c) -> GhcT m a -> GhcT m b -> GhcT m c # (>) :: GhcT m a -> GhcT m b -> GhcT m b # (<*) :: GhcT m a -> GhcT m b -> GhcT m a #
MonadIO m => MonadIO (GhcT m)
Instance details Defined in GhcMonad Methods liftIO :: IO a -> GhcT m a #
ExceptionMonad m => GhcMonad (GhcT m)
Instance details Defined in GhcMonad Methods getSession :: GhcT m HscEnv # setSession :: HscEnv -> GhcT m () #
MonadIO m => HasDynFlags (GhcT m)
Instance details Defined in GhcMonad Methods getDynFlags :: GhcT m DynFlags #
ExceptionMonad m => ExceptionMonad (GhcT m)
Instance details Defined in GhcMonad Methods gcatch :: Exception e => GhcT m a -> (e -> GhcT m a) -> GhcT m a # gmask :: ((GhcT m a -> GhcT m a) -> GhcT m b) -> GhcT m b # gbracket :: GhcT m a -> (a -> GhcT m b) -> (a -> GhcT m c) -> GhcT m c # gfinally :: GhcT m a -> GhcT m b -> GhcT m a #

type WarnErrLogger = forall (m :: Type -> Type). GhcMonad m => Maybe SourceError -> m () #

A function called to log warnings and errors.

ms_mod_name :: ModSummary -> ModuleName #

mkModuleGraph :: [ModSummary] -> ModuleGraph #

emptyMG :: ModuleGraph #

mgLookupModule :: ModuleGraph -> Module -> Maybe ModSummary #

Look up a ModSummary in the ModuleGraph

mgModSummaries :: ModuleGraph -> [ModSummary] #

mapMG :: (ModSummary -> ModSummary) -> ModuleGraph -> ModuleGraph #

Map a function f over all the ModSummaries. To preserve invariants f can't change the isBoot status.

needsTemplateHaskellOrQQ :: ModuleGraph -> Bool #

Determines whether a set of modules requires Template Haskell or Quasi Quotes

Note that if the session's DynFlags enabled Template Haskell when depanal was called, then each module in the returned module graph will have Template Haskell enabled whether it is actually needed or not.

handleSourceError #

Arguments

:: ExceptionMonad m
=> (SourceError -> m a)	exception handler
-> m a	action to perform
-> m a

Perform the given action and call the exception handler if the action throws a SourceError. See SourceError for more information.

data HscEnv #

HscEnv is like Session, except that some of the fields are immutable. An HscEnv is used to compile a single module from plain Haskell source code (after preprocessing) to either C, assembly or C--. Things like the module graph don't change during a single compilation.

Historical note: "hsc" used to be the name of the compiler binary, when there was a separate driver and compiler. To compile a single module, the driver would invoke hsc on the source code... so nowadays we think of hsc as the layer of the compiler that deals with compiling a single module.

data Target #

A compilation target.

A target may be supplied with the actual text of the module. If so, use this instead of the file contents (this is for use in an IDE where the file hasn't been saved by the user yet).

Constructors

Target
Fields targetId :: TargetId module or filename targetAllowObjCode :: Bool object code allowed? targetContents :: Maybe (StringBuffer, UTCTime) in-memory text buffer?

Instances

Outputable Target
Instance details Defined in HscTypes Methods ppr :: Target -> SDoc # pprPrec :: Rational -> Target -> SDoc #

data TargetId #

Constructors

TargetModule ModuleName	A module name: search for the file
TargetFile FilePath (Maybe Phase)	A filename: preprocess & parse it to find the module name. If specified, the Phase indicates how to compile this file (which phase to start from). Nothing indicates the starting phase should be determined from the suffix of the filename.

Instances

Eq TargetId
Instance details Defined in HscTypes Methods (==) :: TargetId -> TargetId -> Bool # (/=) :: TargetId -> TargetId -> Bool #
Outputable TargetId
Instance details Defined in HscTypes Methods ppr :: TargetId -> SDoc # pprPrec :: Rational -> TargetId -> SDoc #

data ModIface #

A ModIface plus a ModDetails summarises everything we know about a compiled module. The ModIface is the stuff *before* linking, and can be written out to an interface file. The 'ModDetails is after linking and can be completely recovered from just the ModIface.

When we read an interface file, we also construct a ModIface from it, except that we explicitly make the mi_decls and a few other fields empty; as when reading we consolidate the declarations etc. into a number of indexed maps and environments in the ExternalPackageState.

Constructors

ModIface

Fields

mi_module :: !Module
Name of the module we are for
mi_sig_of :: !(Maybe Module)
Are we a sig of another mod?
mi_iface_hash :: !Fingerprint
Hash of the whole interface
mi_mod_hash :: !Fingerprint
Hash of the ABI only
mi_flag_hash :: !Fingerprint
Hash of the important flags used when compiling the module, excluding optimisation flags
mi_opt_hash :: !Fingerprint
Hash of optimisation flags
mi_hpc_hash :: !Fingerprint
Hash of hpc flags
mi_plugin_hash :: !Fingerprint
Hash of plugins
mi_orphan :: !WhetherHasOrphans
Whether this module has orphans
mi_finsts :: !WhetherHasFamInst
Whether this module has family instances. See Note [The type family instance consistency story].
mi_hsc_src :: !HscSource
Boot? Signature?
mi_deps :: Dependencies
The dependencies of the module. This is consulted for directly-imported modules, but not for anything else (hence lazy)
mi_usages :: [Usage]
Usages; kept sorted so that it's easy to decide whether to write a new iface file (changing usages doesn't affect the hash of this module) NOT STRICT! we read this field lazily from the interface file It is *only* consulted by the recompilation checker
mi_exports :: ![IfaceExport]
Exports Kept sorted by (mod,occ), to make version comparisons easier Records the modules that are the declaration points for things exported by this module, and the OccNames of those things
mi_exp_hash :: !Fingerprint
Hash of export list
mi_used_th :: !Bool
Module required TH splices when it was compiled. This disables recompilation avoidance (see #481).
mi_fixities :: [(OccName, Fixity)]
Fixities NOT STRICT! we read this field lazily from the interface file
mi_warns :: Warnings
Warnings NOT STRICT! we read this field lazily from the interface file
mi_anns :: [IfaceAnnotation]
Annotations NOT STRICT! we read this field lazily from the interface file
mi_decls :: [(Fingerprint, IfaceDecl)]
Type, class and variable declarations The hash of an Id changes if its fixity or deprecations change (as well as its type of course) Ditto data constructors, class operations, except that the hash of the parent class/tycon changes
mi_globals :: !(Maybe GlobalRdrEnv)
Binds all the things defined at the top level in the original source code for this module. which is NOT the same as mi_exports, nor mi_decls (which may contains declarations for things not actually defined by the user). Used for GHCi and for inspecting the contents of modules via the GHC API only.
(We need the source file to figure out the top-level environment, if we didn't compile this module from source then this field contains Nothing).
Strictly speaking this field should live in the HomeModInfo, but that leads to more plumbing.
mi_insts :: [IfaceClsInst]
Sorted class instance
mi_fam_insts :: [IfaceFamInst]
Sorted family instances
mi_rules :: [IfaceRule]
Sorted rules
mi_orphan_hash :: !Fingerprint
Hash for orphan rules, class and family instances combined
mi_warn_fn :: OccName -> Maybe WarningTxt
Cached lookup for mi_warns
mi_fix_fn :: OccName -> Maybe Fixity
Cached lookup for mi_fixities
mi_hash_fn :: OccName -> Maybe (OccName, Fingerprint)
Cached lookup for mi_decls. The Nothing in mi_hash_fn means that the thing isn't in decls. It's useful to know that when seeing if we are up to date wrt. the old interface. The OccName is the parent of the name, if it has one.
mi_hpc :: !AnyHpcUsage
True if this program uses Hpc at any point in the program.
mi_trust :: !IfaceTrustInfo
Safe Haskell Trust information for this module.
mi_trust_pkg :: !Bool
Do we require the package this module resides in be trusted to trust this module? This is used for the situation where a module is Safe (so doesn't require the package be trusted itself) but imports some trustworthy modules from its own package (which does require its own package be trusted). See Note [RnNames . Trust Own Package]
mi_complete_sigs :: [IfaceCompleteMatch]
mi_doc_hdr :: Maybe HsDocString
Module header.
mi_decl_docs :: DeclDocMap
Docs on declarations.
mi_arg_docs :: ArgDocMap
Docs on arguments.

Instances

Binary ModIface
Instance details Defined in HscTypes Methods put_ :: BinHandle -> ModIface -> IO () # put :: BinHandle -> ModIface -> IO (Bin ModIface) # get :: BinHandle -> IO ModIface #

data InteractiveImport #

Constructors

IIDecl (ImportDecl GhcPs)	Bring the exports of a particular module (filtered by an import decl) into scope
IIModule ModuleName	Bring into scope the entire top-level envt of of this module, including the things imported into it.

Instances

Outputable InteractiveImport
Instance details Defined in HscTypes Methods ppr :: InteractiveImport -> SDoc # pprPrec :: Rational -> InteractiveImport -> SDoc #

data ModuleGraph #

A ModuleGraph contains all the nodes from the home package (only). There will be a node for each source module, plus a node for each hi-boot module.

The graph is not necessarily stored in topologically-sorted order. Use topSortModuleGraph and flattenSCC to achieve this.

data ModSummary #

A single node in a ModuleGraph. The nodes of the module graph are one of:

A regular Haskell source module
A hi-boot source module

Constructors

ModSummary

Fields

ms_mod :: Module
Identity of the module
ms_hsc_src :: HscSource
The module source either plain Haskell or hs-boot
ms_location :: ModLocation
Location of the various files belonging to the module
ms_hs_date :: UTCTime
Timestamp of source file
ms_obj_date :: Maybe UTCTime
Timestamp of object, if we have one
ms_iface_date :: Maybe UTCTime
Timestamp of hi file, if we *only* are typechecking (it is Nothing otherwise. See Note [Recompilation checking in -fno-code mode] and #9243
ms_srcimps :: [(Maybe FastString, Located ModuleName)]
Source imports of the module
ms_textual_imps :: [(Maybe FastString, Located ModuleName)]
Non-source imports of the module from the module *text*
ms_parsed_mod :: Maybe HsParsedModule
The parsed, nonrenamed source, if we have it. This is also used to support "inline module syntax" in Backpack files.
ms_hspp_file :: FilePath
Filename of preprocessed source file
ms_hspp_opts :: DynFlags
Cached flags from OPTIONS, INCLUDE and LANGUAGE pragmas in the modules source code
ms_hspp_buf :: Maybe StringBuffer
The actual preprocessed source, if we have it

Instances

Show ModSummary Source #
Instance details Defined in Development.IDE.GHC.Orphans Methods showsPrec :: Int -> ModSummary -> ShowS # show :: ModSummary -> String # showList :: [ModSummary] -> ShowS #
NFData ModSummary Source #
Instance details Defined in Development.IDE.GHC.Orphans Methods rnf :: ModSummary -> () #
Outputable ModSummary
Instance details Defined in HscTypes Methods ppr :: ModSummary -> SDoc # pprPrec :: Rational -> ModSummary -> SDoc #

data HsModule pass #

Haskell Module

All we actually declare here is the top-level structure for a module.

Constructors

HsModule

AnnKeywordIds

AnnModule,AnnWhere
AnnOpen,AnnSemi, AnnClose for explicit braces and semi around hsmodImports,hsmodDecls if this style is used.

Fields

hsmodName :: Maybe (Located ModuleName)
Nothing: "module X where" is omitted (in which case the next field is Nothing too)
hsmodExports :: Maybe (Located [LIE pass])
Export list
- Nothing: export list omitted, so export everything
- Just []: export nothing
- Just [...]: as you would expect...
- AnnKeywordIds : AnnOpen ,AnnClose
hsmodImports :: [LImportDecl pass]
We snaffle interesting stuff out of the imported interfaces early on, adding that info to TyDecls/etc; so this list is often empty, downstream.
hsmodDecls :: [LHsDecl pass]
Type, class, value, and interface signature decls
hsmodDeprecMessage :: Maybe (Located WarningTxt)
reason/explanation for warning/deprecation of this module
- AnnKeywordIds : AnnOpen ,AnnClose
hsmodHaddockModHeader :: Maybe LHsDocString
Haddock module info and description, unparsed
- AnnKeywordIds : AnnOpen ,AnnClose

Instances

Data (HsModule GhcPs)
Instance details Defined in HsSyn 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 :: (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 HsSyn 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 :: (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 HsSyn 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 :: (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) #
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsModule p)
Instance details Defined in HsSyn Methods ppr :: HsModule p -> SDoc # pprPrec :: Rational -> HsModule p -> SDoc #

lPatImplicits :: LPat GhcRn -> NameSet #

hsValBindsImplicits :: HsValBindsLR GhcRn (GhcPass idR) -> NameSet #

lStmtsImplicits :: [LStmtLR GhcRn (GhcPass idR) (Located (body (GhcPass idR)))] -> NameSet #

hsDataFamInstBinders :: DataFamInstDecl pass -> ([Located (IdP pass)], [LFieldOcc pass]) #

getPatSynBinds :: [(RecFlag, LHsBinds id)] -> [PatSynBind id id] #

hsPatSynSelectors :: HsValBinds (GhcPass p) -> [IdP (GhcPass p)] #

hsForeignDeclsBinders :: [LForeignDecl pass] -> [Located (IdP pass)] #

hsLTyClDeclBinders :: Located (TyClDecl pass) -> ([Located (IdP pass)], [LFieldOcc pass]) #

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 :: [LPat a] -> [IdP a] #

collectPatBinders :: LPat a -> [IdP a] #

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

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

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

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

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

collectHsBindListBinders :: [LHsBindLR idL idR] -> [IdP idL] #

collectHsBindsBinders :: LHsBindsLR idL idR -> [IdP idL] #

collectHsBindBinders :: HsBindLR idL idR -> [IdP idL] #

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

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

collectLocalBinders :: 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 :: 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

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

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 :: 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 #

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

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

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

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

mkLHsCmdWrap :: HsWrapper -> LHsCmd (GhcPass p) -> LHsCmd (GhcPass p) #

mkHsCmdWrap :: HsWrapper -> HsCmd (GhcPass p) -> HsCmd (GhcPass p) #

mkLHsWrapCo :: TcCoercionN -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #

mkHsWrapCoR :: TcCoercionR -> HsExpr (GhcPass id) -> HsExpr (GhcPass id) #

mkHsWrapCo :: TcCoercionN -> HsExpr (GhcPass id) -> HsExpr (GhcPass id) #

mkHsWrap :: HsWrapper -> HsExpr (GhcPass id) -> HsExpr (GhcPass id) #

mkLHsWrap :: 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] #

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 #

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

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

missingTupArg :: HsTupArg GhcPs #

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

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

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

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

nlHsParTy :: LHsType (GhcPass p) -> LHsType (GhcPass p) #

nlHsFunTy :: LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) #

nlHsTyVar :: IdP (GhcPass p) -> LHsType (GhcPass p) #

nlHsAppTy :: LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) #

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

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

nlHsIf :: LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #

nlHsPar :: 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 #

nlWildPat :: LPat GhcPs #

nlWildConPat :: DataCon -> LPat GhcPs #

nlNullaryConPat :: IdP id -> LPat id #

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 :: IdP (GhcPass id) -> [IdP (GhcPass id)] -> LHsExpr (GhcPass id) #

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

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

nlHsApp :: LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #

nlLitPat :: HsLit GhcPs -> LPat GhcPs #

nlVarPat :: IdP (GhcPass id) -> LPat (GhcPass id) #

nlHsIntLit :: Integer -> LHsExpr (GhcPass p) #

nlHsLit :: HsLit (GhcPass p) -> LHsExpr (GhcPass p) #

nlHsDataCon :: DataCon -> LHsExpr GhcTc #

nlHsVar :: IdP (GhcPass id) -> LHsExpr (GhcPass id) #

userHsTyVarBndrs :: SrcSpan -> [IdP (GhcPass p)] -> [LHsTyVarBndr (GhcPass p)] #

userHsLTyVarBndrs :: SrcSpan -> [Located (IdP (GhcPass p))] -> [LHsTyVarBndr (GhcPass p)] #

mkHsStringPrimLit :: FastString -> HsLit (GhcPass p) #

mkHsString :: String -> HsLit (GhcPass p) #

unqualQuasiQuote :: RdrName #

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

mkHsSpliceTy :: SpliceDecoration -> LHsExpr GhcPs -> HsType GhcPs #

mkHsSpliceTE :: SpliceDecoration -> LHsExpr GhcPs -> HsExpr GhcPs #

mkHsSpliceE :: SpliceDecoration -> LHsExpr GhcPs -> HsExpr GhcPs #

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

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

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

emptyRecStmtId :: StmtLR GhcTc GhcTc bodyR #

emptyRecStmtName :: StmtLR GhcRn GhcRn bodyR #

emptyRecStmt :: StmtLR (GhcPass idL) GhcPs bodyR #

unitRecStmtTc :: RecStmtTc #

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

mkBindStmt :: XBindStmt (GhcPass idL) (GhcPass idR) (Located (bodyR (GhcPass idR))) ~ NoExt => LPat (GhcPass idL) -> Located (bodyR (GhcPass idR)) -> StmtLR (GhcPass idL) (GhcPass idR) (Located (bodyR (GhcPass idR))) #

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

mkLastStmt :: 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 #

mkHsIf :: 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 :: LPat (GhcPass name) -> LPat (GhcPass name) #

mkParPat :: LPat (GhcPass name) -> LPat (GhcPass name) #

mkLHsPar :: LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #

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

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

mkHsCaseAlt :: 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 :: [LPat GhcPs] -> LHsExpr GhcPs -> LHsExpr GhcPs #

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

mkHsAppType :: XAppTypeE (GhcPass id) ~ LHsWcType GhcRn => LHsExpr (GhcPass id) -> LHsWcType GhcRn -> LHsExpr (GhcPass id) #

mkHsApp :: LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #

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

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

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

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

mkHsPar :: LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #

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

pprMatchInCtxt :: (OutputableBndrId (GhcPass 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 #

isMonadFailStmtContext :: HsStmtContext id -> Bool #

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

isListCompExpr :: HsStmtContext id -> Bool #

isPatSynCtxt :: HsMatchContext id -> Bool #

pp_dotdot :: SDoc #

thTyBrackets :: SDoc -> SDoc #

thBrackets :: SDoc -> SDoc -> SDoc #

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

isTypedBracket :: HsBracket id -> Bool #

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

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

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

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

isTypedSplice :: HsSplice id -> Bool #

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

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

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

pprDo :: (OutputableBndrId (GhcPass 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 :: OutputableBndrId (GhcPass p) => [IdP (GhcPass p)] -> LHsExpr (GhcPass p) -> Maybe (LHsExpr (GhcPass p)) -> SDoc #

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

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

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

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

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

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

hsLMatchPats :: LMatch id body -> [LPat id] #

matchGroupArity :: MatchGroup 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 :: OutputableBndrId (GhcPass p) => HsCmdTop (GhcPass p) -> SDoc #

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

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

isQuietHsCmd :: HsCmd id -> Bool #

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

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

isAtomicHsExpr :: HsExpr id -> Bool #

parenthesizeHsExpr :: 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 :: OutputableBndrId (GhcPass p) => PprPrec -> HsExpr (GhcPass p) -> SDoc #

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

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

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

ppr_apps :: OutputableBndrId (GhcPass p) => HsExpr (GhcPass p) -> [Either (LHsExpr (GhcPass p)) (XAppTypeE (GhcPass p))] -> SDoc #

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

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

pprBinds :: (OutputableBndrId (GhcPass idL), OutputableBndrId (GhcPass 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.

noSyntaxExpr :: SyntaxExpr (GhcPass p) #

noExpr :: 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

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

Data UnboundVar
Instance details Defined in HsExpr 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 :: (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 HsExpr 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

Data RecordUpdTc

Instance details

Defined in HsExpr

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 :: (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

type LHsCmd id = Located (HsCmd id) #

Located Haskell Command (for arrow syntax)

data HsArrAppType #

Haskell Array Application Type

Constructors

HsHigherOrderApp
HsFirstOrderApp

Instances

Data HsArrAppType

Instance details

Defined in HsExpr

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 :: (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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsCmdTop p)
Instance details Defined in HsExpr Methods ppr :: HsCmdTop p -> SDoc # pprPrec :: Rational -> HsCmdTop p -> SDoc #

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

Data MatchGroupTc

Instance details

Defined in HsExpr

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 :: (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

(idR ~ GhcPass pr, OutputableBndrId idR, Outputable body) => Outputable (Match idR body)
Instance details Defined in HsExpr Methods ppr :: Match idR body -> SDoc # pprPrec :: Rational -> Match idR body -> SDoc #

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)

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

(idL ~ GhcPass pl, idR ~ GhcPass pr, OutputableBndrId idL, OutputableBndrId idR, Outputable body) => Outputable (StmtLR idL idR body)
Instance details Defined in HsExpr Methods ppr :: StmtLR idL idR body -> SDoc # pprPrec :: Rational -> StmtLR idL idR 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

Data TransForm

Instance details

Defined in HsExpr

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 :: (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

(Outputable (StmtLR idL idL (LHsExpr idL)), Outputable (XXParStmtBlock idL idR)) => Outputable (ParStmtBlock idL idR)
Instance details Defined in HsExpr Methods ppr :: ParStmtBlock idL idR -> SDoc # pprPrec :: Rational -> ParStmtBlock idL idR -> SDoc #

data ApplicativeArg idL #

Applicative Argument

Constructors

ApplicativeArgOne (XApplicativeArgOne idL) (LPat idL) (LHsExpr idL) Bool
ApplicativeArgMany (XApplicativeArgMany idL) [ExprLStmt idL] (HsExpr idL) (LPat idL)
XApplicativeArg (XXApplicativeArg idL)

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

Eq SpliceDecoration
Instance details Defined in HsExpr Methods (==) :: SpliceDecoration -> SpliceDecoration -> Bool # (/=) :: SpliceDecoration -> SpliceDecoration -> Bool #
Data SpliceDecoration
Instance details Defined in HsExpr 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 :: (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 HsExpr Methods showsPrec :: Int -> SpliceDecoration -> ShowS # show :: SpliceDecoration -> String # showList :: [SpliceDecoration] -> ShowS #
Outputable SpliceDecoration
Instance details Defined in HsExpr 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

Data ThModFinalizers

Instance details

Defined in HsExpr

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 :: (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 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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsSplicedThing p)
Instance details Defined in HsExpr Methods ppr :: HsSplicedThing p -> SDoc # pprPrec :: Rational -> HsSplicedThing p -> SDoc #

type SplicePointName = Name #

data PendingRnSplice #

Pending Renamer Splice

Constructors

PendingRnSplice UntypedSpliceFlavour SplicePointName (LHsExpr GhcRn)

Instances

Outputable PendingRnSplice
Instance details Defined in HsExpr Methods ppr :: PendingRnSplice -> SDoc # pprPrec :: Rational -> PendingRnSplice -> SDoc #

data UntypedSpliceFlavour #

Constructors

UntypedExpSplice
UntypedPatSplice
UntypedTypeSplice
UntypedDeclSplice

Instances

Data UntypedSpliceFlavour

Instance details

Defined in HsExpr

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 :: (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

Outputable PendingTcSplice
Instance details Defined in HsExpr 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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsBracket p)
Instance details Defined in HsExpr Methods ppr :: HsBracket p -> SDoc # pprPrec :: Rational -> HsBracket 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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (ArithSeqInfo p)
Instance details Defined in HsExpr Methods ppr :: ArithSeqInfo p -> SDoc # pprPrec :: Rational -> ArithSeqInfo 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

Functor HsMatchContext
Instance details Defined in HsExpr Methods fmap :: (a -> b) -> HsMatchContext a -> HsMatchContext b # (<$) :: a -> HsMatchContext b -> HsMatchContext a #
Data id => Data (HsMatchContext id)
Instance details Defined in HsExpr 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 :: (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 HsExpr 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

Functor HsStmtContext
Instance details Defined in HsExpr Methods fmap :: (a -> b) -> HsStmtContext a -> HsStmtContext b # (<$) :: a -> HsStmtContext b -> HsStmtContext a #
Data id => Data (HsStmtContext id)
Instance details Defined in HsExpr 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 :: (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 p, Outputable (NameOrRdrName p)) => Outputable (HsStmtContext p)
Instance details Defined in HsExpr Methods ppr :: HsStmtContext p -> SDoc # pprPrec :: Rational -> HsStmtContext p -> SDoc #

roleAnnotDeclName :: RoleAnnotDecl pass -> IdP pass #

annProvenanceName_maybe :: AnnProvenance name -> Maybe name #

docDeclDoc :: DocDecl -> HsDocString #

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

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

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

derivStrategyName :: DerivStrategy a -> SDoc #

A short description of a DerivStrategy'.

instDeclDataFamInsts :: [LInstDecl pass] -> [DataFamInstDecl pass] #

pprFamInstLHS :: OutputableBndrId (GhcPass p) => Located (IdP (GhcPass p)) -> HsTyPats (GhcPass p) -> LexicalFixity -> HsContext (GhcPass p) -> Maybe (LHsKind (GhcPass p)) -> SDoc #

pprDataFamInstFlavour :: DataFamInstDecl (GhcPass p) -> SDoc #

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

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

getConNames :: ConDecl pass -> [Located (IdP pass)] #

newOrDataToFlavour :: NewOrData -> TyConFlavour #

Convert a NewOrData to a TyConFlavour

resultVariableName :: FamilyResultSig a -> Maybe (IdP a) #

Maybe return name of the result type variable

famDeclHasCusk #

Arguments

:: Maybe Bool	if associated, does the enclosing class have a CUSK?
-> FamilyDecl pass
-> Bool

Does this family declaration have a complete, user-supplied kind signature?

mkTyClGroup :: [LTyClDecl (GhcPass p)] -> [LInstDecl (GhcPass p)] -> TyClGroup (GhcPass p) #

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

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

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

emptyTyClGroup :: TyClGroup (GhcPass p) #

pprTyClDeclFlavour :: TyClDecl (GhcPass p) -> SDoc #

hsDeclHasCusk :: TyClDecl GhcRn -> Bool #

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

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

tyClDeclTyVars :: TyClDecl pass -> LHsQTyVars pass #

tcdName :: TyClDecl pass -> IdP pass #

tyClDeclLName :: TyClDecl pass -> Located (IdP pass) #

tyFamInstDeclLName :: TyFamInstDecl pass -> Located (IdP pass) #

tyFamInstDeclName :: TyFamInstDecl pass -> IdP pass #

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 :: HsGroup (GhcPass p) -> HsGroup (GhcPass p) -> HsGroup (GhcPass p) #

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

emptyRnGroup :: HsGroup (GhcPass p) #

emptyRdrGroup :: 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

DefD (XDefD p) (DefaultDecl p)	'default' 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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsDecl p)
Instance details Defined in HsDecls Methods ppr :: HsDecl p -> SDoc # pprPrec :: Rational -> HsDecl p -> SDoc #

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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsGroup p)
Instance details Defined in HsDecls Methods ppr :: HsGroup p -> SDoc # pprPrec :: Rational -> HsGroup 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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (SpliceDecl p)
Instance details Defined in HsDecls Methods ppr :: SpliceDecl p -> SDoc # pprPrec :: Rational -> SpliceDecl p -> SDoc #

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 :: [Located (FunDep (Located (IdP pass)))] Functional deps tcdSigs :: [LSig pass] Methods' signatures tcdMeths :: LHsBinds pass Default methods tcdATs :: [LFamilyDecl pass] Associated types; tcdATDefs :: [LTyFamDefltEqn pass] Associated type defaults tcdDocs :: [LDocDecl] Haddock docs
XTyClDecl (XXTyClDecl pass)

Instances

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (TyClDecl p)
Instance details Defined in HsDecls Methods ppr :: TyClDecl p -> SDoc # pprPrec :: Rational -> TyClDecl p -> SDoc #

data DataDeclRn #

Constructors

DataDeclRn
Fields tcdDataCusk :: Bool does this have a CUSK? tcdFVs :: NameSet

Instances

Data DataDeclRn

Instance details

Defined in HsDecls

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 :: (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_instds :: [LInstDecl pass]
XTyClGroup (XXTyClGroup pass)

Instances

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (TyClGroup p)
Instance details Defined in HsDecls Methods ppr :: TyClGroup p -> SDoc # pprPrec :: Rational -> TyClGroup 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)

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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (FamilyDecl p)
Instance details Defined in HsDecls Methods ppr :: FamilyDecl p -> SDoc # pprPrec :: Rational -> FamilyDecl p -> SDoc #

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

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

Outputable (FamilyInfo pass)
Instance details Defined in HsDecls 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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsDataDefn p)
Instance details Defined in HsDecls Methods ppr :: HsDataDefn p -> SDoc # pprPrec :: Rational -> HsDataDefn 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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsDerivingClause p)
Instance details Defined in HsDecls Methods ppr :: HsDerivingClause p -> SDoc # pprPrec :: Rational -> HsDerivingClause p -> SDoc #

data NewOrData #

Constructors

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

Instances

Eq NewOrData
Instance details Defined in HsDecls Methods (==) :: NewOrData -> NewOrData -> Bool # (/=) :: NewOrData -> NewOrData -> Bool #
Data NewOrData
Instance details Defined in HsDecls 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 :: (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 HsDecls 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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (ConDecl p)
Instance details Defined in HsDecls Methods ppr :: ConDecl p -> SDoc # pprPrec :: Rational -> ConDecl p -> SDoc #

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 LTyFamDefltEqn pass = Located (TyFamDefltEqn pass) #

Located Type Family Default Equation

type HsTyPats pass = [LHsType pass] #

Haskell Type Patterns

type TyFamInstEqn pass = FamInstEqn pass (LHsType pass) #

Type Family Instance Equation

type TyFamDefltEqn pass = FamEqn pass (LHsQTyVars pass) (LHsType pass) #

Type Family Default Equation

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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (TyFamInstDecl p)
Instance details Defined in HsDecls Methods ppr :: TyFamInstDecl p -> SDoc # pprPrec :: Rational -> TyFamInstDecl p -> SDoc #

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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (DataFamInstDecl p)
Instance details Defined in HsDecls Methods ppr :: DataFamInstDecl p -> SDoc # pprPrec :: Rational -> DataFamInstDecl p -> SDoc #

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

Located Family Instance Equation

type FamInstEqn pass rhs #

Arguments

= HsImplicitBndrs pass (FamEqn pass (HsTyPats 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 pats 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 pats rhs feqn_tycon :: Located (IdP pass) feqn_pats :: pats feqn_fixity :: LexicalFixity Fixity used in the declaration feqn_rhs :: rhs
XFamEqn (XXFamEqn pass pats rhs)

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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (ClsInstDecl p)
Instance details Defined in HsDecls Methods ppr :: ClsInstDecl p -> SDoc # pprPrec :: Rational -> ClsInstDecl p -> SDoc #

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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (InstDecl p)
Instance details Defined in HsDecls Methods ppr :: InstDecl p -> SDoc # pprPrec :: Rational -> InstDecl p -> SDoc #

type LDerivDecl pass = Located (DerivDecl pass) #

Located Deriving Declaration

data DerivDecl pass #

Deriving 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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (DerivDecl p)
Instance details Defined in HsDecls Methods ppr :: DerivDecl p -> SDoc # pprPrec :: Rational -> DerivDecl p -> SDoc #

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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (DerivStrategy p)
Instance details Defined in HsDecls Methods ppr :: DerivStrategy p -> SDoc # pprPrec :: Rational -> DerivStrategy p -> SDoc #

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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (DefaultDecl p)
Instance details Defined in HsDecls Methods ppr :: DefaultDecl p -> SDoc # pprPrec :: Rational -> DefaultDecl p -> SDoc #

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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (ForeignDecl p)
Instance details Defined in HsDecls Methods ppr :: ForeignDecl p -> SDoc # pprPrec :: Rational -> ForeignDecl p -> SDoc #

data ForeignImport #

Constructors

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

Instances

Data ForeignImport
Instance details Defined in HsDecls 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 :: (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 HsDecls Methods ppr :: ForeignImport -> SDoc # pprPrec :: Rational -> ForeignImport -> SDoc #

data CImportSpec #

Constructors

CLabel CLabelString
CFunction CCallTarget
CWrapper

Instances

Data CImportSpec

Instance details

Defined in HsDecls

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 :: (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

Data ForeignExport
Instance details Defined in HsDecls 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 :: (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 HsDecls 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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (RuleDecls p)
Instance details Defined in HsDecls Methods ppr :: RuleDecls p -> SDoc # pprPrec :: Rational -> RuleDecls p -> SDoc #

type LRuleDecl pass = Located (RuleDecl pass) #

Located Rule Declaration

data RuleDecl pass #

Rule Declaration

Constructors

HsRule (XHsRule pass) (Located (SourceText, RuleName)) Activation [LRuleBndr pass] (Located (HsExpr pass)) (Located (HsExpr pass))	`AnnKeywordId` : `AnnOpen`,`AnnTilde`, `AnnVal`, `AnnClose`, `AnnForall`,`AnnDot`, `AnnEqual`,
XRuleDecl (XXRuleDecl pass)

Instances

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (RuleDecl p)
Instance details Defined in HsDecls Methods ppr :: RuleDecl p -> SDoc # pprPrec :: Rational -> RuleDecl p -> SDoc #

data HsRuleRn #

Constructors

HsRuleRn NameSet NameSet

Instances

Data HsRuleRn

Instance details

Defined in HsDecls

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 :: (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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (RuleBndr p)
Instance details Defined in HsDecls Methods ppr :: RuleBndr p -> SDoc # pprPrec :: Rational -> RuleBndr p -> SDoc #

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

Data DocDecl
Instance details Defined in HsDecls 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 :: (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 HsDecls Methods ppr :: DocDecl -> SDoc # pprPrec :: Rational -> DocDecl -> SDoc #

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

(p ~ GhcPass pass, OutputableBndr (IdP p)) => Outputable (WarnDecls p)
Instance details Defined in HsDecls Methods ppr :: WarnDecls p -> SDoc # pprPrec :: Rational -> WarnDecls p -> SDoc #

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

(p ~ GhcPass pass, OutputableBndr (IdP p)) => Outputable (WarnDecl p)
Instance details Defined in HsDecls Methods ppr :: WarnDecl p -> SDoc # pprPrec :: Rational -> WarnDecl p -> SDoc #

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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (AnnDecl p)
Instance details Defined in HsDecls Methods ppr :: AnnDecl p -> SDoc # pprPrec :: Rational -> AnnDecl p -> SDoc #

data AnnProvenance name #

Annotation Provenance

Constructors

ValueAnnProvenance (Located name)
TypeAnnProvenance (Located name)
ModuleAnnProvenance

Instances

Functor AnnProvenance
Instance details Defined in HsDecls Methods fmap :: (a -> b) -> AnnProvenance a -> AnnProvenance b # (<$) :: a -> AnnProvenance b -> AnnProvenance a #
Foldable AnnProvenance
Instance details Defined in HsDecls Methods fold :: Monoid m => AnnProvenance m -> 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 HsDecls 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 HsDecls 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 :: (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

(p ~ GhcPass pass, OutputableBndr (IdP p)) => Outputable (RoleAnnotDecl p)
Instance details Defined in HsDecls Methods ppr :: RoleAnnotDecl p -> SDoc # pprPrec :: Rational -> RoleAnnotDecl p -> SDoc #

collectEvVarsPat :: Pat GhcTc -> Bag EvVar #

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

parenthesizePat :: 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 :: OutputableBndrId p => LPat p -> Bool #

looksLazyPatBind :: HsBind p -> Bool #

isBangedLPat :: LPat p -> Bool #

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

mkNilPat :: Type -> OutPat p #

mkPrefixConPat :: DataCon -> [OutPat p] -> [Type] -> OutPat p #

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

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

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

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

hsRecUpdFieldRdr :: 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 Int

Instances

Functor (HsRecFields p)
Instance details Defined in HsPat Methods fmap :: (a -> b) -> HsRecFields p a -> HsRecFields p b # (<$) :: a -> HsRecFields p b -> HsRecFields p a #
Foldable (HsRecFields p)
Instance details Defined in HsPat Methods fold :: Monoid m => HsRecFields p m -> 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 HsPat 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 HsPat 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

Functor (HsRecField' id)
Instance details Defined in HsPat Methods fmap :: (a -> b) -> HsRecField' id a -> HsRecField' id b # (<$) :: a -> HsRecField' id b -> HsRecField' id a #
Foldable (HsRecField' id)
Instance details Defined in HsPat Methods fold :: Monoid m => HsRecField' id m -> 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 HsPat 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) #
(Data id, Data arg) => Data (HsRecField' id arg)
Instance details Defined in HsPat 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 :: (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 HsPat Methods ppr :: HsRecField' p arg -> SDoc # pprPrec :: Rational -> HsRecField' p arg -> SDoc #

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 :: OutputableBndrId (GhcPass 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 :: HsIPBinds (GhcPass p) -> Bool #

pprTicks :: SDoc -> SDoc -> SDoc #

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

plusHsValBinds :: HsValBinds (GhcPass a) -> HsValBinds (GhcPass a) -> HsValBinds (GhcPass a) #

isEmptyLHsBinds :: LHsBindsLR idL idR -> Bool #

emptyLHsBinds :: LHsBindsLR idL idR #

emptyValBindsOut :: HsValBindsLR (GhcPass a) (GhcPass b) #

emptyValBindsIn :: HsValBindsLR (GhcPass a) (GhcPass b) #

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

eqEmptyLocalBinds :: HsLocalBindsLR a b -> Bool #

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

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

emptyLocalBinds :: HsLocalBindsLR (GhcPass a) (GhcPass b) #

pprDeclList :: [SDoc] -> SDoc #

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

pprLHsBinds :: (OutputableBndrId (GhcPass idL), OutputableBndrId (GhcPass 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

(idL ~ GhcPass pl, idR ~ GhcPass pr, OutputableBndrId idL, OutputableBndrId idR) => Outputable (HsLocalBindsLR idL idR)
Instance details Defined in HsBinds Methods ppr :: HsLocalBindsLR idL idR -> SDoc # pprPrec :: Rational -> HsLocalBindsLR idL idR -> 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

(idL ~ GhcPass pl, idR ~ GhcPass pr, OutputableBndrId idL, OutputableBndrId idR) => Outputable (HsValBindsLR idL idR)
Instance details Defined in HsBinds Methods ppr :: HsValBindsLR idL idR -> SDoc # pprPrec :: Rational -> HsValBindsLR idL idR -> 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
XHsBindsLR (XXHsBindsLR idL idR)

Instances

(idL ~ GhcPass pl, idR ~ GhcPass pr, OutputableBndrId idL, OutputableBndrId idR) => Outputable (HsBindLR idL idR)
Instance details Defined in HsBinds Methods ppr :: HsBindLR idL idR -> SDoc # pprPrec :: Rational -> HsBindLR idL idR -> SDoc #

data NPatBindTc #

Constructors

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

Instances

Data NPatBindTc

Instance details

Defined in HsBinds

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 :: (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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (ABExport p)
Instance details Defined in HsBinds Methods ppr :: ABExport p -> SDoc # pprPrec :: Rational -> ABExport p -> SDoc #

pattern XPatSynBind :: XXPatSynBind idL idR -> PatSynBind idL idR #

pattern PSB :: XPSB idL idR -> Located (IdP idL) -> HsPatSynDetails (Located (IdP idR)) -> LPat idR -> HsPatSynDir idR -> PatSynBind idL idR #

psb_ext :: PatSynBind idL idR -> XPSB idL idR #

Post renaming, FVs. See Note [Bind free vars]

psb_id :: PatSynBind idL idR -> Located (IdP idL) #

Name of the pattern synonym

psb_args :: PatSynBind idL idR -> HsPatSynDetails (Located (IdP idR)) #

Formal parameter names

psb_def :: PatSynBind idL idR -> LPat idR #

Right-hand side

psb_dir :: PatSynBind idL idR -> HsPatSynDir idR #

Directionality

data HsIPBinds id #

Haskell Implicit Parameter Bindings

Constructors

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

Instances

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsIPBinds p)
Instance details Defined in HsBinds Methods ppr :: HsIPBinds p -> SDoc # pprPrec :: Rational -> HsIPBinds 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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (IPBind p)
Instance details Defined in HsBinds Methods ppr :: IPBind p -> SDoc # pprPrec :: Rational -> IPBind p -> SDoc #

type LSig pass = Located (Sig pass) #

Located Signature

data Sig pass #

Signatures and pragmas

Constructors

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`
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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (Sig p)
Instance details Defined in HsBinds Methods ppr :: Sig p -> SDoc # pprPrec :: Rational -> Sig p -> SDoc #

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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (FixitySig p)
Instance details Defined in HsBinds Methods ppr :: FixitySig p -> SDoc # pprPrec :: Rational -> FixitySig 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

Data TcSpecPrags

Instance details

Defined in HsBinds

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 :: (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

Data TcSpecPrag
Instance details Defined in HsBinds 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 :: (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 HsBinds 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

Functor RecordPatSynField
Instance details Defined in HsBinds Methods fmap :: (a -> b) -> RecordPatSynField a -> RecordPatSynField b # (<$) :: a -> RecordPatSynField b -> RecordPatSynField a #
Foldable RecordPatSynField
Instance details Defined in HsBinds Methods fold :: Monoid m => RecordPatSynField m -> 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 HsBinds 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 HsBinds 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 :: (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 HsBinds 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))

pprInstanceHdr :: ClsInst -> SDoc #

pprInstance :: ClsInst -> SDoc #

instanceDFunId :: ClsInst -> DFunId #

data ClsInst #

A type-class instance. Note that there is some tricky laziness at work here. See Note [ClsInst laziness and the rough-match fields] for more details.

Instances

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

data FamInst #

Instances

NamedThing FamInst
Instance details Defined in FamInstEnv Methods getOccName :: FamInst -> OccName # getName :: FamInst -> Name #
Outputable FamInst
Instance details Defined in FamInstEnv Methods ppr :: FamInst -> SDoc # pprPrec :: Rational -> FamInst -> SDoc #

type BreakIndex = Int #

Breakpoint index

data ModBreaks #

All the information about the breakpoints for a module

Constructors

ModBreaks

Fields

modBreaks_flags :: ForeignRef BreakArray
The array of flags, one per breakpoint, indicating which breakpoints are enabled.
modBreaks_locs :: !(Array BreakIndex SrcSpan)
An array giving the source span of each breakpoint.
modBreaks_vars :: !(Array BreakIndex [OccName])
An array giving the names of the free variables at each breakpoint.
modBreaks_decls :: !(Array BreakIndex [String])
An array giving the names of the declarations enclosing each breakpoint.
modBreaks_ccs :: !(Array BreakIndex (RemotePtr CostCentre))
Array pointing to cost centre for each breakpoint
modBreaks_breakInfo :: IntMap CgBreakInfo
info about each breakpoint from the bytecode generator

parenthesizeHsType :: 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 :: OutputableBndrId (GhcPass p) => HsType (GhcPass p) -> SDoc #

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

pprHsContextMaybe :: OutputableBndrId (GhcPass p) => HsContext (GhcPass p) -> Maybe SDoc #

pprHsContextNoArrow :: OutputableBndrId (GhcPass p) => HsContext (GhcPass p) -> SDoc #

pprHsContext :: OutputableBndrId (GhcPass p) => HsContext (GhcPass p) -> SDoc #

pprHsForAllTvs :: OutputableBndrId (GhcPass p) => [LHsTyVarBndr (GhcPass p)] -> SDoc #

pprHsForAllExtra :: OutputableBndrId (GhcPass p) => Maybe SrcSpan -> [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 :: OutputableBndrId (GhcPass p) => [LHsTyVarBndr (GhcPass p)] -> LHsContext (GhcPass p) -> SDoc #

pprAnonWildCard :: SDoc #

ambiguousFieldOcc :: FieldOcc GhcTc -> AmbiguousFieldOcc GhcTc #

unambiguousFieldOcc :: AmbiguousFieldOcc GhcTc -> FieldOcc GhcTc #

selectorAmbiguousFieldOcc :: AmbiguousFieldOcc GhcTc -> Id #

rdrNameAmbiguousFieldOcc :: AmbiguousFieldOcc (GhcPass p) -> RdrName #

mkAmbiguousFieldOcc :: Located RdrName -> AmbiguousFieldOcc GhcPs #

mkFieldOcc :: Located RdrName -> FieldOcc GhcPs #

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

getLHsInstDeclHead :: LHsSigType pass -> LHsType pass #

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

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

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

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

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

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

hsTyGetAppHead_maybe :: LHsType (GhcPass p) -> Maybe (Located (IdP (GhcPass p)), [LHsType (GhcPass p)]) #

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

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

mkHsAppTy :: LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) #

mkHsOpTy :: 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 #

sameWildCard :: Located HsWildCardInfo -> Located HsWildCardInfo -> Bool #

wildCardName :: HsWildCardInfo -> Name #

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

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

hsLTyVarBndrToType :: LHsTyVarBndr (GhcPass p) -> LHsType (GhcPass p) #

Convert a LHsTyVarBndr to an equivalent LHsType.

hsLTyVarLocNames :: LHsQTyVars pass -> [Located (IdP pass)] #

hsLTyVarLocName :: LHsTyVarBndr pass -> Located (IdP pass) #

hsAllLTyVarNames :: LHsQTyVars GhcRn -> [Name] #

hsExplicitLTyVarNames :: LHsQTyVars pass -> [IdP pass] #

hsLTyVarName :: LHsTyVarBndr pass -> IdP pass #

hsTyVarName :: HsTyVarBndr pass -> IdP pass #

hsScopedTvs :: LHsSigType GhcRn -> [Name] #

hsWcScopedTvs :: LHsSigWcType GhcRn -> [Name] #

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 :: LHsSigType pass -> LHsType pass #

hsImplicitBody :: HsImplicitBndrs pass thing -> thing #

isEmptyLHsQTvs :: LHsQTyVars GhcRn -> Bool #

emptyLHsQTvs :: LHsQTyVars GhcRn #

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

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

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

type LHsContext pass #

Arguments

= Located (HsContext pass)

AnnKeywordId : AnnUnit

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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (LHsQTyVars p)
Instance details Defined in HsTypes Methods ppr :: LHsQTyVars p -> SDoc # pprPrec :: Rational -> LHsQTyVars p -> SDoc #

data HsQTvsRn #

Constructors

HsQTvsRn
Fields hsq_implicit :: [Name] hsq_dependent :: NameSet

Instances

Data HsQTvsRn

Instance details

Defined in HsTypes

Methods

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

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

toConstr :: HsQTvsRn -> Constr #

dataTypeOf :: HsQTvsRn -> DataType #

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

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

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

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

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

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

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

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

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

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

data HsImplicitBndrs pass thing #

Haskell Implicit Binders

Constructors

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

Instances

(p ~ GhcPass pass, Outputable thing) => Outputable (HsImplicitBndrs p thing)
Instance details Defined in HsTypes Methods ppr :: HsImplicitBndrs p thing -> SDoc # pprPrec :: Rational -> HsImplicitBndrs p thing -> SDoc #

data HsIBRn #

Constructors

HsIBRn
Fields hsib_vars :: [Name] hsib_closed :: Bool

Instances

Data HsIBRn

Instance details

Defined in HsTypes

Methods

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

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

toConstr :: HsIBRn -> Constr #

dataTypeOf :: HsIBRn -> DataType #

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

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

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

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

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

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

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

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

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

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

data HsWildCardBndrs pass thing #

Haskell Wildcard Binders

Constructors

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

Instances

(p ~ GhcPass pass, Outputable thing) => Outputable (HsWildCardBndrs p thing)
Instance details Defined in HsTypes Methods ppr :: HsWildCardBndrs p thing -> SDoc # pprPrec :: Rational -> HsWildCardBndrs 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

Eq HsIPName
Instance details Defined in HsTypes Methods (==) :: HsIPName -> HsIPName -> Bool # (/=) :: HsIPName -> HsIPName -> Bool #
Data HsIPName
Instance details Defined in HsTypes 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 :: (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 HsTypes Methods ppr :: HsIPName -> SDoc # pprPrec :: Rational -> HsIPName -> SDoc #
OutputableBndr HsIPName
Instance details Defined in HsTypes Methods pprBndr :: BindingSite -> HsIPName -> SDoc # pprPrefixOcc :: HsIPName -> SDoc # pprInfixOcc :: HsIPName -> SDoc # bndrIsJoin_maybe :: HsIPName -> Maybe Int #

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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsTyVarBndr p)
Instance details Defined in HsTypes Methods ppr :: HsTyVarBndr p -> SDoc # pprPrec :: Rational -> HsTyVarBndr p -> SDoc #

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_bndrs :: [LHsTyVarBndr pass] hst_body :: LHsType pass
HsQualTy
Fields hst_xqual :: XQualTy pass hst_ctxt :: LHsContext pass hst_body :: LHsType pass
HsTyVar (XTyVar pass) Promoted (Located (IdP pass))	`AnnKeywordId` : None
HsAppTy (XAppTy pass) (LHsType pass) (LHsType pass)	`AnnKeywordId` : None
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) Promoted [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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsType p)
Instance details Defined in HsTypes Methods ppr :: HsType p -> SDoc # pprPrec :: Rational -> HsType p -> SDoc #

data NewHsTypeX #

Constructors

NHsCoreTy Type

Instances

Data NewHsTypeX	`AnnKeywordId` : None
Instance details Defined in HsTypes 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 :: (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 HsTypes Methods ppr :: NewHsTypeX -> SDoc # pprPrec :: Rational -> NewHsTypeX -> SDoc #

data HsTyLit #

Haskell Type Literal

Constructors

HsNumTy SourceText Integer
HsStrTy SourceText FastString

Instances

Data HsTyLit
Instance details Defined in HsTypes 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 :: (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 HsTypes Methods ppr :: HsTyLit -> SDoc # pprPrec :: Rational -> HsTyLit -> SDoc #

newtype HsWildCardInfo #

Constructors

AnonWildCard (Located Name)

Instances

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

data HsTupleSort #

Haskell Tuple Sort

Constructors

HsUnboxedTuple
HsBoxedTuple
HsConstraintTuple
HsBoxedOrConstraintTuple

Instances

Data HsTupleSort

Instance details

Defined in HsTypes

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 :: (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 #

data Promoted #

Promoted data types.

Constructors

Promoted
NotPromoted

Instances

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

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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (ConDeclField p)
Instance details Defined in HsTypes Methods ppr :: ConDeclField p -> SDoc # pprPrec :: Rational -> ConDeclField p -> SDoc #

data HsConDetails arg rec #

Haskell Constructor Details

Constructors

PrefixCon [arg]
RecCon rec
InfixCon arg arg

Instances

(Data arg, Data rec) => Data (HsConDetails arg rec)
Instance details Defined in HsTypes 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 :: (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 HsTypes Methods ppr :: HsConDetails arg rec -> SDoc # pprPrec :: Rational -> HsConDetails arg rec -> SDoc #

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 HsExpr
XFieldOcc (XXFieldOcc pass)

Instances

(p ~ GhcPass pass, Eq (XCFieldOcc p)) => Eq (FieldOcc p)
Instance details Defined in HsTypes Methods (==) :: FieldOcc p -> FieldOcc p -> Bool # (/=) :: FieldOcc p -> FieldOcc p -> Bool #
(p ~ GhcPass pass, Ord (XCFieldOcc p)) => Ord (FieldOcc p)
Instance details Defined in HsTypes Methods compare :: FieldOcc p -> FieldOcc p -> Ordering # (<) :: FieldOcc p -> FieldOcc p -> Bool # (<=) :: FieldOcc p -> FieldOcc p -> Bool # (>) :: FieldOcc p -> FieldOcc p -> Bool # (>=) :: FieldOcc p -> FieldOcc p -> Bool # max :: FieldOcc p -> FieldOcc p -> FieldOcc p # min :: FieldOcc p -> FieldOcc p -> FieldOcc p #
Outputable (FieldOcc pass)
Instance details Defined in HsTypes Methods ppr :: FieldOcc pass -> SDoc # pprPrec :: Rational -> FieldOcc pass -> SDoc #

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 HsPat and Note [Disambiguating record fields] in TcExpr. See Note [Located RdrNames] in HsExpr

Constructors

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

Instances

p ~ GhcPass pass => Outputable (AmbiguousFieldOcc p)
Instance details Defined in HsTypes Methods ppr :: AmbiguousFieldOcc p -> SDoc # pprPrec :: Rational -> AmbiguousFieldOcc p -> SDoc #
p ~ GhcPass pass => OutputableBndr (AmbiguousFieldOcc p)
Instance details Defined in HsTypes Methods pprBndr :: BindingSite -> AmbiguousFieldOcc p -> SDoc # pprPrefixOcc :: AmbiguousFieldOcc p -> SDoc # pprInfixOcc :: AmbiguousFieldOcc p -> SDoc # bndrIsJoin_maybe :: AmbiguousFieldOcc p -> Maybe Int #

data ExecOptions #

Constructors

ExecOptions
Fields execSingleStep :: SingleStep stepping mode execSourceFile :: String filename (for errors) execLineNumber :: Int line number (for errors) execWrap :: ForeignHValue -> EvalExpr ForeignHValue

data SingleStep #

Constructors

RunToCompletion
SingleStep
RunAndLogSteps

data ExecResult #

Constructors

ExecComplete
Fields execResult :: Either SomeException [Name] execAllocation :: Word64
ExecBreak
Fields breakNames :: [Name] breakInfo :: Maybe BreakInfo

data BreakInfo #

data Resume #

Constructors

Resume
Fields resumeStmt :: String resumeContext :: ForeignRef (ResumeContext [HValueRef]) resumeBindings :: ([TyThing], GlobalRdrEnv) resumeFinalIds :: [Id] resumeApStack :: ForeignHValue resumeBreakInfo :: Maybe BreakInfo resumeSpan :: SrcSpan resumeDecl :: String resumeCCS :: RemotePtr CostCentreStack resumeHistory :: [History] resumeHistoryIx :: Int

data History #

isBottomingId :: Var -> Bool #

Returns true if an application to n args would diverge

isDeadBinder :: Id -> Bool #

isImplicitId :: Id -> Bool #

isImplicitId tells whether an Ids info is implied by other declarations, so we don't need to put its signature in an interface file, even if it's mentioned in some other interface unfolding.

idDataCon :: Id -> DataCon #

Get from either the worker or the wrapper Id to the DataCon. Currently used only in the desugarer.

INVARIANT: idDataCon (dataConWrapId d) = d: remember, dataConWrapId can return either the wrapper or the worker

isDataConWorkId :: Id -> Bool #

isFCallId :: Id -> Bool #

isPrimOpId :: Id -> Bool #

isClassOpId_maybe :: Id -> Maybe Class #

isRecordSelector :: Id -> Bool #

recordSelectorTyCon :: Id -> RecSelParent #

If the Id is that for a record selector, extract the sel_tycon. Panic otherwise.

idType :: Id -> Kind #

isVanillaDataCon :: DataCon -> Bool #

Vanilla DataCons are those that are nice boring Haskell 98 constructors

dataConUserType :: DataCon -> Type #

The user-declared type of the data constructor in the nice-to-read form:

T :: forall a b. a -> b -> T [a]

rather than:

T :: forall a c. forall b. (c~[a]) => a -> b -> T c

The type variables are quantified in the order that the user wrote them. See Note [DataCon user type variable binders].

NB: If the constructor is part of a data instance, the result type mentions the family tycon, not the internal one.

dataConSig :: DataCon -> ([TyVar], ThetaType, [Type], Type) #

The "signature" of the DataCon returns, in order:

1) The result of dataConUnivAndExTyVars,

2) All the ThetaTypes relating to the DataCon (coercion, dictionary, implicit parameter - whatever)

3) The type arguments to the constructor

4) The original result type of the DataCon

dataConSrcBangs :: DataCon -> [HsSrcBang] #

Strictness/unpack annotations, from user; or, for imported DataCons, from the interface file The list is in one-to-one correspondence with the arity of the DataCon

dataConIsInfix :: DataCon -> Bool #

Should the DataCon be presented infix?

isMarkedStrict :: StrictnessMark -> Bool #

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

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 :: (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

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 :: (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

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 :: (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

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 :: (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 #

data StrictnessMark #

Constructors

MarkedStrict
NotMarkedStrict

Instances

Outputable StrictnessMark
Instance details Defined in DataCon Methods ppr :: StrictnessMark -> SDoc # pprPrec :: Rational -> StrictnessMark -> 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 :: 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

Eq (HsLit x)
Instance details Defined in HsLit Methods (==) :: HsLit x -> HsLit x -> Bool # (/=) :: HsLit x -> HsLit x -> Bool #
p ~ GhcPass pass => Outputable (HsLit p)
Instance details Defined in HsLit Methods ppr :: HsLit p -> SDoc # pprPrec :: Rational -> HsLit p -> SDoc #

data HsOverLit p #

Haskell Overloaded Literal

Constructors

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

Instances

Eq (XXOverLit p) => Eq (HsOverLit p)
Instance details Defined in HsLit Methods (==) :: HsOverLit p -> HsOverLit p -> Bool # (/=) :: HsOverLit p -> HsOverLit p -> Bool #
Ord (XXOverLit p) => Ord (HsOverLit p)
Instance details Defined in HsLit 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 #
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsOverLit p)
Instance details Defined in HsLit Methods ppr :: HsOverLit p -> SDoc # pprPrec :: Rational -> HsOverLit p -> SDoc #

data OverLitTc #

Constructors

OverLitTc
Fields ol_rebindable :: Bool ol_type :: Type

Instances

Data OverLitTc

Instance details

Defined in HsLit

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 :: (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

Eq OverLitVal
Instance details Defined in HsLit Methods (==) :: OverLitVal -> OverLitVal -> Bool # (/=) :: OverLitVal -> OverLitVal -> Bool #
Data OverLitVal
Instance details Defined in HsLit 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 :: (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 HsLit 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 HsLit Methods ppr :: OverLitVal -> SDoc # pprPrec :: Rational -> OverLitVal -> SDoc #

splitForAllTys :: Type -> ([TyVar], Type) #

Take a ForAllTy apart, returning the list of tyvars and the result type. This always succeeds, even if it returns only an empty list. Note that the result type returned may have free variables that were bound by a forall.

funResultTy :: Type -> Type #

Extract the function result type and panic if that is not possible

alphaTyVars :: [TyVar] #

pprTypeApp :: TyCon -> [Type] -> SDoc #

pprForAll :: [TyVarBinder] -> SDoc #

pprThetaArrowTy :: ThetaType -> SDoc #

pprParendType :: Type -> SDoc #

tyConClass_maybe :: TyCon -> Maybe Class #

If this TyCon is that for a class instance, return the class it is for. Otherwise returns Nothing

isClassTyCon :: TyCon -> Bool #

Is this TyCon that for a class instance?

synTyConRhs_maybe :: TyCon -> Maybe Type #

Extract the information pertaining to the right hand side of a type synonym (type) declaration.

synTyConDefn_maybe :: TyCon -> Maybe ([TyVar], Type) #

Extract the TyVars bound by a vanilla type synonym and the corresponding (unsubstituted) right hand side.

tyConDataCons :: TyCon -> [DataCon] #

As tyConDataCons_maybe, but returns the empty list of constructors if no constructors could be found

isOpenTypeFamilyTyCon :: TyCon -> Bool #

Is this an open type family TyCon?

isTypeFamilyTyCon :: TyCon -> Bool #

Is this a synonym TyCon that can have may have further instances appear?

isOpenFamilyTyCon :: TyCon -> Bool #

Is this a TyCon, synonym or otherwise, that defines a family with instances?

isFamilyTyCon :: TyCon -> Bool #

Is this a TyCon, synonym or otherwise, that defines a family?

isTypeSynonymTyCon :: TyCon -> Bool #

Is this a TyCon representing a regular H98 type synonym (type)?

isNewTyCon :: TyCon -> Bool #

Is this TyCon that for a newtype

isPrimTyCon :: TyCon -> Bool #

Does this TyCon represent something that cannot be defined in Haskell?

pprFundeps :: Outputable a => [FunDep a] -> SDoc #

classTvsFds :: Class -> ([TyVar], [FunDep TyVar]) #

classSCTheta :: Class -> [PredType] #

classATs :: Class -> [TyCon] #

classMethods :: Class -> [Id] #

data Class #

Instances

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

dataConTyCon :: DataCon -> TyCon #

The type constructor that we are building via this data constructor

dataConFieldLabels :: DataCon -> [FieldLabel] #

The labels for the fields of this particular DataCon

data DataCon #

A data constructor

AnnKeywordId : AnnOpen, AnnClose,AnnComma

Instances

Eq DataCon
Instance details Defined in DataCon Methods (==) :: DataCon -> DataCon -> Bool # (/=) :: DataCon -> DataCon -> Bool #
Data DataCon
Instance details Defined in DataCon Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DataCon -> c DataCon # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DataCon # toConstr :: DataCon -> Constr # dataTypeOf :: DataCon -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DataCon) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataCon) # gmapT :: (forall b. Data b => b -> b) -> DataCon -> DataCon # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DataCon -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DataCon -> r # gmapQ :: (forall d. Data d => d -> u) -> DataCon -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DataCon -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DataCon -> m DataCon # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DataCon -> m DataCon # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DataCon -> m DataCon #
NamedThing DataCon
Instance details Defined in DataCon Methods getOccName :: DataCon -> OccName # getName :: DataCon -> Name #
Uniquable DataCon
Instance details Defined in DataCon Methods getUnique :: DataCon -> Unique #
Outputable DataCon
Instance details Defined in DataCon Methods ppr :: DataCon -> SDoc # pprPrec :: Rational -> DataCon -> SDoc #
OutputableBndr DataCon
Instance details Defined in DataCon Methods pprBndr :: BindingSite -> DataCon -> SDoc # pprPrefixOcc :: DataCon -> SDoc # pprInfixOcc :: DataCon -> SDoc # bndrIsJoin_maybe :: DataCon -> Maybe Int #

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

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

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

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

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

pprFunBind :: (OutputableBndrId (GhcPass 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)	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)	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`,
HsArrApp (XArrApp p) (LHsExpr p) (LHsExpr p) HsArrAppType Bool	`AnnKeywordId` : `Annlarrowtail`, `Annrarrowtail`,`AnnLarrowtail`, `AnnRarrowtail`
HsArrForm (XArrForm p) (LHsExpr p) (Maybe Fixity) [LHsCmdTop p]	`AnnKeywordId` : `AnnOpenB` `'(\|'`, `AnnCloseB` `'\|)'`
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` `'#-}'`
EWildPat (XEWildPat p)
EAsPat (XEAsPat p) (Located (IdP p)) (LHsExpr p)	`AnnKeywordId` : `AnnAt`
EViewPat (XEViewPat p) (LHsExpr p) (LHsExpr p)	`AnnKeywordId` : `AnnRarrow`
ELazyPat (XELazyPat p) (LHsExpr p)	`AnnKeywordId` : `AnnTilde`
HsWrap (XWrap p) HsWrapper (HsExpr p)
XExpr (XXExpr p)

Instances

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsExpr p)
Instance details Defined in HsExpr Methods ppr :: HsExpr p -> SDoc # pprPrec :: Rational -> HsExpr p -> SDoc #

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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsCmd p)
Instance details Defined in HsExpr Methods ppr :: HsCmd p -> SDoc # pprPrec :: Rational -> HsCmd p -> SDoc #

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)
XSplice (XXSplice id)

Instances

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsSplice p)
Instance details Defined in HsExpr Methods ppr :: HsSplice p -> SDoc # pprPrec :: Rational -> HsSplice p -> SDoc #

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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (SyntaxExpr p)
Instance details Defined in HsExpr Methods ppr :: SyntaxExpr p -> SDoc # pprPrec :: Rational -> SyntaxExpr 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 #

ieWrappedName :: IEWrappedName name -> name #

ieNames :: IE pass -> [IdP pass] #

ieName :: IE pass -> IdP pass #

simpleImportDecl :: ModuleName -> ImportDecl (GhcPass p) #

type LImportDecl pass #

Arguments

= Located (ImportDecl pass)

When in a list this may have

AnnKeywordId : AnnSemi

Located Import Declaration

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 :: Bool
True => 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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (ImportDecl p)
Instance details Defined in HsImpExp Methods ppr :: ImportDecl p -> SDoc # pprPrec :: Rational -> ImportDecl p -> SDoc #

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

Eq name => Eq (IEWrappedName name)
Instance details Defined in HsImpExp Methods (==) :: IEWrappedName name -> IEWrappedName name -> Bool # (/=) :: IEWrappedName name -> IEWrappedName name -> Bool #
Data name => Data (IEWrappedName name)
Instance details Defined in HsImpExp 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 :: (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 HsImpExp Methods occName :: IEWrappedName name -> OccName #
OutputableBndr name => Outputable (IEWrappedName name)
Instance details Defined in HsImpExp Methods ppr :: IEWrappedName name -> SDoc # pprPrec :: Rational -> IEWrappedName name -> SDoc #
OutputableBndr name => OutputableBndr (IEWrappedName name)
Instance details Defined in HsImpExp Methods pprBndr :: BindingSite -> IEWrappedName name -> SDoc # pprPrefixOcc :: IEWrappedName name -> SDoc # pprInfixOcc :: IEWrappedName name -> SDoc # bndrIsJoin_maybe :: IEWrappedName name -> Maybe Int #

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`
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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (IE p)
Instance details Defined in HsImpExp Methods ppr :: IE p -> SDoc # pprPrec :: Rational -> IE p -> SDoc #

data IEWildcard #

Imported or Exported Wildcard

Constructors

NoIEWildcard
IEWildcard Int

Instances

Eq IEWildcard
Instance details Defined in HsImpExp Methods (==) :: IEWildcard -> IEWildcard -> Bool # (/=) :: IEWildcard -> IEWildcard -> Bool #
Data IEWildcard
Instance details Defined in HsImpExp 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 :: (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
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 HsExpr ^ - `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)	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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (Pat p)
Instance details Defined in HsPat Methods ppr :: Pat p -> SDoc # pprPrec :: Rational -> Pat p -> SDoc #

type LPat p = Located (Pat p) #

noExt :: NoExt #

Used when constructing a term with an unused extension point.

data NoExt #

used as place holder in TTG values

Constructors

NoExt

Instances

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

data GhcPass (c :: Pass) #

Used as a data type index for the hsSyn AST

Instances

Eq (GhcPass c)
Instance details Defined in HsExtension Methods (==) :: GhcPass c -> GhcPass c -> Bool # (/=) :: GhcPass c -> GhcPass c -> Bool #
Data (HsModule GhcPs)
Instance details Defined in HsSyn 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 :: (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 HsSyn 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 :: (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 HsSyn 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 :: (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 HsExtension 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 :: (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) #
OutputableBndrId (GhcPass a) => Outputable (InstInfo (GhcPass a))
Instance details Defined in TcEnv Methods ppr :: InstInfo (GhcPass a) -> SDoc # pprPrec :: Rational -> InstInfo (GhcPass a) -> SDoc #
type IdP GhcPs
Instance details Defined in HsExtension type IdP GhcPs = RdrName
type IdP GhcRn
Instance details Defined in HsExtension type IdP GhcRn = Name
type IdP GhcTc
Instance details Defined in HsExtension type IdP GhcTc = Id
type XIPBinds GhcPs
Instance details Defined in HsBinds type XIPBinds GhcPs = NoExt
type XIPBinds GhcRn
Instance details Defined in HsBinds type XIPBinds GhcRn = NoExt
type XIPBinds GhcTc
Instance details Defined in HsBinds type XIPBinds GhcTc = TcEvBinds
type XSynDecl GhcPs
Instance details Defined in HsDecls type XSynDecl GhcPs = NoExt
type XSynDecl GhcRn
Instance details Defined in HsDecls type XSynDecl GhcRn = NameSet
type XSynDecl GhcTc
Instance details Defined in HsDecls type XSynDecl GhcTc = NameSet
type XDataDecl GhcPs
Instance details Defined in HsDecls type XDataDecl GhcPs = NoExt
type XDataDecl GhcRn
Instance details Defined in HsDecls type XDataDecl GhcRn = DataDeclRn
type XDataDecl GhcTc
Instance details Defined in HsDecls type XDataDecl GhcTc = DataDeclRn
type XClassDecl GhcPs
Instance details Defined in HsDecls type XClassDecl GhcPs = NoExt
type XClassDecl GhcRn
Instance details Defined in HsDecls type XClassDecl GhcRn = NameSet
type XClassDecl GhcTc
Instance details Defined in HsDecls type XClassDecl GhcTc = NameSet
type XViaStrategy GhcPs
Instance details Defined in HsDecls type XViaStrategy GhcPs = LHsSigType GhcPs
type XViaStrategy GhcRn
Instance details Defined in HsDecls type XViaStrategy GhcRn = LHsSigType GhcRn
type XViaStrategy GhcTc
Instance details Defined in HsDecls type XViaStrategy GhcTc = Type
type XForeignImport GhcPs
Instance details Defined in HsDecls type XForeignImport GhcPs = NoExt
type XForeignImport GhcRn
Instance details Defined in HsDecls type XForeignImport GhcRn = NoExt
type XForeignImport GhcTc
Instance details Defined in HsDecls type XForeignImport GhcTc = Coercion
type XForeignExport GhcPs
Instance details Defined in HsDecls type XForeignExport GhcPs = NoExt
type XForeignExport GhcRn
Instance details Defined in HsDecls type XForeignExport GhcRn = NoExt
type XForeignExport GhcTc
Instance details Defined in HsDecls type XForeignExport GhcTc = Coercion
type XHsRule GhcPs
Instance details Defined in HsDecls type XHsRule GhcPs = NoExt
type XHsRule GhcRn
Instance details Defined in HsDecls type XHsRule GhcRn = HsRuleRn
type XHsRule GhcTc
Instance details Defined in HsDecls type XHsRule GhcTc = HsRuleRn
type XAppTypeE GhcPs
Instance details Defined in HsExpr type XAppTypeE GhcPs = LHsWcType GhcPs
type XAppTypeE GhcRn
Instance details Defined in HsExpr type XAppTypeE GhcRn = LHsWcType GhcRn
type XAppTypeE GhcTc
Instance details Defined in HsExpr type XAppTypeE GhcTc = LHsWcType GhcRn
type XOpApp GhcPs
Instance details Defined in HsExpr type XOpApp GhcPs = NoExt
type XOpApp GhcRn
Instance details Defined in HsExpr type XOpApp GhcRn = Fixity
type XOpApp GhcTc
Instance details Defined in HsExpr type XOpApp GhcTc = Fixity
type XExplicitSum GhcPs
Instance details Defined in HsExpr type XExplicitSum GhcPs = NoExt
type XExplicitSum GhcRn
Instance details Defined in HsExpr type XExplicitSum GhcRn = NoExt
type XExplicitSum GhcTc
Instance details Defined in HsExpr type XExplicitSum GhcTc = [Type]
type XMultiIf GhcPs
Instance details Defined in HsExpr type XMultiIf GhcPs = NoExt
type XMultiIf GhcRn
Instance details Defined in HsExpr type XMultiIf GhcRn = NoExt
type XMultiIf GhcTc
Instance details Defined in HsExpr type XMultiIf GhcTc = Type
type XDo GhcPs
Instance details Defined in HsExpr type XDo GhcPs = NoExt
type XDo GhcRn
Instance details Defined in HsExpr type XDo GhcRn = NoExt
type XDo GhcTc
Instance details Defined in HsExpr type XDo GhcTc = Type
type XExplicitList GhcPs
Instance details Defined in HsExpr type XExplicitList GhcPs = NoExt
type XExplicitList GhcRn
Instance details Defined in HsExpr type XExplicitList GhcRn = NoExt
type XExplicitList GhcTc
Instance details Defined in HsExpr type XExplicitList GhcTc = Type
type XRecordCon GhcPs
Instance details Defined in HsExpr type XRecordCon GhcPs = NoExt
type XRecordCon GhcRn
Instance details Defined in HsExpr type XRecordCon GhcRn = NoExt
type XRecordCon GhcTc
Instance details Defined in HsExpr type XRecordCon GhcTc = RecordConTc
type XRecordUpd GhcPs
Instance details Defined in HsExpr type XRecordUpd GhcPs = NoExt
type XRecordUpd GhcRn
Instance details Defined in HsExpr type XRecordUpd GhcRn = NoExt
type XRecordUpd GhcTc
Instance details Defined in HsExpr type XRecordUpd GhcTc = RecordUpdTc
type XExprWithTySig GhcPs
Instance details Defined in HsExpr type XExprWithTySig GhcPs = LHsSigWcType GhcPs
type XExprWithTySig GhcRn
Instance details Defined in HsExpr type XExprWithTySig GhcRn = LHsSigWcType GhcRn
type XExprWithTySig GhcTc
Instance details Defined in HsExpr type XExprWithTySig GhcTc = LHsSigWcType GhcRn
type XArithSeq GhcPs
Instance details Defined in HsExpr type XArithSeq GhcPs = NoExt
type XArithSeq GhcRn
Instance details Defined in HsExpr type XArithSeq GhcRn = NoExt
type XArithSeq GhcTc
Instance details Defined in HsExpr type XArithSeq GhcTc = PostTcExpr
type XStatic GhcPs
Instance details Defined in HsExpr type XStatic GhcPs = NoExt
type XStatic GhcRn
Instance details Defined in HsExpr type XStatic GhcRn = NameSet
type XStatic GhcTc
Instance details Defined in HsExpr type XStatic GhcTc = NameSet
type XArrApp GhcPs
Instance details Defined in HsExpr type XArrApp GhcPs = NoExt
type XArrApp GhcRn
Instance details Defined in HsExpr type XArrApp GhcRn = NoExt
type XArrApp GhcTc
Instance details Defined in HsExpr type XArrApp GhcTc = Type
type XUnambiguous GhcPs
Instance details Defined in HsTypes type XUnambiguous GhcPs = NoExt
type XUnambiguous GhcRn
Instance details Defined in HsTypes type XUnambiguous GhcRn = Name
type XUnambiguous GhcTc
Instance details Defined in HsTypes type XUnambiguous GhcTc = Id
type XAmbiguous GhcPs
Instance details Defined in HsTypes type XAmbiguous GhcPs = NoExt
type XAmbiguous GhcRn
Instance details Defined in HsTypes type XAmbiguous GhcRn = NoExt
type XAmbiguous GhcTc
Instance details Defined in HsTypes type XAmbiguous GhcTc = Id
type XMissing GhcPs
Instance details Defined in HsExpr type XMissing GhcPs = NoExt
type XMissing GhcRn
Instance details Defined in HsExpr type XMissing GhcRn = NoExt
type XMissing GhcTc
Instance details Defined in HsExpr type XMissing GhcTc = Type
type XCmdTop GhcPs
Instance details Defined in HsExpr type XCmdTop GhcPs = NoExt
type XCmdTop GhcRn
Instance details Defined in HsExpr type XCmdTop GhcRn = CmdSyntaxTable GhcRn
type XCmdTop GhcTc
Instance details Defined in HsExpr type XCmdTop GhcTc = CmdTopTc
type XCmdArrApp GhcPs
Instance details Defined in HsExpr type XCmdArrApp GhcPs = NoExt
type XCmdArrApp GhcRn
Instance details Defined in HsExpr type XCmdArrApp GhcRn = NoExt
type XCmdArrApp GhcTc
Instance details Defined in HsExpr type XCmdArrApp GhcTc = Type
type XCmdDo GhcPs
Instance details Defined in HsExpr type XCmdDo GhcPs = NoExt
type XCmdDo GhcRn
Instance details Defined in HsExpr type XCmdDo GhcRn = NoExt
type XCmdDo GhcTc
Instance details Defined in HsExpr type XCmdDo GhcTc = Type
type XOverLit GhcPs
Instance details Defined in HsLit type XOverLit GhcPs = NoExt
type XOverLit GhcRn
Instance details Defined in HsLit type XOverLit GhcRn = Bool
type XOverLit GhcTc
Instance details Defined in HsLit type XOverLit GhcTc = OverLitTc
type XWildPat GhcPs
Instance details Defined in HsPat type XWildPat GhcPs = NoExt
type XWildPat GhcRn
Instance details Defined in HsPat type XWildPat GhcRn = NoExt
type XWildPat GhcTc
Instance details Defined in HsPat type XWildPat GhcTc = Type
type XListPat GhcPs
Instance details Defined in HsPat type XListPat GhcPs = NoExt
type XListPat GhcRn
Instance details Defined in HsPat type XListPat GhcRn = Maybe (SyntaxExpr GhcRn)
type XListPat GhcTc
Instance details Defined in HsPat type XListPat GhcTc = ListPatTc
type XTuplePat GhcPs
Instance details Defined in HsPat type XTuplePat GhcPs = NoExt
type XTuplePat GhcRn
Instance details Defined in HsPat type XTuplePat GhcRn = NoExt
type XTuplePat GhcTc
Instance details Defined in HsPat type XTuplePat GhcTc = [Type]
type XSumPat GhcPs
Instance details Defined in HsPat type XSumPat GhcPs = NoExt
type XSumPat GhcRn
Instance details Defined in HsPat type XSumPat GhcRn = NoExt
type XSumPat GhcTc
Instance details Defined in HsPat type XSumPat GhcTc = [Type]
type XViewPat GhcPs
Instance details Defined in HsPat type XViewPat GhcPs = NoExt
type XViewPat GhcRn
Instance details Defined in HsPat type XViewPat GhcRn = NoExt
type XViewPat GhcTc
Instance details Defined in HsPat type XViewPat GhcTc = Type
type XNPat GhcPs
Instance details Defined in HsPat type XNPat GhcPs = NoExt
type XNPat GhcRn
Instance details Defined in HsPat type XNPat GhcRn = NoExt
type XNPat GhcTc
Instance details Defined in HsPat type XNPat GhcTc = Type
type XNPlusKPat GhcPs
Instance details Defined in HsPat type XNPlusKPat GhcPs = NoExt
type XNPlusKPat GhcRn
Instance details Defined in HsPat type XNPlusKPat GhcRn = NoExt
type XNPlusKPat GhcTc
Instance details Defined in HsPat type XNPlusKPat GhcTc = Type
type XSigPat GhcPs
Instance details Defined in HsPat type XSigPat GhcPs = LHsSigWcType GhcPs
type XSigPat GhcRn
Instance details Defined in HsPat type XSigPat GhcRn = LHsSigWcType GhcRn
type XSigPat GhcTc
Instance details Defined in HsPat type XSigPat GhcTc = Type
type XHsQTvs GhcPs
Instance details Defined in HsTypes type XHsQTvs GhcPs = NoExt
type XHsQTvs GhcRn
Instance details Defined in HsTypes type XHsQTvs GhcRn = HsQTvsRn
type XHsQTvs GhcTc
Instance details Defined in HsTypes type XHsQTvs GhcTc = HsQTvsRn
type XSpliceTy GhcPs
Instance details Defined in HsTypes type XSpliceTy GhcPs = NoExt
type XSpliceTy GhcRn
Instance details Defined in HsTypes type XSpliceTy GhcRn = NoExt
type XSpliceTy GhcTc
Instance details Defined in HsTypes type XSpliceTy GhcTc = Kind
type XExplicitListTy GhcPs
Instance details Defined in HsTypes type XExplicitListTy GhcPs = NoExt
type XExplicitListTy GhcRn
Instance details Defined in HsTypes type XExplicitListTy GhcRn = NoExt
type XExplicitListTy GhcTc
Instance details Defined in HsTypes type XExplicitListTy GhcTc = Kind
type XExplicitTupleTy GhcPs
Instance details Defined in HsTypes type XExplicitTupleTy GhcPs = NoExt
type XExplicitTupleTy GhcRn
Instance details Defined in HsTypes type XExplicitTupleTy GhcRn = NoExt
type XExplicitTupleTy GhcTc
Instance details Defined in HsTypes type XExplicitTupleTy GhcTc = [Kind]
type XWildCardTy GhcPs
Instance details Defined in HsTypes type XWildCardTy GhcPs = NoExt
type XWildCardTy GhcRn
Instance details Defined in HsTypes type XWildCardTy GhcRn = HsWildCardInfo
type XWildCardTy GhcTc
Instance details Defined in HsTypes type XWildCardTy GhcTc = HsWildCardInfo
type XCFieldOcc GhcPs
Instance details Defined in HsTypes type XCFieldOcc GhcPs = NoExt
type XCFieldOcc GhcRn
Instance details Defined in HsTypes type XCFieldOcc GhcRn = Name
type XCFieldOcc GhcTc
Instance details Defined in HsTypes type XCFieldOcc GhcTc = Id
type XMG GhcPs b
Instance details Defined in HsExpr type XMG GhcPs b = NoExt
type XMG GhcRn b
Instance details Defined in HsExpr type XMG GhcRn b = NoExt
type XMG GhcTc b
Instance details Defined in HsExpr type XMG GhcTc b = MatchGroupTc
type XHsIB GhcPs _
Instance details Defined in HsTypes type XHsIB GhcPs _ = NoExt
type XHsIB GhcRn _
Instance details Defined in HsTypes type XHsIB GhcRn _ = HsIBRn
type XHsIB GhcTc _
Instance details Defined in HsTypes type XHsIB GhcTc _ = HsIBRn
type XHsWC GhcPs b
Instance details Defined in HsTypes type XHsWC GhcPs b = NoExt
type XHsWC GhcRn b
Instance details Defined in HsTypes type XHsWC GhcRn b = [Name]
type XHsWC GhcTc b
Instance details Defined in HsTypes type XHsWC GhcTc b = [Name]
type XPatBind GhcPs (GhcPass pR)
Instance details Defined in HsBinds type XPatBind GhcPs (GhcPass pR) = NoExt
type XPatBind GhcRn (GhcPass pR)
Instance details Defined in HsBinds type XPatBind GhcRn (GhcPass pR) = NameSet
type XPatBind GhcTc (GhcPass pR)
Instance details Defined in HsBinds type XPatBind GhcTc (GhcPass pR) = NPatBindTc
type XABE (GhcPass p)
Instance details Defined in HsBinds type XABE (GhcPass p) = NoExt
type XXABExport (GhcPass p)
Instance details Defined in HsBinds type XXABExport (GhcPass p) = NoExt
type XXHsIPBinds (GhcPass p)
Instance details Defined in HsBinds type XXHsIPBinds (GhcPass p) = NoExt
type XCIPBind (GhcPass p)
Instance details Defined in HsBinds type XCIPBind (GhcPass p) = NoExt
type XXIPBind (GhcPass p)
Instance details Defined in HsBinds type XXIPBind (GhcPass p) = NoExt
type XTypeSig (GhcPass p)
Instance details Defined in HsBinds type XTypeSig (GhcPass p) = NoExt
type XPatSynSig (GhcPass p)
Instance details Defined in HsBinds type XPatSynSig (GhcPass p) = NoExt
type XClassOpSig (GhcPass p)
Instance details Defined in HsBinds type XClassOpSig (GhcPass p) = NoExt
type XIdSig (GhcPass p)
Instance details Defined in HsBinds type XIdSig (GhcPass p) = NoExt
type XFixSig (GhcPass p)
Instance details Defined in HsBinds type XFixSig (GhcPass p) = NoExt
type XInlineSig (GhcPass p)
Instance details Defined in HsBinds type XInlineSig (GhcPass p) = NoExt
type XSpecSig (GhcPass p)
Instance details Defined in HsBinds type XSpecSig (GhcPass p) = NoExt
type XSpecInstSig (GhcPass p)
Instance details Defined in HsBinds type XSpecInstSig (GhcPass p) = NoExt
type XMinimalSig (GhcPass p)
Instance details Defined in HsBinds type XMinimalSig (GhcPass p) = NoExt
type XSCCFunSig (GhcPass p)
Instance details Defined in HsBinds type XSCCFunSig (GhcPass p) = NoExt
type XCompleteMatchSig (GhcPass p)
Instance details Defined in HsBinds type XCompleteMatchSig (GhcPass p) = NoExt
type XXSig (GhcPass p)
Instance details Defined in HsBinds type XXSig (GhcPass p) = NoExt
type XFixitySig (GhcPass p)
Instance details Defined in HsBinds type XFixitySig (GhcPass p) = NoExt
type XXFixitySig (GhcPass p)
Instance details Defined in HsBinds type XXFixitySig (GhcPass p) = NoExt
type XTyClD (GhcPass _)
Instance details Defined in HsDecls type XTyClD (GhcPass _) = NoExt
type XInstD (GhcPass _)
Instance details Defined in HsDecls type XInstD (GhcPass _) = NoExt
type XDerivD (GhcPass _)
Instance details Defined in HsDecls type XDerivD (GhcPass _) = NoExt
type XValD (GhcPass _)
Instance details Defined in HsDecls type XValD (GhcPass _) = NoExt
type XSigD (GhcPass _)
Instance details Defined in HsDecls type XSigD (GhcPass _) = NoExt
type XDefD (GhcPass _)
Instance details Defined in HsDecls type XDefD (GhcPass _) = NoExt
type XForD (GhcPass _)
Instance details Defined in HsDecls type XForD (GhcPass _) = NoExt
type XWarningD (GhcPass _)
Instance details Defined in HsDecls type XWarningD (GhcPass _) = NoExt
type XAnnD (GhcPass _)
Instance details Defined in HsDecls type XAnnD (GhcPass _) = NoExt
type XRuleD (GhcPass _)
Instance details Defined in HsDecls type XRuleD (GhcPass _) = NoExt
type XSpliceD (GhcPass _)
Instance details Defined in HsDecls type XSpliceD (GhcPass _) = NoExt
type XDocD (GhcPass _)
Instance details Defined in HsDecls type XDocD (GhcPass _) = NoExt
type XRoleAnnotD (GhcPass _)
Instance details Defined in HsDecls type XRoleAnnotD (GhcPass _) = NoExt
type XXHsDecl (GhcPass _)
Instance details Defined in HsDecls type XXHsDecl (GhcPass _) = NoExt
type XCHsGroup (GhcPass _)
Instance details Defined in HsDecls type XCHsGroup (GhcPass _) = NoExt
type XXHsGroup (GhcPass _)
Instance details Defined in HsDecls type XXHsGroup (GhcPass _) = NoExt
type XSpliceDecl (GhcPass _)
Instance details Defined in HsDecls type XSpliceDecl (GhcPass _) = NoExt
type XXSpliceDecl (GhcPass _)
Instance details Defined in HsDecls type XXSpliceDecl (GhcPass _) = NoExt
type XFamDecl (GhcPass _)
Instance details Defined in HsDecls type XFamDecl (GhcPass _) = NoExt
type XXTyClDecl (GhcPass _)
Instance details Defined in HsDecls type XXTyClDecl (GhcPass _) = NoExt
type XCTyClGroup (GhcPass _)
Instance details Defined in HsDecls type XCTyClGroup (GhcPass _) = NoExt
type XXTyClGroup (GhcPass _)
Instance details Defined in HsDecls type XXTyClGroup (GhcPass _) = NoExt
type XNoSig (GhcPass _)
Instance details Defined in HsDecls type XNoSig (GhcPass _) = NoExt
type XCKindSig (GhcPass _)
Instance details Defined in HsDecls type XCKindSig (GhcPass _) = NoExt
type XTyVarSig (GhcPass _)
Instance details Defined in HsDecls type XTyVarSig (GhcPass _) = NoExt
type XXFamilyResultSig (GhcPass _)
Instance details Defined in HsDecls type XXFamilyResultSig (GhcPass _) = NoExt
type XCFamilyDecl (GhcPass _)
Instance details Defined in HsDecls type XCFamilyDecl (GhcPass _) = NoExt
type XXFamilyDecl (GhcPass _)
Instance details Defined in HsDecls type XXFamilyDecl (GhcPass _) = NoExt
type XCHsDataDefn (GhcPass _)
Instance details Defined in HsDecls type XCHsDataDefn (GhcPass _) = NoExt
type XXHsDataDefn (GhcPass _)
Instance details Defined in HsDecls type XXHsDataDefn (GhcPass _) = NoExt
type XCHsDerivingClause (GhcPass _)
Instance details Defined in HsDecls type XCHsDerivingClause (GhcPass _) = NoExt
type XXHsDerivingClause (GhcPass _)
Instance details Defined in HsDecls type XXHsDerivingClause (GhcPass _) = NoExt
type XConDeclGADT (GhcPass _)
Instance details Defined in HsDecls type XConDeclGADT (GhcPass _) = NoExt
type XConDeclH98 (GhcPass _)
Instance details Defined in HsDecls type XConDeclH98 (GhcPass _) = NoExt
type XXConDecl (GhcPass _)
Instance details Defined in HsDecls type XXConDecl (GhcPass _) = NoExt
type XCClsInstDecl (GhcPass _)
Instance details Defined in HsDecls type XCClsInstDecl (GhcPass _) = NoExt
type XXClsInstDecl (GhcPass _)
Instance details Defined in HsDecls type XXClsInstDecl (GhcPass _) = NoExt
type XClsInstD (GhcPass _)
Instance details Defined in HsDecls type XClsInstD (GhcPass _) = NoExt
type XDataFamInstD (GhcPass _)
Instance details Defined in HsDecls type XDataFamInstD (GhcPass _) = NoExt
type XTyFamInstD (GhcPass _)
Instance details Defined in HsDecls type XTyFamInstD (GhcPass _) = NoExt
type XXInstDecl (GhcPass _)
Instance details Defined in HsDecls type XXInstDecl (GhcPass _) = NoExt
type XCDerivDecl (GhcPass _)
Instance details Defined in HsDecls type XCDerivDecl (GhcPass _) = NoExt
type XXDerivDecl (GhcPass _)
Instance details Defined in HsDecls type XXDerivDecl (GhcPass _) = NoExt
type XCDefaultDecl (GhcPass _)
Instance details Defined in HsDecls type XCDefaultDecl (GhcPass _) = NoExt
type XXDefaultDecl (GhcPass _)
Instance details Defined in HsDecls type XXDefaultDecl (GhcPass _) = NoExt
type XXForeignDecl (GhcPass _)
Instance details Defined in HsDecls type XXForeignDecl (GhcPass _) = NoExt
type XCRuleDecls (GhcPass _)
Instance details Defined in HsDecls type XCRuleDecls (GhcPass _) = NoExt
type XXRuleDecls (GhcPass _)
Instance details Defined in HsDecls type XXRuleDecls (GhcPass _) = NoExt
type XXRuleDecl (GhcPass _)
Instance details Defined in HsDecls type XXRuleDecl (GhcPass _) = NoExt
type XCRuleBndr (GhcPass _)
Instance details Defined in HsDecls type XCRuleBndr (GhcPass _) = NoExt
type XRuleBndrSig (GhcPass _)
Instance details Defined in HsDecls type XRuleBndrSig (GhcPass _) = NoExt
type XXRuleBndr (GhcPass _)
Instance details Defined in HsDecls type XXRuleBndr (GhcPass _) = NoExt
type XWarnings (GhcPass _)
Instance details Defined in HsDecls type XWarnings (GhcPass _) = NoExt
type XXWarnDecls (GhcPass _)
Instance details Defined in HsDecls type XXWarnDecls (GhcPass _) = NoExt
type XWarning (GhcPass _)
Instance details Defined in HsDecls type XWarning (GhcPass _) = NoExt
type XXWarnDecl (GhcPass _)
Instance details Defined in HsDecls type XXWarnDecl (GhcPass _) = NoExt
type XHsAnnotation (GhcPass _)
Instance details Defined in HsDecls type XHsAnnotation (GhcPass _) = NoExt
type XXAnnDecl (GhcPass _)
Instance details Defined in HsDecls type XXAnnDecl (GhcPass _) = NoExt
type XCRoleAnnotDecl (GhcPass _)
Instance details Defined in HsDecls type XCRoleAnnotDecl (GhcPass _) = NoExt
type XXRoleAnnotDecl (GhcPass _)
Instance details Defined in HsDecls type XXRoleAnnotDecl (GhcPass _) = NoExt
type XVar (GhcPass _)
Instance details Defined in HsExpr type XVar (GhcPass _) = NoExt
type XUnboundVar (GhcPass _)
Instance details Defined in HsExpr type XUnboundVar (GhcPass _) = NoExt
type XConLikeOut (GhcPass _)
Instance details Defined in HsExpr type XConLikeOut (GhcPass _) = NoExt
type XRecFld (GhcPass _)
Instance details Defined in HsExpr type XRecFld (GhcPass _) = NoExt
type XOverLabel (GhcPass _)
Instance details Defined in HsExpr type XOverLabel (GhcPass _) = NoExt
type XIPVar (GhcPass _)
Instance details Defined in HsExpr type XIPVar (GhcPass _) = NoExt
type XOverLitE (GhcPass _)
Instance details Defined in HsExpr type XOverLitE (GhcPass _) = NoExt
type XLitE (GhcPass _)
Instance details Defined in HsExpr type XLitE (GhcPass _) = NoExt
type XLam (GhcPass _)
Instance details Defined in HsExpr type XLam (GhcPass _) = NoExt
type XLamCase (GhcPass _)
Instance details Defined in HsExpr type XLamCase (GhcPass _) = NoExt
type XApp (GhcPass _)
Instance details Defined in HsExpr type XApp (GhcPass _) = NoExt
type XNegApp (GhcPass _)
Instance details Defined in HsExpr type XNegApp (GhcPass _) = NoExt
type XPar (GhcPass _)
Instance details Defined in HsExpr type XPar (GhcPass _) = NoExt
type XSectionL (GhcPass _)
Instance details Defined in HsExpr type XSectionL (GhcPass _) = NoExt
type XSectionR (GhcPass _)
Instance details Defined in HsExpr type XSectionR (GhcPass _) = NoExt
type XExplicitTuple (GhcPass _)
Instance details Defined in HsExpr type XExplicitTuple (GhcPass _) = NoExt
type XCase (GhcPass _)
Instance details Defined in HsExpr type XCase (GhcPass _) = NoExt
type XIf (GhcPass _)
Instance details Defined in HsExpr type XIf (GhcPass _) = NoExt
type XLet (GhcPass _)
Instance details Defined in HsExpr type XLet (GhcPass _) = NoExt
type XSCC (GhcPass _)
Instance details Defined in HsExpr type XSCC (GhcPass _) = NoExt
type XCoreAnn (GhcPass _)
Instance details Defined in HsExpr type XCoreAnn (GhcPass _) = NoExt
type XBracket (GhcPass _)
Instance details Defined in HsExpr type XBracket (GhcPass _) = NoExt
type XRnBracketOut (GhcPass _)
Instance details Defined in HsExpr type XRnBracketOut (GhcPass _) = NoExt
type XTcBracketOut (GhcPass _)
Instance details Defined in HsExpr type XTcBracketOut (GhcPass _) = NoExt
type XSpliceE (GhcPass _)
Instance details Defined in HsExpr type XSpliceE (GhcPass _) = NoExt
type XProc (GhcPass _)
Instance details Defined in HsExpr type XProc (GhcPass _) = NoExt
type XArrForm (GhcPass _)
Instance details Defined in HsExpr type XArrForm (GhcPass _) = NoExt
type XTick (GhcPass _)
Instance details Defined in HsExpr type XTick (GhcPass _) = NoExt
type XBinTick (GhcPass _)
Instance details Defined in HsExpr type XBinTick (GhcPass _) = NoExt
type XTickPragma (GhcPass _)
Instance details Defined in HsExpr type XTickPragma (GhcPass _) = NoExt
type XEWildPat (GhcPass _)
Instance details Defined in HsExpr type XEWildPat (GhcPass _) = NoExt
type XEAsPat (GhcPass _)
Instance details Defined in HsExpr type XEAsPat (GhcPass _) = NoExt
type XEViewPat (GhcPass _)
Instance details Defined in HsExpr type XEViewPat (GhcPass _) = NoExt
type XELazyPat (GhcPass _)
Instance details Defined in HsExpr type XELazyPat (GhcPass _) = NoExt
type XWrap (GhcPass _)
Instance details Defined in HsExpr type XWrap (GhcPass _) = NoExt
type XXExpr (GhcPass _)
Instance details Defined in HsExpr type XXExpr (GhcPass _) = NoExt
type XXAmbiguousFieldOcc (GhcPass _)
Instance details Defined in HsTypes type XXAmbiguousFieldOcc (GhcPass _) = NoExt
type XPresent (GhcPass _)
Instance details Defined in HsExpr type XPresent (GhcPass _) = NoExt
type XXTupArg (GhcPass _)
Instance details Defined in HsExpr type XXTupArg (GhcPass _) = NoExt
type XTypedSplice (GhcPass _)
Instance details Defined in HsExpr type XTypedSplice (GhcPass _) = NoExt
type XUntypedSplice (GhcPass _)
Instance details Defined in HsExpr type XUntypedSplice (GhcPass _) = NoExt
type XQuasiQuote (GhcPass _)
Instance details Defined in HsExpr type XQuasiQuote (GhcPass _) = NoExt
type XSpliced (GhcPass _)
Instance details Defined in HsExpr type XSpliced (GhcPass _) = NoExt
type XXSplice (GhcPass _)
Instance details Defined in HsExpr type XXSplice (GhcPass _) = NoExt
type XExpBr (GhcPass _)
Instance details Defined in HsExpr type XExpBr (GhcPass _) = NoExt
type XPatBr (GhcPass _)
Instance details Defined in HsExpr type XPatBr (GhcPass _) = NoExt
type XDecBrL (GhcPass _)
Instance details Defined in HsExpr type XDecBrL (GhcPass _) = NoExt
type XDecBrG (GhcPass _)
Instance details Defined in HsExpr type XDecBrG (GhcPass _) = NoExt
type XTypBr (GhcPass _)
Instance details Defined in HsExpr type XTypBr (GhcPass _) = NoExt
type XVarBr (GhcPass _)
Instance details Defined in HsExpr type XVarBr (GhcPass _) = NoExt
type XTExpBr (GhcPass _)
Instance details Defined in HsExpr type XTExpBr (GhcPass _) = NoExt
type XXBracket (GhcPass _)
Instance details Defined in HsExpr type XXBracket (GhcPass _) = NoExt
type XXCmdTop (GhcPass _)
Instance details Defined in HsExpr type XXCmdTop (GhcPass _) = NoExt
type XCmdArrForm (GhcPass _)
Instance details Defined in HsExpr type XCmdArrForm (GhcPass _) = NoExt
type XCmdApp (GhcPass _)
Instance details Defined in HsExpr type XCmdApp (GhcPass _) = NoExt
type XCmdLam (GhcPass _)
Instance details Defined in HsExpr type XCmdLam (GhcPass _) = NoExt
type XCmdPar (GhcPass _)
Instance details Defined in HsExpr type XCmdPar (GhcPass _) = NoExt
type XCmdCase (GhcPass _)
Instance details Defined in HsExpr type XCmdCase (GhcPass _) = NoExt
type XCmdIf (GhcPass _)
Instance details Defined in HsExpr type XCmdIf (GhcPass _) = NoExt
type XCmdLet (GhcPass _)
Instance details Defined in HsExpr type XCmdLet (GhcPass _) = NoExt
type XCmdWrap (GhcPass _)
Instance details Defined in HsExpr type XCmdWrap (GhcPass _) = NoExt
type XXCmd (GhcPass _)
Instance details Defined in HsExpr type XXCmd (GhcPass _) = NoExt
type XApplicativeArgOne (GhcPass _)
Instance details Defined in HsExpr type XApplicativeArgOne (GhcPass _) = NoExt
type XApplicativeArgMany (GhcPass _)
Instance details Defined in HsExpr type XApplicativeArgMany (GhcPass _) = NoExt
type XXApplicativeArg (GhcPass _)
Instance details Defined in HsExpr type XXApplicativeArg (GhcPass _) = NoExt
type XHsChar (GhcPass _)
Instance details Defined in HsLit type XHsChar (GhcPass _) = SourceText
type XHsCharPrim (GhcPass _)
Instance details Defined in HsLit type XHsCharPrim (GhcPass _) = SourceText
type XHsString (GhcPass _)
Instance details Defined in HsLit type XHsString (GhcPass _) = SourceText
type XHsStringPrim (GhcPass _)
Instance details Defined in HsLit type XHsStringPrim (GhcPass _) = SourceText
type XHsInt (GhcPass _)
Instance details Defined in HsLit type XHsInt (GhcPass _) = NoExt
type XHsIntPrim (GhcPass _)
Instance details Defined in HsLit type XHsIntPrim (GhcPass _) = SourceText
type XHsWordPrim (GhcPass _)
Instance details Defined in HsLit type XHsWordPrim (GhcPass _) = SourceText
type XHsInt64Prim (GhcPass _)
Instance details Defined in HsLit type XHsInt64Prim (GhcPass _) = SourceText
type XHsWord64Prim (GhcPass _)
Instance details Defined in HsLit type XHsWord64Prim (GhcPass _) = SourceText
type XHsInteger (GhcPass _)
Instance details Defined in HsLit type XHsInteger (GhcPass _) = SourceText
type XHsRat (GhcPass _)
Instance details Defined in HsLit type XHsRat (GhcPass _) = NoExt
type XHsFloatPrim (GhcPass _)
Instance details Defined in HsLit type XHsFloatPrim (GhcPass _) = NoExt
type XHsDoublePrim (GhcPass _)
Instance details Defined in HsLit type XHsDoublePrim (GhcPass _) = NoExt
type XXLit (GhcPass _)
Instance details Defined in HsLit type XXLit (GhcPass _) = NoExt
type XXOverLit (GhcPass _)
Instance details Defined in HsLit type XXOverLit (GhcPass _) = NoExt
type XVarPat (GhcPass _)
Instance details Defined in HsPat type XVarPat (GhcPass _) = NoExt
type XLazyPat (GhcPass _)
Instance details Defined in HsPat type XLazyPat (GhcPass _) = NoExt
type XAsPat (GhcPass _)
Instance details Defined in HsPat type XAsPat (GhcPass _) = NoExt
type XParPat (GhcPass _)
Instance details Defined in HsPat type XParPat (GhcPass _) = NoExt
type XBangPat (GhcPass _)
Instance details Defined in HsPat type XBangPat (GhcPass _) = NoExt
type XSplicePat (GhcPass _)
Instance details Defined in HsPat type XSplicePat (GhcPass _) = NoExt
type XLitPat (GhcPass _)
Instance details Defined in HsPat type XLitPat (GhcPass _) = NoExt
type XCoPat (GhcPass _)
Instance details Defined in HsPat type XCoPat (GhcPass _) = NoExt
type XXPat (GhcPass _)
Instance details Defined in HsPat type XXPat (GhcPass _) = NoExt
type XXLHsQTyVars (GhcPass _)
Instance details Defined in HsTypes type XXLHsQTyVars (GhcPass _) = NoExt
type XForAllTy (GhcPass _)
Instance details Defined in HsTypes type XForAllTy (GhcPass _) = NoExt
type XQualTy (GhcPass _)
Instance details Defined in HsTypes type XQualTy (GhcPass _) = NoExt
type XTyVar (GhcPass _)
Instance details Defined in HsTypes type XTyVar (GhcPass _) = NoExt
type XAppTy (GhcPass _)
Instance details Defined in HsTypes type XAppTy (GhcPass _) = NoExt
type XFunTy (GhcPass _)
Instance details Defined in HsTypes type XFunTy (GhcPass _) = NoExt
type XListTy (GhcPass _)
Instance details Defined in HsTypes type XListTy (GhcPass _) = NoExt
type XTupleTy (GhcPass _)
Instance details Defined in HsTypes type XTupleTy (GhcPass _) = NoExt
type XSumTy (GhcPass _)
Instance details Defined in HsTypes type XSumTy (GhcPass _) = NoExt
type XOpTy (GhcPass _)
Instance details Defined in HsTypes type XOpTy (GhcPass _) = NoExt
type XParTy (GhcPass _)
Instance details Defined in HsTypes type XParTy (GhcPass _) = NoExt
type XIParamTy (GhcPass _)
Instance details Defined in HsTypes type XIParamTy (GhcPass _) = NoExt
type XStarTy (GhcPass _)
Instance details Defined in HsTypes type XStarTy (GhcPass _) = NoExt
type XKindSig (GhcPass _)
Instance details Defined in HsTypes type XKindSig (GhcPass _) = NoExt
type XDocTy (GhcPass _)
Instance details Defined in HsTypes type XDocTy (GhcPass _) = NoExt
type XBangTy (GhcPass _)
Instance details Defined in HsTypes type XBangTy (GhcPass _) = NoExt
type XRecTy (GhcPass _)
Instance details Defined in HsTypes type XRecTy (GhcPass _) = NoExt
type XTyLit (GhcPass _)
Instance details Defined in HsTypes type XTyLit (GhcPass _) = NoExt
type XXType (GhcPass _)
Instance details Defined in HsTypes type XXType (GhcPass _) = NewHsTypeX
type XUserTyVar (GhcPass _)
Instance details Defined in HsTypes type XUserTyVar (GhcPass _) = NoExt
type XKindedTyVar (GhcPass _)
Instance details Defined in HsTypes type XKindedTyVar (GhcPass _) = NoExt
type XXTyVarBndr (GhcPass _)
Instance details Defined in HsTypes type XXTyVarBndr (GhcPass _) = NoExt
type XConDeclField (GhcPass _)
Instance details Defined in HsTypes type XConDeclField (GhcPass _) = NoExt
type XXConDeclField (GhcPass _)
Instance details Defined in HsTypes type XXConDeclField (GhcPass _) = NoExt
type XXFieldOcc (GhcPass _)
Instance details Defined in HsTypes type XXFieldOcc (GhcPass _) = NoExt
type XCImportDecl (GhcPass _)
Instance details Defined in HsImpExp type XCImportDecl (GhcPass _) = NoExt
type XXImportDecl (GhcPass _)
Instance details Defined in HsImpExp type XXImportDecl (GhcPass _) = NoExt
type XIEVar (GhcPass _)
Instance details Defined in HsImpExp type XIEVar (GhcPass _) = NoExt
type XIEThingAbs (GhcPass _)
Instance details Defined in HsImpExp type XIEThingAbs (GhcPass _) = NoExt
type XIEThingAll (GhcPass _)
Instance details Defined in HsImpExp type XIEThingAll (GhcPass _) = NoExt
type XIEThingWith (GhcPass _)
Instance details Defined in HsImpExp type XIEThingWith (GhcPass _) = NoExt
type XIEModuleContents (GhcPass _)
Instance details Defined in HsImpExp type XIEModuleContents (GhcPass _) = NoExt
type XIEGroup (GhcPass _)
Instance details Defined in HsImpExp type XIEGroup (GhcPass _) = NoExt
type XIEDoc (GhcPass _)
Instance details Defined in HsImpExp type XIEDoc (GhcPass _) = NoExt
type XIEDocNamed (GhcPass _)
Instance details Defined in HsImpExp type XIEDocNamed (GhcPass _) = NoExt
type XXIE (GhcPass _)
Instance details Defined in HsImpExp type XXIE (GhcPass _) = NoExt
type XFunBind (GhcPass pL) GhcTc
Instance details Defined in HsBinds type XFunBind (GhcPass pL) GhcTc = NameSet
type XFunBind (GhcPass pL) GhcRn
Instance details Defined in HsBinds type XFunBind (GhcPass pL) GhcRn = NameSet
type XFunBind (GhcPass pL) GhcPs
Instance details Defined in HsBinds type XFunBind (GhcPass pL) GhcPs = NoExt
type XPSB (GhcPass idL) GhcTc
Instance details Defined in HsBinds type XPSB (GhcPass idL) GhcTc = NameSet
type XPSB (GhcPass idL) GhcRn
Instance details Defined in HsBinds type XPSB (GhcPass idL) GhcRn = NameSet
type XPSB (GhcPass idL) GhcPs
Instance details Defined in HsBinds type XPSB (GhcPass idL) GhcPs = NoExt
type XXMatchGroup (GhcPass _) b
Instance details Defined in HsExpr type XXMatchGroup (GhcPass _) b = NoExt
type XCMatch (GhcPass _) b
Instance details Defined in HsExpr type XCMatch (GhcPass _) b = NoExt
type XXMatch (GhcPass _) b
Instance details Defined in HsExpr type XXMatch (GhcPass _) b = NoExt
type XCGRHSs (GhcPass _) b
Instance details Defined in HsExpr type XCGRHSs (GhcPass _) b = NoExt
type XXGRHSs (GhcPass _) b
Instance details Defined in HsExpr type XXGRHSs (GhcPass _) b = NoExt
type XCGRHS (GhcPass _) b
Instance details Defined in HsExpr type XCGRHS (GhcPass _) b = NoExt
type XXGRHS (GhcPass _) b
Instance details Defined in HsExpr type XXGRHS (GhcPass _) b = NoExt
type XXHsImplicitBndrs (GhcPass _1) _2
Instance details Defined in HsTypes type XXHsImplicitBndrs (GhcPass _1) _2 = NoExt
type XXHsWildCardBndrs (GhcPass _) b
Instance details Defined in HsTypes type XXHsWildCardBndrs (GhcPass _) b = NoExt
type XCFamEqn (GhcPass _) p r
Instance details Defined in HsDecls type XCFamEqn (GhcPass _) p r = NoExt
type XXFamEqn (GhcPass _) p r
Instance details Defined in HsDecls type XXFamEqn (GhcPass _) p r = NoExt
type XBindStmt (GhcPass _) GhcTc b
Instance details Defined in HsExpr type XBindStmt (GhcPass _) GhcTc b = Type
type XBindStmt (GhcPass _) GhcRn b
Instance details Defined in HsExpr type XBindStmt (GhcPass _) GhcRn b = NoExt
type XBindStmt (GhcPass _) GhcPs b
Instance details Defined in HsExpr type XBindStmt (GhcPass _) GhcPs b = NoExt
type XApplicativeStmt (GhcPass _) GhcTc b
Instance details Defined in HsExpr type XApplicativeStmt (GhcPass _) GhcTc b = Type
type XApplicativeStmt (GhcPass _) GhcRn b
Instance details Defined in HsExpr type XApplicativeStmt (GhcPass _) GhcRn b = NoExt
type XApplicativeStmt (GhcPass _) GhcPs b
Instance details Defined in HsExpr type XApplicativeStmt (GhcPass _) GhcPs b = NoExt
type XBodyStmt (GhcPass _) GhcTc b
Instance details Defined in HsExpr type XBodyStmt (GhcPass _) GhcTc b = Type
type XBodyStmt (GhcPass _) GhcRn b
Instance details Defined in HsExpr type XBodyStmt (GhcPass _) GhcRn b = NoExt
type XBodyStmt (GhcPass _) GhcPs b
Instance details Defined in HsExpr type XBodyStmt (GhcPass _) GhcPs b = NoExt
type XParStmt (GhcPass _) GhcTc b
Instance details Defined in HsExpr type XParStmt (GhcPass _) GhcTc b = Type
type XParStmt (GhcPass _) GhcRn b
Instance details Defined in HsExpr type XParStmt (GhcPass _) GhcRn b = NoExt
type XParStmt (GhcPass _) GhcPs b
Instance details Defined in HsExpr type XParStmt (GhcPass _) GhcPs b = NoExt
type XTransStmt (GhcPass _) GhcTc b
Instance details Defined in HsExpr type XTransStmt (GhcPass _) GhcTc b = Type
type XTransStmt (GhcPass _) GhcRn b
Instance details Defined in HsExpr type XTransStmt (GhcPass _) GhcRn b = NoExt
type XTransStmt (GhcPass _) GhcPs b
Instance details Defined in HsExpr type XTransStmt (GhcPass _) GhcPs b = NoExt
type XRecStmt (GhcPass _) GhcRn b
Instance details Defined in HsExpr type XRecStmt (GhcPass _) GhcRn b = NoExt
type XRecStmt (GhcPass _) GhcPs b
Instance details Defined in HsExpr type XRecStmt (GhcPass _) GhcPs b = NoExt
type XRecStmt (GhcPass _) GhcTc b
Instance details Defined in HsExpr type XRecStmt (GhcPass _) GhcTc b = RecStmtTc
type XHsValBinds (GhcPass pL) (GhcPass pR)
Instance details Defined in HsBinds type XHsValBinds (GhcPass pL) (GhcPass pR) = NoExt
type XHsIPBinds (GhcPass pL) (GhcPass pR)
Instance details Defined in HsBinds type XHsIPBinds (GhcPass pL) (GhcPass pR) = NoExt
type XEmptyLocalBinds (GhcPass pL) (GhcPass pR)
Instance details Defined in HsBinds type XEmptyLocalBinds (GhcPass pL) (GhcPass pR) = NoExt
type XXHsLocalBindsLR (GhcPass pL) (GhcPass pR)
Instance details Defined in HsBinds type XXHsLocalBindsLR (GhcPass pL) (GhcPass pR) = NoExt
type XValBinds (GhcPass pL) (GhcPass pR)
Instance details Defined in HsBinds type XValBinds (GhcPass pL) (GhcPass pR) = NoExt
type XXValBindsLR (GhcPass pL) (GhcPass pR)
Instance details Defined in HsBinds type XXValBindsLR (GhcPass pL) (GhcPass pR) = NHsValBindsLR (GhcPass pL)
type XVarBind (GhcPass pL) (GhcPass pR)
Instance details Defined in HsBinds type XVarBind (GhcPass pL) (GhcPass pR) = NoExt
type XAbsBinds (GhcPass pL) (GhcPass pR)
Instance details Defined in HsBinds type XAbsBinds (GhcPass pL) (GhcPass pR) = NoExt
type XPatSynBind (GhcPass pL) (GhcPass pR)
Instance details Defined in HsBinds type XPatSynBind (GhcPass pL) (GhcPass pR) = NoExt
type XXHsBindsLR (GhcPass pL) (GhcPass pR)
Instance details Defined in HsBinds type XXHsBindsLR (GhcPass pL) (GhcPass pR) = NoExt
type XXPatSynBind (GhcPass idL) (GhcPass idR)
Instance details Defined in HsBinds type XXPatSynBind (GhcPass idL) (GhcPass idR) = NoExt
type XParStmtBlock (GhcPass pL) (GhcPass pR)
Instance details Defined in HsExpr type XParStmtBlock (GhcPass pL) (GhcPass pR) = NoExt
type XXParStmtBlock (GhcPass pL) (GhcPass pR)
Instance details Defined in HsExpr type XXParStmtBlock (GhcPass pL) (GhcPass pR) = NoExt
type XLastStmt (GhcPass _1) (GhcPass _2) b
Instance details Defined in HsExpr type XLastStmt (GhcPass _1) (GhcPass _2) b = NoExt
type XLetStmt (GhcPass _1) (GhcPass _2) b
Instance details Defined in HsExpr type XLetStmt (GhcPass _1) (GhcPass _2) b = NoExt
type XXStmtLR (GhcPass _1) (GhcPass _2) b
Instance details Defined in HsExpr type XXStmtLR (GhcPass _1) (GhcPass _2) b = NoExt

data Pass #

Constructors

Parsed
Renamed
Typechecked

Instances

Data Pass

Instance details

Defined in HsExtension

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 :: (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 IdP p :: Type #

Maps the "normal" id type for a given pass

Instances

type IdP GhcPs
Instance details Defined in HsExtension type IdP GhcPs = RdrName
type IdP GhcRn
Instance details Defined in HsExtension type IdP GhcRn = Name
type IdP GhcTc
Instance details Defined in HsExtension type IdP GhcTc = Id

type LIdP p = Located (IdP p) #

type family XHsValBinds x x' :: Type #

Instances

type XHsValBinds (GhcPass pL) (GhcPass pR)
Instance details Defined in HsBinds type XHsValBinds (GhcPass pL) (GhcPass pR) = NoExt

type family XHsIPBinds x x' :: Type #

Instances

type XHsIPBinds (GhcPass pL) (GhcPass pR)
Instance details Defined in HsBinds type XHsIPBinds (GhcPass pL) (GhcPass pR) = NoExt

type family XEmptyLocalBinds x x' :: Type #

Instances

type XEmptyLocalBinds (GhcPass pL) (GhcPass pR)
Instance details Defined in HsBinds type XEmptyLocalBinds (GhcPass pL) (GhcPass pR) = NoExt

type family XXHsLocalBindsLR x x' :: Type #

Instances

type XXHsLocalBindsLR (GhcPass pL) (GhcPass pR)
Instance details Defined in HsBinds type XXHsLocalBindsLR (GhcPass pL) (GhcPass pR) = NoExt

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' :: Type #

Instances

type XValBinds (GhcPass pL) (GhcPass pR)
Instance details Defined in HsBinds type XValBinds (GhcPass pL) (GhcPass pR) = NoExt

type family XXValBindsLR x x' :: Type #

Instances

type XXValBindsLR (GhcPass pL) (GhcPass pR)
Instance details Defined in HsBinds 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' :: Type #

Instances

type XFunBind (GhcPass pL) GhcTc
Instance details Defined in HsBinds type XFunBind (GhcPass pL) GhcTc = NameSet
type XFunBind (GhcPass pL) GhcRn
Instance details Defined in HsBinds type XFunBind (GhcPass pL) GhcRn = NameSet
type XFunBind (GhcPass pL) GhcPs
Instance details Defined in HsBinds type XFunBind (GhcPass pL) GhcPs = NoExt

type family XPatBind x x' :: Type #

Instances

type XPatBind GhcPs (GhcPass pR)
Instance details Defined in HsBinds type XPatBind GhcPs (GhcPass pR) = NoExt
type XPatBind GhcRn (GhcPass pR)
Instance details Defined in HsBinds type XPatBind GhcRn (GhcPass pR) = NameSet
type XPatBind GhcTc (GhcPass pR)
Instance details Defined in HsBinds type XPatBind GhcTc (GhcPass pR) = NPatBindTc

type family XVarBind x x' :: Type #

Instances

type XVarBind (GhcPass pL) (GhcPass pR)
Instance details Defined in HsBinds type XVarBind (GhcPass pL) (GhcPass pR) = NoExt

type family XAbsBinds x x' :: Type #

Instances

type XAbsBinds (GhcPass pL) (GhcPass pR)
Instance details Defined in HsBinds type XAbsBinds (GhcPass pL) (GhcPass pR) = NoExt

type family XPatSynBind x x' :: Type #

Instances

type XPatSynBind (GhcPass pL) (GhcPass pR)
Instance details Defined in HsBinds type XPatSynBind (GhcPass pL) (GhcPass pR) = NoExt

type family XXHsBindsLR x x' :: Type #

Instances

type XXHsBindsLR (GhcPass pL) (GhcPass pR)
Instance details Defined in HsBinds type XXHsBindsLR (GhcPass pL) (GhcPass pR) = NoExt

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 :: Type #

Instances

type XABE (GhcPass p)
Instance details Defined in HsBinds type XABE (GhcPass p) = NoExt

type family XXABExport x :: Type #

Instances

type XXABExport (GhcPass p)
Instance details Defined in HsBinds type XXABExport (GhcPass p) = NoExt

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

type family XPSB x x' :: Type #

Instances

type XPSB (GhcPass idL) GhcTc
Instance details Defined in HsBinds type XPSB (GhcPass idL) GhcTc = NameSet
type XPSB (GhcPass idL) GhcRn
Instance details Defined in HsBinds type XPSB (GhcPass idL) GhcRn = NameSet
type XPSB (GhcPass idL) GhcPs
Instance details Defined in HsBinds type XPSB (GhcPass idL) GhcPs = NoExt

type family XXPatSynBind x x' :: Type #

Instances

type XXPatSynBind (GhcPass idL) (GhcPass idR)
Instance details Defined in HsBinds type XXPatSynBind (GhcPass idL) (GhcPass idR) = NoExt

type ForallXPatSynBind (c :: Type -> Constraint) x x' = (c (XPSB x x'), c (XXPatSynBind x x')) #

type family XIPBinds x :: Type #

Instances

type XIPBinds GhcPs
Instance details Defined in HsBinds type XIPBinds GhcPs = NoExt
type XIPBinds GhcRn
Instance details Defined in HsBinds type XIPBinds GhcRn = NoExt
type XIPBinds GhcTc
Instance details Defined in HsBinds type XIPBinds GhcTc = TcEvBinds

type family XXHsIPBinds x :: Type #

Instances

type XXHsIPBinds (GhcPass p)
Instance details Defined in HsBinds type XXHsIPBinds (GhcPass p) = NoExt

type ForallXHsIPBinds (c :: Type -> Constraint) x = (c (XIPBinds x), c (XXHsIPBinds x)) #

type family XCIPBind x :: Type #

Instances

type XCIPBind (GhcPass p)
Instance details Defined in HsBinds type XCIPBind (GhcPass p) = NoExt

type family XXIPBind x :: Type #

Instances

type XXIPBind (GhcPass p)
Instance details Defined in HsBinds type XXIPBind (GhcPass p) = NoExt

type ForallXIPBind (c :: Type -> Constraint) x = (c (XCIPBind x), c (XXIPBind x)) #

type family XTypeSig x :: Type #

Instances

type XTypeSig (GhcPass p)
Instance details Defined in HsBinds type XTypeSig (GhcPass p) = NoExt

type family XPatSynSig x :: Type #

Instances

type XPatSynSig (GhcPass p)
Instance details Defined in HsBinds type XPatSynSig (GhcPass p) = NoExt

type family XClassOpSig x :: Type #

Instances

type XClassOpSig (GhcPass p)
Instance details Defined in HsBinds type XClassOpSig (GhcPass p) = NoExt

type family XIdSig x :: Type #

Instances

type XIdSig (GhcPass p)
Instance details Defined in HsBinds type XIdSig (GhcPass p) = NoExt

type family XFixSig x :: Type #

Instances

type XFixSig (GhcPass p)
Instance details Defined in HsBinds type XFixSig (GhcPass p) = NoExt

type family XInlineSig x :: Type #

Instances

type XInlineSig (GhcPass p)
Instance details Defined in HsBinds type XInlineSig (GhcPass p) = NoExt

type family XSpecSig x :: Type #

Instances

type XSpecSig (GhcPass p)
Instance details Defined in HsBinds type XSpecSig (GhcPass p) = NoExt

type family XSpecInstSig x :: Type #

Instances

type XSpecInstSig (GhcPass p)
Instance details Defined in HsBinds type XSpecInstSig (GhcPass p) = NoExt

type family XMinimalSig x :: Type #

Instances

type XMinimalSig (GhcPass p)
Instance details Defined in HsBinds type XMinimalSig (GhcPass p) = NoExt

type family XSCCFunSig x :: Type #

Instances

type XSCCFunSig (GhcPass p)
Instance details Defined in HsBinds type XSCCFunSig (GhcPass p) = NoExt

type family XCompleteMatchSig x :: Type #

Instances

type XCompleteMatchSig (GhcPass p)
Instance details Defined in HsBinds type XCompleteMatchSig (GhcPass p) = NoExt

type family XXSig x :: Type #

Instances

type XXSig (GhcPass p)
Instance details Defined in HsBinds type XXSig (GhcPass p) = NoExt

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 :: Type #

Instances

type XFixitySig (GhcPass p)
Instance details Defined in HsBinds type XFixitySig (GhcPass p) = NoExt

type family XXFixitySig x :: Type #

Instances

type XXFixitySig (GhcPass p)
Instance details Defined in HsBinds type XXFixitySig (GhcPass p) = NoExt

type ForallXFixitySig (c :: Type -> Constraint) x = (c (XFixitySig x), c (XXFixitySig x)) #

type family XTyClD x :: Type #

Instances

type XTyClD (GhcPass _)
Instance details Defined in HsDecls type XTyClD (GhcPass _) = NoExt

type family XInstD x :: Type #

Instances

type XInstD (GhcPass _)
Instance details Defined in HsDecls type XInstD (GhcPass _) = NoExt

type family XDerivD x :: Type #

Instances

type XDerivD (GhcPass _)
Instance details Defined in HsDecls type XDerivD (GhcPass _) = NoExt

type family XValD x :: Type #

Instances

type XValD (GhcPass _)
Instance details Defined in HsDecls type XValD (GhcPass _) = NoExt

type family XSigD x :: Type #

Instances

type XSigD (GhcPass _)
Instance details Defined in HsDecls type XSigD (GhcPass _) = NoExt

type family XDefD x :: Type #

Instances

type XDefD (GhcPass _)
Instance details Defined in HsDecls type XDefD (GhcPass _) = NoExt

type family XForD x :: Type #

Instances

type XForD (GhcPass _)
Instance details Defined in HsDecls type XForD (GhcPass _) = NoExt

type family XWarningD x :: Type #

Instances

type XWarningD (GhcPass _)
Instance details Defined in HsDecls type XWarningD (GhcPass _) = NoExt

type family XAnnD x :: Type #

Instances

type XAnnD (GhcPass _)
Instance details Defined in HsDecls type XAnnD (GhcPass _) = NoExt

type family XRuleD x :: Type #

Instances

type XRuleD (GhcPass _)
Instance details Defined in HsDecls type XRuleD (GhcPass _) = NoExt

type family XSpliceD x :: Type #

Instances

type XSpliceD (GhcPass _)
Instance details Defined in HsDecls type XSpliceD (GhcPass _) = NoExt

type family XDocD x :: Type #

Instances

type XDocD (GhcPass _)
Instance details Defined in HsDecls type XDocD (GhcPass _) = NoExt

type family XRoleAnnotD x :: Type #

Instances

type XRoleAnnotD (GhcPass _)
Instance details Defined in HsDecls type XRoleAnnotD (GhcPass _) = NoExt

type family XXHsDecl x :: Type #

Instances

type XXHsDecl (GhcPass _)
Instance details Defined in HsDecls type XXHsDecl (GhcPass _) = NoExt

type ForallXHsDecl (c :: Type -> Constraint) x = (c (XTyClD x), c (XInstD x), c (XDerivD x), c (XValD x), c (XSigD 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 :: Type #

Instances

type XCHsGroup (GhcPass _)
Instance details Defined in HsDecls type XCHsGroup (GhcPass _) = NoExt

type family XXHsGroup x :: Type #

Instances

type XXHsGroup (GhcPass _)
Instance details Defined in HsDecls type XXHsGroup (GhcPass _) = NoExt

type ForallXHsGroup (c :: Type -> Constraint) x = (c (XCHsGroup x), c (XXHsGroup x)) #

type family XSpliceDecl x :: Type #

Instances

type XSpliceDecl (GhcPass _)
Instance details Defined in HsDecls type XSpliceDecl (GhcPass _) = NoExt

type family XXSpliceDecl x :: Type #

Instances

type XXSpliceDecl (GhcPass _)
Instance details Defined in HsDecls type XXSpliceDecl (GhcPass _) = NoExt

type ForallXSpliceDecl (c :: Type -> Constraint) x = (c (XSpliceDecl x), c (XXSpliceDecl x)) #

type family XFamDecl x :: Type #

Instances

type XFamDecl (GhcPass _)
Instance details Defined in HsDecls type XFamDecl (GhcPass _) = NoExt

type family XSynDecl x :: Type #

Instances

type XSynDecl GhcPs
Instance details Defined in HsDecls type XSynDecl GhcPs = NoExt
type XSynDecl GhcRn
Instance details Defined in HsDecls type XSynDecl GhcRn = NameSet
type XSynDecl GhcTc
Instance details Defined in HsDecls type XSynDecl GhcTc = NameSet

type family XDataDecl x :: Type #

Instances

type XDataDecl GhcPs
Instance details Defined in HsDecls type XDataDecl GhcPs = NoExt
type XDataDecl GhcRn
Instance details Defined in HsDecls type XDataDecl GhcRn = DataDeclRn
type XDataDecl GhcTc
Instance details Defined in HsDecls type XDataDecl GhcTc = DataDeclRn

type family XClassDecl x :: Type #

Instances

type XClassDecl GhcPs
Instance details Defined in HsDecls type XClassDecl GhcPs = NoExt
type XClassDecl GhcRn
Instance details Defined in HsDecls type XClassDecl GhcRn = NameSet
type XClassDecl GhcTc
Instance details Defined in HsDecls type XClassDecl GhcTc = NameSet

type family XXTyClDecl x :: Type #

Instances

type XXTyClDecl (GhcPass _)
Instance details Defined in HsDecls type XXTyClDecl (GhcPass _) = NoExt

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 :: Type #

Instances

type XCTyClGroup (GhcPass _)
Instance details Defined in HsDecls type XCTyClGroup (GhcPass _) = NoExt

type family XXTyClGroup x :: Type #

Instances

type XXTyClGroup (GhcPass _)
Instance details Defined in HsDecls type XXTyClGroup (GhcPass _) = NoExt

type ForallXTyClGroup (c :: Type -> Constraint) x = (c (XCTyClGroup x), c (XXTyClGroup x)) #

type family XNoSig x :: Type #

Instances

type XNoSig (GhcPass _)
Instance details Defined in HsDecls type XNoSig (GhcPass _) = NoExt

type family XCKindSig x :: Type #

Instances

type XCKindSig (GhcPass _)
Instance details Defined in HsDecls type XCKindSig (GhcPass _) = NoExt

type family XTyVarSig x :: Type #

Instances

type XTyVarSig (GhcPass _)
Instance details Defined in HsDecls type XTyVarSig (GhcPass _) = NoExt

type family XXFamilyResultSig x :: Type #

Instances

type XXFamilyResultSig (GhcPass _)
Instance details Defined in HsDecls type XXFamilyResultSig (GhcPass _) = NoExt

type ForallXFamilyResultSig (c :: Type -> Constraint) x = (c (XNoSig x), c (XCKindSig x), c (XTyVarSig x), c (XXFamilyResultSig x)) #

type family XCFamilyDecl x :: Type #

Instances

type XCFamilyDecl (GhcPass _)
Instance details Defined in HsDecls type XCFamilyDecl (GhcPass _) = NoExt

type family XXFamilyDecl x :: Type #

Instances

type XXFamilyDecl (GhcPass _)
Instance details Defined in HsDecls type XXFamilyDecl (GhcPass _) = NoExt

type ForallXFamilyDecl (c :: Type -> Constraint) x = (c (XCFamilyDecl x), c (XXFamilyDecl x)) #

type family XCHsDataDefn x :: Type #

Instances

type XCHsDataDefn (GhcPass _)
Instance details Defined in HsDecls type XCHsDataDefn (GhcPass _) = NoExt

type family XXHsDataDefn x :: Type #

Instances

type XXHsDataDefn (GhcPass _)
Instance details Defined in HsDecls type XXHsDataDefn (GhcPass _) = NoExt

type ForallXHsDataDefn (c :: Type -> Constraint) x = (c (XCHsDataDefn x), c (XXHsDataDefn x)) #

type family XCHsDerivingClause x :: Type #

Instances

type XCHsDerivingClause (GhcPass _)
Instance details Defined in HsDecls type XCHsDerivingClause (GhcPass _) = NoExt

type family XXHsDerivingClause x :: Type #

Instances

type XXHsDerivingClause (GhcPass _)
Instance details Defined in HsDecls type XXHsDerivingClause (GhcPass _) = NoExt

type ForallXHsDerivingClause (c :: Type -> Constraint) x = (c (XCHsDerivingClause x), c (XXHsDerivingClause x)) #

type family XConDeclGADT x :: Type #

Instances

type XConDeclGADT (GhcPass _)
Instance details Defined in HsDecls type XConDeclGADT (GhcPass _) = NoExt

type family XConDeclH98 x :: Type #

Instances

type XConDeclH98 (GhcPass _)
Instance details Defined in HsDecls type XConDeclH98 (GhcPass _) = NoExt

type family XXConDecl x :: Type #

Instances

type XXConDecl (GhcPass _)
Instance details Defined in HsDecls type XXConDecl (GhcPass _) = NoExt

type ForallXConDecl (c :: Type -> Constraint) x = (c (XConDeclGADT x), c (XConDeclH98 x), c (XXConDecl x)) #

type family XCFamEqn x p r :: Type #

Instances

type XCFamEqn (GhcPass _) p r
Instance details Defined in HsDecls type XCFamEqn (GhcPass _) p r = NoExt

type family XXFamEqn x p r :: Type #

Instances

type XXFamEqn (GhcPass _) p r
Instance details Defined in HsDecls type XXFamEqn (GhcPass _) p r = NoExt

type ForallXFamEqn (c :: Type -> Constraint) x p r = (c (XCFamEqn x p r), c (XXFamEqn x p r)) #

type family XCClsInstDecl x :: Type #

Instances

type XCClsInstDecl (GhcPass _)
Instance details Defined in HsDecls type XCClsInstDecl (GhcPass _) = NoExt

type family XXClsInstDecl x :: Type #

Instances

type XXClsInstDecl (GhcPass _)
Instance details Defined in HsDecls type XXClsInstDecl (GhcPass _) = NoExt

type ForallXClsInstDecl (c :: Type -> Constraint) x = (c (XCClsInstDecl x), c (XXClsInstDecl x)) #

type family XClsInstD x :: Type #

Instances

type XClsInstD (GhcPass _)
Instance details Defined in HsDecls type XClsInstD (GhcPass _) = NoExt

type family XDataFamInstD x :: Type #

Instances

type XDataFamInstD (GhcPass _)
Instance details Defined in HsDecls type XDataFamInstD (GhcPass _) = NoExt

type family XTyFamInstD x :: Type #

Instances

type XTyFamInstD (GhcPass _)
Instance details Defined in HsDecls type XTyFamInstD (GhcPass _) = NoExt

type family XXInstDecl x :: Type #

Instances

type XXInstDecl (GhcPass _)
Instance details Defined in HsDecls type XXInstDecl (GhcPass _) = NoExt

type ForallXInstDecl (c :: Type -> Constraint) x = (c (XClsInstD x), c (XDataFamInstD x), c (XTyFamInstD x), c (XXInstDecl x)) #

type family XCDerivDecl x :: Type #

Instances

type XCDerivDecl (GhcPass _)
Instance details Defined in HsDecls type XCDerivDecl (GhcPass _) = NoExt

type family XXDerivDecl x :: Type #

Instances

type XXDerivDecl (GhcPass _)
Instance details Defined in HsDecls type XXDerivDecl (GhcPass _) = NoExt

type ForallXDerivDecl (c :: Type -> Constraint) x = (c (XCDerivDecl x), c (XXDerivDecl x)) #

type family XViaStrategy x :: Type #

Instances

type XViaStrategy GhcPs
Instance details Defined in HsDecls type XViaStrategy GhcPs = LHsSigType GhcPs
type XViaStrategy GhcRn
Instance details Defined in HsDecls type XViaStrategy GhcRn = LHsSigType GhcRn
type XViaStrategy GhcTc
Instance details Defined in HsDecls type XViaStrategy GhcTc = Type

type family XCDefaultDecl x :: Type #

Instances

type XCDefaultDecl (GhcPass _)
Instance details Defined in HsDecls type XCDefaultDecl (GhcPass _) = NoExt

type family XXDefaultDecl x :: Type #

Instances

type XXDefaultDecl (GhcPass _)
Instance details Defined in HsDecls type XXDefaultDecl (GhcPass _) = NoExt

type ForallXDefaultDecl (c :: Type -> Constraint) x = (c (XCDefaultDecl x), c (XXDefaultDecl x)) #

type family XForeignImport x :: Type #

Instances

type XForeignImport GhcPs
Instance details Defined in HsDecls type XForeignImport GhcPs = NoExt
type XForeignImport GhcRn
Instance details Defined in HsDecls type XForeignImport GhcRn = NoExt
type XForeignImport GhcTc
Instance details Defined in HsDecls type XForeignImport GhcTc = Coercion

type family XForeignExport x :: Type #

Instances

type XForeignExport GhcPs
Instance details Defined in HsDecls type XForeignExport GhcPs = NoExt
type XForeignExport GhcRn
Instance details Defined in HsDecls type XForeignExport GhcRn = NoExt
type XForeignExport GhcTc
Instance details Defined in HsDecls type XForeignExport GhcTc = Coercion

type family XXForeignDecl x :: Type #

Instances

type XXForeignDecl (GhcPass _)
Instance details Defined in HsDecls type XXForeignDecl (GhcPass _) = NoExt

type ForallXForeignDecl (c :: Type -> Constraint) x = (c (XForeignImport x), c (XForeignExport x), c (XXForeignDecl x)) #

type family XCRuleDecls x :: Type #

Instances

type XCRuleDecls (GhcPass _)
Instance details Defined in HsDecls type XCRuleDecls (GhcPass _) = NoExt

type family XXRuleDecls x :: Type #

Instances

type XXRuleDecls (GhcPass _)
Instance details Defined in HsDecls type XXRuleDecls (GhcPass _) = NoExt

type ForallXRuleDecls (c :: Type -> Constraint) x = (c (XCRuleDecls x), c (XXRuleDecls x)) #

type family XHsRule x :: Type #

Instances

type XHsRule GhcPs
Instance details Defined in HsDecls type XHsRule GhcPs = NoExt
type XHsRule GhcRn
Instance details Defined in HsDecls type XHsRule GhcRn = HsRuleRn
type XHsRule GhcTc
Instance details Defined in HsDecls type XHsRule GhcTc = HsRuleRn

type family XXRuleDecl x :: Type #

Instances

type XXRuleDecl (GhcPass _)
Instance details Defined in HsDecls type XXRuleDecl (GhcPass _) = NoExt

type ForallXRuleDecl (c :: Type -> Constraint) x = (c (XHsRule x), c (XXRuleDecl x)) #

type family XCRuleBndr x :: Type #

Instances

type XCRuleBndr (GhcPass _)
Instance details Defined in HsDecls type XCRuleBndr (GhcPass _) = NoExt

type family XRuleBndrSig x :: Type #

Instances

type XRuleBndrSig (GhcPass _)
Instance details Defined in HsDecls type XRuleBndrSig (GhcPass _) = NoExt

type family XXRuleBndr x :: Type #

Instances

type XXRuleBndr (GhcPass _)
Instance details Defined in HsDecls type XXRuleBndr (GhcPass _) = NoExt

type ForallXRuleBndr (c :: Type -> Constraint) x = (c (XCRuleBndr x), c (XRuleBndrSig x), c (XXRuleBndr x)) #

type family XWarnings x :: Type #

Instances

type XWarnings (GhcPass _)
Instance details Defined in HsDecls type XWarnings (GhcPass _) = NoExt

type family XXWarnDecls x :: Type #

Instances

type XXWarnDecls (GhcPass _)
Instance details Defined in HsDecls type XXWarnDecls (GhcPass _) = NoExt

type ForallXWarnDecls (c :: Type -> Constraint) x = (c (XWarnings x), c (XXWarnDecls x)) #

type family XWarning x :: Type #

Instances

type XWarning (GhcPass _)
Instance details Defined in HsDecls type XWarning (GhcPass _) = NoExt

type family XXWarnDecl x :: Type #

Instances

type XXWarnDecl (GhcPass _)
Instance details Defined in HsDecls type XXWarnDecl (GhcPass _) = NoExt

type ForallXWarnDecl (c :: Type -> Constraint) x = (c (XWarning x), c (XXWarnDecl x)) #

type family XHsAnnotation x :: Type #

Instances

type XHsAnnotation (GhcPass _)
Instance details Defined in HsDecls type XHsAnnotation (GhcPass _) = NoExt

type family XXAnnDecl x :: Type #

Instances

type XXAnnDecl (GhcPass _)
Instance details Defined in HsDecls type XXAnnDecl (GhcPass _) = NoExt

type ForallXAnnDecl (c :: Type -> Constraint) x = (c (XHsAnnotation x), c (XXAnnDecl x)) #

type family XCRoleAnnotDecl x :: Type #

Instances

type XCRoleAnnotDecl (GhcPass _)
Instance details Defined in HsDecls type XCRoleAnnotDecl (GhcPass _) = NoExt

type family XXRoleAnnotDecl x :: Type #

Instances

type XXRoleAnnotDecl (GhcPass _)
Instance details Defined in HsDecls type XXRoleAnnotDecl (GhcPass _) = NoExt

type ForallXRoleAnnotDecl (c :: Type -> Constraint) x = (c (XCRoleAnnotDecl x), c (XXRoleAnnotDecl x)) #

type family XVar x :: Type #

Instances

type XVar (GhcPass _)
Instance details Defined in HsExpr type XVar (GhcPass _) = NoExt

type family XUnboundVar x :: Type #

Instances

type XUnboundVar (GhcPass _)
Instance details Defined in HsExpr type XUnboundVar (GhcPass _) = NoExt

type family XConLikeOut x :: Type #

Instances

type XConLikeOut (GhcPass _)
Instance details Defined in HsExpr type XConLikeOut (GhcPass _) = NoExt

type family XRecFld x :: Type #

Instances

type XRecFld (GhcPass _)
Instance details Defined in HsExpr type XRecFld (GhcPass _) = NoExt

type family XOverLabel x :: Type #

Instances

type XOverLabel (GhcPass _)
Instance details Defined in HsExpr type XOverLabel (GhcPass _) = NoExt

type family XIPVar x :: Type #

Instances

type XIPVar (GhcPass _)
Instance details Defined in HsExpr type XIPVar (GhcPass _) = NoExt

type family XOverLitE x :: Type #

Instances

type XOverLitE (GhcPass _)
Instance details Defined in HsExpr type XOverLitE (GhcPass _) = NoExt

type family XLitE x :: Type #

Instances

type XLitE (GhcPass _)
Instance details Defined in HsExpr type XLitE (GhcPass _) = NoExt

type family XLam x :: Type #

Instances

type XLam (GhcPass _)
Instance details Defined in HsExpr type XLam (GhcPass _) = NoExt

type family XLamCase x :: Type #

Instances

type XLamCase (GhcPass _)
Instance details Defined in HsExpr type XLamCase (GhcPass _) = NoExt

type family XApp x :: Type #

Instances

type XApp (GhcPass _)
Instance details Defined in HsExpr type XApp (GhcPass _) = NoExt

type family XAppTypeE x :: Type #

Instances

type XAppTypeE GhcPs
Instance details Defined in HsExpr type XAppTypeE GhcPs = LHsWcType GhcPs
type XAppTypeE GhcRn
Instance details Defined in HsExpr type XAppTypeE GhcRn = LHsWcType GhcRn
type XAppTypeE GhcTc
Instance details Defined in HsExpr type XAppTypeE GhcTc = LHsWcType GhcRn

type family XOpApp x :: Type #

Instances

type XOpApp GhcPs
Instance details Defined in HsExpr type XOpApp GhcPs = NoExt
type XOpApp GhcRn
Instance details Defined in HsExpr type XOpApp GhcRn = Fixity
type XOpApp GhcTc
Instance details Defined in HsExpr type XOpApp GhcTc = Fixity

type family XNegApp x :: Type #

Instances

type XNegApp (GhcPass _)
Instance details Defined in HsExpr type XNegApp (GhcPass _) = NoExt

type family XPar x :: Type #

Instances

type XPar (GhcPass _)
Instance details Defined in HsExpr type XPar (GhcPass _) = NoExt

type family XSectionL x :: Type #

Instances

type XSectionL (GhcPass _)
Instance details Defined in HsExpr type XSectionL (GhcPass _) = NoExt

type family XSectionR x :: Type #

Instances

type XSectionR (GhcPass _)
Instance details Defined in HsExpr type XSectionR (GhcPass _) = NoExt

type family XExplicitTuple x :: Type #

Instances

type XExplicitTuple (GhcPass _)
Instance details Defined in HsExpr type XExplicitTuple (GhcPass _) = NoExt

type family XExplicitSum x :: Type #

Instances

type XExplicitSum GhcPs
Instance details Defined in HsExpr type XExplicitSum GhcPs = NoExt
type XExplicitSum GhcRn
Instance details Defined in HsExpr type XExplicitSum GhcRn = NoExt
type XExplicitSum GhcTc
Instance details Defined in HsExpr type XExplicitSum GhcTc = [Type]

type family XCase x :: Type #

Instances

type XCase (GhcPass _)
Instance details Defined in HsExpr type XCase (GhcPass _) = NoExt

type family XIf x :: Type #

Instances

type XIf (GhcPass _)
Instance details Defined in HsExpr type XIf (GhcPass _) = NoExt

type family XMultiIf x :: Type #

Instances

type XMultiIf GhcPs
Instance details Defined in HsExpr type XMultiIf GhcPs = NoExt
type XMultiIf GhcRn
Instance details Defined in HsExpr type XMultiIf GhcRn = NoExt
type XMultiIf GhcTc
Instance details Defined in HsExpr type XMultiIf GhcTc = Type

type family XLet x :: Type #

Instances

type XLet (GhcPass _)
Instance details Defined in HsExpr type XLet (GhcPass _) = NoExt

type family XDo x :: Type #

Instances

type XDo GhcPs
Instance details Defined in HsExpr type XDo GhcPs = NoExt
type XDo GhcRn
Instance details Defined in HsExpr type XDo GhcRn = NoExt
type XDo GhcTc
Instance details Defined in HsExpr type XDo GhcTc = Type

type family XExplicitList x :: Type #

Instances

type XExplicitList GhcPs
Instance details Defined in HsExpr type XExplicitList GhcPs = NoExt
type XExplicitList GhcRn
Instance details Defined in HsExpr type XExplicitList GhcRn = NoExt
type XExplicitList GhcTc
Instance details Defined in HsExpr type XExplicitList GhcTc = Type

type family XRecordCon x :: Type #

Instances

type XRecordCon GhcPs
Instance details Defined in HsExpr type XRecordCon GhcPs = NoExt
type XRecordCon GhcRn
Instance details Defined in HsExpr type XRecordCon GhcRn = NoExt
type XRecordCon GhcTc
Instance details Defined in HsExpr type XRecordCon GhcTc = RecordConTc

type family XRecordUpd x :: Type #

Instances

type XRecordUpd GhcPs
Instance details Defined in HsExpr type XRecordUpd GhcPs = NoExt
type XRecordUpd GhcRn
Instance details Defined in HsExpr type XRecordUpd GhcRn = NoExt
type XRecordUpd GhcTc
Instance details Defined in HsExpr type XRecordUpd GhcTc = RecordUpdTc

type family XExprWithTySig x :: Type #

Instances

type XExprWithTySig GhcPs
Instance details Defined in HsExpr type XExprWithTySig GhcPs = LHsSigWcType GhcPs
type XExprWithTySig GhcRn
Instance details Defined in HsExpr type XExprWithTySig GhcRn = LHsSigWcType GhcRn
type XExprWithTySig GhcTc
Instance details Defined in HsExpr type XExprWithTySig GhcTc = LHsSigWcType GhcRn

type family XArithSeq x :: Type #

Instances

type XArithSeq GhcPs
Instance details Defined in HsExpr type XArithSeq GhcPs = NoExt
type XArithSeq GhcRn
Instance details Defined in HsExpr type XArithSeq GhcRn = NoExt
type XArithSeq GhcTc
Instance details Defined in HsExpr type XArithSeq GhcTc = PostTcExpr

type family XSCC x :: Type #

Instances

type XSCC (GhcPass _)
Instance details Defined in HsExpr type XSCC (GhcPass _) = NoExt

type family XCoreAnn x :: Type #

Instances

type XCoreAnn (GhcPass _)
Instance details Defined in HsExpr type XCoreAnn (GhcPass _) = NoExt

type family XBracket x :: Type #

Instances

type XBracket (GhcPass _)
Instance details Defined in HsExpr type XBracket (GhcPass _) = NoExt

type family XRnBracketOut x :: Type #

Instances

type XRnBracketOut (GhcPass _)
Instance details Defined in HsExpr type XRnBracketOut (GhcPass _) = NoExt

type family XTcBracketOut x :: Type #

Instances

type XTcBracketOut (GhcPass _)
Instance details Defined in HsExpr type XTcBracketOut (GhcPass _) = NoExt

type family XSpliceE x :: Type #

Instances

type XSpliceE (GhcPass _)
Instance details Defined in HsExpr type XSpliceE (GhcPass _) = NoExt

type family XProc x :: Type #

Instances

type XProc (GhcPass _)
Instance details Defined in HsExpr type XProc (GhcPass _) = NoExt

type family XStatic x :: Type #

Instances

type XStatic GhcPs
Instance details Defined in HsExpr type XStatic GhcPs = NoExt
type XStatic GhcRn
Instance details Defined in HsExpr type XStatic GhcRn = NameSet
type XStatic GhcTc
Instance details Defined in HsExpr type XStatic GhcTc = NameSet

type family XArrApp x :: Type #

Instances

type XArrApp GhcPs
Instance details Defined in HsExpr type XArrApp GhcPs = NoExt
type XArrApp GhcRn
Instance details Defined in HsExpr type XArrApp GhcRn = NoExt
type XArrApp GhcTc
Instance details Defined in HsExpr type XArrApp GhcTc = Type

type family XArrForm x :: Type #

Instances

type XArrForm (GhcPass _)
Instance details Defined in HsExpr type XArrForm (GhcPass _) = NoExt

type family XTick x :: Type #

Instances

type XTick (GhcPass _)
Instance details Defined in HsExpr type XTick (GhcPass _) = NoExt

type family XBinTick x :: Type #

Instances

type XBinTick (GhcPass _)
Instance details Defined in HsExpr type XBinTick (GhcPass _) = NoExt

type family XTickPragma x :: Type #

Instances

type XTickPragma (GhcPass _)
Instance details Defined in HsExpr type XTickPragma (GhcPass _) = NoExt

type family XEWildPat x :: Type #

Instances

type XEWildPat (GhcPass _)
Instance details Defined in HsExpr type XEWildPat (GhcPass _) = NoExt

type family XEAsPat x :: Type #

Instances

type XEAsPat (GhcPass _)
Instance details Defined in HsExpr type XEAsPat (GhcPass _) = NoExt

type family XEViewPat x :: Type #

Instances

type XEViewPat (GhcPass _)
Instance details Defined in HsExpr type XEViewPat (GhcPass _) = NoExt

type family XELazyPat x :: Type #

Instances

type XELazyPat (GhcPass _)
Instance details Defined in HsExpr type XELazyPat (GhcPass _) = NoExt

type family XWrap x :: Type #

Instances

type XWrap (GhcPass _)
Instance details Defined in HsExpr type XWrap (GhcPass _) = NoExt

type family XXExpr x :: Type #

Instances

type XXExpr (GhcPass _)
Instance details Defined in HsExpr type XXExpr (GhcPass _) = NoExt

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 (XArrApp x), c (XArrForm x), c (XTick x), c (XBinTick x), c (XTickPragma x), c (XEWildPat x), c (XEAsPat x), c (XEViewPat x), c (XELazyPat x), c (XWrap x), c (XXExpr x)) #

type family XUnambiguous x :: Type #

Instances

type XUnambiguous GhcPs
Instance details Defined in HsTypes type XUnambiguous GhcPs = NoExt
type XUnambiguous GhcRn
Instance details Defined in HsTypes type XUnambiguous GhcRn = Name
type XUnambiguous GhcTc
Instance details Defined in HsTypes type XUnambiguous GhcTc = Id

type family XAmbiguous x :: Type #

Instances

type XAmbiguous GhcPs
Instance details Defined in HsTypes type XAmbiguous GhcPs = NoExt
type XAmbiguous GhcRn
Instance details Defined in HsTypes type XAmbiguous GhcRn = NoExt
type XAmbiguous GhcTc
Instance details Defined in HsTypes type XAmbiguous GhcTc = Id

type family XXAmbiguousFieldOcc x :: Type #

Instances

type XXAmbiguousFieldOcc (GhcPass _)
Instance details Defined in HsTypes type XXAmbiguousFieldOcc (GhcPass _) = NoExt

type ForallXAmbiguousFieldOcc (c :: Type -> Constraint) x = (c (XUnambiguous x), c (XAmbiguous x), c (XXAmbiguousFieldOcc x)) #

type family XPresent x :: Type #

Instances

type XPresent (GhcPass _)
Instance details Defined in HsExpr type XPresent (GhcPass _) = NoExt

type family XMissing x :: Type #

Instances

type XMissing GhcPs
Instance details Defined in HsExpr type XMissing GhcPs = NoExt
type XMissing GhcRn
Instance details Defined in HsExpr type XMissing GhcRn = NoExt
type XMissing GhcTc
Instance details Defined in HsExpr type XMissing GhcTc = Type

type family XXTupArg x :: Type #

Instances

type XXTupArg (GhcPass _)
Instance details Defined in HsExpr type XXTupArg (GhcPass _) = NoExt

type ForallXTupArg (c :: Type -> Constraint) x = (c (XPresent x), c (XMissing x), c (XXTupArg x)) #

type family XTypedSplice x :: Type #

Instances

type XTypedSplice (GhcPass _)
Instance details Defined in HsExpr type XTypedSplice (GhcPass _) = NoExt

type family XUntypedSplice x :: Type #

Instances

type XUntypedSplice (GhcPass _)
Instance details Defined in HsExpr type XUntypedSplice (GhcPass _) = NoExt

type family XQuasiQuote x :: Type #

Instances

type XQuasiQuote (GhcPass _)
Instance details Defined in HsExpr type XQuasiQuote (GhcPass _) = NoExt

type family XSpliced x :: Type #

Instances

type XSpliced (GhcPass _)
Instance details Defined in HsExpr type XSpliced (GhcPass _) = NoExt

type family XXSplice x :: Type #

Instances

type XXSplice (GhcPass _)
Instance details Defined in HsExpr type XXSplice (GhcPass _) = NoExt

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 :: Type #

Instances

type XExpBr (GhcPass _)
Instance details Defined in HsExpr type XExpBr (GhcPass _) = NoExt

type family XPatBr x :: Type #

Instances

type XPatBr (GhcPass _)
Instance details Defined in HsExpr type XPatBr (GhcPass _) = NoExt

type family XDecBrL x :: Type #

Instances

type XDecBrL (GhcPass _)
Instance details Defined in HsExpr type XDecBrL (GhcPass _) = NoExt

type family XDecBrG x :: Type #

Instances

type XDecBrG (GhcPass _)
Instance details Defined in HsExpr type XDecBrG (GhcPass _) = NoExt

type family XTypBr x :: Type #

Instances

type XTypBr (GhcPass _)
Instance details Defined in HsExpr type XTypBr (GhcPass _) = NoExt

type family XVarBr x :: Type #

Instances

type XVarBr (GhcPass _)
Instance details Defined in HsExpr type XVarBr (GhcPass _) = NoExt

type family XTExpBr x :: Type #

Instances

type XTExpBr (GhcPass _)
Instance details Defined in HsExpr type XTExpBr (GhcPass _) = NoExt

type family XXBracket x :: Type #

Instances

type XXBracket (GhcPass _)
Instance details Defined in HsExpr type XXBracket (GhcPass _) = NoExt

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 :: Type #

Instances

type XCmdTop GhcPs
Instance details Defined in HsExpr type XCmdTop GhcPs = NoExt
type XCmdTop GhcRn
Instance details Defined in HsExpr type XCmdTop GhcRn = CmdSyntaxTable GhcRn
type XCmdTop GhcTc
Instance details Defined in HsExpr type XCmdTop GhcTc = CmdTopTc

type family XXCmdTop x :: Type #

Instances

type XXCmdTop (GhcPass _)
Instance details Defined in HsExpr type XXCmdTop (GhcPass _) = NoExt

type ForallXCmdTop (c :: Type -> Constraint) x = (c (XCmdTop x), c (XXCmdTop x)) #

type family XMG x b :: Type #

Instances

type XMG GhcPs b
Instance details Defined in HsExpr type XMG GhcPs b = NoExt
type XMG GhcRn b
Instance details Defined in HsExpr type XMG GhcRn b = NoExt
type XMG GhcTc b
Instance details Defined in HsExpr type XMG GhcTc b = MatchGroupTc

type family XXMatchGroup x b :: Type #

Instances

type XXMatchGroup (GhcPass _) b
Instance details Defined in HsExpr type XXMatchGroup (GhcPass _) b = NoExt

type ForallXMatchGroup (c :: Type -> Constraint) x b = (c (XMG x b), c (XXMatchGroup x b)) #

type family XCMatch x b :: Type #

Instances

type XCMatch (GhcPass _) b
Instance details Defined in HsExpr type XCMatch (GhcPass _) b = NoExt

type family XXMatch x b :: Type #

Instances

type XXMatch (GhcPass _) b
Instance details Defined in HsExpr type XXMatch (GhcPass _) b = NoExt

type ForallXMatch (c :: Type -> Constraint) x b = (c (XCMatch x b), c (XXMatch x b)) #

type family XCGRHSs x b :: Type #

Instances

type XCGRHSs (GhcPass _) b
Instance details Defined in HsExpr type XCGRHSs (GhcPass _) b = NoExt

type family XXGRHSs x b :: Type #

Instances

type XXGRHSs (GhcPass _) b
Instance details Defined in HsExpr type XXGRHSs (GhcPass _) b = NoExt

type ForallXGRHSs (c :: Type -> Constraint) x b = (c (XCGRHSs x b), c (XXGRHSs x b)) #

type family XCGRHS x b :: Type #

Instances

type XCGRHS (GhcPass _) b
Instance details Defined in HsExpr type XCGRHS (GhcPass _) b = NoExt

type family XXGRHS x b :: Type #

Instances

type XXGRHS (GhcPass _) b
Instance details Defined in HsExpr type XXGRHS (GhcPass _) b = NoExt

type ForallXGRHS (c :: Type -> Constraint) x b = (c (XCGRHS x b), c (XXGRHS x b)) #

type family XLastStmt x x' b :: Type #

Instances

type XLastStmt (GhcPass _1) (GhcPass _2) b
Instance details Defined in HsExpr type XLastStmt (GhcPass _1) (GhcPass _2) b = NoExt

type family XBindStmt x x' b :: Type #

Instances

type XBindStmt (GhcPass _) GhcTc b
Instance details Defined in HsExpr type XBindStmt (GhcPass _) GhcTc b = Type
type XBindStmt (GhcPass _) GhcRn b
Instance details Defined in HsExpr type XBindStmt (GhcPass _) GhcRn b = NoExt
type XBindStmt (GhcPass _) GhcPs b
Instance details Defined in HsExpr type XBindStmt (GhcPass _) GhcPs b = NoExt

type family XApplicativeStmt x x' b :: Type #

Instances

type XApplicativeStmt (GhcPass _) GhcTc b
Instance details Defined in HsExpr type XApplicativeStmt (GhcPass _) GhcTc b = Type
type XApplicativeStmt (GhcPass _) GhcRn b
Instance details Defined in HsExpr type XApplicativeStmt (GhcPass _) GhcRn b = NoExt
type XApplicativeStmt (GhcPass _) GhcPs b
Instance details Defined in HsExpr type XApplicativeStmt (GhcPass _) GhcPs b = NoExt

type family XBodyStmt x x' b :: Type #

Instances

type XBodyStmt (GhcPass _) GhcTc b
Instance details Defined in HsExpr type XBodyStmt (GhcPass _) GhcTc b = Type
type XBodyStmt (GhcPass _) GhcRn b
Instance details Defined in HsExpr type XBodyStmt (GhcPass _) GhcRn b = NoExt
type XBodyStmt (GhcPass _) GhcPs b
Instance details Defined in HsExpr type XBodyStmt (GhcPass _) GhcPs b = NoExt

type family XLetStmt x x' b :: Type #

Instances

type XLetStmt (GhcPass _1) (GhcPass _2) b
Instance details Defined in HsExpr type XLetStmt (GhcPass _1) (GhcPass _2) b = NoExt

type family XParStmt x x' b :: Type #

Instances

type XParStmt (GhcPass _) GhcTc b
Instance details Defined in HsExpr type XParStmt (GhcPass _) GhcTc b = Type
type XParStmt (GhcPass _) GhcRn b
Instance details Defined in HsExpr type XParStmt (GhcPass _) GhcRn b = NoExt
type XParStmt (GhcPass _) GhcPs b
Instance details Defined in HsExpr type XParStmt (GhcPass _) GhcPs b = NoExt

type family XTransStmt x x' b :: Type #

Instances

type XTransStmt (GhcPass _) GhcTc b
Instance details Defined in HsExpr type XTransStmt (GhcPass _) GhcTc b = Type
type XTransStmt (GhcPass _) GhcRn b
Instance details Defined in HsExpr type XTransStmt (GhcPass _) GhcRn b = NoExt
type XTransStmt (GhcPass _) GhcPs b
Instance details Defined in HsExpr type XTransStmt (GhcPass _) GhcPs b = NoExt

type family XRecStmt x x' b :: Type #

Instances

type XRecStmt (GhcPass _) GhcRn b
Instance details Defined in HsExpr type XRecStmt (GhcPass _) GhcRn b = NoExt
type XRecStmt (GhcPass _) GhcPs b
Instance details Defined in HsExpr type XRecStmt (GhcPass _) GhcPs b = NoExt
type XRecStmt (GhcPass _) GhcTc b
Instance details Defined in HsExpr type XRecStmt (GhcPass _) GhcTc b = RecStmtTc

type family XXStmtLR x x' b :: Type #

Instances

type XXStmtLR (GhcPass _1) (GhcPass _2) b
Instance details Defined in HsExpr type XXStmtLR (GhcPass _1) (GhcPass _2) b = NoExt

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 :: Type #

Instances

type XCmdArrApp GhcPs
Instance details Defined in HsExpr type XCmdArrApp GhcPs = NoExt
type XCmdArrApp GhcRn
Instance details Defined in HsExpr type XCmdArrApp GhcRn = NoExt
type XCmdArrApp GhcTc
Instance details Defined in HsExpr type XCmdArrApp GhcTc = Type

type family XCmdArrForm x :: Type #

Instances

type XCmdArrForm (GhcPass _)
Instance details Defined in HsExpr type XCmdArrForm (GhcPass _) = NoExt

type family XCmdApp x :: Type #

Instances

type XCmdApp (GhcPass _)
Instance details Defined in HsExpr type XCmdApp (GhcPass _) = NoExt

type family XCmdLam x :: Type #

Instances

type XCmdLam (GhcPass _)
Instance details Defined in HsExpr type XCmdLam (GhcPass _) = NoExt

type family XCmdPar x :: Type #

Instances

type XCmdPar (GhcPass _)
Instance details Defined in HsExpr type XCmdPar (GhcPass _) = NoExt

type family XCmdCase x :: Type #

Instances

type XCmdCase (GhcPass _)
Instance details Defined in HsExpr type XCmdCase (GhcPass _) = NoExt

type family XCmdIf x :: Type #

Instances

type XCmdIf (GhcPass _)
Instance details Defined in HsExpr type XCmdIf (GhcPass _) = NoExt

type family XCmdLet x :: Type #

Instances

type XCmdLet (GhcPass _)
Instance details Defined in HsExpr type XCmdLet (GhcPass _) = NoExt

type family XCmdDo x :: Type #

Instances

type XCmdDo GhcPs
Instance details Defined in HsExpr type XCmdDo GhcPs = NoExt
type XCmdDo GhcRn
Instance details Defined in HsExpr type XCmdDo GhcRn = NoExt
type XCmdDo GhcTc
Instance details Defined in HsExpr type XCmdDo GhcTc = Type

type family XCmdWrap x :: Type #

Instances

type XCmdWrap (GhcPass _)
Instance details Defined in HsExpr type XCmdWrap (GhcPass _) = NoExt

type family XXCmd x :: Type #

Instances

type XXCmd (GhcPass _)
Instance details Defined in HsExpr type XXCmd (GhcPass _) = NoExt

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' :: Type #

Instances

type XParStmtBlock (GhcPass pL) (GhcPass pR)
Instance details Defined in HsExpr type XParStmtBlock (GhcPass pL) (GhcPass pR) = NoExt

type family XXParStmtBlock x x' :: Type #

Instances

type XXParStmtBlock (GhcPass pL) (GhcPass pR)
Instance details Defined in HsExpr type XXParStmtBlock (GhcPass pL) (GhcPass pR) = NoExt

type ForallXParStmtBlock (c :: Type -> Constraint) x x' = (c (XParStmtBlock x x'), c (XXParStmtBlock x x')) #

type family XApplicativeArgOne x :: Type #

Instances

type XApplicativeArgOne (GhcPass _)
Instance details Defined in HsExpr type XApplicativeArgOne (GhcPass _) = NoExt

type family XApplicativeArgMany x :: Type #

Instances

type XApplicativeArgMany (GhcPass _)
Instance details Defined in HsExpr type XApplicativeArgMany (GhcPass _) = NoExt

type family XXApplicativeArg x :: Type #

Instances

type XXApplicativeArg (GhcPass _)
Instance details Defined in HsExpr type XXApplicativeArg (GhcPass _) = NoExt

type ForallXApplicativeArg (c :: Type -> Constraint) x = (c (XApplicativeArgOne x), c (XApplicativeArgMany x), c (XXApplicativeArg x)) #

type family XHsChar x :: Type #

Instances

type XHsChar (GhcPass _)
Instance details Defined in HsLit type XHsChar (GhcPass _) = SourceText

type family XHsCharPrim x :: Type #

Instances

type XHsCharPrim (GhcPass _)
Instance details Defined in HsLit type XHsCharPrim (GhcPass _) = SourceText

type family XHsString x :: Type #

Instances

type XHsString (GhcPass _)
Instance details Defined in HsLit type XHsString (GhcPass _) = SourceText

type family XHsStringPrim x :: Type #

Instances

type XHsStringPrim (GhcPass _)
Instance details Defined in HsLit type XHsStringPrim (GhcPass _) = SourceText

type family XHsInt x :: Type #

Instances

type XHsInt (GhcPass _)
Instance details Defined in HsLit type XHsInt (GhcPass _) = NoExt

type family XHsIntPrim x :: Type #

Instances

type XHsIntPrim (GhcPass _)
Instance details Defined in HsLit type XHsIntPrim (GhcPass _) = SourceText

type family XHsWordPrim x :: Type #

Instances

type XHsWordPrim (GhcPass _)
Instance details Defined in HsLit type XHsWordPrim (GhcPass _) = SourceText

type family XHsInt64Prim x :: Type #

Instances

type XHsInt64Prim (GhcPass _)
Instance details Defined in HsLit type XHsInt64Prim (GhcPass _) = SourceText

type family XHsWord64Prim x :: Type #

Instances

type XHsWord64Prim (GhcPass _)
Instance details Defined in HsLit type XHsWord64Prim (GhcPass _) = SourceText

type family XHsInteger x :: Type #

Instances

type XHsInteger (GhcPass _)
Instance details Defined in HsLit type XHsInteger (GhcPass _) = SourceText

type family XHsRat x :: Type #

Instances

type XHsRat (GhcPass _)
Instance details Defined in HsLit type XHsRat (GhcPass _) = NoExt

type family XHsFloatPrim x :: Type #

Instances

type XHsFloatPrim (GhcPass _)
Instance details Defined in HsLit type XHsFloatPrim (GhcPass _) = NoExt

type family XHsDoublePrim x :: Type #

Instances

type XHsDoublePrim (GhcPass _)
Instance details Defined in HsLit type XHsDoublePrim (GhcPass _) = NoExt

type family XXLit x :: Type #

Instances

type XXLit (GhcPass _)
Instance details Defined in HsLit type XXLit (GhcPass _) = NoExt

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 :: Type #

Instances

type XOverLit GhcPs
Instance details Defined in HsLit type XOverLit GhcPs = NoExt
type XOverLit GhcRn
Instance details Defined in HsLit type XOverLit GhcRn = Bool
type XOverLit GhcTc
Instance details Defined in HsLit type XOverLit GhcTc = OverLitTc

type family XXOverLit x :: Type #

Instances

type XXOverLit (GhcPass _)
Instance details Defined in HsLit type XXOverLit (GhcPass _) = NoExt

type ForallXOverLit (c :: Type -> Constraint) x = (c (XOverLit x), c (XXOverLit x)) #

type family XWildPat x :: Type #

Instances

type XWildPat GhcPs
Instance details Defined in HsPat type XWildPat GhcPs = NoExt
type XWildPat GhcRn
Instance details Defined in HsPat type XWildPat GhcRn = NoExt
type XWildPat GhcTc
Instance details Defined in HsPat type XWildPat GhcTc = Type

type family XVarPat x :: Type #

Instances

type XVarPat (GhcPass _)
Instance details Defined in HsPat type XVarPat (GhcPass _) = NoExt

type family XLazyPat x :: Type #

Instances

type XLazyPat (GhcPass _)
Instance details Defined in HsPat type XLazyPat (GhcPass _) = NoExt

type family XAsPat x :: Type #

Instances

type XAsPat (GhcPass _)
Instance details Defined in HsPat type XAsPat (GhcPass _) = NoExt

type family XParPat x :: Type #

Instances

type XParPat (GhcPass _)
Instance details Defined in HsPat type XParPat (GhcPass _) = NoExt

type family XBangPat x :: Type #

Instances

type XBangPat (GhcPass _)
Instance details Defined in HsPat type XBangPat (GhcPass _) = NoExt

type family XListPat x :: Type #

Instances

type XListPat GhcPs
Instance details Defined in HsPat type XListPat GhcPs = NoExt
type XListPat GhcRn
Instance details Defined in HsPat type XListPat GhcRn = Maybe (SyntaxExpr GhcRn)
type XListPat GhcTc
Instance details Defined in HsPat type XListPat GhcTc = ListPatTc

type family XTuplePat x :: Type #

Instances

type XTuplePat GhcPs
Instance details Defined in HsPat type XTuplePat GhcPs = NoExt
type XTuplePat GhcRn
Instance details Defined in HsPat type XTuplePat GhcRn = NoExt
type XTuplePat GhcTc
Instance details Defined in HsPat type XTuplePat GhcTc = [Type]

type family XSumPat x :: Type #

Instances

type XSumPat GhcPs
Instance details Defined in HsPat type XSumPat GhcPs = NoExt
type XSumPat GhcRn
Instance details Defined in HsPat type XSumPat GhcRn = NoExt
type XSumPat GhcTc
Instance details Defined in HsPat type XSumPat GhcTc = [Type]

type family XConPat x :: Type #

type family XViewPat x :: Type #

Instances

type XViewPat GhcPs
Instance details Defined in HsPat type XViewPat GhcPs = NoExt
type XViewPat GhcRn
Instance details Defined in HsPat type XViewPat GhcRn = NoExt
type XViewPat GhcTc
Instance details Defined in HsPat type XViewPat GhcTc = Type

type family XSplicePat x :: Type #

Instances

type XSplicePat (GhcPass _)
Instance details Defined in HsPat type XSplicePat (GhcPass _) = NoExt

type family XLitPat x :: Type #

Instances

type XLitPat (GhcPass _)
Instance details Defined in HsPat type XLitPat (GhcPass _) = NoExt

type family XNPat x :: Type #

Instances

type XNPat GhcPs
Instance details Defined in HsPat type XNPat GhcPs = NoExt
type XNPat GhcRn
Instance details Defined in HsPat type XNPat GhcRn = NoExt
type XNPat GhcTc
Instance details Defined in HsPat type XNPat GhcTc = Type

type family XNPlusKPat x :: Type #

Instances

type XNPlusKPat GhcPs
Instance details Defined in HsPat type XNPlusKPat GhcPs = NoExt
type XNPlusKPat GhcRn
Instance details Defined in HsPat type XNPlusKPat GhcRn = NoExt
type XNPlusKPat GhcTc
Instance details Defined in HsPat type XNPlusKPat GhcTc = Type

type family XSigPat x :: Type #

Instances

type XSigPat GhcPs
Instance details Defined in HsPat type XSigPat GhcPs = LHsSigWcType GhcPs
type XSigPat GhcRn
Instance details Defined in HsPat type XSigPat GhcRn = LHsSigWcType GhcRn
type XSigPat GhcTc
Instance details Defined in HsPat type XSigPat GhcTc = Type

type family XCoPat x :: Type #

Instances

type XCoPat (GhcPass _)
Instance details Defined in HsPat type XCoPat (GhcPass _) = NoExt

type family XXPat x :: Type #

Instances

type XXPat (GhcPass _)
Instance details Defined in HsPat type XXPat (GhcPass _) = NoExt

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 :: Type #

Instances

type XHsQTvs GhcPs
Instance details Defined in HsTypes type XHsQTvs GhcPs = NoExt
type XHsQTvs GhcRn
Instance details Defined in HsTypes type XHsQTvs GhcRn = HsQTvsRn
type XHsQTvs GhcTc
Instance details Defined in HsTypes type XHsQTvs GhcTc = HsQTvsRn

type family XXLHsQTyVars x :: Type #

Instances

type XXLHsQTyVars (GhcPass _)
Instance details Defined in HsTypes type XXLHsQTyVars (GhcPass _) = NoExt

type ForallXLHsQTyVars (c :: Type -> Constraint) x = (c (XHsQTvs x), c (XXLHsQTyVars x)) #

type family XHsIB x b :: Type #

Instances

type XHsIB GhcPs _
Instance details Defined in HsTypes type XHsIB GhcPs _ = NoExt
type XHsIB GhcRn _
Instance details Defined in HsTypes type XHsIB GhcRn _ = HsIBRn
type XHsIB GhcTc _
Instance details Defined in HsTypes type XHsIB GhcTc _ = HsIBRn

type family XXHsImplicitBndrs x b :: Type #

Instances

type XXHsImplicitBndrs (GhcPass _1) _2
Instance details Defined in HsTypes type XXHsImplicitBndrs (GhcPass _1) _2 = NoExt

type ForallXHsImplicitBndrs (c :: Type -> Constraint) x b = (c (XHsIB x b), c (XXHsImplicitBndrs x b)) #

type family XHsWC x b :: Type #

Instances

type XHsWC GhcPs b
Instance details Defined in HsTypes type XHsWC GhcPs b = NoExt
type XHsWC GhcRn b
Instance details Defined in HsTypes type XHsWC GhcRn b = [Name]
type XHsWC GhcTc b
Instance details Defined in HsTypes type XHsWC GhcTc b = [Name]

type family XXHsWildCardBndrs x b :: Type #

Instances

type XXHsWildCardBndrs (GhcPass _) b
Instance details Defined in HsTypes type XXHsWildCardBndrs (GhcPass _) b = NoExt

type ForallXHsWildCardBndrs (c :: Type -> Constraint) x b = (c (XHsWC x b), c (XXHsWildCardBndrs x b)) #

type family XForAllTy x :: Type #

Instances

type XForAllTy (GhcPass _)
Instance details Defined in HsTypes type XForAllTy (GhcPass _) = NoExt

type family XQualTy x :: Type #

Instances

type XQualTy (GhcPass _)
Instance details Defined in HsTypes type XQualTy (GhcPass _) = NoExt

type family XTyVar x :: Type #

Instances

type XTyVar (GhcPass _)
Instance details Defined in HsTypes type XTyVar (GhcPass _) = NoExt

type family XAppTy x :: Type #

Instances

type XAppTy (GhcPass _)
Instance details Defined in HsTypes type XAppTy (GhcPass _) = NoExt

type family XFunTy x :: Type #

Instances

type XFunTy (GhcPass _)
Instance details Defined in HsTypes type XFunTy (GhcPass _) = NoExt

type family XListTy x :: Type #

Instances

type XListTy (GhcPass _)
Instance details Defined in HsTypes type XListTy (GhcPass _) = NoExt

type family XTupleTy x :: Type #

Instances

type XTupleTy (GhcPass _)
Instance details Defined in HsTypes type XTupleTy (GhcPass _) = NoExt

type family XSumTy x :: Type #

Instances

type XSumTy (GhcPass _)
Instance details Defined in HsTypes type XSumTy (GhcPass _) = NoExt

type family XOpTy x :: Type #

Instances

type XOpTy (GhcPass _)
Instance details Defined in HsTypes type XOpTy (GhcPass _) = NoExt

type family XParTy x :: Type #

Instances

type XParTy (GhcPass _)
Instance details Defined in HsTypes type XParTy (GhcPass _) = NoExt

type family XIParamTy x :: Type #

Instances

type XIParamTy (GhcPass _)
Instance details Defined in HsTypes type XIParamTy (GhcPass _) = NoExt

type family XStarTy x :: Type #

Instances

type XStarTy (GhcPass _)
Instance details Defined in HsTypes type XStarTy (GhcPass _) = NoExt

type family XKindSig x :: Type #

Instances

type XKindSig (GhcPass _)
Instance details Defined in HsTypes type XKindSig (GhcPass _) = NoExt

type family XSpliceTy x :: Type #

Instances

type XSpliceTy GhcPs
Instance details Defined in HsTypes type XSpliceTy GhcPs = NoExt
type XSpliceTy GhcRn
Instance details Defined in HsTypes type XSpliceTy GhcRn = NoExt
type XSpliceTy GhcTc
Instance details Defined in HsTypes type XSpliceTy GhcTc = Kind

type family XDocTy x :: Type #

Instances

type XDocTy (GhcPass _)
Instance details Defined in HsTypes type XDocTy (GhcPass _) = NoExt

type family XBangTy x :: Type #

Instances

type XBangTy (GhcPass _)
Instance details Defined in HsTypes type XBangTy (GhcPass _) = NoExt

type family XRecTy x :: Type #

Instances

type XRecTy (GhcPass _)
Instance details Defined in HsTypes type XRecTy (GhcPass _) = NoExt

type family XExplicitListTy x :: Type #

Instances

type XExplicitListTy GhcPs
Instance details Defined in HsTypes type XExplicitListTy GhcPs = NoExt
type XExplicitListTy GhcRn
Instance details Defined in HsTypes type XExplicitListTy GhcRn = NoExt
type XExplicitListTy GhcTc
Instance details Defined in HsTypes type XExplicitListTy GhcTc = Kind

type family XExplicitTupleTy x :: Type #

Instances

type XExplicitTupleTy GhcPs
Instance details Defined in HsTypes type XExplicitTupleTy GhcPs = NoExt
type XExplicitTupleTy GhcRn
Instance details Defined in HsTypes type XExplicitTupleTy GhcRn = NoExt
type XExplicitTupleTy GhcTc
Instance details Defined in HsTypes type XExplicitTupleTy GhcTc = [Kind]

type family XTyLit x :: Type #

Instances

type XTyLit (GhcPass _)
Instance details Defined in HsTypes type XTyLit (GhcPass _) = NoExt

type family XWildCardTy x :: Type #

Instances

type XWildCardTy GhcPs
Instance details Defined in HsTypes type XWildCardTy GhcPs = NoExt
type XWildCardTy GhcRn
Instance details Defined in HsTypes type XWildCardTy GhcRn = HsWildCardInfo
type XWildCardTy GhcTc
Instance details Defined in HsTypes type XWildCardTy GhcTc = HsWildCardInfo

type family XXType x :: Type #

Instances

type XXType (GhcPass _)
Instance details Defined in HsTypes type XXType (GhcPass _) = NewHsTypeX

type ForallXType (c :: Type -> Constraint) x = (c (XForAllTy x), c (XQualTy x), c (XTyVar x), c (XAppTy 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 :: Type #

Instances

type XUserTyVar (GhcPass _)
Instance details Defined in HsTypes type XUserTyVar (GhcPass _) = NoExt

type family XKindedTyVar x :: Type #

Instances

type XKindedTyVar (GhcPass _)
Instance details Defined in HsTypes type XKindedTyVar (GhcPass _) = NoExt

type family XXTyVarBndr x :: Type #

Instances

type XXTyVarBndr (GhcPass _)
Instance details Defined in HsTypes type XXTyVarBndr (GhcPass _) = NoExt

type ForallXTyVarBndr (c :: Type -> Constraint) x = (c (XUserTyVar x), c (XKindedTyVar x), c (XXTyVarBndr x)) #

type family XConDeclField x :: Type #

Instances

type XConDeclField (GhcPass _)
Instance details Defined in HsTypes type XConDeclField (GhcPass _) = NoExt

type family XXConDeclField x :: Type #

Instances

type XXConDeclField (GhcPass _)
Instance details Defined in HsTypes type XXConDeclField (GhcPass _) = NoExt

type ForallXConDeclField (c :: Type -> Constraint) x = (c (XConDeclField x), c (XXConDeclField x)) #

type family XCFieldOcc x :: Type #

Instances

type XCFieldOcc GhcPs
Instance details Defined in HsTypes type XCFieldOcc GhcPs = NoExt
type XCFieldOcc GhcRn
Instance details Defined in HsTypes type XCFieldOcc GhcRn = Name
type XCFieldOcc GhcTc
Instance details Defined in HsTypes type XCFieldOcc GhcTc = Id

type family XXFieldOcc x :: Type #

Instances

type XXFieldOcc (GhcPass _)
Instance details Defined in HsTypes type XXFieldOcc (GhcPass _) = NoExt

type ForallXFieldOcc (c :: Type -> Constraint) x = (c (XCFieldOcc x), c (XXFieldOcc x)) #

type family XCImportDecl x :: Type #

Instances

type XCImportDecl (GhcPass _)
Instance details Defined in HsImpExp type XCImportDecl (GhcPass _) = NoExt

type family XXImportDecl x :: Type #

Instances

type XXImportDecl (GhcPass _)
Instance details Defined in HsImpExp type XXImportDecl (GhcPass _) = NoExt

type ForallXImportDecl (c :: Type -> Constraint) x = (c (XCImportDecl x), c (XXImportDecl x)) #

type family XIEVar x :: Type #

Instances

type XIEVar (GhcPass _)
Instance details Defined in HsImpExp type XIEVar (GhcPass _) = NoExt

type family XIEThingAbs x :: Type #

Instances

type XIEThingAbs (GhcPass _)
Instance details Defined in HsImpExp type XIEThingAbs (GhcPass _) = NoExt

type family XIEThingAll x :: Type #

Instances

type XIEThingAll (GhcPass _)
Instance details Defined in HsImpExp type XIEThingAll (GhcPass _) = NoExt

type family XIEThingWith x :: Type #

Instances

type XIEThingWith (GhcPass _)
Instance details Defined in HsImpExp type XIEThingWith (GhcPass _) = NoExt

type family XIEModuleContents x :: Type #

Instances

type XIEModuleContents (GhcPass _)
Instance details Defined in HsImpExp type XIEModuleContents (GhcPass _) = NoExt

type family XIEGroup x :: Type #

Instances

type XIEGroup (GhcPass _)
Instance details Defined in HsImpExp type XIEGroup (GhcPass _) = NoExt

type family XIEDoc x :: Type #

Instances

type XIEDoc (GhcPass _)
Instance details Defined in HsImpExp type XIEDoc (GhcPass _) = NoExt

type family XIEDocNamed x :: Type #

Instances

type XIEDocNamed (GhcPass _)
Instance details Defined in HsImpExp type XIEDocNamed (GhcPass _) = NoExt

type family XXIE x :: Type #

Instances

type XXIE (GhcPass _)
Instance details Defined in HsImpExp type XXIE (GhcPass _) = NoExt

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

Convertable a a
Instance details Defined in HsExtension 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 (XSigPat p), Outputable (XSigPat GhcRn), Outputable (XIPBinds p), Outputable (XExprWithTySig p), Outputable (XExprWithTySig GhcRn), Outputable (XAppTypeE p), Outputable (XAppTypeE GhcRn), Outputable (XViaStrategy p), Outputable (XViaStrategy GhcRn)) #

Provide a summary constraint that gives all am Outputable constraint to extension points needing one

type OutputableBndrId id = (OutputableBndr (NameOrRdrName (IdP id)), OutputableBndr (IdP id), OutputableX id) #

Constraint type to bundle up the requirement for OutputableBndr on both the id and the NameOrRdrName type for it

placeHolderNamesTc :: NameSet #

type family NameOrRdrName id :: Type 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

isExportedId :: Var -> Bool #

isExportedIdVar means "don't throw this away"

isGlobalId :: Var -> Bool #

isLocalId :: Var -> Bool #

type Id = Var #

Identifier

type TyVar = Var #

Type or kind Variable

data Token #

Instances

Show Token
Instance details Defined in Lexer Methods showsPrec :: Int -> Token -> ShowS # show :: Token -> String # showList :: [Token] -> ShowS #
Outputable Token
Instance details Defined in Lexer Methods ppr :: Token -> SDoc # pprPrec :: Rational -> Token -> SDoc #

unicodeAnn :: AnnKeywordId -> AnnKeywordId #

Convert a normal annotation into its unicode equivalent one

getAndRemoveAnnotationComments :: ApiAnns -> SrcSpan -> ([Located AnnotationComment], ApiAnns) #

Retrieve the comments allocated to the current SrcSpan, and remove them from the annotations

getAnnotationComments :: ApiAnns -> SrcSpan -> [Located AnnotationComment] #

Retrieve the comments allocated to the current SrcSpan

Note: A given SrcSpan may appear in multiple AST elements, beware of duplicates

getAndRemoveAnnotation :: ApiAnns -> SrcSpan -> AnnKeywordId -> ([SrcSpan], ApiAnns) #

Retrieve a list of annotation SrcSpans based on the SrcSpan of the annotated AST element, and the known type of the annotation. The list is removed from the annotations.

getAnnotation :: ApiAnns -> SrcSpan -> AnnKeywordId -> [SrcSpan] #

Retrieve a list of annotation SrcSpans based on the SrcSpan of the annotated AST element, and the known type of the annotation.

type ApiAnns = (Map ApiAnnKey [SrcSpan], Map SrcSpan [Located AnnotationComment]) #

data AnnKeywordId #

API Annotations exist so that tools can perform source to source conversions of Haskell code. They are used to keep track of the various syntactic keywords that are not captured in the existing AST.

The annotations, together with original source comments are made available in the pm_annotations field of ParsedModule. Comments are only retained if Opt_KeepRawTokenStream is set in DynFlags before parsing.

The wiki page describing this feature is https://ghc.haskell.org/trac/ghc/wiki/ApiAnnotations

Note: in general the names of these are taken from the corresponding token, unless otherwise noted See note [Api annotations] above for details of the usage

Constructors

AnnAnyclass
AnnAs
AnnAt
AnnBang	`!`
AnnBackquote	'`'
AnnBy
AnnCase	case or lambda case
AnnClass
AnnClose	'#)' or '#-}' etc
AnnCloseB	'\|)'
AnnCloseBU	'\|)', unicode variant
AnnCloseC	'}'
AnnCloseQ	'\|]'
AnnCloseQU	'\|]', unicode variant
AnnCloseP	')'
AnnCloseS	']'
AnnColon
AnnComma	as a list separator
AnnCommaTuple	in a RdrName for a tuple
AnnDarrow	'=>'
AnnDarrowU	'=>', unicode variant
AnnData
AnnDcolon	'::'
AnnDcolonU	'::', unicode variant
AnnDefault
AnnDeriving
AnnDo
AnnDot	`.`
AnnDotdot	'..'
AnnElse
AnnEqual
AnnExport
AnnFamily
AnnForall
AnnForallU	Unicode variant
AnnForeign
AnnFunId	for function name in matches where there are multiple equations for the function.
AnnGroup
AnnHeader	for CType
AnnHiding
AnnIf
AnnImport
AnnIn
AnnInfix	'infix' or 'infixl' or 'infixr'
AnnInstance
AnnLam
AnnLarrow	'<-'
AnnLarrowU	'<-', unicode variant
AnnLet
AnnMdo
AnnMinus	`-`
AnnModule
AnnNewtype
AnnName	where a name loses its location in the AST, this carries it
AnnOf
AnnOpen	'(#' or '{-# LANGUAGE' etc
AnnOpenB	'(\|'
AnnOpenBU	'(\|', unicode variant
AnnOpenC	'{'
AnnOpenE	'[e\|' or '[e\|\|'
AnnOpenEQ	'[\|'
AnnOpenEQU	'[\|', unicode variant
AnnOpenP	'('
AnnOpenPE	'$('
AnnOpenPTE	'$$('
AnnOpenS	'['
AnnPackageName
AnnPattern
AnnProc
AnnQualified
AnnRarrow	'->'
AnnRarrowU	'->', unicode variant
AnnRec
AnnRole
AnnSafe
AnnSemi	';'
AnnSimpleQuote	'''
AnnSignature
AnnStatic	`static`
AnnStock
AnnThen
AnnThIdSplice	`$`
AnnThIdTySplice	`$$`
AnnThTyQuote	double '''
AnnTilde	'~'
AnnType
AnnUnit	'()' for types
AnnUsing
AnnVal	e.g. INTEGER
AnnValStr	String value, will need quotes when output
AnnVbar	'\|'
AnnVia	`via`
AnnWhere
Annlarrowtail	`-<`
AnnlarrowtailU	`-<`, unicode variant
Annrarrowtail	'->'
AnnrarrowtailU	'->', unicode variant
AnnLarrowtail	`-<<`
AnnLarrowtailU	`-<<`, unicode variant
AnnRarrowtail	`>>-`
AnnRarrowtailU	`>>-`, unicode variant
AnnEofPos

Instances

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

data AnnotationComment #

Constructors

AnnDocCommentNext String	something beginning '-- \|'
AnnDocCommentPrev String	something beginning '-- ^'
AnnDocCommentNamed String	something beginning '-- $'
AnnDocSection Int String	a section heading
AnnDocOptions String	doc options (prune, ignore-exports, etc)
AnnLineComment String	comment starting by "--"
AnnBlockComment String	comment in {- -}

Instances

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

data RdrName #

Reader Name

Do not use the data constructors of RdrName directly: prefer the family of functions that creates them, such as mkRdrUnqual

Note: A Located RdrName will only have API Annotations if it is a compound one, e.g.

`bar`
( ~ )

AnnKeywordId : AnnType, AnnOpen '(' or '[' or '[:', AnnClose ')' or ']' or ':]',, AnnBackquote '`', AnnVal AnnTilde,

Constructors

Unqual OccName

Unqualified name

Used for ordinary, unqualified occurrences, e.g. x, y or Foo. Create such a RdrName with mkRdrUnqual

Qual ModuleName OccName

Qualified name

A qualified name written by the user in source code. The module isn't necessarily the module where the thing is defined; just the one from which it is imported. Examples are Bar.x, Bar.y or Bar.Foo. Create such a RdrName with mkRdrQual

Instances

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

prettyPrintGhcErrors :: ExceptionMonad m => DynFlags -> m a -> m a #

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

Eq HsDocString
Instance details Defined in HsDoc Methods (==) :: HsDocString -> HsDocString -> Bool # (/=) :: HsDocString -> HsDocString -> Bool #
Data HsDocString
Instance details Defined in HsDoc 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 :: (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 HsDoc Methods showsPrec :: Int -> HsDocString -> ShowS # show :: HsDocString -> String # showList :: [HsDocString] -> ShowS #
Binary HsDocString
Instance details Defined in HsDoc Methods put_ :: BinHandle -> HsDocString -> IO () # put :: BinHandle -> HsDocString -> IO (Bin HsDocString) # get :: BinHandle -> IO HsDocString #
Outputable HsDocString
Instance details Defined in HsDoc Methods ppr :: HsDocString -> SDoc # pprPrec :: Rational -> HsDocString -> SDoc #

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

Binary DeclDocMap
Instance details Defined in HsDoc Methods put_ :: BinHandle -> DeclDocMap -> IO () # put :: BinHandle -> DeclDocMap -> IO (Bin DeclDocMap) # get :: BinHandle -> IO DeclDocMap #
Outputable DeclDocMap
Instance details Defined in HsDoc 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

Binary ArgDocMap
Instance details Defined in HsDoc Methods put_ :: BinHandle -> ArgDocMap -> IO () # put :: BinHandle -> ArgDocMap -> IO (Bin ArgDocMap) # get :: BinHandle -> IO ArgDocMap #
Outputable ArgDocMap
Instance details Defined in HsDoc Methods ppr :: ArgDocMap -> SDoc # pprPrec :: Rational -> ArgDocMap -> SDoc #

nameModule :: HasDebugCallStack -> Name -> Module #

isExternalName :: Name -> Bool #

nameSrcSpan :: Name -> SrcSpan #

class NamedThing a where #

A class allowing convenient access to the Name of various datatypes

Minimal complete definition

getName

Methods

getOccName :: a -> OccName #

getName :: a -> Name #

Instances

NamedThing ClsInst
Instance details Defined in InstEnv Methods getOccName :: ClsInst -> OccName # getName :: ClsInst -> Name #
NamedThing FamInst
Instance details Defined in FamInstEnv Methods getOccName :: FamInst -> OccName # getName :: FamInst -> Name #
NamedThing IfaceDecl
Instance details Defined in IfaceSyn Methods getOccName :: IfaceDecl -> OccName # getName :: IfaceDecl -> Name #
NamedThing IfaceClassOp
Instance details Defined in IfaceSyn Methods getOccName :: IfaceClassOp -> OccName # getName :: IfaceClassOp -> Name #
NamedThing IfaceConDecl
Instance details Defined in IfaceSyn Methods getOccName :: IfaceConDecl -> OccName # getName :: IfaceConDecl -> Name #
NamedThing Class
Instance details Defined in Class Methods getOccName :: Class -> OccName # getName :: Class -> Name #
NamedThing ConLike
Instance details Defined in ConLike Methods getOccName :: ConLike -> OccName # getName :: ConLike -> Name #
NamedThing DataCon
Instance details Defined in DataCon Methods getOccName :: DataCon -> OccName # getName :: DataCon -> Name #
NamedThing Var
Instance details Defined in Var Methods getOccName :: Var -> OccName # getName :: Var -> Name #
NamedThing TyThing
Instance details Defined in TyCoRep Methods getOccName :: TyThing -> OccName # getName :: TyThing -> Name #
NamedThing TyCon
Instance details Defined in TyCon Methods getOccName :: TyCon -> OccName # getName :: TyCon -> Name #
NamedThing Name
Instance details Defined in Name Methods getOccName :: Name -> OccName # getName :: Name -> Name #
NamedThing (CoAxiom br)
Instance details Defined in CoAxiom Methods getOccName :: CoAxiom br -> OccName # getName :: CoAxiom br -> Name #
NamedThing e => NamedThing (GenLocated l e)
Instance details Defined in Name Methods getOccName :: GenLocated l e -> OccName # getName :: GenLocated l e -> Name #

gopt :: GeneralFlag -> DynFlags -> Bool #

Test whether a GeneralFlag is set

defaultObjectTarget :: Platform -> HscTarget #

The HscTarget value corresponding to the default way to create object files on the current platform.

data SafeHaskellMode #

The various Safe Haskell modes

Constructors

Sf_None
Sf_Unsafe
Sf_Trustworthy
Sf_Safe

Instances

Eq SafeHaskellMode
Instance details Defined in DynFlags Methods (==) :: SafeHaskellMode -> SafeHaskellMode -> Bool # (/=) :: SafeHaskellMode -> SafeHaskellMode -> Bool #
Show SafeHaskellMode
Instance details Defined in DynFlags Methods showsPrec :: Int -> SafeHaskellMode -> ShowS # show :: SafeHaskellMode -> String # showList :: [SafeHaskellMode] -> ShowS #
NFData SafeHaskellMode Source #
Instance details Defined in Development.IDE.GHC.Orphans Methods rnf :: SafeHaskellMode -> () #
Outputable SafeHaskellMode
Instance details Defined in DynFlags Methods ppr :: SafeHaskellMode -> SDoc # pprPrec :: Rational -> SafeHaskellMode -> SDoc #

data HscTarget #

The target code type of the compilation (if any).

Whenever you change the target, also make sure to set ghcLink to something sensible.

HscNothing can be used to avoid generating any output, however, note that:

If a program uses Template Haskell the typechecker may need to run code from an imported module. To facilitate this, code generation is enabled for modules imported by modules that use template haskell. See Note [-fno-code mode].

Constructors

HscC	Generate C code.
HscAsm	Generate assembly using the native code generator.
HscLlvm	Generate assembly using the llvm code generator.
HscInterpreted	Generate bytecode. (Requires `LinkInMemory`)
HscNothing	Don't generate any code. See notes above.

Instances

Eq HscTarget
Instance details Defined in DynFlags Methods (==) :: HscTarget -> HscTarget -> Bool # (/=) :: HscTarget -> HscTarget -> Bool #
Show HscTarget
Instance details Defined in DynFlags Methods showsPrec :: Int -> HscTarget -> ShowS # show :: HscTarget -> String # showList :: [HscTarget] -> ShowS #

data GhcMode #

The GhcMode tells us whether we're doing multi-module compilation (controlled via the GHC API) or one-shot (single-module) compilation. This makes a difference primarily to the Finder: in one-shot mode we look for interface files for imported modules, but in multi-module mode we look for source files in order to check whether they need to be recompiled.

Constructors

CompManager	`--make`, GHCi, etc.
OneShot	ghc -c Foo.hs
MkDepend	`ghc -M`, see Finder for why we need this

Instances

Eq GhcMode
Instance details Defined in DynFlags Methods (==) :: GhcMode -> GhcMode -> Bool # (/=) :: GhcMode -> GhcMode -> Bool #
Outputable GhcMode
Instance details Defined in DynFlags Methods ppr :: GhcMode -> SDoc # pprPrec :: Rational -> GhcMode -> SDoc #

data GhcLink #

What to do in the link step, if there is one.

Constructors

NoLink	Don't link at all
LinkBinary	Link object code into a binary
LinkInMemory	Use the in-memory dynamic linker (works for both bytecode and object code).
LinkDynLib	Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)
LinkStaticLib	Link objects into a static lib

Instances

Eq GhcLink
Instance details Defined in DynFlags Methods (==) :: GhcLink -> GhcLink -> Bool # (/=) :: GhcLink -> GhcLink -> Bool #
Show GhcLink
Instance details Defined in DynFlags Methods showsPrec :: Int -> GhcLink -> ShowS # show :: GhcLink -> String # showList :: [GhcLink] -> ShowS #

data Phase #

Instances

Eq Phase
Instance details Defined in DriverPhases Methods (==) :: Phase -> Phase -> Bool # (/=) :: Phase -> Phase -> Bool #
Show Phase
Instance details Defined in DriverPhases Methods showsPrec :: Int -> Phase -> ShowS # show :: Phase -> String # showList :: [Phase] -> ShowS #
Outputable Phase
Instance details Defined in DriverPhases Methods ppr :: Phase -> SDoc # pprPrec :: Rational -> Phase -> SDoc #

pprModule :: Module -> SDoc #

mkModule :: UnitId -> ModuleName -> Module #

mkModuleName :: String -> ModuleName #

moduleNameString :: ModuleName -> String #

ml_hs_file :: ModLocation -> Maybe FilePath #

ml_hi_file :: ModLocation -> FilePath #

ml_obj_file :: ModLocation -> FilePath #

failed :: SuccessFlag -> Bool #

succeeded :: SuccessFlag -> Bool #

compareFixity :: Fixity -> Fixity -> (Bool, Bool) #

negateFixity :: Fixity #

defaultFixity :: Fixity #

maxPrecedence :: Int #

data Fixity #

Instances

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 :: (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 #
Binary Fixity
Instance details Defined in Binary Methods put_ :: BinHandle -> Fixity -> IO () # put :: BinHandle -> Fixity -> IO (Bin Fixity) # get :: BinHandle -> IO Fixity #
Outputable Fixity
Instance details Defined in BasicTypes Methods ppr :: Fixity -> SDoc # pprPrec :: Rational -> Fixity -> SDoc #

data FixityDirection #

Constructors

InfixL
InfixR
InfixN

Instances

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

data LexicalFixity #

Captures the fixity of declarations as they are parsed. This is not necessarily the same as the fixity declaration, as the normal fixity may be overridden using parens or backticks.

Constructors

Prefix
Infix

Instances

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

data SuccessFlag #

Constructors

Succeeded
Failed

Instances

Outputable SuccessFlag
Instance details Defined in BasicTypes Methods ppr :: SuccessFlag -> SDoc # pprPrec :: Rational -> SuccessFlag -> SDoc #

data SpliceExplicitFlag #

Constructors

ExplicitSplice	= $(f x y)
ImplicitSplice	= f x y, i.e. a naked top level expression

Instances

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 :: (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 #

data Severity #

Constructors

SevOutput
SevFatal
SevInteractive
SevDump	Log message intended for compiler developers No filelinecolumn stuff
SevInfo	Log messages intended for end users. No filelinecolumn stuff.
SevWarning
SevError	SevWarning and SevError are used for warnings and errors o The message has a filelinecolumn heading, plus "warning:" or "error:", added by mkLocMessags o Output is intended for end users

Instances

Show Severity
Instance details Defined in ErrUtils Methods showsPrec :: Int -> Severity -> ShowS # show :: Severity -> String # showList :: [Severity] -> ShowS #
ToJson Severity
Instance details Defined in ErrUtils Methods json :: Severity -> JsonDoc #

isSubspanOf #

Arguments

:: SrcSpan	The span that may be enclosed by the other
-> SrcSpan	The span it may be enclosed by
-> Bool

Determines whether a span is enclosed by another one

spans :: SrcSpan -> (Int, Int) -> Bool #

Determines whether a span encloses a given line and column index

leftmost_largest :: SrcSpan -> SrcSpan -> Ordering #

Alternative strategies for ordering SrcSpans

leftmost_smallest :: SrcSpan -> SrcSpan -> Ordering #

Alternative strategies for ordering SrcSpans

rightmost :: SrcSpan -> SrcSpan -> Ordering #

Alternative strategies for ordering SrcSpans

cmpLocated :: Ord a => Located a -> Located a -> Ordering #

Tests the ordering of the two located things

eqLocated :: Eq a => Located a -> Located a -> Bool #

Tests whether the two located things are equal

addCLoc :: Located a -> Located b -> c -> Located c #

Combine locations from two Located things and add them to a third thing

combineLocs :: Located a -> Located b -> SrcSpan #

mkGeneralLocated :: String -> e -> Located e #

noLoc :: e -> Located e #

unLoc :: GenLocated l e -> e #

srcSpanEnd :: SrcSpan -> SrcLoc #

Returns the location at the end of the SrcSpan or a "bad" SrcSpan if that is unavailable

srcSpanStart :: SrcSpan -> SrcLoc #

Returns the location at the start of the SrcSpan or a "bad" SrcSpan if that is unavailable

srcSpanEndCol :: RealSrcSpan -> Int #

srcSpanStartCol :: RealSrcSpan -> Int #

srcSpanEndLine :: RealSrcSpan -> Int #

srcSpanStartLine :: RealSrcSpan -> Int #

isGoodSrcSpan :: SrcSpan -> Bool #

Test if a SrcSpan is "good", i.e. has precise location information

mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan #

Create a SrcSpan between two points in a file

srcLocSpan :: SrcLoc -> SrcSpan #

Create a SrcSpan corresponding to a single point

noSrcSpan :: SrcSpan #

Built-in "bad" SrcSpans for common sources of location uncertainty

srcLocCol :: RealSrcLoc -> Int #

Raises an error when used on a "bad" RealSrcLoc

srcLocLine :: RealSrcLoc -> Int #

Raises an error when used on a "bad" RealSrcLoc

srcLocFile :: RealSrcLoc -> FastString #

Gives the filename of the RealSrcLoc

noSrcLoc :: SrcLoc #

Built-in "bad" RealSrcLoc values for particular locations

mkSrcLoc :: FastString -> Int -> Int -> SrcLoc #

data RealSrcLoc #

Real Source Location

Represents a single point within a file

Instances

Eq RealSrcLoc
Instance details Defined in SrcLoc Methods (==) :: RealSrcLoc -> RealSrcLoc -> Bool # (/=) :: RealSrcLoc -> RealSrcLoc -> Bool #
Ord RealSrcLoc
Instance details Defined in SrcLoc Methods compare :: RealSrcLoc -> RealSrcLoc -> Ordering # (<) :: RealSrcLoc -> RealSrcLoc -> Bool # (<=) :: RealSrcLoc -> RealSrcLoc -> Bool # (>) :: RealSrcLoc -> RealSrcLoc -> Bool # (>=) :: RealSrcLoc -> RealSrcLoc -> Bool # max :: RealSrcLoc -> RealSrcLoc -> RealSrcLoc # min :: RealSrcLoc -> RealSrcLoc -> RealSrcLoc #
Show RealSrcLoc
Instance details Defined in SrcLoc Methods showsPrec :: Int -> RealSrcLoc -> ShowS # show :: RealSrcLoc -> String # showList :: [RealSrcLoc] -> ShowS #
Outputable RealSrcLoc
Instance details Defined in SrcLoc Methods ppr :: RealSrcLoc -> SDoc # pprPrec :: Rational -> RealSrcLoc -> SDoc #

data SrcLoc #

Source Location

Constructors

RealSrcLoc !RealSrcLoc
UnhelpfulLoc FastString

Instances

Eq SrcLoc
Instance details Defined in SrcLoc Methods (==) :: SrcLoc -> SrcLoc -> Bool # (/=) :: SrcLoc -> SrcLoc -> Bool #
Ord SrcLoc
Instance details Defined in SrcLoc Methods compare :: SrcLoc -> SrcLoc -> Ordering # (<) :: SrcLoc -> SrcLoc -> Bool # (<=) :: SrcLoc -> SrcLoc -> Bool # (>) :: SrcLoc -> SrcLoc -> Bool # (>=) :: SrcLoc -> SrcLoc -> Bool # max :: SrcLoc -> SrcLoc -> SrcLoc # min :: SrcLoc -> SrcLoc -> SrcLoc #
Show SrcLoc
Instance details Defined in SrcLoc Methods showsPrec :: Int -> SrcLoc -> ShowS # show :: SrcLoc -> String # showList :: [SrcLoc] -> ShowS #
Outputable SrcLoc
Instance details Defined in SrcLoc Methods ppr :: SrcLoc -> SDoc # pprPrec :: Rational -> SrcLoc -> SDoc #

data RealSrcSpan #

A RealSrcSpan delimits a portion of a text file. It could be represented by a pair of (line,column) coordinates, but in fact we optimise slightly by using more compact representations for single-line and zero-length spans, both of which are quite common.

The end position is defined to be the column after the end of the span. That is, a span of (1,1)-(1,2) is one character long, and a span of (1,1)-(1,1) is zero characters long.

Real Source Span

Instances

Eq RealSrcSpan
Instance details Defined in SrcLoc Methods (==) :: RealSrcSpan -> RealSrcSpan -> Bool # (/=) :: RealSrcSpan -> RealSrcSpan -> Bool #
Data RealSrcSpan
Instance details Defined in SrcLoc Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RealSrcSpan -> c RealSrcSpan # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RealSrcSpan # toConstr :: RealSrcSpan -> Constr # dataTypeOf :: RealSrcSpan -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RealSrcSpan) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RealSrcSpan) # gmapT :: (forall b. Data b => b -> b) -> RealSrcSpan -> RealSrcSpan # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RealSrcSpan -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RealSrcSpan -> r # gmapQ :: (forall d. Data d => d -> u) -> RealSrcSpan -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RealSrcSpan -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RealSrcSpan -> m RealSrcSpan # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RealSrcSpan -> m RealSrcSpan # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RealSrcSpan -> m RealSrcSpan #
Ord RealSrcSpan
Instance details Defined in SrcLoc Methods compare :: RealSrcSpan -> RealSrcSpan -> Ordering # (<) :: RealSrcSpan -> RealSrcSpan -> Bool # (<=) :: RealSrcSpan -> RealSrcSpan -> Bool # (>) :: RealSrcSpan -> RealSrcSpan -> Bool # (>=) :: RealSrcSpan -> RealSrcSpan -> Bool # max :: RealSrcSpan -> RealSrcSpan -> RealSrcSpan # min :: RealSrcSpan -> RealSrcSpan -> RealSrcSpan #
Show RealSrcSpan
Instance details Defined in SrcLoc Methods showsPrec :: Int -> RealSrcSpan -> ShowS # show :: RealSrcSpan -> String # showList :: [RealSrcSpan] -> ShowS #
Binary RealSrcSpan Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods put_ :: BinHandle -> RealSrcSpan -> IO () # put :: BinHandle -> RealSrcSpan -> IO (Bin RealSrcSpan) # get :: BinHandle -> IO RealSrcSpan #
ToJson RealSrcSpan
Instance details Defined in SrcLoc Methods json :: RealSrcSpan -> JsonDoc #
Outputable RealSrcSpan
Instance details Defined in SrcLoc Methods ppr :: RealSrcSpan -> SDoc # pprPrec :: Rational -> RealSrcSpan -> SDoc #

data SrcSpan #

Source Span

A SrcSpan identifies either a specific portion of a text file or a human-readable description of a location.

Constructors

RealSrcSpan !RealSrcSpan
UnhelpfulSpan !FastString

Instances

Eq SrcSpan
Instance details Defined in SrcLoc Methods (==) :: SrcSpan -> SrcSpan -> Bool # (/=) :: SrcSpan -> SrcSpan -> Bool #
Data SrcSpan
Instance details Defined in SrcLoc Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcSpan -> c SrcSpan # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SrcSpan # toConstr :: SrcSpan -> Constr # dataTypeOf :: SrcSpan -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SrcSpan) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcSpan) # gmapT :: (forall b. Data b => b -> b) -> SrcSpan -> SrcSpan # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcSpan -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SrcSpan -> r # gmapQ :: (forall d. Data d => d -> u) -> SrcSpan -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcSpan -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan #
Ord SrcSpan
Instance details Defined in SrcLoc Methods compare :: SrcSpan -> SrcSpan -> Ordering # (<) :: SrcSpan -> SrcSpan -> Bool # (<=) :: SrcSpan -> SrcSpan -> Bool # (>) :: SrcSpan -> SrcSpan -> Bool # (>=) :: SrcSpan -> SrcSpan -> Bool # max :: SrcSpan -> SrcSpan -> SrcSpan # min :: SrcSpan -> SrcSpan -> SrcSpan #
Show SrcSpan
Instance details Defined in SrcLoc Methods showsPrec :: Int -> SrcSpan -> ShowS # show :: SrcSpan -> String # showList :: [SrcSpan] -> ShowS #
NFData SrcSpan
Instance details Defined in SrcLoc Methods rnf :: SrcSpan -> () #
Binary SrcSpan
Instance details Defined in Binary Methods put_ :: BinHandle -> SrcSpan -> IO () # put :: BinHandle -> SrcSpan -> IO (Bin SrcSpan) # get :: BinHandle -> IO SrcSpan #
ToJson SrcSpan
Instance details Defined in SrcLoc Methods json :: SrcSpan -> JsonDoc #
Outputable SrcSpan
Instance details Defined in SrcLoc Methods ppr :: SrcSpan -> SDoc # pprPrec :: Rational -> SrcSpan -> SDoc #
Show (GenLocated SrcSpan ModuleName) Source #
Instance details Defined in Development.IDE.GHC.Orphans Methods showsPrec :: Int -> GenLocated SrcSpan ModuleName -> ShowS # show :: GenLocated SrcSpan ModuleName -> String # showList :: [GenLocated SrcSpan ModuleName] -> ShowS #
Binary a => Binary (GenLocated SrcSpan a)
Instance details Defined in Binary Methods put_ :: BinHandle -> GenLocated SrcSpan a -> IO () # put :: BinHandle -> GenLocated SrcSpan a -> IO (Bin (GenLocated SrcSpan a)) # get :: BinHandle -> IO (GenLocated SrcSpan a) #
HasSrcSpan (GenLocated SrcSpan a) Source #
Instance details Defined in Development.IDE.GHC.Compat Methods getLoc :: GenLocated SrcSpan a -> SrcSpan Source #

data GenLocated l e #

We attach SrcSpans to lots of things, so let's have a datatype for it.

Constructors

L l e

Instances

Functor (GenLocated l)
Instance details Defined in SrcLoc Methods fmap :: (a -> b) -> GenLocated l a -> GenLocated l b # (<$) :: a -> GenLocated l b -> GenLocated l a #
Foldable (GenLocated l)
Instance details Defined in SrcLoc Methods fold :: Monoid m => GenLocated l m -> m # foldMap :: Monoid m => (a -> m) -> GenLocated l a -> m # foldr :: (a -> b -> b) -> b -> GenLocated l a -> b # foldr' :: (a -> b -> b) -> b -> GenLocated l a -> b # foldl :: (b -> a -> b) -> b -> GenLocated l a -> b # foldl' :: (b -> a -> b) -> b -> GenLocated l a -> b # foldr1 :: (a -> a -> a) -> GenLocated l a -> a # foldl1 :: (a -> a -> a) -> GenLocated l a -> a # toList :: GenLocated l a -> [a] # null :: GenLocated l a -> Bool # length :: GenLocated l a -> Int # elem :: Eq a => a -> GenLocated l a -> Bool # maximum :: Ord a => GenLocated l a -> a # minimum :: Ord a => GenLocated l a -> a # sum :: Num a => GenLocated l a -> a # product :: Num a => GenLocated l a -> a #
Traversable (GenLocated l)
Instance details Defined in SrcLoc Methods traverse :: Applicative f => (a -> f b) -> GenLocated l a -> f (GenLocated l b) # sequenceA :: Applicative f => GenLocated l (f a) -> f (GenLocated l a) # mapM :: Monad m => (a -> m b) -> GenLocated l a -> m (GenLocated l b) # sequence :: Monad m => GenLocated l (m a) -> m (GenLocated l a) #
(Eq l, Eq e) => Eq (GenLocated l e)
Instance details Defined in SrcLoc Methods (==) :: GenLocated l e -> GenLocated l e -> Bool # (/=) :: GenLocated l e -> GenLocated l e -> Bool #
(Data l, Data e) => Data (GenLocated l e)
Instance details Defined in SrcLoc Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GenLocated l e -> c (GenLocated l e) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GenLocated l e) # toConstr :: GenLocated l e -> Constr # dataTypeOf :: GenLocated l e -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GenLocated l e)) # dataCast2 :: Typeable t => (forall d e0. (Data d, Data e0) => c (t d e0)) -> Maybe (c (GenLocated l e)) # gmapT :: (forall b. Data b => b -> b) -> GenLocated l e -> GenLocated l e # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GenLocated l e -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GenLocated l e -> r # gmapQ :: (forall d. Data d => d -> u) -> GenLocated l e -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> GenLocated l e -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> GenLocated l e -> m (GenLocated l e) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GenLocated l e -> m (GenLocated l e) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GenLocated l e -> m (GenLocated l e) #
(Ord l, Ord e) => Ord (GenLocated l e)
Instance details Defined in SrcLoc Methods compare :: GenLocated l e -> GenLocated l e -> Ordering # (<) :: GenLocated l e -> GenLocated l e -> Bool # (<=) :: GenLocated l e -> GenLocated l e -> Bool # (>) :: GenLocated l e -> GenLocated l e -> Bool # (>=) :: GenLocated l e -> GenLocated l e -> Bool # max :: GenLocated l e -> GenLocated l e -> GenLocated l e # min :: GenLocated l e -> GenLocated l e -> GenLocated l e #
Show (GenLocated SrcSpan ModuleName) Source #
Instance details Defined in Development.IDE.GHC.Orphans Methods showsPrec :: Int -> GenLocated SrcSpan ModuleName -> ShowS # show :: GenLocated SrcSpan ModuleName -> String # showList :: [GenLocated SrcSpan ModuleName] -> ShowS #
(NFData l, NFData e) => NFData (GenLocated l e) Source #
Instance details Defined in Development.IDE.GHC.Orphans Methods rnf :: GenLocated l e -> () #
NamedThing e => NamedThing (GenLocated l e)
Instance details Defined in Name Methods getOccName :: GenLocated l e -> OccName # getName :: GenLocated l e -> Name #
Binary a => Binary (GenLocated SrcSpan a)
Instance details Defined in Binary Methods put_ :: BinHandle -> GenLocated SrcSpan a -> IO () # put :: BinHandle -> GenLocated SrcSpan a -> IO (Bin (GenLocated SrcSpan a)) # get :: BinHandle -> IO (GenLocated SrcSpan a) #
(Outputable l, Outputable e) => Outputable (GenLocated l e)
Instance details Defined in SrcLoc Methods ppr :: GenLocated l e -> SDoc # pprPrec :: Rational -> GenLocated l e -> SDoc #
HasSrcSpan (GenLocated SrcSpan a) Source #
Instance details Defined in Development.IDE.GHC.Compat Methods getLoc :: GenLocated SrcSpan a -> SrcSpan Source #

type Located = GenLocated SrcSpan #

data Type #

Instances

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

data TyThing #

A global typecheckable-thing, essentially anything that has a name. Not to be confused with a TcTyThing, which is also a typecheckable thing but in the *local* context. See TcEnv for how to retrieve a TyThing given a Name.

Constructors

AnId Id
AConLike ConLike
ATyCon TyCon
ACoAxiom (CoAxiom Branched)

Instances

NamedThing TyThing
Instance details Defined in TyCoRep Methods getOccName :: TyThing -> OccName # getName :: TyThing -> Name #
Outputable TyThing
Instance details Defined in TyCoRep Methods ppr :: TyThing -> SDoc # pprPrec :: Rational -> TyThing -> SDoc #

type PredType = Type #

A type of the form p of kind Constraint represents a value whose type is the Haskell predicate p, where a predicate is what occurs before the => in a Haskell type.

We use PredType as documentation to mark those types that we guarantee to have this kind.

It can be expanded into its representation, but:

The type checker must treat it as opaque
The rest of the compiler treats it as transparent

Consider these examples:

f :: (Eq a) => a -> Int
g :: (?x :: Int -> Int) => a -> Int
h :: (r\l) => {r} => {l::Int | r}

Here the Eq a and ?x :: Int -> Int and rl are all called "predicates"

type Kind = Type #

The key type representing kinds in the compiler.

type ThetaType = [PredType] #

A collection of PredTypes

alwaysQualify :: PrintUnqualified #

data PrintUnqualified #

When printing code that contains original names, we need to map the original names back to something the user understands. This is the purpose of the triple of functions that gets passed around when rendering SDoc.

data Module #

A Module is a pair of a UnitId and a ModuleName.

Module variables (i.e. H) which can be instantiated to a specific module at some later point in time are represented with moduleUnitId set to holeUnitId (this allows us to avoid having to make moduleUnitId a partial operation.)

Instances

Eq Module
Instance details Defined in Module Methods (==) :: Module -> Module -> Bool # (/=) :: Module -> Module -> Bool #
Data Module
Instance details Defined in Module Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Module -> c Module # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Module # toConstr :: Module -> Constr # dataTypeOf :: Module -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Module) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module) # gmapT :: (forall b. Data b => b -> b) -> Module -> Module # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r # gmapQ :: (forall d. Data d => d -> u) -> Module -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Module -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Module -> m Module # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module #
Ord Module
Instance details Defined in Module Methods compare :: Module -> Module -> Ordering # (<) :: Module -> Module -> Bool # (<=) :: Module -> Module -> Bool # (>) :: Module -> Module -> Bool # (>=) :: Module -> Module -> Bool # max :: Module -> Module -> Module # min :: Module -> Module -> Module #
Show Module Source #
Instance details Defined in Development.IDE.GHC.Orphans Methods showsPrec :: Int -> Module -> ShowS # show :: Module -> String # showList :: [Module] -> ShowS #
NFData Module
Instance details Defined in Module Methods rnf :: Module -> () #
Binary Module
Instance details Defined in Module Methods put_ :: BinHandle -> Module -> IO () # put :: BinHandle -> Module -> IO (Bin Module) # get :: BinHandle -> IO Module #
Uniquable Module
Instance details Defined in Module Methods getUnique :: Module -> Unique #
Outputable Module
Instance details Defined in Module Methods ppr :: Module -> SDoc # pprPrec :: Rational -> Module -> SDoc #
DbUnitIdModuleRep InstalledUnitId ComponentId UnitId ModuleName Module
Instance details Defined in Module Methods fromDbModule :: DbModule InstalledUnitId ComponentId UnitId ModuleName Module -> Module # toDbModule :: Module -> DbModule InstalledUnitId ComponentId UnitId ModuleName Module # fromDbUnitId :: DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module -> UnitId # toDbUnitId :: UnitId -> DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module #

data ModuleName #

A ModuleName is essentially a simple string, e.g. Data.List.

Instances

Eq ModuleName
Instance details Defined in Module Methods (==) :: ModuleName -> ModuleName -> Bool # (/=) :: ModuleName -> ModuleName -> Bool #
Data ModuleName
Instance details Defined in Module Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModuleName -> c ModuleName # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ModuleName # toConstr :: ModuleName -> Constr # dataTypeOf :: ModuleName -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ModuleName) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleName) # gmapT :: (forall b. Data b => b -> b) -> ModuleName -> ModuleName # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModuleName -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModuleName -> r # gmapQ :: (forall d. Data d => d -> u) -> ModuleName -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ModuleName -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModuleName -> m ModuleName # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleName -> m ModuleName # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleName -> m ModuleName #
Ord ModuleName
Instance details Defined in Module Methods compare :: ModuleName -> ModuleName -> Ordering # (<) :: ModuleName -> ModuleName -> Bool # (<=) :: ModuleName -> ModuleName -> Bool # (>) :: ModuleName -> ModuleName -> Bool # (>=) :: ModuleName -> ModuleName -> Bool # max :: ModuleName -> ModuleName -> ModuleName # min :: ModuleName -> ModuleName -> ModuleName #
NFData ModuleName
Instance details Defined in Module Methods rnf :: ModuleName -> () #
Binary ModuleName
Instance details Defined in Module Methods put_ :: BinHandle -> ModuleName -> IO () # put :: BinHandle -> ModuleName -> IO (Bin ModuleName) # get :: BinHandle -> IO ModuleName #
Uniquable ModuleName
Instance details Defined in Module Methods getUnique :: ModuleName -> Unique #
Outputable ModuleName
Instance details Defined in Module Methods ppr :: ModuleName -> SDoc # pprPrec :: Rational -> ModuleName -> SDoc #
BinaryStringRep ModuleName
Instance details Defined in Module Methods fromStringRep :: ByteString -> ModuleName # toStringRep :: ModuleName -> ByteString #
DbUnitIdModuleRep InstalledUnitId ComponentId UnitId ModuleName Module
Instance details Defined in Module Methods fromDbModule :: DbModule InstalledUnitId ComponentId UnitId ModuleName Module -> Module # toDbModule :: Module -> DbModule InstalledUnitId ComponentId UnitId ModuleName Module # fromDbUnitId :: DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module -> UnitId # toDbUnitId :: UnitId -> DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module #
Show (GenLocated SrcSpan ModuleName) Source #
Instance details Defined in Development.IDE.GHC.Orphans Methods showsPrec :: Int -> GenLocated SrcSpan ModuleName -> ShowS # show :: GenLocated SrcSpan ModuleName -> String # showList :: [GenLocated SrcSpan ModuleName] -> ShowS #

data UnitId #

A unit identifier identifies a (possibly partially) instantiated library. It is primarily used as part of Module, which in turn is used in Name, which is used to give names to entities when typechecking.

There are two possible forms for a UnitId. It can be a DefiniteUnitId, in which case we just have a string that uniquely identifies some fully compiled, installed library we have on disk. However, when we are typechecking a library with missing holes, we may need to instantiate a library on the fly (in which case we don't have any on-disk representation.) In that case, you have an IndefiniteUnitId, which explicitly records the instantiation, so that we can substitute over it.

Instances

Eq UnitId
Instance details Defined in Module Methods (==) :: UnitId -> UnitId -> Bool # (/=) :: UnitId -> UnitId -> Bool #
Data UnitId
Instance details Defined in Module Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UnitId -> c UnitId # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UnitId # toConstr :: UnitId -> Constr # dataTypeOf :: UnitId -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UnitId) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnitId) # gmapT :: (forall b. Data b => b -> b) -> UnitId -> UnitId # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UnitId -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UnitId -> r # gmapQ :: (forall d. Data d => d -> u) -> UnitId -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> UnitId -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> UnitId -> m UnitId # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UnitId -> m UnitId # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UnitId -> m UnitId #
Ord UnitId
Instance details Defined in Module Methods compare :: UnitId -> UnitId -> Ordering # (<) :: UnitId -> UnitId -> Bool # (<=) :: UnitId -> UnitId -> Bool # (>) :: UnitId -> UnitId -> Bool # (>=) :: UnitId -> UnitId -> Bool # max :: UnitId -> UnitId -> UnitId # min :: UnitId -> UnitId -> UnitId #
Show UnitId
Instance details Defined in Module Methods showsPrec :: Int -> UnitId -> ShowS # show :: UnitId -> String # showList :: [UnitId] -> ShowS #
NFData UnitId
Instance details Defined in Module Methods rnf :: UnitId -> () #
Binary UnitId
Instance details Defined in Module Methods put_ :: BinHandle -> UnitId -> IO () # put :: BinHandle -> UnitId -> IO (Bin UnitId) # get :: BinHandle -> IO UnitId #
Uniquable UnitId
Instance details Defined in Module Methods getUnique :: UnitId -> Unique #
Outputable UnitId
Instance details Defined in Module Methods ppr :: UnitId -> SDoc # pprPrec :: Rational -> UnitId -> SDoc #
DbUnitIdModuleRep InstalledUnitId ComponentId UnitId ModuleName Module
Instance details Defined in Module Methods fromDbModule :: DbModule InstalledUnitId ComponentId UnitId ModuleName Module -> Module # toDbModule :: Module -> DbModule InstalledUnitId ComponentId UnitId ModuleName Module # fromDbUnitId :: DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module -> UnitId # toDbUnitId :: UnitId -> DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module #

isFunTyCon :: TyCon -> Bool #

data TyCon #

TyCons represent type constructors. Type constructors are introduced by things such as:

1) Data declarations: data Foo = ... creates the Foo type constructor of kind *

2) Type synonyms: type Foo = ... creates the Foo type constructor

3) Newtypes: newtype Foo a = MkFoo ... creates the Foo type constructor of kind * -> *

4) Class declarations: class Foo where creates the Foo type constructor of kind *

This data type also encodes a number of primitive, built in type constructors such as those for function and tuple types.

Instances

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

data DynFlags #

Contains not only a collection of GeneralFlags but also a plethora of information relating to the compilation of a single file or GHC session

Constructors

DynFlags

Fields

ghcMode :: GhcMode
ghcLink :: GhcLink
hscTarget :: HscTarget
settings :: Settings
llvmTargets :: LlvmTargets
llvmPasses :: LlvmPasses
verbosity :: Int
Verbosity level: see Note [Verbosity levels]
optLevel :: Int
Optimisation level
debugLevel :: Int
How much debug information to produce
simplPhases :: Int
Number of simplifier phases
maxSimplIterations :: Int
Max simplifier iterations
maxPmCheckIterations :: Int
Max no iterations for pm checking
ruleCheck :: Maybe String
inlineCheck :: Maybe String
A prefix to report inlining decisions about
strictnessBefore :: [Int]
Additional demand analysis
parMakeCount :: Maybe Int
The number of modules to compile in parallel in --make mode, where Nothing ==> compile as many in parallel as there are CPUs.
enableTimeStats :: Bool
Enable RTS timing statistics?
ghcHeapSize :: Maybe Int
The heap size to set.
maxRelevantBinds :: Maybe Int
Maximum number of bindings from the type envt to show in type error messages
maxValidHoleFits :: Maybe Int
Maximum number of hole fits to show in typed hole error messages
maxRefHoleFits :: Maybe Int
Maximum number of refinement hole fits to show in typed hole error messages
refLevelHoleFits :: Maybe Int
Maximum level of refinement for refinement hole fits in typed hole error messages
maxUncoveredPatterns :: Int
Maximum number of unmatched patterns to show in non-exhaustiveness warnings
simplTickFactor :: Int
Multiplier for simplifier ticks
specConstrThreshold :: Maybe Int
Threshold for SpecConstr
specConstrCount :: Maybe Int
Max number of specialisations for any one function
specConstrRecursive :: Int
Max number of specialisations for recursive types Not optional; otherwise ForceSpecConstr can diverge.
liberateCaseThreshold :: Maybe Int
Threshold for LiberateCase
floatLamArgs :: Maybe Int
Arg count for lambda floating See CoreMonad.FloatOutSwitches
cmmProcAlignment :: Maybe Int
Align Cmm functions at this boundary or use default.
historySize :: Int
Simplification history size
importPaths :: [FilePath]
mainModIs :: Module
mainFunIs :: Maybe String
reductionDepth :: IntWithInf
Typechecker maximum stack depth
solverIterations :: IntWithInf
Number of iterations in the constraints solver Typically only 1 is needed
thisInstalledUnitId :: InstalledUnitId
thisComponentId_ :: Maybe ComponentId
thisUnitIdInsts_ :: Maybe [(ModuleName, Module)]
ways :: [Way]
Way flags from the command line
buildTag :: String
The global "way" (e.g. "p" for prof)
splitInfo :: Maybe (String, Int)
objectDir :: Maybe String
dylibInstallName :: Maybe String
hiDir :: Maybe String
stubDir :: Maybe String
dumpDir :: Maybe String
objectSuf :: String
hcSuf :: String
hiSuf :: String
canGenerateDynamicToo :: IORef Bool
dynObjectSuf :: String
dynHiSuf :: String
outputFile :: Maybe String
dynOutputFile :: Maybe String
outputHi :: Maybe String
dynLibLoader :: DynLibLoader
dumpPrefix :: Maybe FilePath
This is set by runPipeline based on where its output is going.
dumpPrefixForce :: Maybe FilePath
Override the dumpPrefix set by runPipeline. Set by -ddump-file-prefix
ldInputs :: [Option]
includePaths :: IncludeSpecs
libraryPaths :: [String]
frameworkPaths :: [String]
cmdlineFrameworks :: [String]
rtsOpts :: Maybe String
rtsOptsEnabled :: RtsOptsEnabled
rtsOptsSuggestions :: Bool
hpcDir :: String
Path to store the .mix files
pluginModNames :: [ModuleName]
pluginModNameOpts :: [(ModuleName, String)]
frontendPluginOpts :: [String]
the -ffrontend-opt flags given on the command line, in *reverse* order that they're specified on the command line.
plugins :: [LoadedPlugin]
plugins loaded after processing arguments. What will be loaded here is directed by pluginModNames. Arguments are loaded from pluginModNameOpts. The purpose of this field is to cache the plugins so they don't have to be loaded each time they are needed. See initializePlugins.
hooks :: Hooks
depMakefile :: FilePath
depIncludePkgDeps :: Bool
depExcludeMods :: [ModuleName]
depSuffixes :: [String]
packageDBFlags :: [PackageDBFlag]
The -package-db flags given on the command line, In *reverse* order that they're specified on the command line. This is intended to be applied with the list of "initial" package databases derived from GHC_PACKAGE_PATH; see getPackageConfRefs.
ignorePackageFlags :: [IgnorePackageFlag]
The -ignore-package flags from the command line. In *reverse* order that they're specified on the command line.
packageFlags :: [PackageFlag]
The -package and -hide-package flags from the command-line. In *reverse* order that they're specified on the command line.
pluginPackageFlags :: [PackageFlag]
The -plugin-package-id flags from command line. In *reverse* order that they're specified on the command line.
trustFlags :: [TrustFlag]
The -trust and -distrust flags. In *reverse* order that they're specified on the command line.
packageEnv :: Maybe FilePath
Filepath to the package environment file (if overriding default)
pkgDatabase :: Maybe [(FilePath, [PackageConfig])]
pkgState :: PackageState
filesToClean :: IORef FilesToClean
dirsToClean :: IORef (Map FilePath FilePath)
nextTempSuffix :: IORef Int
generatedDumps :: IORef (Set FilePath)
dumpFlags :: EnumSet DumpFlag
generalFlags :: EnumSet GeneralFlag
warningFlags :: EnumSet WarningFlag
fatalWarningFlags :: EnumSet WarningFlag
language :: Maybe Language
safeHaskell :: SafeHaskellMode
Safe Haskell mode
safeInfer :: Bool
safeInferred :: Bool
thOnLoc :: SrcSpan
newDerivOnLoc :: SrcSpan
overlapInstLoc :: SrcSpan
incoherentOnLoc :: SrcSpan
pkgTrustOnLoc :: SrcSpan
warnSafeOnLoc :: SrcSpan
warnUnsafeOnLoc :: SrcSpan
trustworthyOnLoc :: SrcSpan
extensions :: [OnOff Extension]
extensionFlags :: EnumSet Extension
ufCreationThreshold :: Int
ufUseThreshold :: Int
ufFunAppDiscount :: Int
ufDictDiscount :: Int
ufKeenessFactor :: Float
ufDearOp :: Int
ufVeryAggressive :: Bool
maxWorkerArgs :: Int
ghciHistSize :: Int
log_action :: LogAction
MsgDoc output action: use ErrUtils instead of this if you can
flushOut :: FlushOut
flushErr :: FlushErr
ghcVersionFile :: Maybe FilePath
haddockOptions :: Maybe String
ghciScripts :: [String]
GHCi scripts specified by -ghci-script, in reverse order
pprUserLength :: Int
pprCols :: Int
useUnicode :: Bool
useColor :: OverridingBool
canUseColor :: Bool
colScheme :: Scheme
profAuto :: ProfAuto
what kind of {--} to add automatically
interactivePrint :: Maybe String
nextWrapperNum :: IORef (ModuleEnv Int)
sseVersion :: Maybe SseVersion
Machine dependent flags (-mblah stuff)
bmiVersion :: Maybe BmiVersion
avx :: Bool
avx2 :: Bool
avx512cd :: Bool
avx512er :: Bool
avx512f :: Bool
avx512pf :: Bool
rtldInfo :: IORef (Maybe LinkerInfo)
Run-time linker information (what options we need, etc.)
rtccInfo :: IORef (Maybe CompilerInfo)
Run-time compiler information
maxInlineAllocSize :: Int
Max size, in bytes, of inline array allocations.
maxInlineMemcpyInsns :: Int
Only inline memcpy if it generates no more than this many pseudo (roughly: Cmm) instructions.
maxInlineMemsetInsns :: Int
Only inline memset if it generates no more than this many pseudo (roughly: Cmm) instructions.
reverseErrors :: Bool
Reverse the order of error messages in GHC/GHCi
maxErrors :: Maybe Int
Limit the maximum number of errors to show
initialUnique :: Int
Unique supply configuration for testing build determinism
uniqueIncrement :: Int

data GeneralFlag #

Enumerates the simple on-or-off dynamic flags

Constructors

Opt_DumpToFile	Append dump output to files instead of stdout.
Opt_D_faststring_stats
Opt_D_dump_minimal_imports
Opt_DoCoreLinting
Opt_DoStgLinting
Opt_DoCmmLinting
Opt_DoAsmLinting
Opt_DoAnnotationLinting
Opt_NoLlvmMangler
Opt_FastLlvm
Opt_WarnIsError
Opt_ShowWarnGroups
Opt_HideSourcePaths
Opt_PrintExplicitForalls
Opt_PrintExplicitKinds
Opt_PrintExplicitCoercions
Opt_PrintExplicitRuntimeReps
Opt_PrintEqualityRelations
Opt_PrintUnicodeSyntax
Opt_PrintExpandedSynonyms
Opt_PrintPotentialInstances
Opt_PrintTypecheckerElaboration
Opt_CallArity
Opt_Exitification
Opt_Strictness
Opt_LateDmdAnal
Opt_KillAbsence
Opt_KillOneShot
Opt_FullLaziness
Opt_FloatIn
Opt_LateSpecialise
Opt_Specialise
Opt_SpecialiseAggressively
Opt_CrossModuleSpecialise
Opt_StaticArgumentTransformation
Opt_CSE
Opt_StgCSE
Opt_LiberateCase
Opt_SpecConstr
Opt_SpecConstrKeen
Opt_DoLambdaEtaExpansion
Opt_IgnoreAsserts
Opt_DoEtaReduction
Opt_CaseMerge
Opt_CaseFolding
Opt_UnboxStrictFields
Opt_UnboxSmallStrictFields
Opt_DictsCheap
Opt_EnableRewriteRules
Opt_RegsGraph
Opt_RegsIterative
Opt_PedanticBottoms
Opt_LlvmTBAA
Opt_LlvmPassVectorsInRegisters
Opt_LlvmFillUndefWithGarbage
Opt_IrrefutableTuples
Opt_CmmSink
Opt_CmmElimCommonBlocks
Opt_AsmShortcutting
Opt_OmitYields
Opt_FunToThunk
Opt_DictsStrict
Opt_DmdTxDictSel
Opt_Loopification
Opt_CprAnal
Opt_WorkerWrapper
Opt_SolveConstantDicts
Opt_AlignmentSanitisation
Opt_CatchBottoms
Opt_NumConstantFolding
Opt_SimplPreInlining
Opt_IgnoreInterfacePragmas
Opt_OmitInterfacePragmas
Opt_ExposeAllUnfoldings
Opt_WriteInterface
Opt_AutoSccsOnIndividualCafs
Opt_ProfCountEntries
Opt_Pp
Opt_ForceRecomp
Opt_IgnoreOptimChanges
Opt_IgnoreHpcChanges
Opt_ExcessPrecision
Opt_EagerBlackHoling
Opt_NoHsMain
Opt_SplitObjs
Opt_SplitSections
Opt_StgStats
Opt_HideAllPackages
Opt_HideAllPluginPackages
Opt_PrintBindResult
Opt_Haddock
Opt_HaddockOptions
Opt_BreakOnException
Opt_BreakOnError
Opt_PrintEvldWithShow
Opt_PrintBindContents
Opt_GenManifest
Opt_EmbedManifest
Opt_SharedImplib
Opt_BuildingCabalPackage
Opt_IgnoreDotGhci
Opt_GhciSandbox
Opt_GhciHistory
Opt_GhciLeakCheck
Opt_LocalGhciHistory
Opt_NoIt
Opt_HelpfulErrors
Opt_DeferTypeErrors
Opt_DeferTypedHoles
Opt_DeferOutOfScopeVariables
Opt_PIC	-fPIC
Opt_PIE	-fPIE
Opt_PICExecutable	-pie
Opt_ExternalDynamicRefs
Opt_SccProfilingOn
Opt_Ticky
Opt_Ticky_Allocd
Opt_Ticky_LNE
Opt_Ticky_Dyn_Thunk
Opt_RPath
Opt_RelativeDynlibPaths
Opt_Hpc
Opt_FlatCache
Opt_ExternalInterpreter
Opt_OptimalApplicativeDo
Opt_VersionMacros
Opt_WholeArchiveHsLibs
Opt_SingleLibFolder
Opt_ErrorSpans
Opt_DiagnosticsShowCaret
Opt_PprCaseAsLet
Opt_PprShowTicks
Opt_ShowHoleConstraints
Opt_ShowValidHoleFits
Opt_SortValidHoleFits
Opt_SortBySizeHoleFits
Opt_SortBySubsumHoleFits
Opt_AbstractRefHoleFits
Opt_UnclutterValidHoleFits
Opt_ShowTypeAppOfHoleFits
Opt_ShowTypeAppVarsOfHoleFits
Opt_ShowTypeOfHoleFits
Opt_ShowProvOfHoleFits
Opt_ShowMatchesOfHoleFits
Opt_ShowLoadedModules
Opt_HexWordLiterals
Opt_SuppressCoercions
Opt_SuppressVarKinds
Opt_SuppressModulePrefixes
Opt_SuppressTypeApplications
Opt_SuppressIdInfo
Opt_SuppressUnfoldings
Opt_SuppressTypeSignatures
Opt_SuppressUniques
Opt_SuppressStgFreeVars
Opt_SuppressTicks
Opt_SuppressTimestamps	Suppress timestamps in dumps
Opt_AutoLinkPackages
Opt_ImplicitImportQualified
Opt_KeepHiDiffs
Opt_KeepHcFiles
Opt_KeepSFiles
Opt_KeepTmpFiles
Opt_KeepRawTokenStream
Opt_KeepLlvmFiles
Opt_KeepHiFiles
Opt_KeepOFiles
Opt_BuildDynamicToo
Opt_DistrustAllPackages
Opt_PackageTrust
Opt_G_NoStateHack
Opt_G_NoOptCoercion

Instances

Enum GeneralFlag
Instance details Defined in DynFlags Methods succ :: GeneralFlag -> GeneralFlag # pred :: GeneralFlag -> GeneralFlag # toEnum :: Int -> GeneralFlag # fromEnum :: GeneralFlag -> Int # enumFrom :: GeneralFlag -> [GeneralFlag] # enumFromThen :: GeneralFlag -> GeneralFlag -> [GeneralFlag] # enumFromTo :: GeneralFlag -> GeneralFlag -> [GeneralFlag] # enumFromThenTo :: GeneralFlag -> GeneralFlag -> GeneralFlag -> [GeneralFlag] #
Eq GeneralFlag
Instance details Defined in DynFlags Methods (==) :: GeneralFlag -> GeneralFlag -> Bool # (/=) :: GeneralFlag -> GeneralFlag -> Bool #
Show GeneralFlag
Instance details Defined in DynFlags Methods showsPrec :: Int -> GeneralFlag -> ShowS # show :: GeneralFlag -> String # showList :: [GeneralFlag] -> ShowS #

withSignalHandlers :: (ExceptionMonad m, MonadIO m) => m a -> m a #

Temporarily install standard signal handlers for catching ^C, which just throw an exception in the current thread.

showGhcException :: GhcException -> ShowS #

Append a description of the given exception to this string.

Note that this uses unsafeGlobalDynFlags, which may have some uninitialized fields if invoked before initGhcMonad has been called. If the error message to be printed includes a pretty-printer document which forces one of these fields this call may bottom.

data GhcException #

GHC's own exception type error messages all take the form:

     location: error

If the location is on the command line, or in GHC itself, then location="ghc". All of the error types below correspond to a location of "ghc", except for ProgramError (where the string is assumed to contain a location already, so we don't print one).

Constructors

Signal Int	Some other fatal signal (SIGHUP,SIGTERM)
UsageError String	Prints the short usage msg after the error
CmdLineError String	A problem with the command line arguments, but don't print usage.
Panic String	The `impossible` happened.
PprPanic String SDoc
Sorry String	The user tickled something that's known not to work yet, but we're not counting it as a bug.
PprSorry String SDoc
InstallationError String	An installation problem.
ProgramError String	An error in the user's code, probably.
PprProgramError String SDoc

Instances

Show GhcException
Instance details Defined in Panic Methods showsPrec :: Int -> GhcException -> ShowS # show :: GhcException -> String # showList :: [GhcException] -> ShowS #
Exception GhcException
Instance details Defined in Panic Methods toException :: GhcException -> SomeException # fromException :: SomeException -> Maybe GhcException # displayException :: GhcException -> String #

data Name #

A unique, unambiguous name for something, containing information about where that thing originated.

Instances

Eq Name	The same comments as for `Name`'s `Ord` instance apply.
Instance details Defined in Name Methods (==) :: Name -> Name -> Bool # (/=) :: Name -> Name -> Bool #
Data Name
Instance details Defined in Name Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Name -> c Name # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Name # toConstr :: Name -> Constr # dataTypeOf :: Name -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Name) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name) # gmapT :: (forall b. Data b => b -> b) -> Name -> Name # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r # gmapQ :: (forall d. Data d => d -> u) -> Name -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Name -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Name -> m Name # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name #
Ord Name	Caution: This instance is implemented via `nonDetCmpUnique`, which means that the ordering is not stable across deserialization or rebuilds. See `nonDetCmpUnique` for further information, and trac #15240 for a bug caused by improper use of this instance.
Instance details Defined in Name Methods compare :: Name -> Name -> Ordering # (<) :: Name -> Name -> Bool # (<=) :: Name -> Name -> Bool # (>) :: Name -> Name -> Bool # (>=) :: Name -> Name -> Bool # max :: Name -> Name -> Name # min :: Name -> Name -> Name #
NFData Name
Instance details Defined in Name Methods rnf :: Name -> () #
NamedThing Name
Instance details Defined in Name Methods getOccName :: Name -> OccName # getName :: Name -> Name #
HasOccName Name
Instance details Defined in Name Methods occName :: Name -> OccName #
Binary Name	Assumes that the `Name` is a non-binding one. See `putIfaceTopBndr` and `getIfaceTopBndr` for serializing binding `Name`s. See `UserData` for the rationale for this distinction.
Instance details Defined in Name Methods put_ :: BinHandle -> Name -> IO () # put :: BinHandle -> Name -> IO (Bin Name) # get :: BinHandle -> IO Name #
Uniquable Name
Instance details Defined in Name Methods getUnique :: Name -> Unique #
Outputable Name
Instance details Defined in Name Methods ppr :: Name -> SDoc # pprPrec :: Rational -> Name -> SDoc #
OutputableBndr Name
Instance details Defined in Name Methods pprBndr :: BindingSite -> Name -> SDoc # pprPrefixOcc :: Name -> SDoc # pprInfixOcc :: Name -> SDoc # bndrIsJoin_maybe :: Name -> Maybe Int #
HasSrcSpan Name Source #
Instance details Defined in Development.IDE.GHC.Compat Methods getLoc :: Name -> SrcSpan Source #

gcatch :: (ExceptionMonad m, Exception e) => m a -> (e -> m a) -> m a #

Generalised version of catch, allowing an arbitrary exception handling monad instead of just IO.

gbracket :: ExceptionMonad m => m a -> (a -> m b) -> (a -> m c) -> m c #

Generalised version of bracket, allowing an arbitrary exception handling monad instead of just IO.

gfinally :: ExceptionMonad m => m a -> m b -> m a #

Generalised version of finally, allowing an arbitrary exception handling monad instead of just IO.

type ForeignHValue = ForeignRef HValue #

data HValue #

Instances

Show HValue
Instance details Defined in GHCi.RemoteTypes Methods showsPrec :: Int -> HValue -> ShowS # show :: HValue -> String # showList :: [HValue] -> ShowS #

coreModule :: DesugaredMod m => m -> ModGuts #

type Span = RealSrcSpan Source #

hieVersion :: Integer Source #

Current version of .hie files

data HieFile Source #

GHC builds up a wealth of information about Haskell source as it compiles it. .hie files are a way of persisting some of this information to disk so that external tools that need to work with haskell source don't need to parse, typecheck, and rename all over again. These files contain:

a simplified AST
- nodes are annotated with source positions and types
- identifiers are annotated with scope information
the raw bytes of the initial Haskell source

Besides saving compilation cycles, .hie files also offer a more stable interface than the GHC API.

Constructors

HieFile

Fields

hie_hs_file :: FilePath
Initial Haskell source file path
hie_module :: Module
The module this HIE file is for
hie_types :: Array TypeIndex HieTypeFlat
Types referenced in the hie_asts.
See Note [Efficient serialization of redundant type info]
hie_asts :: HieASTs TypeIndex
Type-annotated abstract syntax trees
hie_exports :: [AvailInfo]
The names that this module exports
hie_hs_src :: ByteString
Raw bytes of the initial Haskell source

Instances

Show HieFile Source #
Instance details Defined in Development.IDE.GHC.Orphans Methods showsPrec :: Int -> HieFile -> ShowS # show :: HieFile -> String # showList :: [HieFile] -> ShowS #
NFData HieFile Source #
Instance details Defined in Development.IDE.GHC.Orphans Methods rnf :: HieFile -> () #
Binary HieFile Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods put_ :: BinHandle -> HieFile -> IO () # put :: BinHandle -> HieFile -> IO (Bin HieFile) # get :: BinHandle -> IO HieFile #

type TypeIndex = Int Source #

data HieType a Source #

A flattened version of Type.

See Note [Efficient serialization of redundant type info]

Constructors

HTyVarTy Name
HAppTy a a
HTyConApp IfaceTyCon (HieArgs a)
HForAllTy ((Name, a), ArgFlag) a
HFunTy a a
HQualTy a a	type with constraint: `t1 => t2` (see `IfaceDFunTy`)
HLitTy IfaceTyLit
HCastTy a
HCoercionTy

Instances

Functor HieType Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods fmap :: (a -> b) -> HieType a -> HieType b # (<$) :: a -> HieType b -> HieType a #
Foldable HieType Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods fold :: Monoid m => HieType m -> m # foldMap :: Monoid m => (a -> m) -> HieType a -> m # foldr :: (a -> b -> b) -> b -> HieType a -> b # foldr' :: (a -> b -> b) -> b -> HieType a -> b # foldl :: (b -> a -> b) -> b -> HieType a -> b # foldl' :: (b -> a -> b) -> b -> HieType a -> b # foldr1 :: (a -> a -> a) -> HieType a -> a # foldl1 :: (a -> a -> a) -> HieType a -> a # toList :: HieType a -> [a] # null :: HieType a -> Bool # length :: HieType a -> Int # elem :: Eq a => a -> HieType a -> Bool # maximum :: Ord a => HieType a -> a # minimum :: Ord a => HieType a -> a # sum :: Num a => HieType a -> a # product :: Num a => HieType a -> a #
Traversable HieType Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods traverse :: Applicative f => (a -> f b) -> HieType a -> f (HieType b) # sequenceA :: Applicative f => HieType (f a) -> f (HieType a) # mapM :: Monad m => (a -> m b) -> HieType a -> m (HieType b) # sequence :: Monad m => HieType (m a) -> m (HieType a) #
Eq a => Eq (HieType a) Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods (==) :: HieType a -> HieType a -> Bool # (/=) :: HieType a -> HieType a -> Bool #
Binary (HieType TypeIndex) Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods put_ :: BinHandle -> HieType TypeIndex -> IO () # put :: BinHandle -> HieType TypeIndex -> IO (Bin (HieType TypeIndex)) # get :: BinHandle -> IO (HieType TypeIndex) #

type HieTypeFlat = HieType TypeIndex Source #

newtype HieTypeFix Source #

Roughly isomorphic to the original core Type.

Constructors

Roll (HieType HieTypeFix)

newtype HieArgs a Source #

A list of type arguments along with their respective visibilities (ie. is this an argument that would return True for isVisibleArgFlag?).

Constructors

HieArgs [(Bool, a)]

Instances

Functor HieArgs Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods fmap :: (a -> b) -> HieArgs a -> HieArgs b # (<$) :: a -> HieArgs b -> HieArgs a #
Foldable HieArgs Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods fold :: Monoid m => HieArgs m -> m # foldMap :: Monoid m => (a -> m) -> HieArgs a -> m # foldr :: (a -> b -> b) -> b -> HieArgs a -> b # foldr' :: (a -> b -> b) -> b -> HieArgs a -> b # foldl :: (b -> a -> b) -> b -> HieArgs a -> b # foldl' :: (b -> a -> b) -> b -> HieArgs a -> b # foldr1 :: (a -> a -> a) -> HieArgs a -> a # foldl1 :: (a -> a -> a) -> HieArgs a -> a # toList :: HieArgs a -> [a] # null :: HieArgs a -> Bool # length :: HieArgs a -> Int # elem :: Eq a => a -> HieArgs a -> Bool # maximum :: Ord a => HieArgs a -> a # minimum :: Ord a => HieArgs a -> a # sum :: Num a => HieArgs a -> a # product :: Num a => HieArgs a -> a #
Traversable HieArgs Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods traverse :: Applicative f => (a -> f b) -> HieArgs a -> f (HieArgs b) # sequenceA :: Applicative f => HieArgs (f a) -> f (HieArgs a) # mapM :: Monad m => (a -> m b) -> HieArgs a -> m (HieArgs b) # sequence :: Monad m => HieArgs (m a) -> m (HieArgs a) #
Eq a => Eq (HieArgs a) Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods (==) :: HieArgs a -> HieArgs a -> Bool # (/=) :: HieArgs a -> HieArgs a -> Bool #
Binary (HieArgs TypeIndex) Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods put_ :: BinHandle -> HieArgs TypeIndex -> IO () # put :: BinHandle -> HieArgs TypeIndex -> IO (Bin (HieArgs TypeIndex)) # get :: BinHandle -> IO (HieArgs TypeIndex) #

newtype HieASTs a Source #

Mapping from filepaths (represented using FastString) to the corresponding AST

Constructors

HieASTs
Fields getAsts :: Map FastString (HieAST a)

Instances

Functor HieASTs Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods fmap :: (a -> b) -> HieASTs a -> HieASTs b # (<$) :: a -> HieASTs b -> HieASTs a #
Foldable HieASTs Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods fold :: Monoid m => HieASTs m -> m # foldMap :: Monoid m => (a -> m) -> HieASTs a -> m # foldr :: (a -> b -> b) -> b -> HieASTs a -> b # foldr' :: (a -> b -> b) -> b -> HieASTs a -> b # foldl :: (b -> a -> b) -> b -> HieASTs a -> b # foldl' :: (b -> a -> b) -> b -> HieASTs a -> b # foldr1 :: (a -> a -> a) -> HieASTs a -> a # foldl1 :: (a -> a -> a) -> HieASTs a -> a # toList :: HieASTs a -> [a] # null :: HieASTs a -> Bool # length :: HieASTs a -> Int # elem :: Eq a => a -> HieASTs a -> Bool # maximum :: Ord a => HieASTs a -> a # minimum :: Ord a => HieASTs a -> a # sum :: Num a => HieASTs a -> a # product :: Num a => HieASTs a -> a #
Traversable HieASTs Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods traverse :: Applicative f => (a -> f b) -> HieASTs a -> f (HieASTs b) # sequenceA :: Applicative f => HieASTs (f a) -> f (HieASTs a) # mapM :: Monad m => (a -> m b) -> HieASTs a -> m (HieASTs b) # sequence :: Monad m => HieASTs (m a) -> m (HieASTs a) #
Binary (HieASTs TypeIndex) Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods put_ :: BinHandle -> HieASTs TypeIndex -> IO () # put :: BinHandle -> HieASTs TypeIndex -> IO (Bin (HieASTs TypeIndex)) # get :: BinHandle -> IO (HieASTs TypeIndex) #

data HieAST a Source #

Constructors

Node
Fields nodeInfo :: NodeInfo a nodeSpan :: Span nodeChildren :: [HieAST a]

Instances

Functor HieAST Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods fmap :: (a -> b) -> HieAST a -> HieAST b # (<$) :: a -> HieAST b -> HieAST a #
Foldable HieAST Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods fold :: Monoid m => HieAST m -> m # foldMap :: Monoid m => (a -> m) -> HieAST a -> m # foldr :: (a -> b -> b) -> b -> HieAST a -> b # foldr' :: (a -> b -> b) -> b -> HieAST a -> b # foldl :: (b -> a -> b) -> b -> HieAST a -> b # foldl' :: (b -> a -> b) -> b -> HieAST a -> b # foldr1 :: (a -> a -> a) -> HieAST a -> a # foldl1 :: (a -> a -> a) -> HieAST a -> a # toList :: HieAST a -> [a] # null :: HieAST a -> Bool # length :: HieAST a -> Int # elem :: Eq a => a -> HieAST a -> Bool # maximum :: Ord a => HieAST a -> a # minimum :: Ord a => HieAST a -> a # sum :: Num a => HieAST a -> a # product :: Num a => HieAST a -> a #
Traversable HieAST Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods traverse :: Applicative f => (a -> f b) -> HieAST a -> f (HieAST b) # sequenceA :: Applicative f => HieAST (f a) -> f (HieAST a) # mapM :: Monad m => (a -> m b) -> HieAST a -> m (HieAST b) # sequence :: Monad m => HieAST (m a) -> m (HieAST a) #
Binary (HieAST TypeIndex) Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods put_ :: BinHandle -> HieAST TypeIndex -> IO () # put :: BinHandle -> HieAST TypeIndex -> IO (Bin (HieAST TypeIndex)) # get :: BinHandle -> IO (HieAST TypeIndex) #

data NodeInfo a Source #

The information stored in one AST node.

The type parameter exists to provide flexibility in representation of types (see Note [Efficient serialization of redundant type info]).

Constructors

NodeInfo
Fields nodeAnnotations :: Set (FastString, FastString) (name of the AST node constructor, name of the AST node Type) nodeType :: [a] The Haskell types of this node, if any. nodeIdentifiers :: NodeIdentifiers a All the identifiers and their details

Instances

Functor NodeInfo Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods fmap :: (a -> b) -> NodeInfo a -> NodeInfo b # (<$) :: a -> NodeInfo b -> NodeInfo a #
Foldable NodeInfo Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods fold :: Monoid m => NodeInfo m -> m # foldMap :: Monoid m => (a -> m) -> NodeInfo a -> m # foldr :: (a -> b -> b) -> b -> NodeInfo a -> b # foldr' :: (a -> b -> b) -> b -> NodeInfo a -> b # foldl :: (b -> a -> b) -> b -> NodeInfo a -> b # foldl' :: (b -> a -> b) -> b -> NodeInfo a -> b # foldr1 :: (a -> a -> a) -> NodeInfo a -> a # foldl1 :: (a -> a -> a) -> NodeInfo a -> a # toList :: NodeInfo a -> [a] # null :: NodeInfo a -> Bool # length :: NodeInfo a -> Int # elem :: Eq a => a -> NodeInfo a -> Bool # maximum :: Ord a => NodeInfo a -> a # minimum :: Ord a => NodeInfo a -> a # sum :: Num a => NodeInfo a -> a # product :: Num a => NodeInfo a -> a #
Traversable NodeInfo Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods traverse :: Applicative f => (a -> f b) -> NodeInfo a -> f (NodeInfo b) # sequenceA :: Applicative f => NodeInfo (f a) -> f (NodeInfo a) # mapM :: Monad m => (a -> m b) -> NodeInfo a -> m (NodeInfo b) # sequence :: Monad m => NodeInfo (m a) -> m (NodeInfo a) #
Binary (NodeInfo TypeIndex) Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods put_ :: BinHandle -> NodeInfo TypeIndex -> IO () # put :: BinHandle -> NodeInfo TypeIndex -> IO (Bin (NodeInfo TypeIndex)) # get :: BinHandle -> IO (NodeInfo TypeIndex) #

type Identifier = Either ModuleName Name Source #

type NodeIdentifiers a = Map Identifier (IdentifierDetails a) Source #

data IdentifierDetails a Source #

Information associated with every identifier

We need to include types with identifiers because sometimes multiple identifiers occur in the same span(Overloaded Record Fields and so on)

Constructors

IdentifierDetails
Fields identType :: Maybe a identInfo :: Set ContextInfo

Instances

Functor IdentifierDetails Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods fmap :: (a -> b) -> IdentifierDetails a -> IdentifierDetails b # (<$) :: a -> IdentifierDetails b -> IdentifierDetails a #
Foldable IdentifierDetails Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods fold :: Monoid m => IdentifierDetails m -> m # foldMap :: Monoid m => (a -> m) -> IdentifierDetails a -> m # foldr :: (a -> b -> b) -> b -> IdentifierDetails a -> b # foldr' :: (a -> b -> b) -> b -> IdentifierDetails a -> b # foldl :: (b -> a -> b) -> b -> IdentifierDetails a -> b # foldl' :: (b -> a -> b) -> b -> IdentifierDetails a -> b # foldr1 :: (a -> a -> a) -> IdentifierDetails a -> a # foldl1 :: (a -> a -> a) -> IdentifierDetails a -> a # toList :: IdentifierDetails a -> [a] # null :: IdentifierDetails a -> Bool # length :: IdentifierDetails a -> Int # elem :: Eq a => a -> IdentifierDetails a -> Bool # maximum :: Ord a => IdentifierDetails a -> a # minimum :: Ord a => IdentifierDetails a -> a # sum :: Num a => IdentifierDetails a -> a # product :: Num a => IdentifierDetails a -> a #
Traversable IdentifierDetails Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods traverse :: Applicative f => (a -> f b) -> IdentifierDetails a -> f (IdentifierDetails b) # sequenceA :: Applicative f => IdentifierDetails (f a) -> f (IdentifierDetails a) # mapM :: Monad m => (a -> m b) -> IdentifierDetails a -> m (IdentifierDetails b) # sequence :: Monad m => IdentifierDetails (m a) -> m (IdentifierDetails a) #
Eq a => Eq (IdentifierDetails a) Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods (==) :: IdentifierDetails a -> IdentifierDetails a -> Bool # (/=) :: IdentifierDetails a -> IdentifierDetails a -> Bool #
Semigroup (IdentifierDetails a) Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods (<>) :: IdentifierDetails a -> IdentifierDetails a -> IdentifierDetails a # sconcat :: NonEmpty (IdentifierDetails a) -> IdentifierDetails a # stimes :: Integral b => b -> IdentifierDetails a -> IdentifierDetails a #
Monoid (IdentifierDetails a) Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods mempty :: IdentifierDetails a # mappend :: IdentifierDetails a -> IdentifierDetails a -> IdentifierDetails a # mconcat :: [IdentifierDetails a] -> IdentifierDetails a #
Binary (IdentifierDetails TypeIndex) Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods put_ :: BinHandle -> IdentifierDetails TypeIndex -> IO () # put :: BinHandle -> IdentifierDetails TypeIndex -> IO (Bin (IdentifierDetails TypeIndex)) # get :: BinHandle -> IO (IdentifierDetails TypeIndex) #
Outputable a => Outputable (IdentifierDetails a) Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods ppr :: IdentifierDetails a -> SDoc # pprPrec :: Rational -> IdentifierDetails a -> SDoc #

data ContextInfo Source #

Different contexts under which identifiers exist

Constructors

Use	regular variable
MatchBind
IEThing IEType	import/export
TyDecl
ValBind	Value binding
Fields BindType whether or not the binding is in an instance Scope scope over which the value is bound (Maybe Span) span of entire binding
PatternBind	Pattern binding This case is tricky because the bound identifier can be used in two distinct scopes. Consider the following example (with `-XViewPatterns`) do (b, a, (a -> True)) <- bar foo a The identifier `a` has two scopes: in the view pattern `(a -> True)` and in the rest of the `do`-block in `foo a`.
Fields Scope scope in the pattern (the variable bound can be used further in the pattern) Scope rest of the scope outside the pattern (Maybe Span) span of entire binding
ClassTyDecl (Maybe Span)
Decl	Declaration
Fields DeclType type of declaration (Maybe Span) span of entire binding
TyVarBind Scope TyVarScope	Type variable
RecField RecFieldContext (Maybe Span)	Record field

Instances

Eq ContextInfo Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods (==) :: ContextInfo -> ContextInfo -> Bool # (/=) :: ContextInfo -> ContextInfo -> Bool #
Ord ContextInfo Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods compare :: ContextInfo -> ContextInfo -> Ordering # (<) :: ContextInfo -> ContextInfo -> Bool # (<=) :: ContextInfo -> ContextInfo -> Bool # (>) :: ContextInfo -> ContextInfo -> Bool # (>=) :: ContextInfo -> ContextInfo -> Bool # max :: ContextInfo -> ContextInfo -> ContextInfo # min :: ContextInfo -> ContextInfo -> ContextInfo #
Show ContextInfo Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods showsPrec :: Int -> ContextInfo -> ShowS # show :: ContextInfo -> String # showList :: [ContextInfo] -> ShowS #
Binary ContextInfo Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods put_ :: BinHandle -> ContextInfo -> IO () # put :: BinHandle -> ContextInfo -> IO (Bin ContextInfo) # get :: BinHandle -> IO ContextInfo #
Outputable ContextInfo Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods ppr :: ContextInfo -> SDoc # pprPrec :: Rational -> ContextInfo -> SDoc #

data IEType Source #

Types of imports and exports

Constructors

Import
ImportAs
ImportHiding
Export

Instances

Enum IEType Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods succ :: IEType -> IEType # pred :: IEType -> IEType # toEnum :: Int -> IEType # fromEnum :: IEType -> Int # enumFrom :: IEType -> [IEType] # enumFromThen :: IEType -> IEType -> [IEType] # enumFromTo :: IEType -> IEType -> [IEType] # enumFromThenTo :: IEType -> IEType -> IEType -> [IEType] #
Eq IEType Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods (==) :: IEType -> IEType -> Bool # (/=) :: IEType -> IEType -> Bool #
Ord IEType Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods compare :: IEType -> IEType -> Ordering # (<) :: IEType -> IEType -> Bool # (<=) :: IEType -> IEType -> Bool # (>) :: IEType -> IEType -> Bool # (>=) :: IEType -> IEType -> Bool # max :: IEType -> IEType -> IEType # min :: IEType -> IEType -> IEType #
Show IEType Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods showsPrec :: Int -> IEType -> ShowS # show :: IEType -> String # showList :: [IEType] -> ShowS #
Binary IEType Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods put_ :: BinHandle -> IEType -> IO () # put :: BinHandle -> IEType -> IO (Bin IEType) # get :: BinHandle -> IO IEType #

data RecFieldContext Source #

Constructors

RecFieldDecl
RecFieldAssign
RecFieldMatch
RecFieldOcc

Instances

Enum RecFieldContext Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods succ :: RecFieldContext -> RecFieldContext # pred :: RecFieldContext -> RecFieldContext # toEnum :: Int -> RecFieldContext # fromEnum :: RecFieldContext -> Int # enumFrom :: RecFieldContext -> [RecFieldContext] # enumFromThen :: RecFieldContext -> RecFieldContext -> [RecFieldContext] # enumFromTo :: RecFieldContext -> RecFieldContext -> [RecFieldContext] # enumFromThenTo :: RecFieldContext -> RecFieldContext -> RecFieldContext -> [RecFieldContext] #
Eq RecFieldContext Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods (==) :: RecFieldContext -> RecFieldContext -> Bool # (/=) :: RecFieldContext -> RecFieldContext -> Bool #
Ord RecFieldContext Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods compare :: RecFieldContext -> RecFieldContext -> Ordering # (<) :: RecFieldContext -> RecFieldContext -> Bool # (<=) :: RecFieldContext -> RecFieldContext -> Bool # (>) :: RecFieldContext -> RecFieldContext -> Bool # (>=) :: RecFieldContext -> RecFieldContext -> Bool # max :: RecFieldContext -> RecFieldContext -> RecFieldContext # min :: RecFieldContext -> RecFieldContext -> RecFieldContext #
Show RecFieldContext Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods showsPrec :: Int -> RecFieldContext -> ShowS # show :: RecFieldContext -> String # showList :: [RecFieldContext] -> ShowS #
Binary RecFieldContext Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods put_ :: BinHandle -> RecFieldContext -> IO () # put :: BinHandle -> RecFieldContext -> IO (Bin RecFieldContext) # get :: BinHandle -> IO RecFieldContext #

data BindType Source #

Constructors

RegularBind
InstanceBind

Instances

Enum BindType Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods succ :: BindType -> BindType # pred :: BindType -> BindType # toEnum :: Int -> BindType # fromEnum :: BindType -> Int # enumFrom :: BindType -> [BindType] # enumFromThen :: BindType -> BindType -> [BindType] # enumFromTo :: BindType -> BindType -> [BindType] # enumFromThenTo :: BindType -> BindType -> BindType -> [BindType] #
Eq BindType Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods (==) :: BindType -> BindType -> Bool # (/=) :: BindType -> BindType -> Bool #
Ord BindType Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods compare :: BindType -> BindType -> Ordering # (<) :: BindType -> BindType -> Bool # (<=) :: BindType -> BindType -> Bool # (>) :: BindType -> BindType -> Bool # (>=) :: BindType -> BindType -> Bool # max :: BindType -> BindType -> BindType # min :: BindType -> BindType -> BindType #
Show BindType Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods showsPrec :: Int -> BindType -> ShowS # show :: BindType -> String # showList :: [BindType] -> ShowS #
Binary BindType Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods put_ :: BinHandle -> BindType -> IO () # put :: BinHandle -> BindType -> IO (Bin BindType) # get :: BinHandle -> IO BindType #

data DeclType Source #

Constructors

FamDec	type or data family
SynDec	type synonym
DataDec	data declaration
ConDec	constructor declaration
PatSynDec	pattern synonym
ClassDec	class declaration
InstDec	instance declaration

Instances

Enum DeclType Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods succ :: DeclType -> DeclType # pred :: DeclType -> DeclType # toEnum :: Int -> DeclType # fromEnum :: DeclType -> Int # enumFrom :: DeclType -> [DeclType] # enumFromThen :: DeclType -> DeclType -> [DeclType] # enumFromTo :: DeclType -> DeclType -> [DeclType] # enumFromThenTo :: DeclType -> DeclType -> DeclType -> [DeclType] #
Eq DeclType Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods (==) :: DeclType -> DeclType -> Bool # (/=) :: DeclType -> DeclType -> Bool #
Ord DeclType Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods compare :: DeclType -> DeclType -> Ordering # (<) :: DeclType -> DeclType -> Bool # (<=) :: DeclType -> DeclType -> Bool # (>) :: DeclType -> DeclType -> Bool # (>=) :: DeclType -> DeclType -> Bool # max :: DeclType -> DeclType -> DeclType # min :: DeclType -> DeclType -> DeclType #
Show DeclType Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods showsPrec :: Int -> DeclType -> ShowS # show :: DeclType -> String # showList :: [DeclType] -> ShowS #
Binary DeclType Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods put_ :: BinHandle -> DeclType -> IO () # put :: BinHandle -> DeclType -> IO (Bin DeclType) # get :: BinHandle -> IO DeclType #

data Scope Source #

Constructors

NoScope
LocalScope Span
ModuleScope

Instances

Eq Scope Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods (==) :: Scope -> Scope -> Bool # (/=) :: Scope -> Scope -> Bool #
Data Scope Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Scope -> c Scope # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Scope # toConstr :: Scope -> Constr # dataTypeOf :: Scope -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Scope) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Scope) # gmapT :: (forall b. Data b => b -> b) -> Scope -> Scope # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Scope -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Scope -> r # gmapQ :: (forall d. Data d => d -> u) -> Scope -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Scope -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Scope -> m Scope # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Scope -> m Scope # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Scope -> m Scope #
Ord Scope Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods compare :: Scope -> Scope -> Ordering # (<) :: Scope -> Scope -> Bool # (<=) :: Scope -> Scope -> Bool # (>) :: Scope -> Scope -> Bool # (>=) :: Scope -> Scope -> Bool # max :: Scope -> Scope -> Scope # min :: Scope -> Scope -> Scope #
Show Scope Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods showsPrec :: Int -> Scope -> ShowS # show :: Scope -> String # showList :: [Scope] -> ShowS #
Binary Scope Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods put_ :: BinHandle -> Scope -> IO () # put :: BinHandle -> Scope -> IO (Bin Scope) # get :: BinHandle -> IO Scope #
Outputable Scope Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods ppr :: Scope -> SDoc # pprPrec :: Rational -> Scope -> SDoc #

data TyVarScope Source #

Scope of a type variable.

This warrants a data type apart from Scope because of complexities introduced by features like -XScopedTypeVariables and -XInstanceSigs. For example, consider:

foo, bar, baz :: forall a. a -> a

Here a is in scope in all the definitions of foo, bar, and baz, so we need a list of scopes to keep track of this. Furthermore, this list cannot be computed until we resolve the binding sites of foo, bar, and baz.

Consequently, a starts with an UnresolvedScope [foo, bar, baz] Nothing which later gets resolved into a ResolvedScopes.

Constructors

ResolvedScopes [Scope]
UnresolvedScope	Unresolved scopes should never show up in the final `.hie` file
Fields [Name] names of the definitions over which the scope spans (Maybe Span) the location of the instance/class declaration for the case where the type variable is declared in a method type signature

Instances

Eq TyVarScope Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods (==) :: TyVarScope -> TyVarScope -> Bool # (/=) :: TyVarScope -> TyVarScope -> Bool #
Ord TyVarScope Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods compare :: TyVarScope -> TyVarScope -> Ordering # (<) :: TyVarScope -> TyVarScope -> Bool # (<=) :: TyVarScope -> TyVarScope -> Bool # (>) :: TyVarScope -> TyVarScope -> Bool # (>=) :: TyVarScope -> TyVarScope -> Bool # max :: TyVarScope -> TyVarScope -> TyVarScope # min :: TyVarScope -> TyVarScope -> TyVarScope #
Show TyVarScope Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods showsPrec :: Int -> TyVarScope -> ShowS # show :: TyVarScope -> String # showList :: [TyVarScope] -> ShowS #
Binary TyVarScope Source #
Instance details Defined in Development.IDE.GHC.HieTypes Methods put_ :: BinHandle -> TyVarScope -> IO () # put :: BinHandle -> TyVarScope -> IO (Bin TyVarScope) # get :: BinHandle -> IO TyVarScope #

generateReferencesMap :: Foldable f => f (HieAST a) -> Map Identifier [(Span, IdentifierDetails a)] Source #

renderHieType :: DynFlags -> HieTypeFix -> String Source #

resolveVisibility :: Type -> [Type] -> [(Bool, Type)] Source #

foldType :: (HieType a -> a) -> HieTypeFix -> a Source #

hieTypeToIface :: HieTypeFix -> IfaceType Source #

data HieTypeState Source #

Constructors

HTS
Fields tyMap :: !(TypeMap TypeIndex) htyTable :: !(IntMap HieTypeFlat) freshIndex :: !TypeIndex

initialHTS :: HieTypeState Source #

freshTypeIndex :: State HieTypeState TypeIndex Source #

compressTypes :: HieASTs Type -> (HieASTs TypeIndex, Array TypeIndex HieTypeFlat) Source #

recoverFullType :: TypeIndex -> Array TypeIndex HieTypeFlat -> HieTypeFix Source #

getTypeIndex :: Type -> State HieTypeState TypeIndex Source #

resolveTyVarScopes :: Map FastString (HieAST a) -> Map FastString (HieAST a) Source #

resolveTyVarScopeLocal :: HieAST a -> Map FastString (HieAST a) -> HieAST a Source #

getNameBinding :: Name -> Map FastString (HieAST a) -> Maybe Span Source #

getNameScope :: Name -> Map FastString (HieAST a) -> Maybe [Scope] Source #

getNameBindingInClass :: Name -> Span -> Map FastString (HieAST a) -> Maybe Span Source #

getNameScopeAndBinding :: Name -> Map FastString (HieAST a) -> Maybe ([Scope], Maybe Span) Source #

getScopeFromContext :: ContextInfo -> Maybe [Scope] Source #

getBindSiteFromContext :: ContextInfo -> Maybe Span Source #

flattenAst :: HieAST a -> [HieAST a] Source #

smallestContainingSatisfying :: Span -> (HieAST a -> Bool) -> HieAST a -> Maybe (HieAST a) Source #

selectLargestContainedBy :: Span -> HieAST a -> Maybe (HieAST a) Source #

selectSmallestContaining :: Span -> HieAST a -> Maybe (HieAST a) Source #

definedInAsts :: Map FastString (HieAST a) -> Name -> Bool Source #

isOccurrence :: ContextInfo -> Bool Source #

scopeContainsSpan :: Scope -> Span -> Bool Source #

combineAst :: HieAST Type -> HieAST Type -> HieAST Type Source #

One must contain the other. Leaf nodes cannot contain anything

insertAst :: HieAST Type -> [HieAST Type] -> [HieAST Type] Source #

Insert an AST in a sorted list of disjoint Asts

combineNodeInfo :: NodeInfo Type -> NodeInfo Type -> NodeInfo Type Source #

Merge two nodes together.

Precondition and postcondition: elements in nodeType are ordered.

mergeAsts :: [HieAST Type] -> [HieAST Type] -> [HieAST Type] Source #

Merge two sorted, disjoint lists of ASTs, combining when necessary.

In the absence of position-altering pragmas (ex: # line "file.hs" 3), different nodes in an AST tree should either have disjoint spans (in which case you can say for sure which one comes first) or one span should be completely contained in the other (in which case the contained span corresponds to some child node).

However, since Haskell does have position-altering pragmas it is possible for spans to be overlapping. Here is an example of a source file in which foozball and quuuuuux have overlapping spans:

module Baz where

# line 3 "Baz.hs"
foozball :: Int
foozball = 0

# line 3 "Baz.hs"
bar, quuuuuux :: Int
bar = 1
quuuuuux = 2

In these cases, we just do our best to produce sensible HieAST's. The blame should be laid at the feet of whoever wrote the line pragmas in the first place (usually the C preprocessor...).

rightOf :: Span -> Span -> Bool Source #

leftOf :: Span -> Span -> Bool Source #

startsRightOf :: Span -> Span -> Bool Source #

mergeSortAsts :: [HieAST Type] -> [HieAST Type] Source #

combines and sorts ASTs using a merge sort

simpleNodeInfo :: FastString -> FastString -> NodeInfo a Source #

locOnly :: SrcSpan -> [HieAST a] Source #

mkScope :: SrcSpan -> Scope Source #

mkLScope :: Located a -> Scope Source #

combineScopes :: Scope -> Scope -> Scope Source #

makeNode Source #

Arguments

:: (Applicative m, Data a)
=> a	helps fill in `nodeAnnotations` (with `Data`)
-> SrcSpan	return an empty list if this is unhelpful
-> m [HieAST b]

makeTypeNode Source #

Arguments

:: (Applicative m, Data a)
=> a	helps fill in `nodeAnnotations` (with `Data`)
-> SrcSpan	return an empty list if this is unhelpful
-> Type	type to associate with the node
-> m [HieAST Type]