Safe Haskell | None |
---|---|
Language | Haskell2010 |
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 {}
- data HieFile = HieFile {}
- 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 {}
- data TypecheckedModule = TypecheckedModule {}
- data DesugaredModule = DesugaredModule {}
- 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
- 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
- runTcInteractive :: HscEnv -> TcRn a -> IO (Messages, Maybe a)
- data TcRnExprMode
- 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 {}
- data TargetId
- 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
- 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
- data RecordConTc = RecordConTc {}
- 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
- type LHsCmd id = Located (HsCmd id)
- data HsArrAppType
- type LHsCmdTop p = Located (HsCmdTop p)
- data HsCmdTop 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
- 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 { }
- | 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
- 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
- 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
- data PendingTcSplice = PendingTcSplice SplicePointName (LHsExpr GhcTc)
- data HsBracket p
- data ArithSeqInfo id
- data HsMatchContext id
- = FunRhs { }
- | 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)
- = HsGroup {
- 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 { }
- | 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)
- = FamDecl {
- 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)
- = TyClGroup {
- 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)
- = FamilyDecl {
- 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)
- = HsDataDefn {
- 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)
- = HsDerivingClause {
- data NewOrData
- 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)
- = ConDeclGADT {
- 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)
- = FamEqn {
- 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)
- = ClsInstDecl {
- 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)
- = ClsInstD {
- 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)
- = DerivDecl {
- type LDerivStrategy pass = Located (DerivStrategy pass)
- data DerivStrategy 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)
- = ForeignImport {
- data ForeignImport = CImport (Located CCallConv) (Located Safety) (Maybe Header) CImportSpec (Located SourceText)
- data CImportSpec
- 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)
- = HsRules {
- 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
- type LWarnDecls pass = Located (WarnDecls pass)
- data WarnDecls pass
- = Warnings {
- wd_ext :: XWarnings pass
- wd_src :: SourceText
- wd_warnings :: [LWarnDecl pass]
- | XWarnDecls (XXWarnDecls pass)
- = Warnings {
- 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 { }
- | PatBind { }
- | VarBind { }
- | 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
- 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
- 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
- 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
- pprInstanceHdr :: ClsInst -> SDoc
- pprInstance :: ClsInst -> SDoc
- instanceDFunId :: ClsInst -> DFunId
- data ClsInst
- data FamInst
- type BreakIndex = Int
- data ModBreaks = ModBreaks {}
- 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)
- = HsQTvs {
- data HsQTvsRn = HsQTvsRn {
- hsq_implicit :: [Name]
- hsq_dependent :: NameSet
- data HsImplicitBndrs pass thing
- = HsIB { }
- | XHsImplicitBndrs (XXHsImplicitBndrs pass thing)
- data HsIBRn = HsIBRn {
- hsib_vars :: [Name]
- hsib_closed :: Bool
- data HsWildCardBndrs pass thing
- = HsWC { }
- | 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 { }
- | 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)
- = HsForAllTy {
- data NewHsTypeX = NHsCoreTy Type
- data HsTyLit
- newtype HsWildCardInfo = AnonWildCard (Located Name)
- data HsTupleSort
- data Promoted
- 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)
- = ConDeclField {
- data HsConDetails arg rec
- type LFieldOcc pass = Located (FieldOcc pass)
- data FieldOcc pass
- = FieldOcc {
- extFieldOcc :: XCFieldOcc pass
- rdrNameFieldOcc :: Located RdrName
- | XFieldOcc (XXFieldOcc pass)
- = FieldOcc {
- data AmbiguousFieldOcc pass
- = Unambiguous (XUnambiguous pass) (Located RdrName)
- | Ambiguous (XAmbiguous pass) (Located RdrName)
- | XAmbiguousFieldOcc (XXAmbiguousFieldOcc pass)
- data ExecOptions = ExecOptions {}
- data SingleStep
- data ExecResult
- = ExecComplete { }
- | 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
- data SrcStrictness
- data SrcUnpackedness
- data StrictnessMark
- 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)
- = OverLit {
- data OverLitTc = OverLitTc {
- ol_rebindable :: Bool
- ol_type :: Type
- data OverLitVal
- 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 { }
- | XMatchGroup (XXMatchGroup p body)
- data GRHSs p body
- = GRHSs {
- grhssExt :: XCGRHSs p body
- grhssGRHSs :: [LGRHS p body]
- grhssLocalBinds :: LHsLocalBinds p
- | XGRHSs (XXGRHSs p body)
- = GRHSs {
- 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)
- = ImportDecl {
- data IEWrappedName 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
- 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 { }
- | 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
- data RdrName
- 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
- data HscTarget
- data GhcMode
- data GhcLink
- 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
- data LexicalFixity
- data SuccessFlag
- data SpliceExplicitFlag
- data Severity
- 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
- data RealSrcSpan
- data SrcSpan
- data GenLocated l e = L l e
- type Located = GenLocated SrcSpan
- data Type
- data TyThing
- 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
- 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 {}
- 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 {}
- 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
- data IEType
- = Import
- | ImportAs
- | ImportHiding
- | Export
- data RecFieldContext
- data BindType
- data DeclType
- data Scope
- 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 #
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.
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.
NCU | |
|
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 Name
s and FastString
s
readHieFile :: NameCacheUpdater -> FilePath -> IO HieFileResult Source #
dontWriteHieFiles :: DynFlags -> DynFlags Source #
ml_hie_file :: ModLocation -> FilePath Source #
hPutStringBuffer :: Handle -> StringBuffer -> IO () Source #
includePathsGlobal :: IncludeSpecs -> [String] #
includePathsQuote :: IncludeSpecs -> [String] #
getModuleHash :: ModIface -> Fingerprint Source #
getPackageName :: DynFlags -> InstalledUnitId -> Maybe PackageName Source #
pattern ForD :: ForeignDecl p -> HsDecl 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 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 | |
Defined in Module showsPrec :: Int -> ModLocation -> ShowS # show :: ModLocation -> String # showList :: [ModLocation] -> ShowS # | |
Outputable ModLocation | |
Defined in Module 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 #
Instances
HasSrcSpan Name Source # | |
HasSrcSpan (GenLocated SrcSpan a) Source # | |
Defined in Development.IDE.GHC.Compat |
getLoc :: HasSrcSpan a => a -> SrcSpan Source #
:: 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.
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 #
:: 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
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.
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
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] #
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 #
:: ExceptionMonad m | |
=> Maybe FilePath | See argument to |
-> 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.
:: Maybe FilePath | See argument to |
-> 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.
modSummary, parsedSource
parsedSource :: m -> ParsedSource #
Instances
ParsedMod ParsedModule | |
Defined in GHC | |
ParsedMod TypecheckedModule | |
Defined in GHC | |
ParsedMod DesugaredModule | |
Defined in GHC |
class ParsedMod m => TypecheckedMod m where #
renamedSource, typecheckedSource, moduleInfo, tm_internals
renamedSource :: m -> Maybe RenamedSource #
typecheckedSource :: m -> TypecheckedSource #
moduleInfo :: m -> ModuleInfo #
Instances
TypecheckedMod TypecheckedModule | |
Defined in GHC | |
TypecheckedMod DesugaredModule | |
Defined in GHC |
data ParsedModule #
The result of successful parsing.
Instances
Show ParsedModule Source # | |
Defined in Development.IDE.GHC.Orphans showsPrec :: Int -> ParsedModule -> ShowS # show :: ParsedModule -> String # showList :: [ParsedModule] -> ShowS # | |
NFData ParsedModule Source # | |
Defined in Development.IDE.GHC.Orphans rnf :: ParsedModule -> () # | |
ParsedMod ParsedModule | |
Defined in GHC |
data TypecheckedModule #
The result of successful typechecking. It also contains the parser result.
Instances
ParsedMod TypecheckedModule | |
Defined in GHC | |
TypecheckedMod TypecheckedModule | |
Defined in GHC |
data DesugaredModule #
The result of successful desugaring (i.e., translation to core). Also contains all the information of a typechecked module.
Instances
ParsedMod DesugaredModule | |
Defined in GHC | |
TypecheckedMod DesugaredModule | |
Defined in GHC | |
DesugaredMod DesugaredModule | |
Defined in GHC 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.
CoreModule | |
|
Instances
Show CoreModule Source # | |
Defined in Development.IDE.GHC.Orphans showsPrec :: Int -> CoreModule -> ShowS # show :: CoreModule -> String # showList :: [CoreModule] -> ShowS # | |
NFData CoreModule Source # | |
Defined in Development.IDE.GHC.Orphans rnf :: CoreModule -> () # | |
Outputable CoreModule | |
Defined in GHC ppr :: CoreModule -> SDoc # pprPrec :: Rational -> CoreModule -> SDoc # |
data ModuleInfo #
Container for information about a Module
.
cyclicModuleErr :: [ModSummary] -> SDoc #
:: Bool | Drop hi-boot nodes? (see below) |
-> ModuleGraph | |
-> Maybe ModuleName | Root module name. If |
-> [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 acyclicTrue
: 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
.
:: 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.
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. |
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.
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.
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.
parseName :: GhcMonad m => String -> m [Name] #
Parses a string as an identifier, and returns the list of Name
s that
the identifier can refer to in the current interactive context.
getRdrNamesInScope :: GhcMonad m => m [RdrName] #
Returns all RdrName
s 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 #
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.
:: GhcMonad m | |
=> String | a statement (bind or expression) |
-> ExecOptions | |
-> m ExecResult |
Run a statement in the current interactive context.
default ExecOptions
getHistoryModule :: History -> Module #
getResumeContext :: GhcMonad m => m [Resume] #
data GetDocsFailure #
Failure modes for getDocs
.
NameHasNoModule Name |
|
NoDocsInIface Module Bool |
|
InteractiveName | The |
Instances
Outputable GetDocsFailure | |
Defined in InteractiveEval ppr :: GetDocsFailure -> SDoc # pprPrec :: Rational -> GetDocsFailure -> SDoc # |
data TcRnExprMode #
How should we infer a type? See Note [TcRnExprMode]
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.
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.
getSession :: m HscEnv #
setSession :: HscEnv -> m () #
Instances
GhcMonad Ghc | |
Defined in GhcMonad getSession :: Ghc HscEnv # setSession :: HscEnv -> Ghc () # | |
ExceptionMonad m => GhcMonad (GhcT m) | |
Defined in GhcMonad getSession :: GhcT m HscEnv # setSession :: HscEnv -> GhcT m () # |
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 | |
Functor Ghc | |
MonadFix Ghc | |
Applicative Ghc | |
MonadIO Ghc | |
GhcMonad Ghc | |
Defined in GhcMonad getSession :: Ghc HscEnv # setSession :: HscEnv -> Ghc () # | |
HasDynFlags Ghc | |
Defined in GhcMonad getDynFlags :: Ghc DynFlags # | |
ExceptionMonad Ghc | |
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) | |
Functor m => Functor (GhcT m) | |
Applicative m => Applicative (GhcT m) | |
MonadIO m => MonadIO (GhcT m) | |
ExceptionMonad m => GhcMonad (GhcT m) | |
Defined in GhcMonad getSession :: GhcT m HscEnv # setSession :: HscEnv -> GhcT m () # | |
MonadIO m => HasDynFlags (GhcT m) | |
Defined in GhcMonad getDynFlags :: GhcT m DynFlags # | |
ExceptionMonad m => ExceptionMonad (GhcT m) | |
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.
:: 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.
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.
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).
Target | |
|
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. |
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
.
ModIface | |
|
data InteractiveImport #
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 | |
Defined in HscTypes 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
ModSummary | |
|
Instances
Show ModSummary Source # | |
Defined in Development.IDE.GHC.Orphans showsPrec :: Int -> ModSummary -> ShowS # show :: ModSummary -> String # showList :: [ModSummary] -> ShowS # | |
NFData ModSummary Source # | |
Defined in Development.IDE.GHC.Orphans rnf :: ModSummary -> () # | |
Outputable ModSummary | |
Defined in HscTypes ppr :: ModSummary -> SDoc # pprPrec :: Rational -> ModSummary -> SDoc # |
Haskell Module
All we actually declare here is the top-level structure for a module.
HsModule | |
|
Instances
Data (HsModule GhcPs) | |
Defined in HsSyn 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) | |
Defined in HsSyn 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) | |
Defined in HsSyn 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) | |
lPatImplicits :: LPat GhcRn -> NameSet #
hsValBindsImplicits :: HsValBindsLR GhcRn (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] #
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
isInfixFunBind :: HsBindLR id1 id2 -> Bool #
mkPatSynBind :: Located RdrName -> HsPatSynDetails (Located RdrName) -> LPat GhcPs -> HsPatSynDir GhcPs -> HsBind GhcPs #
mkHsWrapPatCo :: TcCoercionN -> Pat (GhcPass id) -> Type -> Pat (GhcPass id) #
mkLHsWrapCo :: TcCoercionN -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #
mkHsWrapCoR :: TcCoercionR -> HsExpr (GhcPass id) -> HsExpr (GhcPass id) #
mkHsWrapCo :: TcCoercionN -> HsExpr (GhcPass id) -> HsExpr (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.
mkLHsSigWcType :: LHsType GhcPs -> LHsSigWcType GhcPs #
mkLHsSigType :: LHsType GhcPs -> LHsSigType GhcPs #
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
:: ([a] -> a) | "Small" constructor function, of maximum input arity |
-> [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
nlHsIf :: LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #
nlWildPatName :: LPat GhcRn #
nlWildConPat :: DataCon -> LPat GhcPs #
nlNullaryConPat :: IdP id -> LPat id #
nlHsSyntaxApps :: SyntaxExpr (GhcPass id) -> [LHsExpr (GhcPass id)] -> LHsExpr (GhcPass id) #
nlHsIntLit :: Integer -> LHsExpr (GhcPass p) #
nlHsDataCon :: DataCon -> LHsExpr GhcTc #
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) #
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 #
emptyRecStmtId :: StmtLR GhcTc GhcTc bodyR #
emptyRecStmtName :: StmtLR GhcRn GhcRn bodyR #
emptyRecStmt :: StmtLR (GhcPass idL) GhcPs bodyR #
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))) #
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) #
mkTransformByStmt :: [ExprLStmt GhcPs] -> LHsExpr GhcPs -> LHsExpr GhcPs -> StmtLR GhcPs GhcPs (LHsExpr GhcPs) #
mkHsIsString :: SourceText -> FastString -> HsOverLit GhcPs #
mkHsIntegral :: IntegralLit -> HsOverLit GhcPs #
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
mkHsAppType :: XAppTypeE (GhcPass id) ~ LHsWcType GhcRn => LHsExpr (GhcPass id) -> LHsWcType GhcRn -> 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)))] #
mkSimpleMatch :: HsMatchContext (NameOrRdrName (IdP (GhcPass p))) -> [LPat (GhcPass p)] -> Located (body (GhcPass p)) -> LMatch (GhcPass p) (Located (body (GhcPass p))) #
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 #
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 #
isQuietHsCmd :: HsCmd id -> Bool #
isAtomicHsExpr :: HsExpr id -> Bool #
parenthesizeHsExpr :: PprPrec -> LHsExpr (GhcPass p) -> LHsExpr (GhcPass p) #
checks if parenthesizeHsExpr
p e
is true,
and if so, surrounds hsExprNeedsParens
p ee
with an HsPar
. Otherwise, it simply returns e
.
hsExprNeedsParens :: PprPrec -> HsExpr p -> Bool #
returns hsExprNeedsParens
p eTrue
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 #
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
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 | |
Defined in HsExpr 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 | |
Defined in HsExpr ppr :: UnboundVar -> SDoc # pprPrec :: Rational -> UnboundVar -> SDoc # |
data RecordConTc #
Extra data fields for a RecordCon
, added by the type checker
data RecordUpdTc #
Extra data fields for a RecordUpd
, added by the type checker
RecordUpdTc | |
|
Instances
Data RecordUpdTc | |
Defined in HsExpr 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))
Haskell Tuple Argument
data HsArrAppType #
Haskell Array Application Type
Instances
Data HsArrAppType | |
Defined in HsExpr 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
Haskell Top-level Command
type HsRecordBinds p = HsRecFields p (LHsExpr p) #
Haskell Record Bindings
data MatchGroupTc #
MatchGroupTc | |
|
Instances
Data MatchGroupTc | |
Defined in HsExpr 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
Match | |
| |
XMatch (XXMatch p body) |
Instances
(idR ~ GhcPass pr, OutputableBndrId idR, Outputable body) => Outputable (Match idR body) | |
Guarded Right Hand Side.
GRHS (XCGRHS p body) [GuardLStmt p] body | |
XGRHS (XXGRHS p body) |
type LStmtLR idL idR body = Located (StmtLR idL idR body) #
Located Statement with separate Left and Right id's
type GuardLStmt id = LStmt id (LHsExpr id) #
Guard Located Statement
API Annotations when in qualifier lists or guards
- AnnKeywordId
: AnnVbar
,
AnnComma
,AnnThen
,
AnnBy
,AnnBy
,
AnnGroup
,AnnUsing
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)) |
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) |
|
ParStmt (XParStmt idL idR body) [ParStmtBlock idL idR] (HsExpr idR) (SyntaxExpr idR) | |
TransStmt | |
RecStmt | |
| |
XStmtLR (XXStmtLR idL idR body) |
Instances
(idL ~ GhcPass pl, idR ~ GhcPass pr, OutputableBndrId idL, OutputableBndrId idR, Outputable body) => Outputable (StmtLR idL idR body) | |
RecStmtTc | |
|
Instances
Data TransForm | |
Defined in HsExpr 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
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) | |
Defined in HsExpr ppr :: ParStmtBlock idL idR -> SDoc # pprPrec :: Rational -> ParStmtBlock idL idR -> SDoc # |
data ApplicativeArg idL #
Applicative Argument
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.
Instances
newtype ThModFinalizers #
Finalizers produced by a splice with
addModFinalizer
See Note [Delaying modFinalizers in untyped splices] in RnSplice. For how this is used.
ThModFinalizers [ForeignRef (Q ())] |
Instances
Data ThModFinalizers | |
Defined in HsExpr 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.
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) | |
Defined in HsExpr ppr :: HsSplicedThing p -> SDoc # pprPrec :: Rational -> HsSplicedThing p -> SDoc # |
type SplicePointName = Name #
data PendingRnSplice #
Pending Renamer Splice
Instances
Outputable PendingRnSplice | |
Defined in HsExpr ppr :: PendingRnSplice -> SDoc # pprPrec :: Rational -> PendingRnSplice -> SDoc # |
data UntypedSpliceFlavour #
Instances
Data UntypedSpliceFlavour | |
Defined in HsExpr 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
Instances
Outputable PendingTcSplice | |
Defined in HsExpr ppr :: PendingTcSplice -> SDoc # pprPrec :: Rational -> PendingTcSplice -> SDoc # |
Haskell Bracket
data ArithSeqInfo id #
Arithmetic Sequence Information
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) | |
Defined in HsExpr 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].
FunRhs | A pattern matching on an argument of a function binding |
| |
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 | |
Defined in HsExpr fmap :: (a -> b) -> HsMatchContext a -> HsMatchContext b # (<$) :: a -> HsMatchContext b -> HsMatchContext a # | |
Data id => Data (HsMatchContext id) | |
Defined in HsExpr 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) | |
Defined in HsExpr 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
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 | |
Defined in HsExpr fmap :: (a -> b) -> HsStmtContext a -> HsStmtContext b # (<$) :: a -> HsStmtContext b -> HsStmtContext a # | |
Data id => Data (HsStmtContext id) | |
Defined in HsExpr 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) | |
Defined in HsExpr 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
:: 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?
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]
tyClDeclTyVars :: TyClDecl pass -> LHsQTyVars 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
isDataDecl :: TyClDecl pass -> Bool #
True
= argument is a data
/newtype
declaration.
hsGroupInstDecls :: HsGroup id -> [LInstDecl id] #
emptyRnGroup :: HsGroup (GhcPass p) #
emptyRdrGroup :: HsGroup (GhcPass p) #
A Haskell Declaration
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) |
HsGroup | |
| |
XHsGroup (XXHsGroup p) |
type LSpliceDecl pass = Located (SpliceDecl pass) #
Located Splice Declaration
data SpliceDecl p #
Splice Declaration
SpliceDecl (XSpliceDecl p) (Located (HsSplice p)) SpliceExplicitFlag | |
XSpliceDecl (XXSpliceDecl p) |
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (SpliceDecl p) | |
Defined in HsDecls ppr :: SpliceDecl p -> SDoc # pprPrec :: Rational -> SpliceDecl p -> SDoc # |
A type or class declaration.
FamDecl | type/data family T :: *->* |
| |
SynDecl |
|
DataDecl |
|
| |
ClassDecl | |
| |
XTyClDecl (XXTyClDecl pass) |
data DataDeclRn #
DataDeclRn | |
|
Instances
Data DataDeclRn | |
Defined in HsDecls 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 # |
Type or Class Group
TyClGroup | |
| |
XTyClGroup (XXTyClGroup pass) |
type LFamilyResultSig pass = Located (FamilyResultSig pass) #
Located type Family Result Signature
data FamilyResultSig pass #
type Family Result Signature
NoSig (XNoSig pass) | |
KindSig (XCKindSig pass) (LHsKind pass) | |
TyVarSig (XTyVarSig pass) (LHsTyVarBndr pass) | |
XFamilyResultSig (XXFamilyResultSig pass) |
type LFamilyDecl pass = Located (FamilyDecl pass) #
Located type Family Declaration
data FamilyDecl pass #
type Family Declaration
FamilyDecl | |
| |
XFamilyDecl (XXFamilyDecl pass) |
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (FamilyDecl p) | |
Defined in HsDecls 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
]"
InjectivityAnn (Located (IdP pass)) [Located (IdP pass)] |
data FamilyInfo pass #
DataFamily | |
OpenTypeFamily | |
ClosedTypeFamily (Maybe [LTyFamInstEqn pass]) |
|
Instances
Outputable (FamilyInfo pass) | |
Defined in HsDecls ppr :: FamilyInfo pass -> SDoc # pprPrec :: Rational -> FamilyInfo pass -> SDoc # |
data HsDataDefn pass #
Haskell Data type Definition
HsDataDefn | Declares a data type or newtype, giving its constructors
|
| |
XHsDataDefn (XXHsDataDefn pass) |
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsDataDefn p) | |
Defined in HsDecls ppr :: HsDataDefn p -> SDoc # pprPrec :: Rational -> HsDataDefn p -> SDoc # |
type HsDeriving pass #
= Located [LHsDerivingClause pass] | The optional The list of |
Haskell Deriving clause
type LHsDerivingClause pass = Located (HsDerivingClause pass) #
data HsDerivingClause pass #
A single deriving
clause of a data declaration.
HsDerivingClause | |
| |
XHsDerivingClause (XXHsDerivingClause pass) |
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsDerivingClause p) | |
Defined in HsDecls ppr :: HsDerivingClause p -> SDoc # pprPrec :: Rational -> HsDerivingClause p -> SDoc # |
Instances
Eq NewOrData | |
Data NewOrData | |
Defined in HsDecls 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 | |
= Located (ConDecl pass) | May have |
Located data Constructor Declaration
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 = IntMkT
Int | MkT2 data T a where IntMkT
Int :: T Int
AnnKeywordId
s :AnnOpen
,AnnDotdot
,AnnCLose
,AnnEqual
,AnnVbar
,AnnDarrow
,AnnDarrow
,AnnForall
,AnnDot
data Constructor Declaration
ConDeclGADT | |
| |
ConDeclH98 | |
| |
XConDecl (XXConDecl pass) |
type HsConDeclDetails pass = HsConDetails (LBangType pass) (Located [LConDeclField pass]) #
Haskell data Constructor Declaration Details
type LTyFamInstEqn pass #
= Located (TyFamInstEqn pass) | May have |
Located Type Family Instance Equation
type LTyFamDefltEqn pass = Located (TyFamDefltEqn pass) #
Located Type Family Default Equation
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
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (TyFamInstDecl p) | |
Defined in HsDecls 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
DataFamInstDecl | |
|
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (DataFamInstDecl p) | |
Defined in HsDecls 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 #
= HsImplicitBndrs pass (FamEqn pass (HsTyPats pass) rhs) | Here, the |
Family Instance Equation
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]
FamEqn | |
| |
XFamEqn (XXFamEqn pass pats rhs) |
type LClsInstDecl pass = Located (ClsInstDecl pass) #
Located Class Instance Declaration
data ClsInstDecl pass #
Class Instance Declaration
ClsInstDecl | |
| |
XClsInstDecl (XXClsInstDecl pass) |
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (ClsInstDecl p) | |
Defined in HsDecls ppr :: ClsInstDecl p -> SDoc # pprPrec :: Rational -> ClsInstDecl p -> SDoc # |
Instance Declaration
ClsInstD | |
| |
DataFamInstD | |
| |
TyFamInstD | |
| |
XInstDecl (XXInstDecl pass) |
type LDerivDecl pass = Located (DerivDecl pass) #
Located Deriving Declaration
Deriving Declaration
DerivDecl | |
| |
XDerivDecl (XXDerivDecl pass) |
type LDerivStrategy pass = Located (DerivStrategy pass) #
data DerivStrategy pass #
Which technique the user explicitly requested when deriving an instance.
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., |
AnyclassStrategy | -XDeriveAnyClass |
NewtypeStrategy | -XGeneralizedNewtypeDeriving |
ViaStrategy (XViaStrategy pass) | -XDerivingVia |
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (DerivStrategy p) | |
Defined in HsDecls ppr :: DerivStrategy p -> SDoc # pprPrec :: Rational -> DerivStrategy p -> SDoc # |
type LDefaultDecl pass = Located (DefaultDecl pass) #
Located Default Declaration
data DefaultDecl pass #
Default Declaration
DefaultDecl (XCDefaultDecl pass) [LHsType pass] | |
XDefaultDecl (XXDefaultDecl pass) |
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (DefaultDecl p) | |
Defined in HsDecls ppr :: DefaultDecl p -> SDoc # pprPrec :: Rational -> DefaultDecl p -> SDoc # |
type LForeignDecl pass = Located (ForeignDecl pass) #
Located Foreign Declaration
data ForeignDecl pass #
Foreign Declaration
ForeignImport | |
| |
ForeignExport | |
| |
XForeignDecl (XXForeignDecl pass) |
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (ForeignDecl p) | |
Defined in HsDecls ppr :: ForeignDecl p -> SDoc # pprPrec :: Rational -> ForeignDecl p -> SDoc # |
data ForeignImport #
Instances
Data ForeignImport | |
Defined in HsDecls 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 | |
Defined in HsDecls ppr :: ForeignImport -> SDoc # pprPrec :: Rational -> ForeignImport -> SDoc # |
data CImportSpec #
Instances
Data CImportSpec | |
Defined in HsDecls 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 #
Instances
Data ForeignExport | |
Defined in HsDecls 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 | |
Defined in HsDecls ppr :: ForeignExport -> SDoc # pprPrec :: Rational -> ForeignExport -> SDoc # |
type LRuleDecls pass = Located (RuleDecls pass) #
Located Rule Declarations
Rule Declarations
HsRules | |
| |
XRuleDecls (XXRuleDecls pass) |
Rule Declaration
HsRule (XHsRule pass) (Located (SourceText, RuleName)) Activation [LRuleBndr pass] (Located (HsExpr pass)) (Located (HsExpr pass)) | |
XRuleDecl (XXRuleDecl pass) |
Instances
Data HsRuleRn | |
Defined in HsDecls 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 # |
Rule Binder
RuleBndr (XCRuleBndr pass) (Located (IdP pass)) | |
RuleBndrSig (XRuleBndrSig pass) (Located (IdP pass)) (LHsSigWcType pass) | |
XRuleBndr (XXRuleBndr pass) |
Documentation comment Declaration
DocCommentNext HsDocString | |
DocCommentPrev HsDocString | |
DocCommentNamed String HsDocString | |
DocGroup Int HsDocString |
Instances
Data DocDecl | |
Defined in HsDecls 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 | |
type LWarnDecls pass = Located (WarnDecls pass) #
Located Warning Declarations
Warning pragma Declarations
Warnings | |
| |
XWarnDecls (XXWarnDecls pass) |
Warning pragma Declaration
Warning (XWarning pass) [Located (IdP pass)] WarningTxt | |
XWarnDecl (XXWarnDecl pass) |
Annotation Declaration
HsAnnotation (XHsAnnotation pass) SourceText (AnnProvenance (IdP pass)) (Located (HsExpr pass)) | |
XAnnDecl (XXAnnDecl pass) |
data AnnProvenance name #
Annotation Provenance
ValueAnnProvenance (Located name) | |
TypeAnnProvenance (Located name) | |
ModuleAnnProvenance |
Instances
Functor AnnProvenance | |
Defined in HsDecls fmap :: (a -> b) -> AnnProvenance a -> AnnProvenance b # (<$) :: a -> AnnProvenance b -> AnnProvenance a # | |
Foldable AnnProvenance | |
Defined in HsDecls 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 | |
Defined in HsDecls 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) | |
Defined in HsDecls 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
RoleAnnotDecl (XCRoleAnnotDecl pass) (Located (IdP pass)) [Located (Maybe Role)] | |
XRoleAnnotDecl (XXRoleAnnotDecl pass) |
Instances
(p ~ GhcPass pass, OutputableBndr (IdP p)) => Outputable (RoleAnnotDecl p) | |
Defined in HsDecls ppr :: RoleAnnotDecl p -> SDoc # pprPrec :: Rational -> RoleAnnotDecl p -> SDoc # |
parenthesizePat :: PprPrec -> LPat (GhcPass p) -> LPat (GhcPass p) #
checks if parenthesizePat
p pat
is true, and
if so, surrounds patNeedsParens
p patpat
with a ParPat
. Otherwise, it simply returns pat
.
patNeedsParens :: PprPrec -> Pat p -> Bool #
returns patNeedsParens
p patTrue
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) #
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 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)
HsRecFields | |
|
Instances
Functor (HsRecFields p) | |
Defined in HsPat fmap :: (a -> b) -> HsRecFields p a -> HsRecFields p b # (<$) :: a -> HsRecFields p b -> HsRecFields p a # | |
Foldable (HsRecFields p) | |
Defined in HsPat 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) | |
Defined in HsPat 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) | |
Defined in HsPat 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
For details on above see note [Api annotations] in ApiAnnotation
HsRecField | |
|
Instances
Functor (HsRecField' id) | |
Defined in HsPat fmap :: (a -> b) -> HsRecField' id a -> HsRecField' id b # (<$) :: a -> HsRecField' id b -> HsRecField' id a # | |
Foldable (HsRecField' id) | |
Defined in HsPat 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) | |
Defined in HsPat 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) | |
Defined in HsPat 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) | |
Defined in HsPat 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 #
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 #
isEmptyIPBindsTc :: HsIPBinds GhcTc -> Bool #
isEmptyIPBindsPR :: HsIPBinds (GhcPass p) -> Bool #
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
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) | |
Defined in HsBinds 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
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) | |
Defined in HsBinds ppr :: HsValBindsLR idL idR -> SDoc # pprPrec :: Rational -> HsValBindsLR idL idR -> SDoc # |
type LHsBinds id = LHsBindsLR id id #
Located Haskell Bindings
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
Haskell Binding with separate Left and Right id's
FunBind | Function-like Binding FunBind is used for both functions Reason 1: Special case for type inference: see 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 Strict bindings have their strictness recorded in the |
| |
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. |
VarBind | Variable Binding Dictionary binding and suchlike. All VarBinds are introduced by the type checker |
AbsBinds | Abstraction Bindings |
| |
XHsBindsLR (XXHsBindsLR idL idR) |
data NPatBindTc #
NPatBindTc | |
|
Instances
Data NPatBindTc | |
Defined in HsBinds 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 # |
Abtraction Bindings Export
ABE | |
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 #
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
Haskell Implicit Parameter Bindings
IPBinds (XIPBinds id) [LIPBind id] | |
XHsIPBinds (XXHsIPBinds id) |
type LIPBind id = Located (IPBind id) #
Located Implicit Parameter Binding
May have AnnKeywordId
: AnnSemi
when in a
list
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.
Signatures and pragmas
PatSynSig (XPatSynSig pass) [Located (IdP pass)] (LHsSigType pass) | A pattern synonym type signature pattern Single :: () => (Show a) => a -> [a] |
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 *** |
InlineSig (XInlineSig pass) (Located (IdP pass)) InlinePragma | An inline pragma {#- INLINE f #-} |
SpecSig (XSpecSig pass) (Located (IdP pass)) [LHsSigType pass] InlinePragma | A specialisation pragma {-# SPECIALISE f :: Int -> Int #-} |
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 |
MinimalSig (XMinimalSig pass) SourceText (LBooleanFormula (Located (IdP pass))) | A minimal complete definition pragma {-# MINIMAL a | (b, c | (d | e)) #-} |
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) |
type LFixitySig pass = Located (FixitySig pass) #
Located Fixity Signature
Fixity Signature
FixitySig (XFixitySig pass) [Located (IdP pass)] Fixity | |
XFixitySig (XXFixitySig pass) |
data TcSpecPrags #
Type checker Specialisation Pragmas
TcSpecPrags
conveys SPECIALISE
pragmas from the type checker to the desugarer
IsDefaultMethod | Super-specialised: a default method should be macro-expanded at every call site |
SpecPrags [LTcSpecPrag] |
Instances
Data TcSpecPrags | |
Defined in HsBinds 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
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 | |
Defined in HsBinds 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 | |
Defined in HsBinds 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
Instances
data HsPatSynDir id #
Haskell Pattern Synonym Direction
pprInstanceHdr :: ClsInst -> SDoc #
pprInstance :: ClsInst -> SDoc #
instanceDFunId :: ClsInst -> DFunId #
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 | |
Defined in InstEnv 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 | |
Outputable ClsInst | |
Instances
NamedThing FamInst | |
Defined in FamInstEnv | |
Outputable FamInst | |
type BreakIndex = Int #
Breakpoint index
All the information about the breakpoints for a module
ModBreaks | |
|
parenthesizeHsType :: PprPrec -> LHsType (GhcPass p) -> LHsType (GhcPass p) #
checks if parenthesizeHsType
p ty
is
true, and if so, surrounds hsTypeNeedsParens
p tyty
with an HsParTy
. Otherwise, it simply
returns ty
.
hsTypeNeedsParens :: PprPrec -> HsType pass -> Bool #
returns hsTypeNeedsParens
p tTrue
if the type t
needs parentheses
under precedence p
.
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 #
rdrNameAmbiguousFieldOcc :: AmbiguousFieldOcc (GhcPass p) -> RdrName #
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) #
hsTyGetAppHead_maybe :: LHsType (GhcPass p) -> Maybe (Located (IdP (GhcPass p)), [LHsType (GhcPass p)]) #
mkHsOpTy :: LHsType (GhcPass p) -> Located (IdP (GhcPass p)) -> LHsType (GhcPass p) -> HsType (GhcPass p) #
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 #
hsQTvExplicit :: LHsQTyVars pass -> [LHsTyVarBndr pass] #
mkHsQTvs :: [LHsTyVarBndr GhcPs] -> LHsQTyVars GhcPs #
getBangStrictness :: LHsType a -> HsSrcBang #
getBangType :: LHsType a -> LHsType a #
= Located (HsType pass) | May have |
Located Haskell Type
type LHsTyVarBndr pass = Located (HsTyVarBndr pass) #
Located Haskell Type Variable Binder
data LHsQTyVars pass #
Located Haskell Quantified Type Variables
HsQTvs | |
| |
XLHsQTyVars (XXLHsQTyVars pass) |
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (LHsQTyVars p) | |
Defined in HsTypes ppr :: LHsQTyVars p -> SDoc # pprPrec :: Rational -> LHsQTyVars p -> SDoc # |
HsQTvsRn | |
|
Instances
Data HsQTvsRn | |
Defined in HsTypes 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
HsIB | |
XHsImplicitBndrs (XXHsImplicitBndrs pass thing) |
Instances
(p ~ GhcPass pass, Outputable thing) => Outputable (HsImplicitBndrs p thing) | |
Defined in HsTypes ppr :: HsImplicitBndrs p thing -> SDoc # pprPrec :: Rational -> HsImplicitBndrs p thing -> SDoc # |
HsIBRn | |
|
Instances
Data HsIBRn | |
Defined in HsTypes 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
HsWC | |
XHsWildCardBndrs (XXHsWildCardBndrs pass thing) |
Instances
(p ~ GhcPass pass, Outputable thing) => Outputable (HsWildCardBndrs p thing) | |
Defined in HsTypes 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
These names are used early on to store the names of implicit parameters. They completely disappear after type-checking.
Instances
Eq HsIPName | |
Data HsIPName | |
Defined in HsTypes 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 | |
OutputableBndr HsIPName | |
Defined in HsTypes pprBndr :: BindingSite -> HsIPName -> SDoc # pprPrefixOcc :: HsIPName -> SDoc # pprInfixOcc :: HsIPName -> SDoc # bndrIsJoin_maybe :: HsIPName -> Maybe Int # |
data HsTyVarBndr pass #
Haskell Type Variable Binder
UserTyVar (XUserTyVar pass) (Located (IdP pass)) | |
KindedTyVar (XKindedTyVar pass) (Located (IdP pass)) (LHsKind pass) | |
XTyVarBndr (XXTyVarBndr pass) |
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsTyVarBndr p) | |
Defined in HsTypes ppr :: HsTyVarBndr p -> SDoc # pprPrec :: Rational -> HsTyVarBndr p -> SDoc # |
Haskell Type
data NewHsTypeX #
Instances
Data NewHsTypeX |
|
Defined in HsTypes 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 | |
Defined in HsTypes ppr :: NewHsTypeX -> SDoc # pprPrec :: Rational -> NewHsTypeX -> SDoc # |
Haskell Type Literal
Instances
Data HsTyLit | |
Defined in HsTypes 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 | |
newtype HsWildCardInfo #
Instances
Data HsWildCardInfo | |
Defined in HsTypes 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 | |
Defined in HsTypes ppr :: HsWildCardInfo -> SDoc # pprPrec :: Rational -> HsWildCardInfo -> SDoc # |
data HsTupleSort #
Haskell Tuple Sort
Instances
Data HsTupleSort | |
Defined in HsTypes 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 # |
Promoted data types.
Instances
Eq Promoted | |
Data Promoted | |
Defined in HsTypes 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 | |
type LConDeclField pass #
= Located (ConDeclField pass) | May have |
Located Constructor Declaration Field
data ConDeclField pass #
Constructor Declaration Field
ConDeclField | |
| |
XConDeclField (XXConDeclField pass) |
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (ConDeclField p) | |
Defined in HsTypes ppr :: ConDeclField p -> SDoc # pprPrec :: Rational -> ConDeclField p -> SDoc # |
data HsConDetails arg rec #
Haskell Constructor Details
Instances
(Data arg, Data rec) => Data (HsConDetails arg rec) | |
Defined in HsTypes 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) | |
Defined in HsTypes ppr :: HsConDetails arg rec -> SDoc # pprPrec :: Rational -> HsConDetails arg rec -> SDoc # |
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.
FieldOcc | |
| |
XFieldOcc (XXFieldOcc pass) |
Instances
(p ~ GhcPass pass, Eq (XCFieldOcc p)) => Eq (FieldOcc p) | |
(p ~ GhcPass pass, Ord (XCFieldOcc p)) => Ord (FieldOcc p) | |
Outputable (FieldOcc pass) | |
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
Unambiguous (XUnambiguous pass) (Located RdrName) | |
Ambiguous (XAmbiguous pass) (Located RdrName) | |
XAmbiguousFieldOcc (XXAmbiguousFieldOcc pass) |
Instances
p ~ GhcPass pass => Outputable (AmbiguousFieldOcc p) | |
Defined in HsTypes ppr :: AmbiguousFieldOcc p -> SDoc # pprPrec :: Rational -> AmbiguousFieldOcc p -> SDoc # | |
p ~ GhcPass pass => OutputableBndr (AmbiguousFieldOcc p) | |
Defined in HsTypes pprBndr :: BindingSite -> AmbiguousFieldOcc p -> SDoc # pprPrefixOcc :: AmbiguousFieldOcc p -> SDoc # pprInfixOcc :: AmbiguousFieldOcc p -> SDoc # bndrIsJoin_maybe :: AmbiguousFieldOcc p -> Maybe Int # |
data ExecOptions #
ExecOptions | |
|
data ExecResult #
Resume | |
|
isBottomingId :: Var -> Bool #
Returns true if an application to n args would diverge
isDeadBinder :: Id -> Bool #
isImplicitId :: Id -> Bool #
isImplicitId
tells whether an Id
s 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.
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 #
isPrimOpId :: Id -> Bool #
isClassOpId_maybe :: Id -> Maybe Class #
isRecordSelector :: Id -> Bool #
recordSelectorTyCon :: Id -> RecSelParent #
isVanillaDataCon :: DataCon -> Bool #
Vanilla DataCon
s 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 ThetaType
s 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 #
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)
Instances
Data HsSrcBang | |
Defined in DataCon 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 | |
data HsImplBang #
Haskell Implementation Bang
Bangs of data constructor arguments as generated by the compiler after consulting HsSrcBang, flags, etc.
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 | |
Defined in DataCon 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 | |
Defined in DataCon ppr :: HsImplBang -> SDoc # pprPrec :: Rational -> HsImplBang -> SDoc # |
data SrcStrictness #
Source Strictness
What strictness annotation the user wrote
SrcLazy | Lazy, ie '~' |
SrcStrict | Strict, ie |
NoSrcStrict | no strictness annotation |
Instances
Eq SrcStrictness | |
Defined in DataCon (==) :: SrcStrictness -> SrcStrictness -> Bool # (/=) :: SrcStrictness -> SrcStrictness -> Bool # | |
Data SrcStrictness | |
Defined in DataCon 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 | |
Defined in DataCon put_ :: BinHandle -> SrcStrictness -> IO () # put :: BinHandle -> SrcStrictness -> IO (Bin SrcStrictness) # get :: BinHandle -> IO SrcStrictness # | |
Outputable SrcStrictness | |
Defined in DataCon ppr :: SrcStrictness -> SDoc # pprPrec :: Rational -> SrcStrictness -> SDoc # |
data SrcUnpackedness #
Source Unpackedness
What unpackedness the user requested
SrcUnpack | |
SrcNoUnpack | |
NoSrcUnpack | no unpack pragma |
Instances
data StrictnessMark #
Instances
Outputable StrictnessMark | |
Defined in DataCon ppr :: StrictnessMark -> SDoc # pprPrec :: Rational -> StrictnessMark -> SDoc # |
hsOverLitNeedsParens :: PprPrec -> HsOverLit x -> Bool #
returns hsOverLitNeedsParens
p olTrue
if an overloaded literal
ol
needs to be parenthesized under precedence p
.
hsLitNeedsParens :: PprPrec -> HsLit x -> Bool #
returns hsLitNeedsParens
p lTrue
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 #
Haskell Literal
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
|
HsIntPrim (XHsIntPrim x) Integer | literal |
HsWordPrim (XHsWordPrim x) Integer | literal |
HsInt64Prim (XHsInt64Prim x) Integer | literal |
HsWord64Prim (XHsWord64Prim x) Integer | literal |
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) |
Haskell Overloaded Literal
OverLit | |
| |
XOverLit (XXOverLit p) |
Instances
Eq (XXOverLit p) => Eq (HsOverLit p) | |
Ord (XXOverLit p) => Ord (HsOverLit p) | |
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsOverLit p) | |
OverLitTc | |
|
Instances
Data OverLitTc | |
Defined in HsLit 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
HsIntegral !IntegralLit | Integer-looking literals; |
HsFractional !FractionalLit | Frac-looking literals |
HsIsString !SourceText !FastString | String-looking literals |
Instances
Eq OverLitVal | |
Defined in HsLit (==) :: OverLitVal -> OverLitVal -> Bool # (/=) :: OverLitVal -> OverLitVal -> Bool # | |
Data OverLitVal | |
Defined in HsLit 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 | |
Defined in HsLit 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 | |
Defined in HsLit 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 TyVar
s 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 #
classSCTheta :: Class -> [PredType] #
classMethods :: Class -> [Id] #
Instances
Eq Class | |
Data Class | |
Defined in Class 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 # 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 | |
Uniquable Class | |
Outputable Class | |
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
A data constructor
Instances
Eq DataCon | |
Data DataCon | |
Defined in DataCon 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 | |
Uniquable DataCon | |
Outputable DataCon | |
OutputableBndr DataCon | |
Defined in DataCon pprBndr :: BindingSite -> DataCon -> SDoc # pprPrefixOcc :: DataCon -> SDoc # pprInfixOcc :: DataCon -> SDoc # bndrIsJoin_maybe :: DataCon -> Maybe Int # |
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 #
A Haskell expression.
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)
|
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 |
HsLamCase (XLamCase p) (MatchGroup p (LHsExpr p)) | Lambda-case |
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 |
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 |
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 |
ExplicitSum (XExplicitSum p) ConTag Arity (LHsExpr p) | Used for unboxed sum types
There will be multiple |
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)] | Multi-way if |
HsLet (XLet p) (LHsLocalBinds p) (LHsExpr p) | let(rec)
|
HsDo (XDo p) (HsStmtContext Name) (Located [ExprLStmt p]) | |
ExplicitList (XExplicitList p) (Maybe (SyntaxExpr p)) [LHsExpr p] | Syntactic list: [a,b,c,...]
|
RecordCon | Record construction
|
| |
RecordUpd | Record update
|
| |
ExprWithTySig (XExprWithTySig p) (LHsExpr p) | Expression with an explicit type signature. |
ArithSeq (XArithSeq p) (Maybe (SyntaxExpr p)) (ArithSeqInfo p) | Arithmetic sequence
|
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) |
Haskell Command (e.g. a "statement" in an Arrow proc block)
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) |
Haskell Splice
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 | |
XMatchGroup (XXMatchGroup p body) |
Guarded Right-Hand Sides
GRHSs are used both for pattern bindings and for Matches
GRHSs | |
| |
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.)
SyntaxExpr | |
|
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (SyntaxExpr p) | |
Defined in HsExpr ppr :: SyntaxExpr p -> SDoc # pprPrec :: Rational -> SyntaxExpr p -> SDoc # |
= Located (HsExpr p) | May have |
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 #
simpleImportDecl :: ModuleName -> ImportDecl (GhcPass p) #
type LImportDecl pass #
= Located (ImportDecl pass) | When in a list this may have |
Located Import Declaration
data ImportDecl pass #
Import Declaration
A single Haskell import
declaration.
ImportDecl | |
| |
XImportDecl (XXImportDecl pass) |
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (ImportDecl p) | |
Defined in HsImpExp 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.
Instances
Eq name => Eq (IEWrappedName name) | |
Defined in HsImpExp (==) :: IEWrappedName name -> IEWrappedName name -> Bool # (/=) :: IEWrappedName name -> IEWrappedName name -> Bool # | |
Data name => Data (IEWrappedName name) | |
Defined in HsImpExp 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) | |
Defined in HsImpExp occName :: IEWrappedName name -> OccName # | |
OutputableBndr name => Outputable (IEWrappedName name) | |
Defined in HsImpExp ppr :: IEWrappedName name -> SDoc # pprPrec :: Rational -> IEWrappedName name -> SDoc # | |
OutputableBndr name => OutputableBndr (IEWrappedName name) | |
Defined in HsImpExp 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
- AnnKeywordId
s : AnnType
,
AnnPattern
Imported or exported entity.
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)
- |
IEModuleContents (XIEModuleContents pass) (Located ModuleName) | Imported or exported module contents (Export Only) |
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) |
data IEWildcard #
Imported or Exported Wildcard
Instances
Eq IEWildcard | |
Defined in HsImpExp (==) :: IEWildcard -> IEWildcard -> Bool # (/=) :: IEWildcard -> IEWildcard -> Bool # | |
Data IEWildcard | |
Defined in HsImpExp 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 # |
Pattern
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
^ - |
AsPat (XAsPat p) (Located (IdP p)) (LPat p) | As pattern
^ - |
ParPat (XParPat p) (LPat p) | Parenthesised pattern
See Note [Parens in HsSyn] in HsExpr
^ - |
BangPat (XBangPat p) (LPat p) | Bang pattern
^ - |
ListPat (XListPat p) [LPat p] | Syntactic List
|
TuplePat (XTuplePat p) [LPat p] Boxity | Tuple sub-patterns
|
SumPat (XSumPat p) (LPat p) ConTag Arity | Anonymous sum pattern
|
ConPatIn (Located (IdP p)) (HsConPatDetails p) | Constructor Pattern In |
ConPatOut | Constructor Pattern Out |
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 |
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 |
used as place holder in TTG values
Instances
Eq NoExt | |
Data NoExt | |
Defined in HsExtension 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 # 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 | |
Outputable NoExt | |
Used as a data type index for the hsSyn AST
Instances
Instances
Data Pass | |
Defined in HsExtension 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 # 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 GhcTc = GhcPass Typechecked #
Maps the "normal" id type for a given pass
type family XHsValBinds x x' :: Type #
Instances
type XHsValBinds (GhcPass pL) (GhcPass pR) | |
Defined in HsBinds |
type family XHsIPBinds x x' :: Type #
Instances
type XHsIPBinds (GhcPass pL) (GhcPass pR) | |
Defined in HsBinds |
type family XEmptyLocalBinds x x' :: Type #
Instances
type XEmptyLocalBinds (GhcPass pL) (GhcPass pR) | |
Defined in HsBinds |
type family XXHsLocalBindsLR x x' :: Type #
Instances
type XXHsLocalBindsLR (GhcPass pL) (GhcPass pR) | |
Defined in HsBinds |
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 XXValBindsLR x x' :: Type #
Instances
type XXValBindsLR (GhcPass pL) (GhcPass pR) | |
Defined in HsBinds |
type ForallXValBindsLR (c :: Type -> Constraint) x x' = (c (XValBinds x x'), c (XXValBindsLR x x')) #
type family XPatSynBind x x' :: Type #
Instances
type XPatSynBind (GhcPass pL) (GhcPass pR) | |
Defined in HsBinds |
type family XXHsBindsLR x x' :: Type #
Instances
type XXHsBindsLR (GhcPass pL) (GhcPass pR) | |
Defined in HsBinds |
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 XXABExport x :: Type #
Instances
type XXABExport (GhcPass p) | |
Defined in HsBinds |
type ForallXABExport (c :: Type -> Constraint) x = (c (XABE x), c (XXABExport x)) #
type family XXPatSynBind x x' :: Type #
Instances
type XXPatSynBind (GhcPass idL) (GhcPass idR) | |
Defined in HsBinds |
type ForallXPatSynBind (c :: Type -> Constraint) x x' = (c (XPSB x x'), c (XXPatSynBind x x')) #
type family XXHsIPBinds x :: Type #
Instances
type XXHsIPBinds (GhcPass p) | |
Defined in HsBinds |
type ForallXHsIPBinds (c :: Type -> Constraint) x = (c (XIPBinds x), c (XXHsIPBinds x)) #
type ForallXIPBind (c :: Type -> Constraint) x = (c (XCIPBind x), c (XXIPBind x)) #
type family XPatSynSig x :: Type #
Instances
type XPatSynSig (GhcPass p) | |
Defined in HsBinds |
type family XClassOpSig x :: Type #
Instances
type XClassOpSig (GhcPass p) | |
Defined in HsBinds |
type family XInlineSig x :: Type #
Instances
type XInlineSig (GhcPass p) | |
Defined in HsBinds |
type family XSpecInstSig x :: Type #
Instances
type XSpecInstSig (GhcPass p) | |
Defined in HsBinds |
type family XMinimalSig x :: Type #
Instances
type XMinimalSig (GhcPass p) | |
Defined in HsBinds |
type family XSCCFunSig x :: Type #
Instances
type XSCCFunSig (GhcPass p) | |
Defined in HsBinds |
type family XCompleteMatchSig x :: Type #
Instances
type XCompleteMatchSig (GhcPass p) | |
Defined in HsBinds |
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) | |
Defined in HsBinds |
type family XXFixitySig x :: Type #
Instances
type XXFixitySig (GhcPass p) | |
Defined in HsBinds |
type ForallXFixitySig (c :: Type -> Constraint) x = (c (XFixitySig x), c (XXFixitySig x)) #
type family XRoleAnnotD x :: Type #
Instances
type XRoleAnnotD (GhcPass _) | |
Defined in HsDecls |
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 ForallXHsGroup (c :: Type -> Constraint) x = (c (XCHsGroup x), c (XXHsGroup x)) #
type family XSpliceDecl x :: Type #
Instances
type XSpliceDecl (GhcPass _) | |
Defined in HsDecls |
type family XXSpliceDecl x :: Type #
Instances
type XXSpliceDecl (GhcPass _) | |
Defined in HsDecls |
type ForallXSpliceDecl (c :: Type -> Constraint) x = (c (XSpliceDecl x), c (XXSpliceDecl x)) #
type family XClassDecl x :: Type #
Instances
type XClassDecl GhcPs | |
Defined in HsDecls | |
type XClassDecl GhcRn | |
Defined in HsDecls | |
type XClassDecl GhcTc | |
Defined in HsDecls |
type family XXTyClDecl x :: Type #
Instances
type XXTyClDecl (GhcPass _) | |
Defined in HsDecls |
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 _) | |
Defined in HsDecls |
type family XXTyClGroup x :: Type #
Instances
type XXTyClGroup (GhcPass _) | |
Defined in HsDecls |
type ForallXTyClGroup (c :: Type -> Constraint) x = (c (XCTyClGroup x), c (XXTyClGroup x)) #
type family XXFamilyResultSig x :: Type #
Instances
type XXFamilyResultSig (GhcPass _) | |
Defined in HsDecls |
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 _) | |
Defined in HsDecls |
type family XXFamilyDecl x :: Type #
Instances
type XXFamilyDecl (GhcPass _) | |
Defined in HsDecls |
type ForallXFamilyDecl (c :: Type -> Constraint) x = (c (XCFamilyDecl x), c (XXFamilyDecl x)) #
type family XCHsDataDefn x :: Type #
Instances
type XCHsDataDefn (GhcPass _) | |
Defined in HsDecls |
type family XXHsDataDefn x :: Type #
Instances
type XXHsDataDefn (GhcPass _) | |
Defined in HsDecls |
type ForallXHsDataDefn (c :: Type -> Constraint) x = (c (XCHsDataDefn x), c (XXHsDataDefn x)) #
type family XCHsDerivingClause x :: Type #
Instances
type XCHsDerivingClause (GhcPass _) | |
Defined in HsDecls |
type family XXHsDerivingClause x :: Type #
Instances
type XXHsDerivingClause (GhcPass _) | |
Defined in HsDecls |
type ForallXHsDerivingClause (c :: Type -> Constraint) x = (c (XCHsDerivingClause x), c (XXHsDerivingClause x)) #
type family XConDeclGADT x :: Type #
Instances
type XConDeclGADT (GhcPass _) | |
Defined in HsDecls |
type family XConDeclH98 x :: Type #
Instances
type XConDeclH98 (GhcPass _) | |
Defined in HsDecls |
type ForallXConDecl (c :: Type -> Constraint) x = (c (XConDeclGADT x), c (XConDeclH98 x), c (XXConDecl x)) #
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 _) | |
Defined in HsDecls |
type family XXClsInstDecl x :: Type #
Instances
type XXClsInstDecl (GhcPass _) | |
Defined in HsDecls |
type ForallXClsInstDecl (c :: Type -> Constraint) x = (c (XCClsInstDecl x), c (XXClsInstDecl x)) #
type family XDataFamInstD x :: Type #
Instances
type XDataFamInstD (GhcPass _) | |
Defined in HsDecls |
type family XTyFamInstD x :: Type #
Instances
type XTyFamInstD (GhcPass _) | |
Defined in HsDecls |
type family XXInstDecl x :: Type #
Instances
type XXInstDecl (GhcPass _) | |
Defined in HsDecls |
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 _) | |
Defined in HsDecls |
type family XXDerivDecl x :: Type #
Instances
type XXDerivDecl (GhcPass _) | |
Defined in HsDecls |
type ForallXDerivDecl (c :: Type -> Constraint) x = (c (XCDerivDecl x), c (XXDerivDecl x)) #
type family XViaStrategy x :: Type #
Instances
type XViaStrategy GhcPs | |
Defined in HsDecls | |
type XViaStrategy GhcRn | |
Defined in HsDecls | |
type XViaStrategy GhcTc | |
Defined in HsDecls |
type family XCDefaultDecl x :: Type #
Instances
type XCDefaultDecl (GhcPass _) | |
Defined in HsDecls |
type family XXDefaultDecl x :: Type #
Instances
type XXDefaultDecl (GhcPass _) | |
Defined in HsDecls |
type ForallXDefaultDecl (c :: Type -> Constraint) x = (c (XCDefaultDecl x), c (XXDefaultDecl x)) #
type family XForeignImport x :: Type #
Instances
type XForeignImport GhcPs | |
Defined in HsDecls | |
type XForeignImport GhcRn | |
Defined in HsDecls | |
type XForeignImport GhcTc | |
Defined in HsDecls |
type family XForeignExport x :: Type #
Instances
type XForeignExport GhcPs | |
Defined in HsDecls | |
type XForeignExport GhcRn | |
Defined in HsDecls | |
type XForeignExport GhcTc | |
Defined in HsDecls |
type family XXForeignDecl x :: Type #
Instances
type XXForeignDecl (GhcPass _) | |
Defined in HsDecls |
type ForallXForeignDecl (c :: Type -> Constraint) x = (c (XForeignImport x), c (XForeignExport x), c (XXForeignDecl x)) #
type family XCRuleDecls x :: Type #
Instances
type XCRuleDecls (GhcPass _) | |
Defined in HsDecls |
type family XXRuleDecls x :: Type #
Instances
type XXRuleDecls (GhcPass _) | |
Defined in HsDecls |
type ForallXRuleDecls (c :: Type -> Constraint) x = (c (XCRuleDecls x), c (XXRuleDecls x)) #
type family XXRuleDecl x :: Type #
Instances
type XXRuleDecl (GhcPass _) | |
Defined in HsDecls |
type ForallXRuleDecl (c :: Type -> Constraint) x = (c (XHsRule x), c (XXRuleDecl x)) #
type family XCRuleBndr x :: Type #
Instances
type XCRuleBndr (GhcPass _) | |
Defined in HsDecls |
type family XRuleBndrSig x :: Type #
Instances
type XRuleBndrSig (GhcPass _) | |
Defined in HsDecls |
type family XXRuleBndr x :: Type #
Instances
type XXRuleBndr (GhcPass _) | |
Defined in HsDecls |
type ForallXRuleBndr (c :: Type -> Constraint) x = (c (XCRuleBndr x), c (XRuleBndrSig x), c (XXRuleBndr x)) #
type family XXWarnDecls x :: Type #
Instances
type XXWarnDecls (GhcPass _) | |
Defined in HsDecls |
type ForallXWarnDecls (c :: Type -> Constraint) x = (c (XWarnings x), c (XXWarnDecls x)) #
type family XXWarnDecl x :: Type #
Instances
type XXWarnDecl (GhcPass _) | |
Defined in HsDecls |
type ForallXWarnDecl (c :: Type -> Constraint) x = (c (XWarning x), c (XXWarnDecl x)) #
type family XHsAnnotation x :: Type #
Instances
type XHsAnnotation (GhcPass _) | |
Defined in HsDecls |
type ForallXAnnDecl (c :: Type -> Constraint) x = (c (XHsAnnotation x), c (XXAnnDecl x)) #
type family XCRoleAnnotDecl x :: Type #
Instances
type XCRoleAnnotDecl (GhcPass _) | |
Defined in HsDecls |
type family XXRoleAnnotDecl x :: Type #
Instances
type XXRoleAnnotDecl (GhcPass _) | |
Defined in HsDecls |
type ForallXRoleAnnotDecl (c :: Type -> Constraint) x = (c (XCRoleAnnotDecl x), c (XXRoleAnnotDecl x)) #
type family XUnboundVar x :: Type #
Instances
type XUnboundVar (GhcPass _) | |
Defined in HsExpr |
type family XConLikeOut x :: Type #
Instances
type XConLikeOut (GhcPass _) | |
Defined in HsExpr |
type family XOverLabel x :: Type #
Instances
type XOverLabel (GhcPass _) | |
Defined in HsExpr |
type family XExplicitTuple x :: Type #
Instances
type XExplicitTuple (GhcPass _) | |
Defined in HsExpr |
type family XExplicitSum x :: Type #
Instances
type XExplicitSum GhcPs | |
Defined in HsExpr | |
type XExplicitSum GhcRn | |
Defined in HsExpr | |
type XExplicitSum GhcTc | |
Defined in HsExpr |
type family XExplicitList x :: Type #
Instances
type XExplicitList GhcPs | |
Defined in HsExpr | |
type XExplicitList GhcRn | |
Defined in HsExpr | |
type XExplicitList GhcTc | |
Defined in HsExpr |
type family XRecordCon x :: Type #
Instances
type XRecordCon GhcPs | |
Defined in HsExpr | |
type XRecordCon GhcRn | |
Defined in HsExpr | |
type XRecordCon GhcTc | |
Defined in HsExpr |
type family XRecordUpd x :: Type #
Instances
type XRecordUpd GhcPs | |
Defined in HsExpr | |
type XRecordUpd GhcRn | |
Defined in HsExpr | |
type XRecordUpd GhcTc | |
Defined in HsExpr |
type family XExprWithTySig x :: Type #
Instances
type XExprWithTySig GhcPs | |
Defined in HsExpr | |
type XExprWithTySig GhcRn | |
Defined in HsExpr | |
type XExprWithTySig GhcTc | |
Defined in HsExpr |
type family XRnBracketOut x :: Type #
Instances
type XRnBracketOut (GhcPass _) | |
Defined in HsExpr |
type family XTcBracketOut x :: Type #
Instances
type XTcBracketOut (GhcPass _) | |
Defined in HsExpr |
type family XTickPragma x :: Type #
Instances
type XTickPragma (GhcPass _) | |
Defined in HsExpr |
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 | |
Defined in HsTypes | |
type XUnambiguous GhcRn | |
Defined in HsTypes | |
type XUnambiguous GhcTc | |
Defined in HsTypes |
type family XAmbiguous x :: Type #
Instances
type XAmbiguous GhcPs | |
Defined in HsTypes | |
type XAmbiguous GhcRn | |
Defined in HsTypes | |
type XAmbiguous GhcTc | |
Defined in HsTypes |
type family XXAmbiguousFieldOcc x :: Type #
Instances
type XXAmbiguousFieldOcc (GhcPass _) | |
Defined in HsTypes |
type ForallXAmbiguousFieldOcc (c :: Type -> Constraint) x = (c (XUnambiguous x), c (XAmbiguous x), c (XXAmbiguousFieldOcc x)) #
type ForallXTupArg (c :: Type -> Constraint) x = (c (XPresent x), c (XMissing x), c (XXTupArg x)) #
type family XTypedSplice x :: Type #
Instances
type XTypedSplice (GhcPass _) | |
Defined in HsExpr |
type family XUntypedSplice x :: Type #
Instances
type XUntypedSplice (GhcPass _) | |
Defined in HsExpr |
type family XQuasiQuote x :: Type #
Instances
type XQuasiQuote (GhcPass _) | |
Defined in HsExpr |
type ForallXSplice (c :: Type -> Constraint) x = (c (XTypedSplice x), c (XUntypedSplice x), c (XQuasiQuote x), c (XSpliced x), c (XXSplice x)) #
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 ForallXCmdTop (c :: Type -> Constraint) x = (c (XCmdTop x), c (XXCmdTop x)) #
type family XXMatchGroup x b :: Type #
Instances
type XXMatchGroup (GhcPass _) b | |
Defined in HsExpr |
type ForallXMatchGroup (c :: Type -> Constraint) x b = (c (XMG x b), c (XXMatchGroup x b)) #
type ForallXMatch (c :: Type -> Constraint) x b = (c (XCMatch x b), c (XXMatch x b)) #
type ForallXGRHSs (c :: Type -> Constraint) x b = (c (XCGRHSs x b), c (XXGRHSs x b)) #
type ForallXGRHS (c :: Type -> Constraint) x b = (c (XCGRHS x b), c (XXGRHS x b)) #
type family XApplicativeStmt x x' b :: Type #
Instances
type XApplicativeStmt (GhcPass _) GhcTc b | |
Defined in HsExpr | |
type XApplicativeStmt (GhcPass _) GhcRn b | |
Defined in HsExpr | |
type XApplicativeStmt (GhcPass _) GhcPs b | |
Defined in HsExpr |
type family XTransStmt x x' b :: Type #
Instances
type XTransStmt (GhcPass _) GhcTc b | |
Defined in HsExpr | |
type XTransStmt (GhcPass _) GhcRn b | |
Defined in HsExpr | |
type XTransStmt (GhcPass _) GhcPs b | |
Defined in HsExpr |
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 | |
Defined in HsExpr | |
type XCmdArrApp GhcRn | |
Defined in HsExpr | |
type XCmdArrApp GhcTc | |
Defined in HsExpr |
type family XCmdArrForm x :: Type #
Instances
type XCmdArrForm (GhcPass _) | |
Defined in HsExpr |
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) | |
Defined in HsExpr |
type family XXParStmtBlock x x' :: Type #
Instances
type XXParStmtBlock (GhcPass pL) (GhcPass pR) | |
Defined in HsExpr |
type ForallXParStmtBlock (c :: Type -> Constraint) x x' = (c (XParStmtBlock x x'), c (XXParStmtBlock x x')) #
type family XApplicativeArgOne x :: Type #
Instances
type XApplicativeArgOne (GhcPass _) | |
Defined in HsExpr |
type family XApplicativeArgMany x :: Type #
Instances
type XApplicativeArgMany (GhcPass _) | |
Defined in HsExpr |
type family XXApplicativeArg x :: Type #
Instances
type XXApplicativeArg (GhcPass _) | |
Defined in HsExpr |
type ForallXApplicativeArg (c :: Type -> Constraint) x = (c (XApplicativeArgOne x), c (XApplicativeArgMany x), c (XXApplicativeArg x)) #
type family XHsCharPrim x :: Type #
Instances
type XHsCharPrim (GhcPass _) | |
Defined in HsLit |
type family XHsStringPrim x :: Type #
Instances
type XHsStringPrim (GhcPass _) | |
Defined in HsLit |
type family XHsIntPrim x :: Type #
Instances
type XHsIntPrim (GhcPass _) | |
Defined in HsLit |
type family XHsWordPrim x :: Type #
Instances
type XHsWordPrim (GhcPass _) | |
Defined in HsLit |
type family XHsInt64Prim x :: Type #
Instances
type XHsInt64Prim (GhcPass _) | |
Defined in HsLit |
type family XHsWord64Prim x :: Type #
Instances
type XHsWord64Prim (GhcPass _) | |
Defined in HsLit |
type family XHsInteger x :: Type #
Instances
type XHsInteger (GhcPass _) | |
Defined in HsLit |
type family XHsFloatPrim x :: Type #
Instances
type XHsFloatPrim (GhcPass _) | |
Defined in HsLit |
type family XHsDoublePrim x :: Type #
Instances
type XHsDoublePrim (GhcPass _) | |
Defined in HsLit |
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 ForallXOverLit (c :: Type -> Constraint) x = (c (XOverLit x), c (XXOverLit x)) #
type family XSplicePat x :: Type #
Instances
type XSplicePat (GhcPass _) | |
Defined in HsPat |
type family XNPlusKPat x :: Type #
Instances
type XNPlusKPat GhcPs | |
Defined in HsPat | |
type XNPlusKPat GhcRn | |
Defined in HsPat | |
type XNPlusKPat GhcTc | |
Defined in HsPat |
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 XXLHsQTyVars x :: Type #
Instances
type XXLHsQTyVars (GhcPass _) | |
Defined in HsTypes |
type ForallXLHsQTyVars (c :: Type -> Constraint) x = (c (XHsQTvs x), c (XXLHsQTyVars x)) #
type family XXHsImplicitBndrs x b :: Type #
Instances
type XXHsImplicitBndrs (GhcPass _1) _2 | |
Defined in HsTypes |
type ForallXHsImplicitBndrs (c :: Type -> Constraint) x b = (c (XHsIB x b), c (XXHsImplicitBndrs x b)) #
type family XXHsWildCardBndrs x b :: Type #
Instances
type XXHsWildCardBndrs (GhcPass _) b | |
Defined in HsTypes |
type ForallXHsWildCardBndrs (c :: Type -> Constraint) x b = (c (XHsWC x b), c (XXHsWildCardBndrs x b)) #
type family XExplicitListTy x :: Type #
Instances
type XExplicitListTy GhcPs | |
Defined in HsTypes | |
type XExplicitListTy GhcRn | |
Defined in HsTypes | |
type XExplicitListTy GhcTc | |
Defined in HsTypes |
type family XExplicitTupleTy x :: Type #
Instances
type XExplicitTupleTy GhcPs | |
Defined in HsTypes | |
type XExplicitTupleTy GhcRn | |
Defined in HsTypes | |
type XExplicitTupleTy GhcTc | |
Defined in HsTypes |
type family XWildCardTy x :: Type #
Instances
type XWildCardTy GhcPs | |
Defined in HsTypes | |
type XWildCardTy GhcRn | |
Defined in HsTypes | |
type XWildCardTy GhcTc | |
Defined in HsTypes |
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 _) | |
Defined in HsTypes |
type family XKindedTyVar x :: Type #
Instances
type XKindedTyVar (GhcPass _) | |
Defined in HsTypes |
type family XXTyVarBndr x :: Type #
Instances
type XXTyVarBndr (GhcPass _) | |
Defined in HsTypes |
type ForallXTyVarBndr (c :: Type -> Constraint) x = (c (XUserTyVar x), c (XKindedTyVar x), c (XXTyVarBndr x)) #
type family XConDeclField x :: Type #
Instances
type XConDeclField (GhcPass _) | |
Defined in HsTypes |
type family XXConDeclField x :: Type #
Instances
type XXConDeclField (GhcPass _) | |
Defined in HsTypes |
type ForallXConDeclField (c :: Type -> Constraint) x = (c (XConDeclField x), c (XXConDeclField x)) #
type family XCFieldOcc x :: Type #
Instances
type XCFieldOcc GhcPs | |
Defined in HsTypes | |
type XCFieldOcc GhcRn | |
Defined in HsTypes | |
type XCFieldOcc GhcTc | |
Defined in HsTypes |
type family XXFieldOcc x :: Type #
Instances
type XXFieldOcc (GhcPass _) | |
Defined in HsTypes |
type ForallXFieldOcc (c :: Type -> Constraint) x = (c (XCFieldOcc x), c (XXFieldOcc x)) #
type family XCImportDecl x :: Type #
Instances
type XCImportDecl (GhcPass _) | |
Defined in HsImpExp |
type family XXImportDecl x :: Type #
Instances
type XXImportDecl (GhcPass _) | |
Defined in HsImpExp |
type ForallXImportDecl (c :: Type -> Constraint) x = (c (XCImportDecl x), c (XXImportDecl x)) #
type family XIEThingAbs x :: Type #
Instances
type XIEThingAbs (GhcPass _) | |
Defined in HsImpExp |
type family XIEThingAll x :: Type #
Instances
type XIEThingAll (GhcPass _) | |
Defined in HsImpExp |
type family XIEThingWith x :: Type #
Instances
type XIEThingWith (GhcPass _) | |
Defined in HsImpExp |
type family XIEModuleContents x :: Type #
Instances
type XIEModuleContents (GhcPass _) | |
Defined in HsImpExp |
type family XIEDocNamed x :: Type #
Instances
type XIEDocNamed (GhcPass _) | |
Defined in HsImpExp |
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.
Instances
Convertable a a | |
Defined in HsExtension |
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
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
isExportedId :: Var -> Bool #
isExportedIdVar
means "don't throw this away"
isGlobalId :: Var -> Bool #
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] #
getAndRemoveAnnotation :: ApiAnns -> SrcSpan -> AnnKeywordId -> ([SrcSpan], ApiAnns) #
getAnnotation :: ApiAnns -> SrcSpan -> AnnKeywordId -> [SrcSpan] #
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
field of pm_annotations
.
Comments are only retained if ParsedModule
is set in
Opt_KeepRawTokenStream
before parsing.DynFlags
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
Instances
data AnnotationComment #
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
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
,
Unqual OccName | Unqualified name Used for ordinary, unqualified occurrences, e.g. |
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 |
Instances
Eq RdrName | |
Data RdrName | |
Defined in RdrName 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 | |
HasOccName RdrName | |
Outputable RdrName | |
OutputableBndr RdrName | |
Defined in RdrName pprBndr :: BindingSite -> RdrName -> SDoc # pprPrefixOcc :: RdrName -> SDoc # pprInfixOcc :: RdrName -> SDoc # bndrIsJoin_maybe :: RdrName -> Maybe Int # |
prettyPrintGhcErrors :: ExceptionMonad m => DynFlags -> m a -> m a #
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 | |
Defined in HsDoc (==) :: HsDocString -> HsDocString -> Bool # (/=) :: HsDocString -> HsDocString -> Bool # | |
Data HsDocString | |
Defined in HsDoc 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 | |
Defined in HsDoc showsPrec :: Int -> HsDocString -> ShowS # show :: HsDocString -> String # showList :: [HsDocString] -> ShowS # | |
Binary HsDocString | |
Defined in HsDoc put_ :: BinHandle -> HsDocString -> IO () # put :: BinHandle -> HsDocString -> IO (Bin HsDocString) # get :: BinHandle -> IO HsDocString # | |
Outputable HsDocString | |
Defined in HsDoc 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.
Instances
Binary DeclDocMap | |
Defined in HsDoc put_ :: BinHandle -> DeclDocMap -> IO () # put :: BinHandle -> DeclDocMap -> IO (Bin DeclDocMap) # get :: BinHandle -> IO DeclDocMap # | |
Outputable DeclDocMap | |
Defined in HsDoc ppr :: DeclDocMap -> SDoc # pprPrec :: Rational -> DeclDocMap -> SDoc # |
Docs for arguments. E.g. function arguments, method arguments.
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
Instances
NamedThing ClsInst | |
NamedThing FamInst | |
Defined in FamInstEnv | |
NamedThing IfaceDecl | |
NamedThing IfaceClassOp | |
Defined in IfaceSyn getOccName :: IfaceClassOp -> OccName # getName :: IfaceClassOp -> Name # | |
NamedThing IfaceConDecl | |
Defined in IfaceSyn getOccName :: IfaceConDecl -> OccName # getName :: IfaceConDecl -> Name # | |
NamedThing Class | |
NamedThing ConLike | |
NamedThing DataCon | |
NamedThing Var | |
NamedThing TyThing | |
NamedThing TyCon | |
NamedThing Name | |
NamedThing (CoAxiom br) | |
NamedThing e => NamedThing (GenLocated l e) | |
Defined in Name 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
Instances
Eq SafeHaskellMode | |
Defined in DynFlags (==) :: SafeHaskellMode -> SafeHaskellMode -> Bool # (/=) :: SafeHaskellMode -> SafeHaskellMode -> Bool # | |
Show SafeHaskellMode | |
Defined in DynFlags showsPrec :: Int -> SafeHaskellMode -> ShowS # show :: SafeHaskellMode -> String # showList :: [SafeHaskellMode] -> ShowS # | |
NFData SafeHaskellMode Source # | |
Defined in Development.IDE.GHC.Orphans rnf :: SafeHaskellMode -> () # | |
Outputable SafeHaskellMode | |
Defined in DynFlags ppr :: SafeHaskellMode -> SDoc # pprPrec :: Rational -> SafeHaskellMode -> SDoc # |
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].
HscC | Generate C code. |
HscAsm | Generate assembly using the native code generator. |
HscLlvm | Generate assembly using the llvm code generator. |
HscInterpreted | Generate bytecode. (Requires |
HscNothing | Don't generate any code. See notes above. |
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.
CompManager |
|
OneShot | ghc -c Foo.hs |
MkDepend |
|
What to do in the link step, if there is one.
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 |
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 #
negateFixity :: Fixity #
defaultFixity :: Fixity #
maxPrecedence :: Int #
Instances
Eq Fixity | |
Data Fixity | |
Defined in BasicTypes 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 | |
Outputable Fixity | |
data FixityDirection #
Instances
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.
Instances
Eq LexicalFixity | |
Defined in BasicTypes (==) :: LexicalFixity -> LexicalFixity -> Bool # (/=) :: LexicalFixity -> LexicalFixity -> Bool # | |
Data LexicalFixity | |
Defined in BasicTypes 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 | |
Defined in BasicTypes ppr :: LexicalFixity -> SDoc # pprPrec :: Rational -> LexicalFixity -> SDoc # |
data SuccessFlag #
Instances
Outputable SuccessFlag | |
Defined in BasicTypes ppr :: SuccessFlag -> SDoc # pprPrec :: Rational -> SuccessFlag -> SDoc # |
data SpliceExplicitFlag #
ExplicitSplice | = $(f x y) |
ImplicitSplice | = f x y, i.e. a naked top level expression |
Instances
Data SpliceExplicitFlag | |
Defined in BasicTypes 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 # |
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 |
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
cmpLocated :: Ord a => Located a -> Located a -> Ordering #
Tests the ordering of the two located things
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 #
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 #
Test if a SrcSpan
is "good", i.e. has precise location information
srcLocSpan :: SrcLoc -> SrcSpan #
Create a SrcSpan
corresponding to a single point
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
Built-in "bad" RealSrcLoc
values for particular locations
data RealSrcLoc #
Real Source Location
Represents a single point within a file
Instances
Eq RealSrcLoc | |
Defined in SrcLoc (==) :: RealSrcLoc -> RealSrcLoc -> Bool # (/=) :: RealSrcLoc -> RealSrcLoc -> Bool # | |
Ord RealSrcLoc | |
Defined in SrcLoc 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 | |
Defined in SrcLoc showsPrec :: Int -> RealSrcLoc -> ShowS # show :: RealSrcLoc -> String # showList :: [RealSrcLoc] -> ShowS # | |
Outputable RealSrcLoc | |
Defined in SrcLoc ppr :: RealSrcLoc -> SDoc # pprPrec :: Rational -> RealSrcLoc -> 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
Source Span
A SrcSpan
identifies either a specific portion of a text file
or a human-readable description of a location.
Instances
Eq SrcSpan | |
Data SrcSpan | |
Defined in SrcLoc 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 | |
Show SrcSpan | |
NFData SrcSpan | |
Binary SrcSpan | |
ToJson SrcSpan | |
Outputable SrcSpan | |
Show (GenLocated SrcSpan ModuleName) Source # | |
Defined in Development.IDE.GHC.Orphans showsPrec :: Int -> GenLocated SrcSpan ModuleName -> ShowS # show :: GenLocated SrcSpan ModuleName -> String # showList :: [GenLocated SrcSpan ModuleName] -> ShowS # | |
Binary a => Binary (GenLocated SrcSpan a) | |
HasSrcSpan (GenLocated SrcSpan a) Source # | |
Defined in Development.IDE.GHC.Compat |
data GenLocated l e #
We attach SrcSpans to lots of things, so let's have a datatype for it.
L l e |
Instances
Functor (GenLocated l) | |
Defined in SrcLoc fmap :: (a -> b) -> GenLocated l a -> GenLocated l b # (<$) :: a -> GenLocated l b -> GenLocated l a # | |
Foldable (GenLocated l) | |
Defined in SrcLoc 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) | |
Defined in SrcLoc 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) | |
Defined in SrcLoc (==) :: GenLocated l e -> GenLocated l e -> Bool # (/=) :: GenLocated l e -> GenLocated l e -> Bool # | |
(Data l, Data e) => Data (GenLocated l e) | |
Defined in SrcLoc 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) | |
Defined in SrcLoc 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 # | |
Defined in Development.IDE.GHC.Orphans 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 # | |
Defined in Development.IDE.GHC.Orphans rnf :: GenLocated l e -> () # | |
NamedThing e => NamedThing (GenLocated l e) | |
Defined in Name getOccName :: GenLocated l e -> OccName # getName :: GenLocated l e -> Name # | |
Binary a => Binary (GenLocated SrcSpan a) | |
(Outputable l, Outputable e) => Outputable (GenLocated l e) | |
Defined in SrcLoc ppr :: GenLocated l e -> SDoc # pprPrec :: Rational -> GenLocated l e -> SDoc # | |
HasSrcSpan (GenLocated SrcSpan a) Source # | |
Defined in Development.IDE.GHC.Compat |
type Located = GenLocated SrcSpan #
Instances
Data Type | |
Defined in TyCoRep 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 # 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 | |
Eq (DeBruijn 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"
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
.
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
data ModuleName #
A ModuleName is essentially a simple string, e.g. Data.List
.
Instances
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
isFunTyCon :: TyCon -> Bool #
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 | |
Data TyCon | |
Defined in TyCon 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 # 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 | |
Uniquable TyCon | |
Outputable TyCon | |
Contains not only a collection of GeneralFlag
s but also a plethora of
information relating to the compilation of a single file or GHC session
DynFlags | |
|
data GeneralFlag #
Enumerates the simple on-or-off dynamic flags
Instances
Enum GeneralFlag | |
Defined in DynFlags 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 | |
Defined in DynFlags (==) :: GeneralFlag -> GeneralFlag -> Bool # (/=) :: GeneralFlag -> GeneralFlag -> Bool # | |
Show GeneralFlag | |
Defined in DynFlags 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).
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 |
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 | |
Defined in Panic showsPrec :: Int -> GhcException -> ShowS # show :: GhcException -> String # showList :: [GhcException] -> ShowS # | |
Exception GhcException | |
Defined in Panic |
A unique, unambiguous name for something, containing information about where that thing originated.
Instances
Eq Name | |
Data Name | |
Defined in Name 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 # 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 See |
NFData Name | |
NamedThing Name | |
HasOccName Name | |
Binary Name | Assumes that the |
Uniquable Name | |
Outputable Name | |
OutputableBndr Name | |
Defined in Name pprBndr :: BindingSite -> Name -> SDoc # pprPrefixOcc :: Name -> SDoc # pprInfixOcc :: Name -> SDoc # bndrIsJoin_maybe :: Name -> Maybe Int # | |
HasSrcSpan Name Source # | |
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 #
coreModule :: DesugaredMod m => m -> ModGuts #
type Span = RealSrcSpan Source #
hieVersion :: Integer Source #
Current version of .hie
files
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.
HieFile | |
|
A flattened version of Type
.
See Note [Efficient serialization of redundant type info]
HTyVarTy Name | |
HAppTy a a | |
HTyConApp IfaceTyCon (HieArgs a) | |
HForAllTy ((Name, a), ArgFlag) a | |
HFunTy a a | |
HQualTy a a | type with constraint: |
HLitTy IfaceTyLit | |
HCastTy a | |
HCoercionTy |
Instances
Functor HieType Source # | |
Foldable HieType Source # | |
Defined in Development.IDE.GHC.HieTypes 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 # elem :: Eq a => a -> HieType a -> Bool # maximum :: Ord a => HieType a -> a # minimum :: Ord a => HieType a -> a # | |
Traversable HieType Source # | |
Eq a => Eq (HieType a) Source # | |
Binary (HieType TypeIndex) Source # | |
type HieTypeFlat = HieType TypeIndex Source #
A list of type arguments along with their respective visibilities (ie. is
this an argument that would return True
for isVisibleArgFlag
?).
Instances
Functor HieArgs Source # | |
Foldable HieArgs Source # | |
Defined in Development.IDE.GHC.HieTypes 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 # elem :: Eq a => a -> HieArgs a -> Bool # maximum :: Ord a => HieArgs a -> a # minimum :: Ord a => HieArgs a -> a # | |
Traversable HieArgs Source # | |
Eq a => Eq (HieArgs a) Source # | |
Binary (HieArgs TypeIndex) Source # | |
Mapping from filepaths (represented using FastString
) to the
corresponding AST
HieASTs | |
|
Instances
Functor HieASTs Source # | |
Foldable HieASTs Source # | |
Defined in Development.IDE.GHC.HieTypes 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 # elem :: Eq a => a -> HieASTs a -> Bool # maximum :: Ord a => HieASTs a -> a # minimum :: Ord a => HieASTs a -> a # | |
Traversable HieASTs Source # | |
Binary (HieASTs TypeIndex) Source # | |
Instances
Functor HieAST Source # | |
Foldable HieAST Source # | |
Defined in Development.IDE.GHC.HieTypes 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 # elem :: Eq a => a -> HieAST a -> Bool # maximum :: Ord a => HieAST a -> a # minimum :: Ord a => HieAST a -> a # | |
Traversable HieAST Source # | |
Binary (HieAST TypeIndex) 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]).
NodeInfo | |
|
Instances
Functor NodeInfo Source # | |
Foldable NodeInfo Source # | |
Defined in Development.IDE.GHC.HieTypes 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 # elem :: Eq a => a -> NodeInfo a -> Bool # maximum :: Ord a => NodeInfo a -> a # minimum :: Ord a => NodeInfo a -> a # | |
Traversable NodeInfo Source # | |
Binary (NodeInfo TypeIndex) Source # | |
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)
Instances
data ContextInfo Source #
Different contexts under which identifiers exist
Use | regular variable |
MatchBind | |
IEThing IEType | import/export |
TyDecl | |
ValBind | Value binding |
PatternBind | Pattern binding This case is tricky because the bound identifier can be used in two
distinct scopes. Consider the following example (with do (b, a, (a -> True)) <- bar foo a The identifier |
ClassTyDecl (Maybe Span) | |
Decl | Declaration |
TyVarBind Scope TyVarScope | Type variable |
RecField RecFieldContext (Maybe Span) | Record field |
Instances
Types of imports and exports
data RecFieldContext Source #
Instances
Instances
Enum BindType Source # | |
Defined in Development.IDE.GHC.HieTypes | |
Eq BindType Source # | |
Ord BindType Source # | |
Defined in Development.IDE.GHC.HieTypes | |
Show BindType Source # | |
Binary BindType Source # | |
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 # | |
Defined in Development.IDE.GHC.HieTypes | |
Eq DeclType Source # | |
Ord DeclType Source # | |
Defined in Development.IDE.GHC.HieTypes | |
Show DeclType Source # | |
Binary DeclType Source # | |
Instances
Eq Scope Source # | |
Data Scope Source # | |
Defined in Development.IDE.GHC.HieTypes 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 # 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 # | |
Show Scope Source # | |
Binary Scope Source # | |
Outputable Scope Source # | |
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
which later gets resolved into a UnresolvedScope
[foo, bar, baz] NothingResolvedScopes
.
ResolvedScopes [Scope] | |
UnresolvedScope | Unresolved scopes should never show up in the final |
Instances
Eq TyVarScope Source # | |
Defined in Development.IDE.GHC.HieTypes (==) :: TyVarScope -> TyVarScope -> Bool # (/=) :: TyVarScope -> TyVarScope -> Bool # | |
Ord TyVarScope Source # | |
Defined in Development.IDE.GHC.HieTypes 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 # | |
Defined in Development.IDE.GHC.HieTypes showsPrec :: Int -> TyVarScope -> ShowS # show :: TyVarScope -> String # showList :: [TyVarScope] -> ShowS # | |
Binary TyVarScope Source # | |
Defined in Development.IDE.GHC.HieTypes 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 #
foldType :: (HieType a -> a) -> HieTypeFix -> a Source #
hieTypeToIface :: HieTypeFix -> IfaceType Source #
data HieTypeState Source #
HTS | |
|
compressTypes :: HieASTs Type -> (HieASTs TypeIndex, Array TypeIndex HieTypeFlat) 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 #
getScopeFromContext :: ContextInfo -> Maybe [Scope] Source #
flattenAst :: HieAST a -> [HieAST a] Source #
definedInAsts :: Map FastString (HieAST a) -> Name -> Bool Source #
isOccurrence :: ContextInfo -> 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...).
simpleNodeInfo :: FastString -> FastString -> NodeInfo a Source #
:: (Applicative m, Data a) | |
=> a | helps fill in |
-> SrcSpan | return an empty list if this is unhelpful |
-> m [HieAST b] |
:: (Applicative m, Data a) | |
=> a | helps fill in |
-> SrcSpan | return an empty list if this is unhelpful |
-> Type | type to associate with the node |
-> m [HieAST Type] |