| Safe Haskell | Safe-Inferred |
|---|---|
| Language | GHC2021 |
Development.IDE.GHC.Compat.Core
Contents
- Session
- Linear Haskell
- Interface Files
- Fixity
- ModSummary
- HomeModInfo
- ModGuts
- ModDetails
- HsExpr,
- Var
- Specs
- SourceText
- Ways
- AvailInfo
- TcGblEnv
- Parsing and LExer types
- Compilation Main
- Typecheck utils
- Source Locations
- Finder
- Module and Package
- Linker
- Hooks
- HPT
- Driver-Make
- GHCi
- ModLocation
- DataCon
- Role
- Panic
- Other
- Util Module re-exports
- Syntax re-exports
Description
Compat Core module that handles the GHC module hierarchy re-organization by re-exporting everything we care about.
This module provides no other compat mechanisms, except for simple backward-compatible pattern synonyms.
Synopsis
- data DynFlags
- extensions :: DynFlags -> [OnOff Extension]
- extensionFlags :: DynFlags -> EnumSet Extension
- targetPlatform :: DynFlags -> Platform
- packageFlags :: DynFlags -> [PackageFlag]
- generalFlags :: DynFlags -> EnumSet GeneralFlag
- warningFlags :: DynFlags -> EnumSet WarningFlag
- topDir :: DynFlags -> FilePath
- hiDir :: DynFlags -> Maybe String
- tmpDir :: DynFlags -> TempDir
- importPaths :: DynFlags -> [FilePath]
- useColor :: DynFlags -> OverridingBool
- canUseColor :: DynFlags -> Bool
- useUnicode :: DynFlags -> Bool
- objectDir :: DynFlags -> Maybe String
- flagsForCompletion :: Bool -> [String]
- setImportPaths :: [FilePath] -> DynFlags -> DynFlags
- outputFile :: DynFlags -> Maybe String
- pluginModNames :: DynFlags -> [ModuleName]
- refLevelHoleFits :: DynFlags -> Maybe Int
- maxRefHoleFits :: DynFlags -> Maybe Int
- maxValidHoleFits :: DynFlags -> Maybe Int
- setOutputFile :: Maybe String -> DynFlags -> DynFlags
- lookupType :: HscEnv -> Name -> IO (Maybe TyThing)
- needWiredInHomeIface :: TyThing -> Bool
- loadWiredInHomeIface :: Name -> IfM lcl ()
- readIface :: DynFlags -> NameCache -> Module -> FilePath -> IO (MaybeErr SDoc ModIface)
- loadSysInterface :: SDoc -> Module -> IfM lcl ModIface
- importDecl :: Name -> IfM lcl (MaybeErr SDoc TyThing)
- type CommandLineOption = String
- sPgm_F :: Settings -> String
- settings :: DynFlags -> Settings
- gopt :: GeneralFlag -> DynFlags -> Bool
- gopt_set :: DynFlags -> GeneralFlag -> DynFlags
- gopt_unset :: DynFlags -> GeneralFlag -> DynFlags
- wopt :: WarningFlag -> DynFlags -> Bool
- wopt_set :: DynFlags -> WarningFlag -> DynFlags
- xFlags :: [FlagSpec Extension]
- xopt :: Extension -> DynFlags -> Bool
- xopt_unset :: DynFlags -> Extension -> DynFlags
- xopt_set :: DynFlags -> Extension -> DynFlags
- data FlagSpec flag = FlagSpec {
- flagSpecName :: String
- flagSpecFlag :: flag
- flagSpecAction :: TurnOnFlag -> DynP ()
- flagSpecGhcMode :: GhcFlagMode
- data WarningFlag
- = Opt_WarnDuplicateExports
- | Opt_WarnDuplicateConstraints
- | Opt_WarnRedundantConstraints
- | Opt_WarnHiShadows
- | Opt_WarnImplicitPrelude
- | Opt_WarnIncompletePatterns
- | Opt_WarnIncompleteUniPatterns
- | Opt_WarnIncompletePatternsRecUpd
- | Opt_WarnOverflowedLiterals
- | Opt_WarnEmptyEnumerations
- | Opt_WarnMissingFields
- | Opt_WarnMissingImportList
- | Opt_WarnMissingMethods
- | Opt_WarnMissingSignatures
- | Opt_WarnMissingLocalSignatures
- | Opt_WarnNameShadowing
- | Opt_WarnOverlappingPatterns
- | Opt_WarnTypeDefaults
- | Opt_WarnMonomorphism
- | Opt_WarnUnusedTopBinds
- | Opt_WarnUnusedLocalBinds
- | Opt_WarnUnusedPatternBinds
- | Opt_WarnUnusedImports
- | Opt_WarnUnusedMatches
- | Opt_WarnUnusedTypePatterns
- | Opt_WarnUnusedForalls
- | Opt_WarnUnusedRecordWildcards
- | Opt_WarnRedundantBangPatterns
- | Opt_WarnRedundantRecordWildcards
- | Opt_WarnWarningsDeprecations
- | Opt_WarnDeprecatedFlags
- | Opt_WarnMissingMonadFailInstances
- | Opt_WarnSemigroup
- | Opt_WarnDodgyExports
- | Opt_WarnDodgyImports
- | Opt_WarnOrphans
- | Opt_WarnAutoOrphans
- | Opt_WarnIdentities
- | Opt_WarnTabs
- | Opt_WarnUnrecognisedPragmas
- | Opt_WarnMisplacedPragmas
- | Opt_WarnDodgyForeignImports
- | Opt_WarnUnusedDoBind
- | Opt_WarnWrongDoBind
- | Opt_WarnAlternativeLayoutRuleTransitional
- | Opt_WarnUnsafe
- | Opt_WarnSafe
- | Opt_WarnTrustworthySafe
- | Opt_WarnMissedSpecs
- | Opt_WarnAllMissedSpecs
- | Opt_WarnUnsupportedCallingConventions
- | Opt_WarnUnsupportedLlvmVersion
- | Opt_WarnMissedExtraSharedLib
- | Opt_WarnInlineRuleShadowing
- | Opt_WarnTypedHoles
- | Opt_WarnPartialTypeSignatures
- | Opt_WarnMissingExportedSignatures
- | Opt_WarnUntickedPromotedConstructors
- | Opt_WarnDerivingTypeable
- | Opt_WarnDeferredTypeErrors
- | Opt_WarnDeferredOutOfScopeVariables
- | Opt_WarnNonCanonicalMonadInstances
- | Opt_WarnNonCanonicalMonadFailInstances
- | Opt_WarnNonCanonicalMonoidInstances
- | Opt_WarnMissingPatternSynonymSignatures
- | Opt_WarnUnrecognisedWarningFlags
- | Opt_WarnSimplifiableClassConstraints
- | Opt_WarnCPPUndef
- | Opt_WarnUnbangedStrictPatterns
- | Opt_WarnMissingHomeModules
- | Opt_WarnPartialFields
- | Opt_WarnMissingExportList
- | Opt_WarnInaccessibleCode
- | Opt_WarnStarIsType
- | Opt_WarnStarBinder
- | Opt_WarnImplicitKindVars
- | Opt_WarnSpaceAfterBang
- | Opt_WarnMissingDerivingStrategies
- | Opt_WarnPrepositiveQualifiedModule
- | Opt_WarnUnusedPackages
- | Opt_WarnInferredSafeImports
- | Opt_WarnMissingSafeHaskellMode
- | Opt_WarnCompatUnqualifiedImports
- | Opt_WarnDerivingDefaults
- | Opt_WarnInvalidHaddock
- | Opt_WarnOperatorWhitespaceExtConflict
- | Opt_WarnOperatorWhitespace
- | Opt_WarnAmbiguousFields
- | Opt_WarnImplicitLift
- | Opt_WarnMissingKindSignatures
- | Opt_WarnMissingExportedPatternSynonymSignatures
- | Opt_WarnRedundantStrictnessFlags
- | Opt_WarnForallIdentifier
- | Opt_WarnUnicodeBidirectionalFormatCharacters
- | Opt_WarnGADTMonoLocalBinds
- | Opt_WarnTypeEqualityOutOfScope
- | Opt_WarnTypeEqualityRequiresOperators
- | Opt_WarnLoopySuperclassSolve
- data GeneralFlag
- = Opt_DumpToFile
- | Opt_DumpWithWays
- | Opt_D_dump_minimal_imports
- | Opt_DoCoreLinting
- | Opt_DoLinearCoreLinting
- | Opt_DoStgLinting
- | Opt_DoCmmLinting
- | Opt_DoAsmLinting
- | Opt_DoAnnotationLinting
- | Opt_DoBoundsChecking
- | Opt_NoLlvmMangler
- | Opt_FastLlvm
- | Opt_NoTypeableBinds
- | Opt_DistinctConstructorTables
- | Opt_InfoTableMap
- | Opt_InfoTableMapWithFallback
- | Opt_InfoTableMapWithStack
- | Opt_WarnIsError
- | Opt_ShowWarnGroups
- | Opt_HideSourcePaths
- | Opt_PrintExplicitForalls
- | Opt_PrintExplicitKinds
- | Opt_PrintExplicitCoercions
- | Opt_PrintExplicitRuntimeReps
- | Opt_PrintEqualityRelations
- | Opt_PrintAxiomIncomps
- | Opt_PrintUnicodeSyntax
- | Opt_PrintExpandedSynonyms
- | Opt_PrintPotentialInstances
- | Opt_PrintRedundantPromotionTicks
- | Opt_PrintTypecheckerElaboration
- | Opt_CallArity
- | Opt_Exitification
- | Opt_Strictness
- | Opt_LateDmdAnal
- | Opt_KillAbsence
- | Opt_KillOneShot
- | Opt_FullLaziness
- | Opt_FloatIn
- | Opt_LocalFloatOut
- | Opt_LocalFloatOutTopLevel
- | Opt_LateSpecialise
- | Opt_Specialise
- | Opt_SpecialiseAggressively
- | Opt_CrossModuleSpecialise
- | Opt_PolymorphicSpecialisation
- | Opt_InlineGenerics
- | Opt_InlineGenericsAggressively
- | Opt_StaticArgumentTransformation
- | Opt_CSE
- | Opt_StgCSE
- | Opt_StgLiftLams
- | 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_EnableThSpliceWarnings
- | Opt_RegsGraph
- | Opt_RegsIterative
- | Opt_PedanticBottoms
- | Opt_LlvmTBAA
- | Opt_LlvmFillUndefWithGarbage
- | Opt_IrrefutableTuples
- | Opt_CmmSink
- | Opt_CmmStaticPred
- | Opt_CmmElimCommonBlocks
- | Opt_CmmControlFlow
- | Opt_AsmShortcutting
- | Opt_OmitYields
- | Opt_FunToThunk
- | Opt_DictsStrict
- | Opt_DmdTxDictSel
- | Opt_Loopification
- | Opt_CfgBlocklayout
- | Opt_WeightlessBlocklayout
- | Opt_CprAnal
- | Opt_WorkerWrapper
- | Opt_WorkerWrapperUnlift
- | Opt_SolveConstantDicts
- | Opt_AlignmentSanitisation
- | Opt_CatchNonexhaustiveCases
- | Opt_NumConstantFolding
- | Opt_CoreConstantFolding
- | Opt_FastPAPCalls
- | Opt_DoTagInferenceChecks
- | Opt_SimplPreInlining
- | Opt_IgnoreInterfacePragmas
- | Opt_OmitInterfacePragmas
- | Opt_ExposeAllUnfoldings
- | Opt_WriteInterface
- | Opt_WriteHie
- | Opt_AutoSccsOnIndividualCafs
- | Opt_ProfCountEntries
- | Opt_ProfLateInlineCcs
- | Opt_ProfLateCcs
- | Opt_ProfManualCcs
- | Opt_Pp
- | Opt_ForceRecomp
- | Opt_IgnoreOptimChanges
- | Opt_IgnoreHpcChanges
- | Opt_ExcessPrecision
- | Opt_EagerBlackHoling
- | Opt_NoHsMain
- | 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_ValidateHie
- | Opt_LocalGhciHistory
- | Opt_NoIt
- | Opt_HelpfulErrors
- | Opt_DeferTypeErrors
- | Opt_DeferTypedHoles
- | Opt_DeferOutOfScopeVariables
- | Opt_PIC
- | Opt_PIE
- | Opt_PICExecutable
- | Opt_ExternalDynamicRefs
- | Opt_Ticky
- | Opt_Ticky_Allocd
- | Opt_Ticky_LNE
- | Opt_Ticky_Dyn_Thunk
- | Opt_Ticky_Tag
- | Opt_Ticky_AP
- | Opt_CmmThreadSanitizer
- | Opt_RPath
- | Opt_RelativeDynlibPaths
- | Opt_CompactUnwind
- | Opt_Hpc
- | Opt_FamAppCache
- | Opt_ExternalInterpreter
- | Opt_OptimalApplicativeDo
- | Opt_VersionMacros
- | Opt_WholeArchiveHsLibs
- | Opt_SingleLibFolder
- | Opt_ExposeInternalSymbols
- | Opt_KeepCAFs
- | Opt_KeepGoing
- | Opt_ByteCode
- | Opt_ByteCodeAndObjectCode
- | Opt_LinkRts
- | Opt_ErrorSpans
- | Opt_DeferDiagnostics
- | 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_ShowDocsOfHoleFits
- | Opt_ShowTypeOfHoleFits
- | Opt_ShowProvOfHoleFits
- | Opt_ShowMatchesOfHoleFits
- | Opt_ShowLoadedModules
- | Opt_HexWordLiterals
- | Opt_SuppressCoercions
- | Opt_SuppressCoercionTypes
- | Opt_SuppressVarKinds
- | Opt_SuppressModulePrefixes
- | Opt_SuppressTypeApplications
- | Opt_SuppressIdInfo
- | Opt_SuppressUnfoldings
- | Opt_SuppressTypeSignatures
- | Opt_SuppressUniques
- | Opt_SuppressStgExts
- | Opt_SuppressStgReps
- | Opt_SuppressTicks
- | Opt_SuppressTimestamps
- | Opt_SuppressCoreSizes
- | Opt_ShowErrorContext
- | Opt_AutoLinkPackages
- | Opt_ImplicitImportQualified
- | Opt_KeepHscppFiles
- | Opt_KeepHiDiffs
- | Opt_KeepHcFiles
- | Opt_KeepSFiles
- | Opt_KeepTmpFiles
- | Opt_KeepRawTokenStream
- | Opt_KeepLlvmFiles
- | Opt_KeepHiFiles
- | Opt_KeepOFiles
- | Opt_BuildDynamicToo
- | Opt_WriteIfSimplifiedCore
- | Opt_UseBytecodeRatherThanObjects
- | Opt_DistrustAllPackages
- | Opt_PackageTrust
- | Opt_PluginTrustworthy
- | Opt_G_NoStateHack
- | Opt_G_NoOptCoercion
- data PackageFlag
- data PackageArg
- data ModRenaming = ModRenaming {}
- pattern ExposePackage :: String -> PackageArg -> ModRenaming -> PackageFlag
- parseDynamicFlagsCmdLine :: MonadIO m => DynFlags -> [Located String] -> m (DynFlags, [Located String], [Warn])
- parseDynamicFilePragma :: MonadIO m => DynFlags -> [Located String] -> m (DynFlags, [Located String], [Warn])
- wWarningFlags :: [FlagSpec WarningFlag]
- updOptLevel :: Int -> DynFlags -> DynFlags
- setUnsafeGlobalDynFlags :: DynFlags -> IO ()
- scaledThing :: Scaled a -> a
- type IfaceExport = AvailInfo
- data IfaceTyCon = IfaceTyCon {}
- type ModIface = ModIface_ 'ModIfaceFinal
- data ModIface_ (phase :: ModIfacePhase) = ModIface {
- mi_module :: !Module
- mi_sig_of :: !(Maybe Module)
- mi_hsc_src :: !HscSource
- mi_deps :: Dependencies
- mi_usages :: [Usage]
- mi_exports :: ![IfaceExport]
- mi_used_th :: !Bool
- mi_fixities :: [(OccName, Fixity)]
- mi_warns :: Warnings GhcRn
- mi_anns :: [IfaceAnnotation]
- mi_decls :: [IfaceDeclExts phase]
- mi_extra_decls :: Maybe [IfaceBindingX IfaceMaybeRhs IfaceTopBndrInfo]
- mi_globals :: !(Maybe GlobalRdrEnv)
- mi_insts :: [IfaceClsInst]
- mi_fam_insts :: [IfaceFamInst]
- mi_rules :: [IfaceRule]
- mi_hpc :: !AnyHpcUsage
- mi_trust :: !IfaceTrustInfo
- mi_trust_pkg :: !Bool
- mi_complete_matches :: ![IfaceCompleteMatch]
- mi_docs :: !(Maybe Docs)
- mi_final_exts :: !(IfaceBackendExts phase)
- mi_ext_fields :: !ExtensibleFields
- mi_src_hash :: !Fingerprint
- data HscSource
- data WhereFrom
- loadInterface :: SDoc -> Module -> WhereFrom -> IfM lcl (MaybeErr SDoc ModIface)
- loadModuleInterface :: SDoc -> Module -> TcM ModIface
- data RecompileRequired
- mkPartialIface :: HscEnv -> CoreProgram -> ModDetails -> ModSummary -> ModGuts -> PartialModIface
- mkFullIface :: HscEnv -> PartialModIface -> Maybe StgCgInfos -> Maybe CmmCgInfos -> IO ModIface
- data IsBootInterface
- data LexicalFixity
- data Fixity = Fixity SourceText Int FixityDirection
- mi_fix :: ModIface -> OccName -> Fixity
- defaultFixity :: Fixity
- lookupFixityRn :: Name -> RnM Fixity
- data ModSummary = ModSummary {
- ms_mod :: Module
- ms_hsc_src :: HscSource
- ms_location :: ModLocation
- ms_hs_hash :: Fingerprint
- ms_obj_date :: Maybe UTCTime
- ms_dyn_obj_date :: !(Maybe UTCTime)
- ms_iface_date :: Maybe UTCTime
- ms_hie_date :: Maybe UTCTime
- ms_srcimps :: [(PkgQual, Located ModuleName)]
- ms_textual_imps :: [(PkgQual, Located ModuleName)]
- ms_ghc_prim_import :: !Bool
- ms_parsed_mod :: Maybe HsParsedModule
- ms_hspp_file :: FilePath
- ms_hspp_opts :: DynFlags
- ms_hspp_buf :: Maybe StringBuffer
- data HomeModInfo = HomeModInfo {}
- data ModGuts = ModGuts {
- mg_module :: !Module
- mg_hsc_src :: HscSource
- mg_loc :: SrcSpan
- mg_exports :: ![AvailInfo]
- mg_deps :: !Dependencies
- mg_usages :: ![Usage]
- mg_used_th :: !Bool
- mg_rdr_env :: !GlobalRdrEnv
- mg_fix_env :: !FixityEnv
- mg_tcs :: ![TyCon]
- mg_insts :: ![ClsInst]
- mg_fam_insts :: ![FamInst]
- mg_patsyns :: ![PatSyn]
- mg_rules :: ![CoreRule]
- mg_binds :: !CoreProgram
- mg_foreign :: !ForeignStubs
- mg_foreign_files :: ![(ForeignSrcLang, FilePath)]
- mg_warns :: !(Warnings GhcRn)
- mg_anns :: [Annotation]
- mg_complete_matches :: [CompleteMatch]
- mg_hpc_info :: !HpcInfo
- mg_modBreaks :: !(Maybe ModBreaks)
- mg_inst_env :: InstEnv
- mg_fam_inst_env :: FamInstEnv
- mg_boot_exports :: !NameSet
- mg_safe_haskell :: SafeHaskellMode
- mg_trust_pkg :: Bool
- mg_docs :: !(Maybe Docs)
- data CgGuts = CgGuts {
- cg_module :: !Module
- cg_tycons :: [TyCon]
- cg_binds :: CoreProgram
- cg_ccs :: [CostCentre]
- cg_foreign :: !ForeignStubs
- cg_foreign_files :: ![(ForeignSrcLang, FilePath)]
- cg_dep_pkgs :: !(Set UnitId)
- cg_hpc_info :: !HpcInfo
- cg_modBreaks :: !(Maybe ModBreaks)
- cg_spt_entries :: [SptEntry]
- data ModDetails = ModDetails {
- md_exports :: [AvailInfo]
- md_types :: !TypeEnv
- md_insts :: InstEnv
- md_fam_insts :: ![FamInst]
- md_rules :: ![CoreRule]
- md_anns :: ![Annotation]
- md_complete_matches :: [CompleteMatch]
- data Type
- pattern FunTy :: FunTyFlag -> Type -> Type -> Type
- pattern ConPatIn :: Located (ConLikeP GhcPs) -> HsConPatDetails GhcPs -> Pat GhcPs
- conPatDetails :: Pat p -> Maybe (HsConPatDetails p)
- mapConPatDetail :: (HsConPatDetails p -> Maybe (HsConPatDetails p)) -> Pat p -> Maybe (Pat p)
- mkVisFunTys :: [Scaled Type] -> Type -> Type
- data ImpDeclSpec = ImpDeclSpec {
- is_mod :: ModuleName
- is_as :: ModuleName
- is_qual :: Bool
- is_dloc :: SrcSpan
- data ImportSpec = ImpSpec {}
- data SourceText
- data Way
- wayGeneralFlags :: Platform -> Way -> [GeneralFlag]
- wayUnsetGeneralFlags :: Platform -> Way -> [GeneralFlag]
- data AvailInfo
- pattern AvailName :: Name -> AvailInfo
- pattern AvailFL :: FieldLabel -> AvailInfo
- pattern AvailTC :: Name -> [Name] -> [FieldLabel] -> AvailInfo
- availName :: AvailInfo -> Name
- availNames :: AvailInfo -> [Name]
- availNamesWithSelectors :: AvailInfo -> [Name]
- availsToNameSet :: [AvailInfo] -> NameSet
- data TcGblEnv = TcGblEnv {
- tcg_mod :: Module
- tcg_semantic_mod :: Module
- tcg_src :: HscSource
- tcg_rdr_env :: GlobalRdrEnv
- tcg_default :: Maybe [Type]
- tcg_fix_env :: FixityEnv
- tcg_field_env :: RecFieldEnv
- tcg_type_env :: TypeEnv
- tcg_type_env_var :: KnotVars (IORef TypeEnv)
- tcg_inst_env :: !InstEnv
- tcg_fam_inst_env :: !FamInstEnv
- tcg_ann_env :: AnnEnv
- tcg_exports :: [AvailInfo]
- tcg_imports :: ImportAvails
- tcg_dus :: DefUses
- tcg_used_gres :: TcRef [GlobalRdrElt]
- tcg_keep :: TcRef NameSet
- tcg_th_used :: TcRef Bool
- tcg_th_splice_used :: TcRef Bool
- tcg_th_needed_deps :: TcRef ([Linkable], PkgsLoaded)
- tcg_dfun_n :: TcRef OccSet
- tcg_merged :: [(Module, Fingerprint)]
- tcg_rn_exports :: Maybe [(LIE GhcRn, Avails)]
- tcg_rn_imports :: [LImportDecl GhcRn]
- tcg_rn_decls :: Maybe (HsGroup GhcRn)
- tcg_dependent_files :: TcRef [FilePath]
- tcg_th_topdecls :: TcRef [LHsDecl GhcPs]
- tcg_th_foreign_files :: TcRef [(ForeignSrcLang, FilePath)]
- tcg_th_topnames :: TcRef NameSet
- tcg_th_modfinalizers :: TcRef [(TcLclEnv, ThModFinalizers)]
- tcg_th_coreplugins :: TcRef [String]
- tcg_th_state :: TcRef (Map TypeRep Dynamic)
- tcg_th_remote_state :: TcRef (Maybe (ForeignRef (IORef QState)))
- tcg_th_docs :: TcRef THDocs
- tcg_ev_binds :: Bag EvBind
- tcg_tr_module :: Maybe Id
- tcg_binds :: LHsBinds GhcTc
- tcg_sigs :: NameSet
- tcg_imp_specs :: [LTcSpecPrag]
- tcg_warns :: Warnings GhcRn
- tcg_anns :: [Annotation]
- tcg_tcs :: [TyCon]
- tcg_ksigs :: NameSet
- tcg_insts :: [ClsInst]
- tcg_fam_insts :: [FamInst]
- tcg_rules :: [LRuleDecl GhcTc]
- tcg_fords :: [LForeignDecl GhcTc]
- tcg_patsyns :: [PatSyn]
- tcg_doc_hdr :: Maybe (LHsDoc GhcRn)
- tcg_hpc :: !AnyHpcUsage
- tcg_self_boot :: SelfBootInfo
- tcg_main :: Maybe Name
- tcg_safe_infer :: TcRef Bool
- tcg_safe_infer_reasons :: TcRef (Messages TcRnMessage)
- tcg_tc_plugin_solvers :: [TcPluginSolver]
- tcg_tc_plugin_rewriters :: UniqFM TyCon [TcPluginRewriter]
- tcg_defaulting_plugins :: [FillDefaulting]
- tcg_hf_plugins :: [HoleFitPlugin]
- tcg_top_loc :: RealSrcSpan
- tcg_static_wc :: TcRef WantedConstraints
- tcg_complete_matches :: !CompleteMatches
- tcg_cc_st :: TcRef CostCentreState
- tcg_next_wrapper_num :: TcRef (ModuleEnv Int)
- data HsModule p
- = HsModule {
- hsmodExt :: XCModule p
- hsmodName :: Maybe (XRec p ModuleName)
- hsmodExports :: Maybe (XRec p [LIE p])
- hsmodImports :: [LImportDecl p]
- hsmodDecls :: [LHsDecl p]
- | XModule !(XXModule p)
- = HsModule {
- type ParsedSource = Located (HsModule GhcPs)
- type RenamedSource = (HsGroup GhcRn, [LImportDecl GhcRn], Maybe [(LIE GhcRn, Avails)], Maybe (LHsDoc GhcRn))
- data HscEnv
- runGhc :: Maybe FilePath -> Ghc a -> IO a
- unGhc :: Ghc a -> Session -> IO a
- data Session = Session !(IORef HscEnv)
- modifySession :: GhcMonad m => (HscEnv -> HscEnv) -> m ()
- getSession :: GhcMonad m => m HscEnv
- setSessionDynFlags :: (HasCallStack, GhcMonad m) => DynFlags -> m ()
- getSessionDynFlags :: GhcMonad m => m DynFlags
- class (Functor m, ExceptionMonad m, HasDynFlags m, HasLogger m) => GhcMonad (m :: Type -> Type)
- data Ghc a
- runHsc :: HscEnv -> Hsc a -> IO a
- compileFile :: HscEnv -> StopPhase -> (FilePath, Maybe Phase) -> IO (Maybe FilePath)
- data Phase
- hscDesugar :: HscEnv -> ModSummary -> TcGblEnv -> IO ModGuts
- hscGenHardCode :: HscEnv -> CgGuts -> ModLocation -> FilePath -> IO (FilePath, Maybe FilePath, [(ForeignSrcLang, FilePath)], Maybe StgCgInfos, Maybe CmmCgInfos)
- hscInteractive :: HscEnv -> CgInteractiveGuts -> ModLocation -> IO (Maybe FilePath, CompiledByteCode, [SptEntry])
- hscSimplify :: HscEnv -> [String] -> ModGuts -> IO ModGuts
- hscTypecheckRename :: HscEnv -> ModSummary -> HsParsedModule -> IO (TcGblEnv, RenamedStuff)
- hscUpdateHPT :: (HomePackageTable -> HomePackageTable) -> HscEnv -> HscEnv
- makeSimpleDetails :: HscEnv -> TcGblEnv -> IO ModDetails
- tcSplitForAllTyVars :: Type -> ([TyVar], Type)
- tcSplitForAllTyVarBinder_maybe :: Type -> Maybe (TyVarBinder, Type)
- typecheckIface :: ModIface -> IfG ModDetails
- mkIfaceTc :: HscEnv -> SafeHaskellMode -> ModDetails -> ModSummary -> Maybe CoreProgram -> TcGblEnv -> IO ModIface
- mkBootModDetailsTc :: HscEnv -> TcGblEnv -> IO ModDetails
- initTidyOpts :: HscEnv -> IO TidyOpts
- driverNoStop :: StopPhase
- tidyProgram :: TidyOpts -> ModGuts -> IO (CgGuts, ModDetails)
- data ImportedModsVal = ImportedModsVal {}
- importedByUser :: [ImportedBy] -> [ImportedModsVal]
- type TypecheckedSource = LHsBinds GhcTc
- class HasSrcSpan a
- type Located = GenLocated SrcSpan
- unLoc :: GenLocated l e -> e
- getLoc :: HasSrcSpan a => a -> SrcSpan
- getLocA :: GenLocated (SrcSpanAnn' a) e -> SrcSpan
- locA :: SrcSpanAnn' a -> SrcSpan
- noLocA :: a -> LocatedAn an a
- unLocA :: forall pass a. XRec (GhcPass pass) a -> a
- type LocatedAn a = LocatedAn a
- type LocatedA = GenLocated SrcSpanAnnA
- data AnnListItem = AnnListItem {
- lann_trailing :: [TrailingAnn]
- data NameAnn
- = NameAnn { }
- | NameAnnCommas { }
- | NameAnnBars { }
- | NameAnnOnly { }
- | NameAnnRArrow { }
- | NameAnnQuote { }
- | NameAnnTrailing {
- nann_trailing :: [TrailingAnn]
- type RealLocated = GenLocated RealSrcSpan
- data GenLocated l e = L l e
- data SrcSpan = UnhelpfulSpan !UnhelpfulSpanReason
- data RealSrcSpan
- pattern RealSrcSpan :: RealSrcSpan -> Maybe BufSpan -> SrcSpan
- data RealSrcLoc
- pattern RealSrcLoc :: RealSrcLoc -> Maybe BufPos -> SrcLoc
- data SrcLoc = UnhelpfulLoc !FastString
- data BufSpan
- type SrcAnn ann = SrcSpanAnn' (EpAnn ann)
- leftmost_smallest :: SrcSpan -> SrcSpan -> Ordering
- containsSpan :: RealSrcSpan -> RealSrcSpan -> Bool
- mkGeneralSrcSpan :: FastString -> SrcSpan
- mkRealSrcSpan :: RealSrcLoc -> RealSrcLoc -> RealSrcSpan
- mkRealSrcLoc :: FastString -> Int -> Int -> RealSrcLoc
- getRealSrcSpan :: RealLocated a -> RealSrcSpan
- realSrcLocSpan :: RealSrcLoc -> RealSrcSpan
- realSrcSpanStart :: RealSrcSpan -> RealSrcLoc
- realSrcSpanEnd :: RealSrcSpan -> RealSrcLoc
- isSubspanOfA :: LocatedAn la a -> LocatedAn lb b -> Bool
- isSubspanOf :: SrcSpan -> SrcSpan -> Bool
- wiredInSrcSpan :: SrcSpan
- mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan
- srcSpanStart :: SrcSpan -> SrcLoc
- srcSpanStartLine :: RealSrcSpan -> Int
- srcSpanStartCol :: RealSrcSpan -> Int
- srcSpanEnd :: SrcSpan -> SrcLoc
- srcSpanEndLine :: RealSrcSpan -> Int
- srcSpanEndCol :: RealSrcSpan -> Int
- srcSpanFile :: RealSrcSpan -> FastString
- srcLocCol :: RealSrcLoc -> Int
- srcLocFile :: RealSrcLoc -> FastString
- srcLocLine :: RealSrcLoc -> Int
- noSrcSpan :: SrcSpan
- noSrcLoc :: SrcLoc
- noLoc :: e -> Located e
- mapLoc :: (a -> b) -> GenLocated l a -> GenLocated l b
- data FindResult
- = Found ModLocation Module
- | NoPackage Unit
- | FoundMultiple [(Module, ModuleOrigin)]
- | NotFound {
- fr_paths :: [FilePath]
- fr_pkg :: Maybe Unit
- fr_mods_hidden :: [Unit]
- fr_pkgs_hidden :: [Unit]
- fr_unusables :: [(Unit, UnusableUnitReason)]
- fr_suggestions :: [ModuleSuggestion]
- mkHomeModLocation :: DynFlags -> ModuleName -> FilePath -> IO ModLocation
- findObjectLinkableMaybe :: Module -> ModLocation -> IO (Maybe Linkable)
- data InstalledFindResult
- data ModuleOrigin
- newtype PackageName = PackageName {}
- data Unlinked
- data Linkable = LM {
- linkableTime :: !UTCTime
- linkableModule :: !Module
- linkableUnlinked :: [Unlinked]
- unload :: HscEnv -> [Linkable] -> IO ()
- data Hooks
- runMetaHook :: Hooks -> Maybe (MetaHook TcM)
- type MetaHook (f :: Type -> Type) = MetaRequest -> LHsExpr GhcTc -> f MetaResult
- data MetaRequest
- = MetaE (LHsExpr GhcPs -> MetaResult)
- | MetaP (LPat GhcPs -> MetaResult)
- | MetaT (LHsType GhcPs -> MetaResult)
- | MetaD ([LHsDecl GhcPs] -> MetaResult)
- | MetaAW (Serialized -> MetaResult)
- metaRequestE :: Functor f => MetaHook f -> LHsExpr GhcTc -> f (LHsExpr GhcPs)
- metaRequestP :: Functor f => MetaHook f -> LHsExpr GhcTc -> f (LPat GhcPs)
- metaRequestT :: Functor f => MetaHook f -> LHsExpr GhcTc -> f (LHsType GhcPs)
- metaRequestD :: Functor f => MetaHook f -> LHsExpr GhcTc -> f [LHsDecl GhcPs]
- metaRequestAW :: Functor f => MetaHook f -> LHsExpr GhcTc -> f Serialized
- addToHpt :: HomePackageTable -> ModuleName -> HomeModInfo -> HomePackageTable
- addListToHpt :: HomePackageTable -> [(ModuleName, HomeModInfo)] -> HomePackageTable
- data Target = Target {
- targetId :: !TargetId
- targetAllowObjCode :: !Bool
- targetUnitId :: !UnitId
- targetContents :: !(Maybe (InputFileBuffer, UTCTime))
- data TargetId
- = TargetModule !ModuleName
- | TargetFile !FilePath !(Maybe Phase)
- mkSimpleTarget :: DynFlags -> FilePath -> Target
- initObjLinker :: HscEnv -> IO ()
- loadDLL :: HscEnv -> String -> IO (Maybe String)
- data InteractiveImport
- getContext :: GhcMonad m => m [InteractiveImport]
- setContext :: GhcMonad m => [InteractiveImport] -> m ()
- parseImportDecl :: GhcMonad m => String -> m (ImportDecl GhcPs)
- runDecls :: GhcMonad m => String -> m [Name]
- data Warn = Warn {}
- data ModLocation
- ml_hs_file :: ModLocation -> Maybe FilePath
- ml_obj_file :: ModLocation -> FilePath
- ml_hi_file :: ModLocation -> FilePath
- ml_hie_file :: ModLocation -> FilePath
- dataConExTyCoVars :: DataCon -> [TyCoVar]
- data Role
- data PlainGhcException
- data CoreModule = CoreModule {
- cm_module :: !Module
- cm_types :: !TypeEnv
- cm_binds :: CoreProgram
- cm_safe :: SafeHaskellMode
- data SafeHaskellMode
- pattern GRE :: Name -> Parent -> Bool -> [ImportSpec] -> GlobalRdrElt
- gre_name :: GlobalRdrElt -> Name
- gre_imp :: GlobalRdrElt -> [ImportSpec]
- gre_lcl :: GlobalRdrElt -> Bool
- gre_par :: GlobalRdrElt -> Parent
- collectHsBindsBinders :: CollectPass p => Bag (XRec p (HsBindLR p idR)) -> [IdP p]
- class Uniquable a where
- hasKey :: Uniquable a => a -> Unique -> Bool
- allNameStrings :: Infinite String
- allNameStringList :: [String]
- itName :: Unique -> SrcSpan -> Name
- mkUnboundName :: OccName -> Name
- isUnboundName :: Name -> Bool
- basicKnownKeyNames :: [Name]
- genericTyConNames :: [Name]
- pRELUDE :: Module
- gHC_PRIM :: Module
- gHC_PRIM_PANIC :: Module
- gHC_TYPES :: Module
- gHC_MAGIC :: Module
- gHC_MAGIC_DICT :: Module
- gHC_CSTRING :: Module
- gHC_CLASSES :: Module
- gHC_PRIMOPWRAPPERS :: Module
- gHC_BASE :: Module
- gHC_ENUM :: Module
- gHC_GHCI :: Module
- gHC_GHCI_HELPERS :: Module
- gHC_SHOW :: Module
- gHC_READ :: Module
- gHC_NUM :: Module
- gHC_MAYBE :: Module
- gHC_NUM_INTEGER :: Module
- gHC_NUM_NATURAL :: Module
- gHC_NUM_BIGNAT :: Module
- gHC_LIST :: Module
- gHC_TUPLE :: Module
- gHC_TUPLE_PRIM :: Module
- dATA_EITHER :: Module
- dATA_LIST :: Module
- dATA_STRING :: Module
- dATA_FOLDABLE :: Module
- dATA_TRAVERSABLE :: Module
- gHC_CONC :: Module
- gHC_IO :: Module
- gHC_IO_Exception :: Module
- gHC_ST :: Module
- gHC_IX :: Module
- gHC_STABLE :: Module
- gHC_PTR :: Module
- gHC_ERR :: Module
- gHC_REAL :: Module
- gHC_FLOAT :: Module
- gHC_TOP_HANDLER :: Module
- sYSTEM_IO :: Module
- dYNAMIC :: Module
- tYPEABLE :: Module
- tYPEABLE_INTERNAL :: Module
- gENERICS :: Module
- rEAD_PREC :: Module
- lEX :: Module
- gHC_INT :: Module
- gHC_WORD :: Module
- mONAD :: Module
- mONAD_FIX :: Module
- mONAD_ZIP :: Module
- mONAD_FAIL :: Module
- aRROW :: Module
- gHC_DESUGAR :: Module
- rANDOM :: Module
- gHC_EXTS :: Module
- gHC_IS_LIST :: Module
- cONTROL_EXCEPTION_BASE :: Module
- gHC_GENERICS :: Module
- gHC_TYPEERROR :: Module
- gHC_TYPELITS :: Module
- gHC_TYPELITS_INTERNAL :: Module
- gHC_TYPENATS :: Module
- gHC_TYPENATS_INTERNAL :: Module
- dATA_COERCE :: Module
- dEBUG_TRACE :: Module
- uNSAFE_COERCE :: Module
- fOREIGN_C_CONSTPTR :: Module
- gHC_SRCLOC :: Module
- gHC_STACK :: Module
- gHC_STACK_TYPES :: Module
- gHC_STATICPTR :: Module
- gHC_STATICPTR_INTERNAL :: Module
- gHC_FINGERPRINT_TYPE :: Module
- gHC_OVER_LABELS :: Module
- gHC_RECORDS :: Module
- rOOT_MAIN :: Module
- mkInteractiveModule :: Int -> Module
- pRELUDE_NAME :: ModuleName
- mAIN_NAME :: ModuleName
- mkPrimModule :: FastString -> Module
- mkBignumModule :: FastString -> Module
- mkBaseModule :: FastString -> Module
- mkBaseModule_ :: ModuleName -> Module
- mkThisGhcModule :: FastString -> Module
- mkThisGhcModule_ :: ModuleName -> Module
- mkMainModule :: FastString -> Module
- mkMainModule_ :: ModuleName -> Module
- main_RDR_Unqual :: RdrName
- eq_RDR :: RdrName
- ge_RDR :: RdrName
- le_RDR :: RdrName
- lt_RDR :: RdrName
- gt_RDR :: RdrName
- compare_RDR :: RdrName
- ltTag_RDR :: RdrName
- eqTag_RDR :: RdrName
- gtTag_RDR :: RdrName
- eqClass_RDR :: RdrName
- numClass_RDR :: RdrName
- ordClass_RDR :: RdrName
- enumClass_RDR :: RdrName
- monadClass_RDR :: RdrName
- map_RDR :: RdrName
- append_RDR :: RdrName
- foldr_RDR :: RdrName
- build_RDR :: RdrName
- returnM_RDR :: RdrName
- bindM_RDR :: RdrName
- failM_RDR :: RdrName
- left_RDR :: RdrName
- right_RDR :: RdrName
- fromEnum_RDR :: RdrName
- toEnum_RDR :: RdrName
- enumFrom_RDR :: RdrName
- enumFromTo_RDR :: RdrName
- enumFromThen_RDR :: RdrName
- enumFromThenTo_RDR :: RdrName
- ratioDataCon_RDR :: RdrName
- integerAdd_RDR :: RdrName
- integerMul_RDR :: RdrName
- ioDataCon_RDR :: RdrName
- newStablePtr_RDR :: RdrName
- bindIO_RDR :: RdrName
- returnIO_RDR :: RdrName
- fromInteger_RDR :: RdrName
- fromRational_RDR :: RdrName
- minus_RDR :: RdrName
- times_RDR :: RdrName
- plus_RDR :: RdrName
- toInteger_RDR :: RdrName
- toRational_RDR :: RdrName
- fromIntegral_RDR :: RdrName
- fromString_RDR :: RdrName
- fromList_RDR :: RdrName
- fromListN_RDR :: RdrName
- toList_RDR :: RdrName
- compose_RDR :: RdrName
- and_RDR :: RdrName
- not_RDR :: RdrName
- dataToTag_RDR :: RdrName
- succ_RDR :: RdrName
- pred_RDR :: RdrName
- minBound_RDR :: RdrName
- maxBound_RDR :: RdrName
- range_RDR :: RdrName
- inRange_RDR :: RdrName
- index_RDR :: RdrName
- unsafeIndex_RDR :: RdrName
- unsafeRangeSize_RDR :: RdrName
- readList_RDR :: RdrName
- readListDefault_RDR :: RdrName
- readListPrec_RDR :: RdrName
- readListPrecDefault_RDR :: RdrName
- readPrec_RDR :: RdrName
- parens_RDR :: RdrName
- choose_RDR :: RdrName
- lexP_RDR :: RdrName
- expectP_RDR :: RdrName
- readField_RDR :: RdrName
- readFieldHash_RDR :: RdrName
- readSymField_RDR :: RdrName
- punc_RDR :: RdrName
- ident_RDR :: RdrName
- symbol_RDR :: RdrName
- step_RDR :: RdrName
- alt_RDR :: RdrName
- reset_RDR :: RdrName
- prec_RDR :: RdrName
- pfail_RDR :: RdrName
- showsPrec_RDR :: RdrName
- shows_RDR :: RdrName
- showString_RDR :: RdrName
- showSpace_RDR :: RdrName
- showCommaSpace_RDR :: RdrName
- showParen_RDR :: RdrName
- error_RDR :: RdrName
- u1DataCon_RDR :: RdrName
- par1DataCon_RDR :: RdrName
- rec1DataCon_RDR :: RdrName
- k1DataCon_RDR :: RdrName
- m1DataCon_RDR :: RdrName
- l1DataCon_RDR :: RdrName
- r1DataCon_RDR :: RdrName
- prodDataCon_RDR :: RdrName
- comp1DataCon_RDR :: RdrName
- unPar1_RDR :: RdrName
- unRec1_RDR :: RdrName
- unK1_RDR :: RdrName
- unComp1_RDR :: RdrName
- from_RDR :: RdrName
- from1_RDR :: RdrName
- to_RDR :: RdrName
- to1_RDR :: RdrName
- datatypeName_RDR :: RdrName
- moduleName_RDR :: RdrName
- packageName_RDR :: RdrName
- isNewtypeName_RDR :: RdrName
- selName_RDR :: RdrName
- conName_RDR :: RdrName
- conFixity_RDR :: RdrName
- conIsRecord_RDR :: RdrName
- prefixDataCon_RDR :: RdrName
- infixDataCon_RDR :: RdrName
- leftAssocDataCon_RDR :: RdrName
- rightAssocDataCon_RDR :: RdrName
- notAssocDataCon_RDR :: RdrName
- uAddrDataCon_RDR :: RdrName
- uCharDataCon_RDR :: RdrName
- uDoubleDataCon_RDR :: RdrName
- uFloatDataCon_RDR :: RdrName
- uIntDataCon_RDR :: RdrName
- uWordDataCon_RDR :: RdrName
- uAddrHash_RDR :: RdrName
- uCharHash_RDR :: RdrName
- uDoubleHash_RDR :: RdrName
- uFloatHash_RDR :: RdrName
- uIntHash_RDR :: RdrName
- uWordHash_RDR :: RdrName
- fmap_RDR :: RdrName
- replace_RDR :: RdrName
- pure_RDR :: RdrName
- ap_RDR :: RdrName
- liftA2_RDR :: RdrName
- foldable_foldr_RDR :: RdrName
- foldMap_RDR :: RdrName
- null_RDR :: RdrName
- all_RDR :: RdrName
- traverse_RDR :: RdrName
- mempty_RDR :: RdrName
- mappend_RDR :: RdrName
- varQual_RDR :: Module -> FastString -> RdrName
- tcQual_RDR :: Module -> FastString -> RdrName
- clsQual_RDR :: Module -> FastString -> RdrName
- dataQual_RDR :: Module -> FastString -> RdrName
- wildCardName :: Name
- runMainIOName :: Name
- runRWName :: Name
- orderingTyConName :: Name
- ordLTDataConName :: Name
- ordEQDataConName :: Name
- ordGTDataConName :: Name
- specTyConName :: Name
- eitherTyConName :: Name
- leftDataConName :: Name
- rightDataConName :: Name
- voidTyConName :: Name
- v1TyConName :: Name
- u1TyConName :: Name
- par1TyConName :: Name
- rec1TyConName :: Name
- k1TyConName :: Name
- m1TyConName :: Name
- sumTyConName :: Name
- prodTyConName :: Name
- compTyConName :: Name
- rTyConName :: Name
- dTyConName :: Name
- cTyConName :: Name
- sTyConName :: Name
- rec0TyConName :: Name
- d1TyConName :: Name
- c1TyConName :: Name
- s1TyConName :: Name
- repTyConName :: Name
- rep1TyConName :: Name
- uRecTyConName :: Name
- uAddrTyConName :: Name
- uCharTyConName :: Name
- uDoubleTyConName :: Name
- uFloatTyConName :: Name
- uIntTyConName :: Name
- uWordTyConName :: Name
- prefixIDataConName :: Name
- infixIDataConName :: Name
- leftAssociativeDataConName :: Name
- rightAssociativeDataConName :: Name
- notAssociativeDataConName :: Name
- sourceUnpackDataConName :: Name
- sourceNoUnpackDataConName :: Name
- noSourceUnpackednessDataConName :: Name
- sourceLazyDataConName :: Name
- sourceStrictDataConName :: Name
- noSourceStrictnessDataConName :: Name
- decidedLazyDataConName :: Name
- decidedStrictDataConName :: Name
- decidedUnpackDataConName :: Name
- metaDataDataConName :: Name
- metaConsDataConName :: Name
- metaSelDataConName :: Name
- divIntName :: Name
- modIntName :: Name
- cstringLengthName :: Name
- eqStringName :: Name
- unpackCStringName :: Name
- unpackCStringAppendName :: Name
- unpackCStringFoldrName :: Name
- unpackCStringUtf8Name :: Name
- unpackCStringAppendUtf8Name :: Name
- unpackCStringFoldrUtf8Name :: Name
- inlineIdName :: Name
- eqClassName :: Name
- eqName :: Name
- ordClassName :: Name
- geName :: Name
- functorClassName :: Name
- fmapName :: Name
- monadClassName :: Name
- thenMName :: Name
- bindMName :: Name
- returnMName :: Name
- monadFailClassName :: Name
- failMName :: Name
- applicativeClassName :: Name
- apAName :: Name
- pureAName :: Name
- thenAName :: Name
- foldableClassName :: Name
- traversableClassName :: Name
- semigroupClassName :: Name
- sappendName :: Name
- monoidClassName :: Name
- memptyName :: Name
- mappendName :: Name
- mconcatName :: Name
- joinMName :: Name
- alternativeClassName :: Name
- joinMIdKey :: Unique
- apAClassOpKey :: Unique
- pureAClassOpKey :: Unique
- thenAClassOpKey :: Unique
- alternativeClassKey :: Unique
- considerAccessibleName :: Name
- dollarName :: Name
- otherwiseIdName :: Name
- foldrName :: Name
- buildName :: Name
- augmentName :: Name
- mapName :: Name
- appendName :: Name
- assertName :: Name
- fromStringName :: Name
- numClassName :: Name
- fromIntegerName :: Name
- minusName :: Name
- negateName :: Name
- bnbVarQual :: String -> Unique -> Name
- bnnVarQual :: String -> Unique -> Name
- bniVarQual :: String -> Unique -> Name
- bignatFromWordListName :: Name
- bignatEqName :: Name
- bignatCompareName :: Name
- bignatCompareWordName :: Name
- naturalToWordName :: Name
- naturalPopCountName :: Name
- naturalShiftRName :: Name
- naturalShiftLName :: Name
- naturalAddName :: Name
- naturalSubName :: Name
- naturalSubThrowName :: Name
- naturalSubUnsafeName :: Name
- naturalMulName :: Name
- naturalQuotRemName :: Name
- naturalQuotName :: Name
- naturalRemName :: Name
- naturalAndName :: Name
- naturalAndNotName :: Name
- naturalOrName :: Name
- naturalXorName :: Name
- naturalTestBitName :: Name
- naturalBitName :: Name
- naturalGcdName :: Name
- naturalLcmName :: Name
- naturalLog2Name :: Name
- naturalLogBaseWordName :: Name
- naturalLogBaseName :: Name
- naturalPowModName :: Name
- naturalSizeInBaseName :: Name
- integerFromNaturalName :: Name
- integerToNaturalClampName :: Name
- integerToNaturalThrowName :: Name
- integerToNaturalName :: Name
- integerToWordName :: Name
- integerToIntName :: Name
- integerToWord64Name :: Name
- integerToInt64Name :: Name
- integerFromWordName :: Name
- integerFromWord64Name :: Name
- integerFromInt64Name :: Name
- integerAddName :: Name
- integerMulName :: Name
- integerSubName :: Name
- integerNegateName :: Name
- integerAbsName :: Name
- integerPopCountName :: Name
- integerQuotName :: Name
- integerRemName :: Name
- integerDivName :: Name
- integerModName :: Name
- integerDivModName :: Name
- integerQuotRemName :: Name
- integerEncodeFloatName :: Name
- integerEncodeDoubleName :: Name
- integerGcdName :: Name
- integerLcmName :: Name
- integerAndName :: Name
- integerOrName :: Name
- integerXorName :: Name
- integerComplementName :: Name
- integerBitName :: Name
- integerTestBitName :: Name
- integerShiftLName :: Name
- integerShiftRName :: Name
- rationalTyConName :: Name
- ratioTyConName :: Name
- ratioDataConName :: Name
- realClassName :: Name
- integralClassName :: Name
- realFracClassName :: Name
- fractionalClassName :: Name
- fromRationalName :: Name
- toIntegerName :: Name
- toRationalName :: Name
- fromIntegralName :: Name
- realToFracName :: Name
- mkRationalBase2Name :: Name
- mkRationalBase10Name :: Name
- floatingClassName :: Name
- realFloatClassName :: Name
- integerToFloatName :: Name
- integerToDoubleName :: Name
- naturalToFloatName :: Name
- naturalToDoubleName :: Name
- rationalToFloatName :: Name
- rationalToDoubleName :: Name
- ixClassName :: Name
- trModuleTyConName :: Name
- trModuleDataConName :: Name
- trNameTyConName :: Name
- trNameSDataConName :: Name
- trNameDDataConName :: Name
- trTyConTyConName :: Name
- trTyConDataConName :: Name
- kindRepTyConName :: Name
- kindRepTyConAppDataConName :: Name
- kindRepVarDataConName :: Name
- kindRepAppDataConName :: Name
- kindRepFunDataConName :: Name
- kindRepTYPEDataConName :: Name
- kindRepTypeLitSDataConName :: Name
- kindRepTypeLitDDataConName :: Name
- typeLitSortTyConName :: Name
- typeLitSymbolDataConName :: Name
- typeLitNatDataConName :: Name
- typeLitCharDataConName :: Name
- typeableClassName :: Name
- typeRepTyConName :: Name
- someTypeRepTyConName :: Name
- someTypeRepDataConName :: Name
- typeRepIdName :: Name
- mkTrTypeName :: Name
- mkTrConName :: Name
- mkTrAppName :: Name
- mkTrFunName :: Name
- typeNatTypeRepName :: Name
- typeSymbolTypeRepName :: Name
- typeCharTypeRepName :: Name
- trGhcPrimModuleName :: Name
- starKindRepName :: Name
- starArrStarKindRepName :: Name
- starArrStarArrStarKindRepName :: Name
- constraintKindRepName :: Name
- withDictClassName :: Name
- nonEmptyTyConName :: Name
- errorMessageTypeErrorFamName :: Name
- typeErrorTextDataConName :: Name
- typeErrorAppendDataConName :: Name
- typeErrorVAppendDataConName :: Name
- typeErrorShowTypeDataConName :: Name
- unsafeEqualityProofName :: Name
- unsafeEqualityTyConName :: Name
- unsafeReflDataConName :: Name
- unsafeCoercePrimName :: Name
- toDynName :: Name
- dataClassName :: Name
- assertErrorName :: Name
- traceName :: Name
- enumClassName :: Name
- enumFromName :: Name
- enumFromToName :: Name
- enumFromThenName :: Name
- enumFromThenToName :: Name
- boundedClassName :: Name
- concatName :: Name
- filterName :: Name
- zipName :: Name
- isListClassName :: Name
- fromListName :: Name
- fromListNName :: Name
- toListName :: Name
- getFieldName :: Name
- setFieldName :: Name
- showClassName :: Name
- readClassName :: Name
- genClassName :: Name
- gen1ClassName :: Name
- datatypeClassName :: Name
- constructorClassName :: Name
- selectorClassName :: Name
- genericClassNames :: [Name]
- ghciIoClassName :: Name
- ghciStepIoMName :: Name
- ioTyConName :: Name
- ioDataConName :: Name
- thenIOName :: Name
- bindIOName :: Name
- returnIOName :: Name
- failIOName :: Name
- int8TyConName :: Name
- int16TyConName :: Name
- int32TyConName :: Name
- int64TyConName :: Name
- word8TyConName :: Name
- word16TyConName :: Name
- word32TyConName :: Name
- word64TyConName :: Name
- ptrTyConName :: Name
- funPtrTyConName :: Name
- stablePtrTyConName :: Name
- newStablePtrName :: Name
- monadFixClassName :: Name
- mfixName :: Name
- arrAName :: Name
- composeAName :: Name
- firstAName :: Name
- appAName :: Name
- choiceAName :: Name
- loopAName :: Name
- guardMName :: Name
- liftMName :: Name
- mzipName :: Name
- toAnnotationWrapperName :: Name
- monadPlusClassName :: Name
- isStringClassName :: Name
- knownNatClassName :: Name
- knownSymbolClassName :: Name
- knownCharClassName :: Name
- fromLabelClassOpName :: Name
- ipClassName :: Name
- hasFieldClassName :: Name
- callStackTyConName :: Name
- emptyCallStackName :: Name
- pushCallStackName :: Name
- srcLocDataConName :: Name
- pLUGINS :: Module
- pluginTyConName :: Name
- frontendPluginTyConName :: Name
- makeStaticName :: Name
- staticPtrInfoTyConName :: Name
- staticPtrInfoDataConName :: Name
- staticPtrTyConName :: Name
- staticPtrDataConName :: Name
- fromStaticPtrName :: Name
- fingerprintDataConName :: Name
- constPtrConName :: Name
- varQual :: Module -> FastString -> Unique -> Name
- tcQual :: Module -> FastString -> Unique -> Name
- clsQual :: Module -> FastString -> Unique -> Name
- dcQual :: Module -> FastString -> Unique -> Name
- mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name
- boundedClassKey :: Unique
- enumClassKey :: Unique
- eqClassKey :: Unique
- floatingClassKey :: Unique
- fractionalClassKey :: Unique
- integralClassKey :: Unique
- monadClassKey :: Unique
- dataClassKey :: Unique
- functorClassKey :: Unique
- numClassKey :: Unique
- ordClassKey :: Unique
- readClassKey :: Unique
- realClassKey :: Unique
- realFloatClassKey :: Unique
- realFracClassKey :: Unique
- showClassKey :: Unique
- ixClassKey :: Unique
- typeableClassKey :: Unique
- withDictClassKey :: Unique
- monadFixClassKey :: Unique
- monadFailClassKey :: Unique
- monadPlusClassKey :: Unique
- randomClassKey :: Unique
- randomGenClassKey :: Unique
- isStringClassKey :: Unique
- applicativeClassKey :: Unique
- foldableClassKey :: Unique
- traversableClassKey :: Unique
- genClassKey :: Unique
- gen1ClassKey :: Unique
- datatypeClassKey :: Unique
- constructorClassKey :: Unique
- selectorClassKey :: Unique
- knownNatClassNameKey :: Unique
- knownSymbolClassNameKey :: Unique
- knownCharClassNameKey :: Unique
- ghciIoClassKey :: Unique
- semigroupClassKey :: Unique
- monoidClassKey :: Unique
- ipClassKey :: Unique
- hasFieldClassNameKey :: Unique
- addrPrimTyConKey :: Unique
- arrayPrimTyConKey :: Unique
- boolTyConKey :: Unique
- byteArrayPrimTyConKey :: Unique
- stringTyConKey :: Unique
- charPrimTyConKey :: Unique
- charTyConKey :: Unique
- doublePrimTyConKey :: Unique
- doubleTyConKey :: Unique
- floatPrimTyConKey :: Unique
- floatTyConKey :: Unique
- fUNTyConKey :: Unique
- intPrimTyConKey :: Unique
- intTyConKey :: Unique
- int8PrimTyConKey :: Unique
- int8TyConKey :: Unique
- int16PrimTyConKey :: Unique
- int16TyConKey :: Unique
- int32PrimTyConKey :: Unique
- int32TyConKey :: Unique
- int64PrimTyConKey :: Unique
- int64TyConKey :: Unique
- integerTyConKey :: Unique
- naturalTyConKey :: Unique
- listTyConKey :: Unique
- foreignObjPrimTyConKey :: Unique
- maybeTyConKey :: Unique
- weakPrimTyConKey :: Unique
- mutableArrayPrimTyConKey :: Unique
- mutableByteArrayPrimTyConKey :: Unique
- orderingTyConKey :: Unique
- mVarPrimTyConKey :: Unique
- ioPortPrimTyConKey :: Unique
- ratioTyConKey :: Unique
- rationalTyConKey :: Unique
- realWorldTyConKey :: Unique
- stablePtrPrimTyConKey :: Unique
- stablePtrTyConKey :: Unique
- eqTyConKey :: Unique
- heqTyConKey :: Unique
- ctArrowTyConKey :: Unique
- ccArrowTyConKey :: Unique
- tcArrowTyConKey :: Unique
- statePrimTyConKey :: Unique
- stableNamePrimTyConKey :: Unique
- stableNameTyConKey :: Unique
- eqPrimTyConKey :: Unique
- eqReprPrimTyConKey :: Unique
- eqPhantPrimTyConKey :: Unique
- mutVarPrimTyConKey :: Unique
- ioTyConKey :: Unique
- wordPrimTyConKey :: Unique
- wordTyConKey :: Unique
- word8PrimTyConKey :: Unique
- word8TyConKey :: Unique
- word16PrimTyConKey :: Unique
- word16TyConKey :: Unique
- word32PrimTyConKey :: Unique
- word32TyConKey :: Unique
- word64PrimTyConKey :: Unique
- word64TyConKey :: Unique
- kindConKey :: Unique
- boxityConKey :: Unique
- typeConKey :: Unique
- threadIdPrimTyConKey :: Unique
- bcoPrimTyConKey :: Unique
- ptrTyConKey :: Unique
- funPtrTyConKey :: Unique
- tVarPrimTyConKey :: Unique
- compactPrimTyConKey :: Unique
- stackSnapshotPrimTyConKey :: Unique
- promptTagPrimTyConKey :: Unique
- eitherTyConKey :: Unique
- voidTyConKey :: Unique
- nonEmptyTyConKey :: Unique
- dictTyConKey :: Unique
- liftedTypeKindTyConKey :: Unique
- unliftedTypeKindTyConKey :: Unique
- tYPETyConKey :: Unique
- cONSTRAINTTyConKey :: Unique
- constraintKindTyConKey :: Unique
- levityTyConKey :: Unique
- runtimeRepTyConKey :: Unique
- vecCountTyConKey :: Unique
- vecElemTyConKey :: Unique
- liftedRepTyConKey :: Unique
- unliftedRepTyConKey :: Unique
- zeroBitRepTyConKey :: Unique
- zeroBitTypeTyConKey :: Unique
- pluginTyConKey :: Unique
- frontendPluginTyConKey :: Unique
- trTyConTyConKey :: Unique
- trModuleTyConKey :: Unique
- trNameTyConKey :: Unique
- kindRepTyConKey :: Unique
- typeLitSortTyConKey :: Unique
- v1TyConKey :: Unique
- u1TyConKey :: Unique
- par1TyConKey :: Unique
- rec1TyConKey :: Unique
- k1TyConKey :: Unique
- m1TyConKey :: Unique
- sumTyConKey :: Unique
- prodTyConKey :: Unique
- compTyConKey :: Unique
- rTyConKey :: Unique
- dTyConKey :: Unique
- cTyConKey :: Unique
- sTyConKey :: Unique
- rec0TyConKey :: Unique
- d1TyConKey :: Unique
- c1TyConKey :: Unique
- s1TyConKey :: Unique
- repTyConKey :: Unique
- rep1TyConKey :: Unique
- uRecTyConKey :: Unique
- uAddrTyConKey :: Unique
- uCharTyConKey :: Unique
- uDoubleTyConKey :: Unique
- uFloatTyConKey :: Unique
- uIntTyConKey :: Unique
- uWordTyConKey :: Unique
- errorMessageTypeErrorFamKey :: Unique
- coercibleTyConKey :: Unique
- proxyPrimTyConKey :: Unique
- specTyConKey :: Unique
- anyTyConKey :: Unique
- smallArrayPrimTyConKey :: Unique
- smallMutableArrayPrimTyConKey :: Unique
- staticPtrTyConKey :: Unique
- staticPtrInfoTyConKey :: Unique
- callStackTyConKey :: Unique
- typeRepTyConKey :: Unique
- someTypeRepTyConKey :: Unique
- someTypeRepDataConKey :: Unique
- typeSymbolAppendFamNameKey :: Unique
- unsafeEqualityTyConKey :: Unique
- multiplicityTyConKey :: Unique
- unrestrictedFunTyConKey :: Unique
- multMulTyConKey :: Unique
- int8X16PrimTyConKey :: Unique
- int16X8PrimTyConKey :: Unique
- int32X4PrimTyConKey :: Unique
- int64X2PrimTyConKey :: Unique
- int8X32PrimTyConKey :: Unique
- int16X16PrimTyConKey :: Unique
- int32X8PrimTyConKey :: Unique
- int64X4PrimTyConKey :: Unique
- int8X64PrimTyConKey :: Unique
- int16X32PrimTyConKey :: Unique
- int32X16PrimTyConKey :: Unique
- int64X8PrimTyConKey :: Unique
- word8X16PrimTyConKey :: Unique
- word16X8PrimTyConKey :: Unique
- word32X4PrimTyConKey :: Unique
- word64X2PrimTyConKey :: Unique
- word8X32PrimTyConKey :: Unique
- word16X16PrimTyConKey :: Unique
- word32X8PrimTyConKey :: Unique
- word64X4PrimTyConKey :: Unique
- word8X64PrimTyConKey :: Unique
- word16X32PrimTyConKey :: Unique
- word32X16PrimTyConKey :: Unique
- word64X8PrimTyConKey :: Unique
- floatX4PrimTyConKey :: Unique
- doubleX2PrimTyConKey :: Unique
- floatX8PrimTyConKey :: Unique
- doubleX4PrimTyConKey :: Unique
- floatX16PrimTyConKey :: Unique
- doubleX8PrimTyConKey :: Unique
- typeSymbolKindConNameKey :: Unique
- typeCharKindConNameKey :: Unique
- typeNatAddTyFamNameKey :: Unique
- typeNatMulTyFamNameKey :: Unique
- typeNatExpTyFamNameKey :: Unique
- typeNatSubTyFamNameKey :: Unique
- typeSymbolCmpTyFamNameKey :: Unique
- typeNatCmpTyFamNameKey :: Unique
- typeCharCmpTyFamNameKey :: Unique
- typeLeqCharTyFamNameKey :: Unique
- typeNatDivTyFamNameKey :: Unique
- typeNatModTyFamNameKey :: Unique
- typeNatLogTyFamNameKey :: Unique
- typeConsSymbolTyFamNameKey :: Unique
- typeUnconsSymbolTyFamNameKey :: Unique
- typeCharToNatTyFamNameKey :: Unique
- typeNatToCharTyFamNameKey :: Unique
- constPtrTyConKey :: Unique
- charDataConKey :: Unique
- consDataConKey :: Unique
- doubleDataConKey :: Unique
- falseDataConKey :: Unique
- floatDataConKey :: Unique
- intDataConKey :: Unique
- nothingDataConKey :: Unique
- justDataConKey :: Unique
- eqDataConKey :: Unique
- nilDataConKey :: Unique
- ratioDataConKey :: Unique
- word8DataConKey :: Unique
- stableNameDataConKey :: Unique
- trueDataConKey :: Unique
- wordDataConKey :: Unique
- ioDataConKey :: Unique
- heqDataConKey :: Unique
- crossDataConKey :: Unique
- inlDataConKey :: Unique
- inrDataConKey :: Unique
- genUnitDataConKey :: Unique
- leftDataConKey :: Unique
- rightDataConKey :: Unique
- ordLTDataConKey :: Unique
- ordEQDataConKey :: Unique
- ordGTDataConKey :: Unique
- mkDictDataConKey :: Unique
- coercibleDataConKey :: Unique
- staticPtrDataConKey :: Unique
- staticPtrInfoDataConKey :: Unique
- fingerprintDataConKey :: Unique
- srcLocDataConKey :: Unique
- trTyConDataConKey :: Unique
- trModuleDataConKey :: Unique
- trNameSDataConKey :: Unique
- trNameDDataConKey :: Unique
- trGhcPrimModuleKey :: Unique
- typeErrorTextDataConKey :: Unique
- typeErrorAppendDataConKey :: Unique
- typeErrorVAppendDataConKey :: Unique
- typeErrorShowTypeDataConKey :: Unique
- prefixIDataConKey :: Unique
- infixIDataConKey :: Unique
- leftAssociativeDataConKey :: Unique
- rightAssociativeDataConKey :: Unique
- notAssociativeDataConKey :: Unique
- sourceUnpackDataConKey :: Unique
- sourceNoUnpackDataConKey :: Unique
- noSourceUnpackednessDataConKey :: Unique
- sourceLazyDataConKey :: Unique
- sourceStrictDataConKey :: Unique
- noSourceStrictnessDataConKey :: Unique
- decidedLazyDataConKey :: Unique
- decidedStrictDataConKey :: Unique
- decidedUnpackDataConKey :: Unique
- metaDataDataConKey :: Unique
- metaConsDataConKey :: Unique
- metaSelDataConKey :: Unique
- vecRepDataConKey :: Unique
- tupleRepDataConKey :: Unique
- sumRepDataConKey :: Unique
- boxedRepDataConKey :: Unique
- boxedRepDataConTyConKey :: Unique
- tupleRepDataConTyConKey :: Unique
- runtimeRepSimpleDataConKeys :: [Unique]
- liftedDataConKey :: Unique
- unliftedDataConKey :: Unique
- vecCountDataConKeys :: [Unique]
- vecElemDataConKeys :: [Unique]
- kindRepTyConAppDataConKey :: Unique
- kindRepVarDataConKey :: Unique
- kindRepAppDataConKey :: Unique
- kindRepFunDataConKey :: Unique
- kindRepTYPEDataConKey :: Unique
- kindRepTypeLitSDataConKey :: Unique
- kindRepTypeLitDDataConKey :: Unique
- typeLitSymbolDataConKey :: Unique
- typeLitNatDataConKey :: Unique
- typeLitCharDataConKey :: Unique
- unsafeReflDataConKey :: Unique
- oneDataConKey :: Unique
- manyDataConKey :: Unique
- integerISDataConKey :: Unique
- integerINDataConKey :: Unique
- integerIPDataConKey :: Unique
- naturalNSDataConKey :: Unique
- naturalNBDataConKey :: Unique
- wildCardKey :: Unique
- absentErrorIdKey :: Unique
- absentConstraintErrorIdKey :: Unique
- augmentIdKey :: Unique
- appendIdKey :: Unique
- buildIdKey :: Unique
- foldrIdKey :: Unique
- recSelErrorIdKey :: Unique
- seqIdKey :: Unique
- absentSumFieldErrorIdKey :: Unique
- eqStringIdKey :: Unique
- noMethodBindingErrorIdKey :: Unique
- nonExhaustiveGuardsErrorIdKey :: Unique
- impossibleErrorIdKey :: Unique
- impossibleConstraintErrorIdKey :: Unique
- patErrorIdKey :: Unique
- realWorldPrimIdKey :: Unique
- recConErrorIdKey :: Unique
- unpackCStringUtf8IdKey :: Unique
- unpackCStringAppendUtf8IdKey :: Unique
- unpackCStringFoldrUtf8IdKey :: Unique
- unpackCStringIdKey :: Unique
- unpackCStringAppendIdKey :: Unique
- unpackCStringFoldrIdKey :: Unique
- voidPrimIdKey :: Unique
- typeErrorIdKey :: Unique
- divIntIdKey :: Unique
- modIntIdKey :: Unique
- cstringLengthIdKey :: Unique
- concatIdKey :: Unique
- filterIdKey :: Unique
- zipIdKey :: Unique
- bindIOIdKey :: Unique
- returnIOIdKey :: Unique
- newStablePtrIdKey :: Unique
- printIdKey :: Unique
- failIOIdKey :: Unique
- nullAddrIdKey :: Unique
- voidArgIdKey :: Unique
- otherwiseIdKey :: Unique
- assertIdKey :: Unique
- leftSectionKey :: Unique
- rightSectionKey :: Unique
- rootMainKey :: Unique
- runMainKey :: Unique
- thenIOIdKey :: Unique
- lazyIdKey :: Unique
- assertErrorIdKey :: Unique
- oneShotKey :: Unique
- runRWKey :: Unique
- traceKey :: Unique
- nospecIdKey :: Unique
- inlineIdKey :: Unique
- mapIdKey :: Unique
- dollarIdKey :: Unique
- coercionTokenIdKey :: Unique
- considerAccessibleIdKey :: Unique
- noinlineIdKey :: Unique
- noinlineConstraintIdKey :: Unique
- integerToFloatIdKey :: Unique
- integerToDoubleIdKey :: Unique
- naturalToFloatIdKey :: Unique
- naturalToDoubleIdKey :: Unique
- rationalToFloatIdKey :: Unique
- rationalToDoubleIdKey :: Unique
- coerceKey :: Unique
- unboundKey :: Unique
- fromIntegerClassOpKey :: Unique
- minusClassOpKey :: Unique
- fromRationalClassOpKey :: Unique
- enumFromClassOpKey :: Unique
- enumFromThenClassOpKey :: Unique
- enumFromToClassOpKey :: Unique
- enumFromThenToClassOpKey :: Unique
- eqClassOpKey :: Unique
- geClassOpKey :: Unique
- negateClassOpKey :: Unique
- bindMClassOpKey :: Unique
- thenMClassOpKey :: Unique
- fmapClassOpKey :: Unique
- returnMClassOpKey :: Unique
- mfixIdKey :: Unique
- failMClassOpKey :: Unique
- fromLabelClassOpKey :: Unique
- arrAIdKey :: Unique
- composeAIdKey :: Unique
- firstAIdKey :: Unique
- appAIdKey :: Unique
- choiceAIdKey :: Unique
- loopAIdKey :: Unique
- fromStringClassOpKey :: Unique
- toAnnotationWrapperIdKey :: Unique
- fromIntegralIdKey :: Unique
- realToFracIdKey :: Unique
- toIntegerClassOpKey :: Unique
- toRationalClassOpKey :: Unique
- guardMIdKey :: Unique
- liftMIdKey :: Unique
- mzipIdKey :: Unique
- ghciStepIoMClassOpKey :: Unique
- isListClassKey :: Unique
- fromListClassOpKey :: Unique
- fromListNClassOpKey :: Unique
- toListClassOpKey :: Unique
- proxyHashKey :: Unique
- mkTyConKey :: Unique
- mkTrTypeKey :: Unique
- mkTrConKey :: Unique
- mkTrAppKey :: Unique
- typeNatTypeRepKey :: Unique
- typeSymbolTypeRepKey :: Unique
- typeCharTypeRepKey :: Unique
- typeRepIdKey :: Unique
- mkTrFunKey :: Unique
- trTYPEKey :: Unique
- trTYPE'PtrRepLiftedKey :: Unique
- trRuntimeRepKey :: Unique
- tr'PtrRepLiftedKey :: Unique
- trLiftedRepKey :: Unique
- starKindRepKey :: Unique
- starArrStarKindRepKey :: Unique
- starArrStarArrStarKindRepKey :: Unique
- constraintKindRepKey :: Unique
- toDynIdKey :: Unique
- bitIntegerIdKey :: Unique
- eqSCSelIdKey :: Unique
- heqSCSelIdKey :: Unique
- coercibleSCSelIdKey :: Unique
- sappendClassOpKey :: Unique
- memptyClassOpKey :: Unique
- mappendClassOpKey :: Unique
- mconcatClassOpKey :: Unique
- emptyCallStackKey :: Unique
- pushCallStackKey :: Unique
- fromStaticPtrClassOpKey :: Unique
- makeStaticKey :: Unique
- unsafeEqualityProofIdKey :: Unique
- unsafeCoercePrimIdKey :: Unique
- getFieldClassOpKey :: Unique
- setFieldClassOpKey :: Unique
- integerFromNaturalIdKey :: Unique
- integerToNaturalClampIdKey :: Unique
- integerToNaturalThrowIdKey :: Unique
- integerToNaturalIdKey :: Unique
- integerToWordIdKey :: Unique
- integerToIntIdKey :: Unique
- integerToWord64IdKey :: Unique
- integerToInt64IdKey :: Unique
- integerAddIdKey :: Unique
- integerMulIdKey :: Unique
- integerSubIdKey :: Unique
- integerNegateIdKey :: Unique
- integerAbsIdKey :: Unique
- integerPopCountIdKey :: Unique
- integerQuotIdKey :: Unique
- integerRemIdKey :: Unique
- integerDivIdKey :: Unique
- integerModIdKey :: Unique
- integerDivModIdKey :: Unique
- integerQuotRemIdKey :: Unique
- integerEncodeFloatIdKey :: Unique
- integerEncodeDoubleIdKey :: Unique
- integerGcdIdKey :: Unique
- integerLcmIdKey :: Unique
- integerAndIdKey :: Unique
- integerOrIdKey :: Unique
- integerXorIdKey :: Unique
- integerComplementIdKey :: Unique
- integerBitIdKey :: Unique
- integerTestBitIdKey :: Unique
- integerShiftLIdKey :: Unique
- integerShiftRIdKey :: Unique
- integerFromWordIdKey :: Unique
- integerFromWord64IdKey :: Unique
- integerFromInt64IdKey :: Unique
- naturalToWordIdKey :: Unique
- naturalPopCountIdKey :: Unique
- naturalShiftRIdKey :: Unique
- naturalShiftLIdKey :: Unique
- naturalAddIdKey :: Unique
- naturalSubIdKey :: Unique
- naturalSubThrowIdKey :: Unique
- naturalSubUnsafeIdKey :: Unique
- naturalMulIdKey :: Unique
- naturalQuotRemIdKey :: Unique
- naturalQuotIdKey :: Unique
- naturalRemIdKey :: Unique
- naturalAndIdKey :: Unique
- naturalAndNotIdKey :: Unique
- naturalOrIdKey :: Unique
- naturalXorIdKey :: Unique
- naturalTestBitIdKey :: Unique
- naturalBitIdKey :: Unique
- naturalGcdIdKey :: Unique
- naturalLcmIdKey :: Unique
- naturalLog2IdKey :: Unique
- naturalLogBaseWordIdKey :: Unique
- naturalLogBaseIdKey :: Unique
- naturalPowModIdKey :: Unique
- naturalSizeInBaseIdKey :: Unique
- bignatFromWordListIdKey :: Unique
- bignatEqIdKey :: Unique
- bignatCompareIdKey :: Unique
- bignatCompareWordIdKey :: Unique
- mkRationalBase2IdKey :: Unique
- mkRationalBase10IdKey :: Unique
- numericClassKeys :: [Unique]
- fractionalClassKeys :: [Unique]
- standardClassKeys :: [Unique]
- derivableClassKeys :: [Unique]
- interactiveClassNames :: [Name]
- interactiveClassKeys :: [Unique]
- pretendNameIsInScope :: Name -> Bool
- module GHC.Builtin.Types
- module GHC.Builtin.Types.Prim
- module GHC.Builtin.Utils
- module GHC.Core.Class
- module GHC.Core.Coercion
- module GHC.Core.ConLike
- data SrcUnpackedness
- data SrcStrictness
- data FieldLabelString
- type ConTag = Int
- data FieldLabel = FieldLabel {}
- data EqSpec
- data DataConRep
- = NoDataConRep
- | DCR {
- dcr_wrap_id :: Id
- dcr_boxer :: DataConBoxer
- dcr_arg_tys :: [Scaled Type]
- dcr_stricts :: [StrictnessMark]
- dcr_bangs :: [HsImplBang]
- data DataCon
- data StrictnessMark
- data HsImplBang
- data HsSrcBang = HsSrcBang SourceText SrcUnpackedness SrcStrictness
- type DataConEnv a = UniqFM DataCon a
- fIRST_TAG :: ConTag
- promoteDataCon :: DataCon -> TyCon
- dataConWrapId :: DataCon -> Id
- isTypeDataCon :: DataCon -> Bool
- isUnboxedSumDataCon :: DataCon -> Bool
- dataConFullSig :: DataCon -> ([TyVar], [TyCoVar], [EqSpec], ThetaType, [Scaled Type], Type)
- dataConStupidTheta :: DataCon -> ThetaType
- dataConInstOrigArgTys :: DataCon -> [Type] -> [Scaled Type]
- dataConFieldLabels :: DataCon -> [FieldLabel]
- dataConSourceArity :: DataCon -> Arity
- dataConUserTyVarBinders :: DataCon -> [InvisTVBinder]
- dataConUserTyVars :: DataCon -> [TyVar]
- dataConTyCon :: DataCon -> TyCon
- dataConWorkId :: DataCon -> Id
- dataConName :: DataCon -> Name
- mkEqSpec :: TyVar -> Type -> EqSpec
- eqSpecTyVar :: EqSpec -> TyVar
- eqSpecType :: EqSpec -> Type
- eqSpecPair :: EqSpec -> (TyVar, Type)
- eqSpecPreds :: [EqSpec] -> ThetaType
- eqHsBang :: HsImplBang -> HsImplBang -> Bool
- isBanged :: HsImplBang -> Bool
- isSrcStrict :: SrcStrictness -> Bool
- isSrcUnpacked :: SrcUnpackedness -> Bool
- isMarkedStrict :: StrictnessMark -> Bool
- cbvFromStrictMark :: StrictnessMark -> CbvMark
- mkDataCon :: Name -> Bool -> TyConRepName -> [HsSrcBang] -> [FieldLabel] -> [TyVar] -> [TyCoVar] -> [InvisTVBinder] -> [EqSpec] -> KnotTied ThetaType -> [KnotTied (Scaled Type)] -> KnotTied Type -> PromDataConInfo -> KnotTied TyCon -> ConTag -> ThetaType -> Id -> DataConRep -> DataCon
- dataConTag :: DataCon -> ConTag
- dataConTagZ :: DataCon -> ConTagZ
- dataConOrigTyCon :: DataCon -> TyCon
- dataConRepType :: DataCon -> Type
- dataConIsInfix :: DataCon -> Bool
- dataConUnivTyVars :: DataCon -> [TyVar]
- dataConUnivAndExTyCoVars :: DataCon -> [TyCoVar]
- dataConTheta :: DataCon -> ThetaType
- dataConWrapId_maybe :: DataCon -> Maybe Id
- dataConImplicitTyThings :: DataCon -> [TyThing]
- dataConFieldType :: DataCon -> FieldLabelString -> Type
- dataConFieldType_maybe :: DataCon -> FieldLabelString -> Maybe (FieldLabel, Type)
- dataConSrcBangs :: DataCon -> [HsSrcBang]
- dataConRepArity :: DataCon -> Arity
- isNullarySrcDataCon :: DataCon -> Bool
- isNullaryRepDataCon :: DataCon -> Bool
- dataConRepStrictness :: DataCon -> [StrictnessMark]
- dataConImplBangs :: DataCon -> [HsImplBang]
- dataConBoxer :: DataCon -> Maybe DataConBoxer
- dataConInstSig :: DataCon -> [Type] -> ([TyCoVar], ThetaType, [Type])
- dataConOrigResTy :: DataCon -> Type
- dataConWrapperType :: DataCon -> Type
- dataConNonlinearType :: DataCon -> Type
- dataConDisplayType :: Bool -> DataCon -> Type
- dataConInstArgTys :: DataCon -> [Type] -> [Scaled Type]
- dataConInstUnivs :: DataCon -> [Type] -> [Type]
- dataConOrigArgTys :: DataCon -> [Scaled Type]
- dataConOtherTheta :: DataCon -> ThetaType
- dataConRepArgTys :: DataCon -> [Scaled Type]
- dataConIdentity :: DataCon -> ByteString
- isTupleDataCon :: DataCon -> Bool
- isBoxedTupleDataCon :: DataCon -> Bool
- isUnboxedTupleDataCon :: DataCon -> Bool
- isVanillaDataCon :: DataCon -> Bool
- isNewDataCon :: DataCon -> Bool
- isCovertGadtDataCon :: DataCon -> Bool
- specialPromotedDc :: DataCon -> Bool
- classDataCon :: Class -> DataCon
- dataConCannotMatch :: [Type] -> DataCon -> Bool
- dataConResRepTyArgs :: DataCon -> [Type]
- checkDataConTyVars :: DataCon -> Bool
- dataConUserTyVarsNeedWrapper :: DataCon -> Bool
- splitDataProductType_maybe :: Type -> Maybe (TyCon, [Type], DataCon, [Scaled Type])
- data FamInstMatch = FamInstMatch {}
- data InjectivityCheckResult
- data FamInstEnv
- type FamInstEnvs = (FamInstEnv, FamInstEnv)
- data FamFlavor
- data FamInst = FamInst {}
- famInstAxiom :: FamInst -> CoAxiom Unbranched
- famInstRHS :: FamInst -> Type
- famInstTyCon :: FamInst -> TyCon
- famInstsRepTyCons :: [FamInst] -> [TyCon]
- famInstRepTyCon_maybe :: FamInst -> Maybe TyCon
- dataFamInstRepTyCon :: FamInst -> TyCon
- orphNamesOfFamInst :: FamInst -> NameSet
- pprFamInsts :: [FamInst] -> SDoc
- mkImportedFamInst :: Name -> [RoughMatchTc] -> CoAxiom Unbranched -> FamInst
- famInstEnvSize :: FamInstEnv -> Int
- emptyFamInstEnvs :: (FamInstEnv, FamInstEnv)
- emptyFamInstEnv :: FamInstEnv
- famInstEnvElts :: FamInstEnv -> [FamInst]
- familyInstances :: (FamInstEnv, FamInstEnv) -> TyCon -> [FamInst]
- familyNameInstances :: (FamInstEnv, FamInstEnv) -> Name -> [FamInst]
- unionFamInstEnv :: FamInstEnv -> FamInstEnv -> FamInstEnv
- extendFamInstEnvList :: FamInstEnv -> [FamInst] -> FamInstEnv
- extendFamInstEnv :: FamInstEnv -> FamInst -> FamInstEnv
- compatibleBranches :: CoAxBranch -> CoAxBranch -> Bool
- injectiveBranches :: [Bool] -> CoAxBranch -> CoAxBranch -> InjectivityCheckResult
- mkCoAxBranch :: [TyVar] -> [TyVar] -> [CoVar] -> [Type] -> Type -> [Role] -> SrcSpan -> CoAxBranch
- mkBranchedCoAxiom :: Name -> TyCon -> [CoAxBranch] -> CoAxiom Branched
- mkUnbranchedCoAxiom :: Name -> TyCon -> CoAxBranch -> CoAxiom Unbranched
- mkSingleCoAxiom :: Role -> Name -> [TyVar] -> [TyVar] -> [CoVar] -> TyCon -> [Type] -> Type -> CoAxiom Unbranched
- mkNewTypeCoAxiom :: Name -> TyCon -> [TyVar] -> [Role] -> Type -> CoAxiom Unbranched
- lookupFamInstEnvByTyCon :: FamInstEnvs -> TyCon -> [FamInst]
- lookupFamInstEnv :: FamInstEnvs -> TyCon -> [Type] -> [FamInstMatch]
- lookupFamInstEnvConflicts :: FamInstEnvs -> FamInst -> [FamInst]
- lookupFamInstEnvInjectivityConflicts :: [Bool] -> FamInstEnvs -> FamInst -> [CoAxBranch]
- isDominatedBy :: CoAxBranch -> [CoAxBranch] -> Bool
- reduceTyFamApp_maybe :: FamInstEnvs -> Role -> TyCon -> [Type] -> Maybe Reduction
- apartnessCheck :: [Type] -> CoAxBranch -> Bool
- topNormaliseType :: FamInstEnvs -> Type -> Type
- topNormaliseType_maybe :: FamInstEnvs -> Type -> Maybe Reduction
- topReduceTyFamApp_maybe :: FamInstEnvs -> TyCon -> [Type] -> Maybe HetReduction
- normaliseType :: FamInstEnvs -> Role -> Type -> Reduction
- normaliseTcApp :: FamInstEnvs -> Role -> TyCon -> [Type] -> Reduction
- module GHC.Core.InstEnv
- module GHC.Types.Unique.FM
- module GHC.Core.PatSyn
- module GHC.Core.Predicate
- module GHC.Core.TyCon
- module GHC.Core.TyCo.Ppr
- module GHC.Core.Type
- module GHC.Core.Unify
- module GHC.Core.Utils
- module GHC.HsToCore.Docs
- module GHC.HsToCore.Expr
- module GHC.HsToCore.Monad
- module GHC.Iface.Syntax
- module GHC.Iface.Recomp
- data DerivStrategy pass
- = StockStrategy (XStockStrategy pass)
- | AnyclassStrategy (XAnyClassStrategy pass)
- | NewtypeStrategy (XNewtypeStrategy pass)
- | ViaStrategy (XViaStrategy pass)
- data InjectivityAnn pass
- = InjectivityAnn (XCInjectivityAnn pass) (LIdP pass) [LIdP pass]
- | XInjectivityAnn !(XXInjectivityAnn pass)
- data RuleBndr pass
- = RuleBndr (XCRuleBndr pass) (LIdP pass)
- | RuleBndrSig (XRuleBndrSig pass) (LIdP pass) (HsPatSigType pass)
- | XRuleBndr !(XXRuleBndr pass)
- data AnnDecl pass
- = HsAnnotation (XHsAnnotation pass) (AnnProvenance pass) (XRec pass (HsExpr pass))
- | XAnnDecl !(XXAnnDecl pass)
- data RoleAnnotDecl pass
- = RoleAnnotDecl (XCRoleAnnotDecl pass) (LIdP pass) [XRec pass (Maybe Role)]
- | XRoleAnnotDecl !(XXRoleAnnotDecl pass)
- type LRoleAnnotDecl pass = XRec pass (RoleAnnotDecl pass)
- data AnnProvenance pass
- = ValueAnnProvenance (LIdP pass)
- | TypeAnnProvenance (LIdP pass)
- | ModuleAnnProvenance
- type LAnnDecl pass = XRec pass (AnnDecl pass)
- data WarnDecl pass
- = Warning (XWarning pass) [LIdP pass] (WarningTxt pass)
- | XWarnDecl !(XXWarnDecl pass)
- type LWarnDecl pass = XRec pass (WarnDecl pass)
- data WarnDecls pass
- = Warnings {
- wd_ext :: XWarnings pass
- wd_warnings :: [LWarnDecl pass]
- | XWarnDecls !(XXWarnDecls pass)
- = Warnings {
- type LWarnDecls pass = XRec pass (WarnDecls pass)
- data DocDecl pass
- = DocCommentNext (LHsDoc pass)
- | DocCommentPrev (LHsDoc pass)
- | DocCommentNamed String (LHsDoc pass)
- | DocGroup Int (LHsDoc pass)
- type LDocDecl pass = XRec pass (DocDecl pass)
- type LRuleBndr pass = XRec pass (RuleBndr pass)
- data RuleDecl pass
- type LRuleDecl pass = XRec pass (RuleDecl pass)
- data RuleDecls pass
- = HsRules {
- rds_ext :: XCRuleDecls pass
- rds_rules :: [LRuleDecl pass]
- | XRuleDecls !(XXRuleDecls pass)
- = HsRules {
- type LRuleDecls pass = XRec pass (RuleDecls pass)
- data ForeignExport pass
- = CExport (XCExport pass) (XRec pass CExportSpec)
- | XForeignExport !(XXForeignExport pass)
- data CImportSpec
- data ForeignImport pass
- = CImport (XCImport pass) (XRec pass CCallConv) (XRec pass Safety) (Maybe Header) CImportSpec
- | XForeignImport !(XXForeignImport pass)
- data ForeignDecl pass
- = ForeignImport {
- fd_i_ext :: XForeignImport pass
- fd_name :: LIdP pass
- fd_sig_ty :: LHsSigType pass
- fd_fi :: ForeignImport pass
- | ForeignExport {
- fd_e_ext :: XForeignExport pass
- fd_name :: LIdP pass
- fd_sig_ty :: LHsSigType pass
- fd_fe :: ForeignExport pass
- | XForeignDecl !(XXForeignDecl pass)
- = ForeignImport {
- type LForeignDecl pass = XRec pass (ForeignDecl pass)
- data DefaultDecl pass
- = DefaultDecl (XCDefaultDecl pass) [LHsType pass]
- | XDefaultDecl !(XXDefaultDecl pass)
- type LDefaultDecl pass = XRec pass (DefaultDecl pass)
- type LDerivStrategy pass = XRec pass (DerivStrategy pass)
- data DerivDecl pass
- = DerivDecl {
- deriv_ext :: XCDerivDecl pass
- deriv_type :: LHsSigWcType pass
- deriv_strategy :: Maybe (LDerivStrategy pass)
- deriv_overlap_mode :: Maybe (XRec pass OverlapMode)
- | XDerivDecl !(XXDerivDecl pass)
- = DerivDecl {
- type LDerivDecl pass = XRec pass (DerivDecl 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 LInstDecl pass = XRec pass (InstDecl 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 (XRec pass OverlapMode)
- | XClsInstDecl !(XXClsInstDecl pass)
- = ClsInstDecl {
- type LClsInstDecl pass = XRec pass (ClsInstDecl pass)
- data FamEqn pass rhs
- = FamEqn {
- feqn_ext :: XCFamEqn pass rhs
- feqn_tycon :: LIdP pass
- feqn_bndrs :: HsOuterFamEqnTyVarBndrs pass
- feqn_pats :: HsTyPats pass
- feqn_fixity :: LexicalFixity
- feqn_rhs :: rhs
- | XFamEqn !(XXFamEqn pass rhs)
- = FamEqn {
- newtype DataFamInstDecl pass = DataFamInstDecl {
- dfid_eqn :: FamEqn pass (HsDataDefn pass)
- type LDataFamInstDecl pass = XRec pass (DataFamInstDecl pass)
- data TyFamInstDecl pass
- = TyFamInstDecl {
- tfid_xtn :: XCTyFamInstDecl pass
- tfid_eqn :: TyFamInstEqn pass
- | XTyFamInstDecl !(XXTyFamInstDecl pass)
- = TyFamInstDecl {
- type LTyFamInstDecl pass = XRec pass (TyFamInstDecl pass)
- type LTyFamDefltDecl pass = XRec pass (TyFamDefltDecl pass)
- type TyFamDefltDecl = TyFamInstDecl
- type TyFamInstEqn pass = FamEqn pass (LHsType pass)
- type HsTyPats pass = [LHsTypeArg pass]
- type LTyFamInstEqn pass = XRec pass (TyFamInstEqn pass)
- data HsConDeclGADTDetails pass
- = PrefixConGADT [HsScaled pass (LBangType pass)]
- | RecConGADT (XRec pass [LConDeclField pass]) (LHsUniToken "->" "\8594" pass)
- type HsConDeclH98Details pass = HsConDetails Void (HsScaled pass (LBangType pass)) (XRec pass [LConDeclField pass])
- data ConDecl pass
- = ConDeclGADT {
- con_g_ext :: XConDeclGADT pass
- con_names :: NonEmpty (LIdP pass)
- con_dcolon :: !(LHsUniToken "::" "\8759" pass)
- con_bndrs :: XRec pass (HsOuterSigTyVarBndrs pass)
- con_mb_cxt :: Maybe (LHsContext pass)
- con_g_args :: HsConDeclGADTDetails pass
- con_res_ty :: LHsType pass
- con_doc :: Maybe (LHsDoc pass)
- | ConDeclH98 {
- con_ext :: XConDeclH98 pass
- con_name :: LIdP pass
- con_forall :: Bool
- con_ex_tvs :: [LHsTyVarBndr Specificity pass]
- con_mb_cxt :: Maybe (LHsContext pass)
- con_args :: HsConDeclH98Details pass
- con_doc :: Maybe (LHsDoc pass)
- | XConDecl !(XXConDecl pass)
- = ConDeclGADT {
- type LConDecl pass = XRec pass (ConDecl pass)
- data NewOrData
- data StandaloneKindSig pass
- = StandaloneKindSig (XStandaloneKindSig pass) (LIdP pass) (LHsSigType pass)
- | XStandaloneKindSig !(XXStandaloneKindSig pass)
- type LStandaloneKindSig pass = XRec pass (StandaloneKindSig pass)
- data DerivClauseTys pass
- = DctSingle (XDctSingle pass) (LHsSigType pass)
- | DctMulti (XDctMulti pass) [LHsSigType pass]
- | XDerivClauseTys !(XXDerivClauseTys pass)
- type LDerivClauseTys pass = XRec pass (DerivClauseTys pass)
- data HsDerivingClause pass
- = HsDerivingClause {
- deriv_clause_ext :: XCHsDerivingClause pass
- deriv_clause_strategy :: Maybe (LDerivStrategy pass)
- deriv_clause_tys :: LDerivClauseTys pass
- | XHsDerivingClause !(XXHsDerivingClause pass)
- = HsDerivingClause {
- type LHsDerivingClause pass = XRec pass (HsDerivingClause pass)
- type HsDeriving pass = [LHsDerivingClause pass]
- data HsDataDefn pass
- = HsDataDefn {
- dd_ext :: XCHsDataDefn pass
- dd_ctxt :: Maybe (LHsContext pass)
- dd_cType :: Maybe (XRec pass CType)
- dd_kindSig :: Maybe (LHsKind pass)
- dd_cons :: DataDefnCons (LConDecl pass)
- dd_derivs :: HsDeriving pass
- | XHsDataDefn !(XXHsDataDefn pass)
- = HsDataDefn {
- data FamilyInfo pass
- = DataFamily
- | OpenTypeFamily
- | ClosedTypeFamily (Maybe [LTyFamInstEqn pass])
- type LInjectivityAnn pass = XRec pass (InjectivityAnn pass)
- data FamilyDecl pass
- = FamilyDecl {
- fdExt :: XCFamilyDecl pass
- fdInfo :: FamilyInfo pass
- fdTopLevel :: TopLevelFlag
- fdLName :: LIdP pass
- fdTyVars :: LHsQTyVars pass
- fdFixity :: LexicalFixity
- fdResultSig :: LFamilyResultSig pass
- fdInjectivityAnn :: Maybe (LInjectivityAnn pass)
- | XFamilyDecl !(XXFamilyDecl pass)
- = FamilyDecl {
- type LFamilyDecl pass = XRec pass (FamilyDecl pass)
- data FamilyResultSig pass
- = NoSig (XNoSig pass)
- | KindSig (XCKindSig pass) (LHsKind pass)
- | TyVarSig (XTyVarSig pass) (LHsTyVarBndr () pass)
- | XFamilyResultSig !(XXFamilyResultSig pass)
- type LFamilyResultSig pass = XRec pass (FamilyResultSig pass)
- data TyClGroup pass
- = TyClGroup {
- group_ext :: XCTyClGroup pass
- group_tyclds :: [LTyClDecl pass]
- group_roles :: [LRoleAnnotDecl pass]
- group_kisigs :: [LStandaloneKindSig pass]
- group_instds :: [LInstDecl pass]
- | XTyClGroup !(XXTyClGroup pass)
- = TyClGroup {
- type LHsFunDep pass = XRec pass (FunDep pass)
- data TyClDecl pass
- = FamDecl {
- tcdFExt :: XFamDecl pass
- tcdFam :: FamilyDecl pass
- | SynDecl {
- tcdSExt :: XSynDecl pass
- tcdLName :: LIdP pass
- tcdTyVars :: LHsQTyVars pass
- tcdFixity :: LexicalFixity
- tcdRhs :: LHsType pass
- | DataDecl {
- tcdDExt :: XDataDecl pass
- tcdLName :: LIdP pass
- tcdTyVars :: LHsQTyVars pass
- tcdFixity :: LexicalFixity
- tcdDataDefn :: HsDataDefn pass
- | ClassDecl {
- tcdCExt :: XClassDecl pass
- tcdLayout :: !(LayoutInfo pass)
- tcdCtxt :: Maybe (LHsContext pass)
- tcdLName :: LIdP pass
- tcdTyVars :: LHsQTyVars pass
- tcdFixity :: LexicalFixity
- tcdFDs :: [LHsFunDep pass]
- tcdSigs :: [LSig pass]
- tcdMeths :: LHsBinds pass
- tcdATs :: [LFamilyDecl pass]
- tcdATDefs :: [LTyFamDefltDecl pass]
- tcdDocs :: [LDocDecl pass]
- | XTyClDecl !(XXTyClDecl pass)
- = FamDecl {
- type LTyClDecl pass = XRec pass (TyClDecl pass)
- data SpliceDecoration
- data SpliceDecl p
- = SpliceDecl (XSpliceDecl p) (XRec p (HsUntypedSplice p)) SpliceDecoration
- | XSpliceDecl !(XXSpliceDecl p)
- type LSpliceDecl pass = XRec pass (SpliceDecl pass)
- 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 p]
- | XHsGroup !(XXHsGroup p)
- = HsGroup {
- data HsDecl p
- = TyClD (XTyClD p) (TyClDecl p)
- | InstD (XInstD p) (InstDecl p)
- | DerivD (XDerivD p) (DerivDecl p)
- | ValD (XValD p) (HsBind p)
- | SigD (XSigD p) (Sig p)
- | KindSigD (XKindSigD p) (StandaloneKindSig p)
- | DefD (XDefD p) (DefaultDecl p)
- | ForD (XForD p) (ForeignDecl 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 p)
- | RoleAnnotD (XRoleAnnotD p) (RoleAnnotDecl p)
- | XHsDecl !(XXHsDecl p)
- type LHsDecl p = XRec p (HsDecl p)
- data HsRuleAnn = HsRuleAnn {}
- data HsRuleRn = HsRuleRn NameSet NameSet
- data XViaStrategyPs = XViaStrategyPs (EpAnn [AddEpAnn]) (LHsSigType GhcPs)
- data DataDeclRn = DataDeclRn {
- tcdDataCusk :: Bool
- tcdFVs :: NameSet
- pattern XFunDep :: !(XXFunDep pass) -> FunDep pass
- hsGroupInstDecls :: HsGroup id -> [LInstDecl id]
- isDataDecl :: TyClDecl pass -> Bool
- isSynDecl :: TyClDecl pass -> Bool
- isClassDecl :: TyClDecl pass -> Bool
- isFamilyDecl :: TyClDecl pass -> Bool
- isTypeFamilyDecl :: TyClDecl pass -> Bool
- isOpenTypeFamilyInfo :: FamilyInfo pass -> Bool
- isClosedTypeFamilyInfo :: FamilyInfo pass -> Bool
- isDataFamilyDecl :: TyClDecl pass -> Bool
- tyClDeclTyVars :: TyClDecl pass -> LHsQTyVars pass
- tyClGroupTyClDecls :: [TyClGroup pass] -> [LTyClDecl pass]
- tyClGroupInstDecls :: [TyClGroup pass] -> [LInstDecl pass]
- tyClGroupRoleDecls :: [TyClGroup pass] -> [LRoleAnnotDecl pass]
- tyClGroupKindSigs :: [TyClGroup pass] -> [LStandaloneKindSig pass]
- collectRuleBndrSigTys :: [RuleBndr pass] -> [HsPatSigType pass]
- docDeclDoc :: DocDecl pass -> LHsDoc pass
- annProvenanceName_maybe :: UnXRec p => AnnProvenance p -> Maybe (IdP p)
- partitionBindsAndSigs :: [LHsDecl GhcPs] -> (LHsBinds GhcPs, [LSig GhcPs], [LFamilyDecl GhcPs], [LTyFamInstDecl GhcPs], [LDataFamInstDecl GhcPs], [LDocDecl GhcPs])
- emptyRdrGroup :: forall (p :: Pass). HsGroup (GhcPass p)
- emptyRnGroup :: forall (p :: Pass). HsGroup (GhcPass p)
- hsGroupTopLevelFixitySigs :: forall (p :: Pass). HsGroup (GhcPass p) -> [LFixitySig (GhcPass p)]
- appendGroups :: forall (p :: Pass). HsGroup (GhcPass p) -> HsGroup (GhcPass p) -> HsGroup (GhcPass p)
- tyFamInstDeclName :: forall (p :: Pass). Anno (IdGhcP p) ~ SrcSpanAnnN => TyFamInstDecl (GhcPass p) -> IdP (GhcPass p)
- tyFamInstDeclLName :: forall (p :: Pass). Anno (IdGhcP p) ~ SrcSpanAnnN => TyFamInstDecl (GhcPass p) -> LocatedN (IdP (GhcPass p))
- tyClDeclLName :: forall (p :: Pass). Anno (IdGhcP p) ~ SrcSpanAnnN => TyClDecl (GhcPass p) -> LocatedN (IdP (GhcPass p))
- countTyClDecls :: [TyClDecl pass] -> (Int, Int, Int, Int, Int)
- tcdName :: forall (p :: Pass). Anno (IdGhcP p) ~ SrcSpanAnnN => TyClDecl (GhcPass p) -> IdP (GhcPass p)
- hsDeclHasCusk :: TyClDecl GhcRn -> Bool
- pp_vanilla_decl_head :: forall (p :: Pass). OutputableBndrId p => XRec (GhcPass p) (IdP (GhcPass p)) -> LHsQTyVars (GhcPass p) -> LexicalFixity -> Maybe (LHsContext (GhcPass p)) -> SDoc
- pprTyClDeclFlavour :: forall (p :: Pass). TyClDecl (GhcPass p) -> SDoc
- familyDeclLName :: forall (p :: Pass). FamilyDecl (GhcPass p) -> XRec (GhcPass p) (IdP (GhcPass p))
- familyDeclName :: forall (p :: Pass). FamilyDecl (GhcPass p) -> IdP (GhcPass p)
- famResultKindSignature :: forall (p :: Pass). FamilyResultSig (GhcPass p) -> Maybe (LHsKind (GhcPass p))
- resultVariableName :: forall (a :: Pass). FamilyResultSig (GhcPass a) -> Maybe (IdP (GhcPass a))
- derivStrategyName :: DerivStrategy a -> SDoc
- standaloneKindSigName :: forall (p :: Pass). StandaloneKindSig (GhcPass p) -> IdP (GhcPass p)
- getConNames :: ConDecl GhcRn -> [LocatedN Name]
- getRecConArgs_maybe :: ConDecl GhcRn -> Maybe (LocatedL [LConDeclField GhcRn])
- hsConDeclTheta :: forall (p :: Pass). Maybe (LHsContext (GhcPass p)) -> [LHsType (GhcPass p)]
- ppDataDefnHeader :: forall (p :: Pass). OutputableBndrId p => (Maybe (LHsContext (GhcPass p)) -> SDoc) -> HsDataDefn (GhcPass p) -> SDoc
- pprTyFamInstDecl :: forall (p :: Pass). OutputableBndrId p => TopLevelFlag -> TyFamInstDecl (GhcPass p) -> SDoc
- pprDataFamInstFlavour :: forall (p :: Pass). DataFamInstDecl (GhcPass p) -> SDoc
- pprHsFamInstLHS :: forall (p :: Pass). OutputableBndrId p => IdP (GhcPass p) -> HsOuterFamEqnTyVarBndrs (GhcPass p) -> HsTyPats (GhcPass p) -> LexicalFixity -> Maybe (LHsContext (GhcPass p)) -> SDoc
- instDeclDataFamInsts :: forall (p :: Pass). [LInstDecl (GhcPass p)] -> [DataFamInstDecl (GhcPass p)]
- newOrDataToFlavour :: NewOrData -> TyConFlavour
- anyLConIsGadt :: Foldable f => f (GenLocated l (ConDecl pass)) -> Bool
- foldDerivStrategy :: forall p (pass :: Pass) r. p ~ GhcPass pass => r -> (XViaStrategy p -> r) -> DerivStrategy p -> r
- mapDerivStrategy :: forall p (pass :: Pass). p ~ GhcPass pass => (XViaStrategy p -> XViaStrategy p) -> DerivStrategy p -> DerivStrategy p
- flattenRuleDecls :: forall (p :: Pass). [LRuleDecls (GhcPass p)] -> [LRuleDecl (GhcPass p)]
- pprFullRuleName :: SourceText -> GenLocated a RuleName -> SDoc
- roleAnnotDeclName :: forall (p :: Pass). RoleAnnotDecl (GhcPass p) -> IdP (GhcPass p)
- module GHC.Hs.Expr
- module GHC.Hs.Doc
- module GHC.Hs.Extension
- module GHC.Hs.ImpExp
- module GHC.Hs.Pat
- module GHC.Hs.Type
- class UnXRec p => CollectPass p where
- collectXXPat :: CollectFlag p -> XXPat p -> [IdP p] -> [IdP p]
- collectXXHsBindsLR :: XXHsBindsLR p pR -> [IdP p] -> [IdP p]
- collectXSplicePat :: CollectFlag p -> XSplicePat p -> [IdP p] -> [IdP p]
- data CollectFlag p where
- CollNoDictBinders :: forall p. CollectFlag p
- CollWithDictBinders :: CollectFlag (GhcPass 'Typechecked)
- mkHsAppTy :: forall (p :: Pass). LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p)
- mkHsAppKindTy :: forall (p :: Pass). XAppKindTy (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p)
- mkHsPar :: forall (id :: Pass). LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)
- mkSimpleMatch :: forall (p :: Pass) body. (Anno (Match (GhcPass p) (LocatedA (body (GhcPass p)))) ~ SrcSpanAnnA, Anno (GRHS (GhcPass p) (LocatedA (body (GhcPass p)))) ~ SrcAnn NoEpAnns) => HsMatchContext (GhcPass p) -> [LPat (GhcPass p)] -> LocatedA (body (GhcPass p)) -> LMatch (GhcPass p) (LocatedA (body (GhcPass p)))
- unguardedGRHSs :: forall (p :: Pass) body. Anno (GRHS (GhcPass p) (LocatedA (body (GhcPass p)))) ~ SrcAnn NoEpAnns => SrcSpan -> LocatedA (body (GhcPass p)) -> EpAnn GrhsAnn -> GRHSs (GhcPass p) (LocatedA (body (GhcPass p)))
- unguardedRHS :: forall (p :: Pass) body. Anno (GRHS (GhcPass p) (LocatedA (body (GhcPass p)))) ~ SrcAnn NoEpAnns => EpAnn GrhsAnn -> SrcSpan -> LocatedA (body (GhcPass p)) -> [LGRHS (GhcPass p) (LocatedA (body (GhcPass p)))]
- mkMatchGroup :: forall (p :: Pass) body. AnnoBody p body => Origin -> LocatedL [LocatedA (Match (GhcPass p) (LocatedA (body (GhcPass p))))] -> MatchGroup (GhcPass p) (LocatedA (body (GhcPass p)))
- mkLamCaseMatchGroup :: forall (p :: Pass) body. AnnoBody p body => Origin -> LamCaseVariant -> LocatedL [LocatedA (Match (GhcPass p) (LocatedA (body (GhcPass p))))] -> MatchGroup (GhcPass p) (LocatedA (body (GhcPass p)))
- mkLocatedList :: Semigroup a => [GenLocated (SrcAnn a) e2] -> LocatedAn an [GenLocated (SrcAnn a) e2]
- mkHsApp :: forall (id :: Pass). LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)
- mkHsAppWith :: forall (id :: Pass). (LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> HsExpr (GhcPass id) -> LHsExpr (GhcPass id)) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)
- mkHsApps :: forall (id :: Pass). LHsExpr (GhcPass id) -> [LHsExpr (GhcPass id)] -> LHsExpr (GhcPass id)
- mkHsAppsWith :: forall (id :: Pass). (LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> HsExpr (GhcPass id) -> LHsExpr (GhcPass id)) -> LHsExpr (GhcPass id) -> [LHsExpr (GhcPass id)] -> LHsExpr (GhcPass id)
- mkHsAppType :: LHsExpr GhcRn -> LHsWcType GhcRn -> LHsExpr GhcRn
- mkHsAppTypes :: LHsExpr GhcRn -> [LHsWcType GhcRn] -> LHsExpr GhcRn
- mkHsLam :: forall (p :: Pass). (IsPass p, XMG (GhcPass p) (LHsExpr (GhcPass p)) ~ Origin) => [LPat (GhcPass p)] -> LHsExpr (GhcPass p) -> LHsExpr (GhcPass p)
- mkHsLams :: [TyVar] -> [EvVar] -> LHsExpr GhcTc -> LHsExpr GhcTc
- mkHsCaseAlt :: forall (p :: Pass) body. (Anno (GRHS (GhcPass p) (LocatedA (body (GhcPass p)))) ~ SrcAnn NoEpAnns, Anno (Match (GhcPass p) (LocatedA (body (GhcPass p)))) ~ SrcSpanAnnA) => LPat (GhcPass p) -> LocatedA (body (GhcPass p)) -> LMatch (GhcPass p) (LocatedA (body (GhcPass p)))
- nlHsTyApp :: Id -> [Type] -> LHsExpr GhcTc
- nlHsTyApps :: Id -> [Type] -> [LHsExpr GhcTc] -> LHsExpr GhcTc
- mkLHsPar :: forall (id :: Pass). IsPass id => LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)
- mkParPat :: forall (p :: Pass). IsPass p => LPat (GhcPass p) -> LPat (GhcPass p)
- nlParPat :: forall (name :: Pass). LPat (GhcPass name) -> LPat (GhcPass name)
- mkRecStmt :: forall (idL :: Pass) bodyR. Anno [GenLocated (Anno (StmtLR (GhcPass idL) GhcPs bodyR)) (StmtLR (GhcPass idL) GhcPs bodyR)] ~ SrcSpanAnnL => EpAnn AnnList -> LocatedL [LStmtLR (GhcPass idL) GhcPs bodyR] -> StmtLR (GhcPass idL) GhcPs bodyR
- mkHsIntegral :: IntegralLit -> HsOverLit GhcPs
- mkHsFractional :: FractionalLit -> HsOverLit GhcPs
- mkHsIsString :: SourceText -> FastString -> HsOverLit GhcPs
- mkHsDo :: HsDoFlavour -> LocatedL [ExprLStmt GhcPs] -> HsExpr GhcPs
- mkHsDoAnns :: HsDoFlavour -> LocatedL [ExprLStmt GhcPs] -> EpAnn AnnList -> HsExpr GhcPs
- mkHsComp :: HsDoFlavour -> [ExprLStmt GhcPs] -> LHsExpr GhcPs -> HsExpr GhcPs
- mkHsCompAnns :: HsDoFlavour -> [ExprLStmt GhcPs] -> LHsExpr GhcPs -> EpAnn AnnList -> HsExpr GhcPs
- mkHsIf :: LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs -> EpAnn AnnsIf -> HsExpr GhcPs
- mkHsCmdIf :: LHsExpr GhcPs -> LHsCmd GhcPs -> LHsCmd GhcPs -> EpAnn AnnsIf -> HsCmd GhcPs
- mkNPat :: LocatedAn NoEpAnns (HsOverLit GhcPs) -> Maybe (SyntaxExpr GhcPs) -> EpAnn [AddEpAnn] -> Pat GhcPs
- mkNPlusKPat :: LocatedN RdrName -> LocatedAn NoEpAnns (HsOverLit GhcPs) -> EpAnn EpaLocation -> Pat GhcPs
- emptyTransStmt :: EpAnn [AddEpAnn] -> StmtLR GhcPs GhcPs (LHsExpr GhcPs)
- mkTransformStmt :: EpAnn [AddEpAnn] -> [ExprLStmt GhcPs] -> LHsExpr GhcPs -> StmtLR GhcPs GhcPs (LHsExpr GhcPs)
- mkTransformByStmt :: EpAnn [AddEpAnn] -> [ExprLStmt GhcPs] -> LHsExpr GhcPs -> LHsExpr GhcPs -> StmtLR GhcPs GhcPs (LHsExpr GhcPs)
- mkGroupUsingStmt :: EpAnn [AddEpAnn] -> [ExprLStmt GhcPs] -> LHsExpr GhcPs -> StmtLR GhcPs GhcPs (LHsExpr GhcPs)
- mkGroupByUsingStmt :: EpAnn [AddEpAnn] -> [ExprLStmt GhcPs] -> LHsExpr GhcPs -> LHsExpr GhcPs -> StmtLR GhcPs GhcPs (LHsExpr GhcPs)
- mkLastStmt :: forall (idR :: Pass) bodyR (idL :: Pass). IsPass idR => LocatedA (bodyR (GhcPass idR)) -> StmtLR (GhcPass idL) (GhcPass idR) (LocatedA (bodyR (GhcPass idR)))
- mkBodyStmt :: forall bodyR (idL :: Pass). LocatedA (bodyR GhcPs) -> StmtLR (GhcPass idL) GhcPs (LocatedA (bodyR GhcPs))
- mkPsBindStmt :: EpAnn [AddEpAnn] -> LPat GhcPs -> LocatedA (bodyR GhcPs) -> StmtLR GhcPs GhcPs (LocatedA (bodyR GhcPs))
- mkRnBindStmt :: LPat GhcRn -> LocatedA (bodyR GhcRn) -> StmtLR GhcRn GhcRn (LocatedA (bodyR GhcRn))
- mkTcBindStmt :: LPat GhcTc -> LocatedA (bodyR GhcTc) -> StmtLR GhcTc GhcTc (LocatedA (bodyR GhcTc))
- unitRecStmtTc :: RecStmtTc
- emptyRecStmt :: forall (idL :: Pass) bodyR. Anno [GenLocated (Anno (StmtLR (GhcPass idL) GhcPs bodyR)) (StmtLR (GhcPass idL) GhcPs bodyR)] ~ SrcSpanAnnL => StmtLR (GhcPass idL) GhcPs bodyR
- emptyRecStmtName :: Anno [GenLocated (Anno (StmtLR GhcRn GhcRn bodyR)) (StmtLR GhcRn GhcRn bodyR)] ~ SrcSpanAnnL => StmtLR GhcRn GhcRn bodyR
- emptyRecStmtId :: Stmt GhcTc (LocatedA (HsCmd GhcTc))
- mkLetStmt :: EpAnn [AddEpAnn] -> HsLocalBinds GhcPs -> StmtLR GhcPs GhcPs (LocatedA b)
- mkHsOpApp :: LHsExpr GhcPs -> IdP GhcPs -> LHsExpr GhcPs -> HsExpr GhcPs
- mkHsString :: forall (p :: Pass). String -> HsLit (GhcPass p)
- mkHsStringFS :: forall (p :: Pass). FastString -> HsLit (GhcPass p)
- mkHsStringPrimLit :: forall (p :: Pass). FastString -> HsLit (GhcPass p)
- mkHsCharPrimLit :: forall (p :: Pass). Char -> HsLit (GhcPass p)
- mkConLikeTc :: ConLike -> HsExpr GhcTc
- nlHsVar :: forall (p :: Pass) a. IsSrcSpanAnn p a => IdP (GhcPass p) -> LHsExpr (GhcPass p)
- nl_HsVar :: forall (p :: Pass) a. IsSrcSpanAnn p a => IdP (GhcPass p) -> HsExpr (GhcPass p)
- nlHsDataCon :: DataCon -> LHsExpr GhcTc
- nlHsLit :: forall (p :: Pass). HsLit (GhcPass p) -> LHsExpr (GhcPass p)
- nlHsIntLit :: forall (p :: Pass). Integer -> LHsExpr (GhcPass p)
- nlVarPat :: forall (p :: Pass) a. IsSrcSpanAnn p a => IdP (GhcPass p) -> LPat (GhcPass p)
- nlLitPat :: HsLit GhcPs -> LPat GhcPs
- nlHsApp :: forall (id :: Pass). IsPass id => LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)
- nlHsSyntaxApps :: SyntaxExprTc -> [LHsExpr GhcTc] -> LHsExpr GhcTc
- nlHsApps :: forall (p :: Pass) a. IsSrcSpanAnn p a => IdP (GhcPass p) -> [LHsExpr (GhcPass p)] -> LHsExpr (GhcPass p)
- nlHsVarApps :: forall (p :: Pass) a. IsSrcSpanAnn p a => IdP (GhcPass p) -> [IdP (GhcPass p)] -> LHsExpr (GhcPass p)
- nlConVarPat :: RdrName -> [RdrName] -> LPat GhcPs
- nlConVarPatName :: Name -> [Name] -> LPat GhcRn
- nlInfixConPat :: RdrName -> LPat GhcPs -> LPat GhcPs -> LPat GhcPs
- nlConPat :: RdrName -> [LPat GhcPs] -> LPat GhcPs
- nlConPatName :: Name -> [LPat GhcRn] -> LPat GhcRn
- nlNullaryConPat :: RdrName -> LPat GhcPs
- nlWildConPat :: DataCon -> LPat GhcPs
- nlWildPat :: LPat GhcPs
- nlWildPatName :: LPat GhcRn
- nlHsDo :: HsDoFlavour -> [LStmt GhcPs (LHsExpr GhcPs)] -> LHsExpr GhcPs
- nlHsOpApp :: LHsExpr GhcPs -> IdP GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs
- nlHsLam :: LMatch GhcPs (LHsExpr GhcPs) -> LHsExpr GhcPs
- nlHsPar :: forall (id :: Pass). LHsExpr (GhcPass id) -> LHsExpr (GhcPass id)
- nlHsIf :: LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs -> LHsExpr GhcPs
- nlHsCase :: LHsExpr GhcPs -> [LMatch GhcPs (LHsExpr GhcPs)] -> LHsExpr GhcPs
- nlList :: [LHsExpr GhcPs] -> LHsExpr GhcPs
- nlHsAppTy :: forall (p :: Pass). LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p)
- nlHsTyVar :: forall (p :: Pass) a. IsSrcSpanAnn p a => PromotionFlag -> IdP (GhcPass p) -> LHsType (GhcPass p)
- nlHsFunTy :: forall (p :: Pass). LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p)
- nlHsParTy :: forall (p :: Pass). LHsType (GhcPass p) -> LHsType (GhcPass p)
- nlHsTyConApp :: forall (p :: Pass) a. IsSrcSpanAnn p a => PromotionFlag -> LexicalFixity -> IdP (GhcPass p) -> [LHsTypeArg (GhcPass p)] -> LHsType (GhcPass p)
- nlHsAppKindTy :: forall (p :: Pass). LHsType (GhcPass p) -> LHsKind (GhcPass p) -> LHsType (GhcPass p)
- mkLHsTupleExpr :: forall (p :: Pass). [LHsExpr (GhcPass p)] -> XExplicitTuple (GhcPass p) -> LHsExpr (GhcPass p)
- mkLHsVarTuple :: forall (p :: Pass) a. IsSrcSpanAnn p a => [IdP (GhcPass p)] -> XExplicitTuple (GhcPass p) -> LHsExpr (GhcPass p)
- nlTuplePat :: [LPat GhcPs] -> Boxity -> LPat GhcPs
- missingTupArg :: EpAnn EpaLocation -> HsTupArg GhcPs
- mkBigLHsVarTup :: forall (p :: Pass) a. IsSrcSpanAnn p a => [IdP (GhcPass p)] -> XExplicitTuple (GhcPass p) -> LHsExpr (GhcPass p)
- mkBigLHsTup :: forall (id :: Pass). [LHsExpr (GhcPass id)] -> XExplicitTuple (GhcPass id) -> LHsExpr (GhcPass id)
- mkBigLHsVarPatTup :: [IdP GhcRn] -> LPat GhcRn
- mkBigLHsPatTup :: [LPat GhcRn] -> LPat GhcRn
- hsTypeToHsSigType :: LHsType GhcPs -> LHsSigType GhcPs
- hsTypeToHsSigWcType :: LHsType GhcPs -> LHsSigWcType GhcPs
- mkHsSigEnv :: (LSig GhcRn -> Maybe ([LocatedN Name], a)) -> [LSig GhcRn] -> NameEnv a
- mkClassOpSigs :: [LSig GhcPs] -> [LSig GhcPs]
- mkLHsWrap :: HsWrapper -> LHsExpr GhcTc -> LHsExpr GhcTc
- mkHsWrap :: HsWrapper -> HsExpr GhcTc -> HsExpr GhcTc
- mkHsWrapCo :: TcCoercionN -> HsExpr GhcTc -> HsExpr GhcTc
- mkHsWrapCoR :: TcCoercionR -> HsExpr GhcTc -> HsExpr GhcTc
- mkLHsWrapCo :: TcCoercionN -> LHsExpr GhcTc -> LHsExpr GhcTc
- mkHsCmdWrap :: HsWrapper -> HsCmd GhcTc -> HsCmd GhcTc
- mkLHsCmdWrap :: HsWrapper -> LHsCmd GhcTc -> LHsCmd GhcTc
- mkHsWrapPat :: HsWrapper -> Pat GhcTc -> Type -> Pat GhcTc
- mkHsWrapPatCo :: TcCoercionN -> Pat GhcTc -> Type -> Pat GhcTc
- mkHsDictLet :: TcEvBinds -> LHsExpr GhcTc -> LHsExpr GhcTc
- mkFunBind :: Origin -> LocatedN RdrName -> [LMatch GhcPs (LHsExpr GhcPs)] -> HsBind GhcPs
- mkTopFunBind :: Origin -> LocatedN Name -> [LMatch GhcRn (LHsExpr GhcRn)] -> HsBind GhcRn
- mkHsVarBind :: SrcSpan -> RdrName -> LHsExpr GhcPs -> LHsBind GhcPs
- mkVarBind :: forall (p :: Pass). IdP (GhcPass p) -> LHsExpr (GhcPass p) -> LHsBind (GhcPass p)
- mkPatSynBind :: LocatedN RdrName -> HsPatSynDetails GhcPs -> LPat GhcPs -> HsPatSynDir GhcPs -> EpAnn [AddEpAnn] -> HsBind GhcPs
- isInfixFunBind :: forall id1 id2. UnXRec id2 => HsBindLR id1 id2 -> Bool
- spanHsLocaLBinds :: forall (p :: Pass). HsLocalBinds (GhcPass p) -> SrcSpan
- mkSimpleGeneratedFunBind :: SrcSpan -> RdrName -> [LPat GhcPs] -> LHsExpr GhcPs -> LHsBind GhcPs
- mkPrefixFunRhs :: LIdP (NoGhcTc p) -> HsMatchContext p
- mkMatch :: forall (p :: Pass). IsPass p => HsMatchContext (GhcPass p) -> [LPat (GhcPass p)] -> LHsExpr (GhcPass p) -> HsLocalBinds (GhcPass p) -> LMatch (GhcPass p) (LHsExpr (GhcPass p))
- isUnliftedHsBind :: HsBind GhcTc -> Bool
- isBangedHsBind :: HsBind GhcTc -> Bool
- collectLocalBinders :: forall (idL :: Pass) (idR :: Pass). CollectPass (GhcPass idL) => CollectFlag (GhcPass idL) -> HsLocalBindsLR (GhcPass idL) (GhcPass idR) -> [IdP (GhcPass idL)]
- collectHsIdBinders :: forall (idL :: Pass) (idR :: Pass). CollectPass (GhcPass idL) => CollectFlag (GhcPass idL) -> HsValBindsLR (GhcPass idL) (GhcPass idR) -> [IdP (GhcPass idL)]
- collectHsValBinders :: forall (idL :: Pass) idR. CollectPass (GhcPass idL) => CollectFlag (GhcPass idL) -> HsValBindsLR (GhcPass idL) idR -> [IdP (GhcPass idL)]
- collectHsBindBinders :: CollectPass p => CollectFlag p -> HsBindLR p idR -> [IdP p]
- collectHsBindListBinders :: CollectPass p => CollectFlag p -> [LHsBindLR p idR] -> [IdP p]
- collectMethodBinders :: UnXRec idL => LHsBindsLR idL idR -> [LIdP idL]
- collectLStmtsBinders :: forall (idL :: Pass) (idR :: Pass) body. CollectPass (GhcPass idL) => CollectFlag (GhcPass idL) -> [LStmtLR (GhcPass idL) (GhcPass idR) body] -> [IdP (GhcPass idL)]
- collectStmtsBinders :: forall (idL :: Pass) (idR :: Pass) body. CollectPass (GhcPass idL) => CollectFlag (GhcPass idL) -> [StmtLR (GhcPass idL) (GhcPass idR) body] -> [IdP (GhcPass idL)]
- collectLStmtBinders :: forall (idL :: Pass) (idR :: Pass) body. CollectPass (GhcPass idL) => CollectFlag (GhcPass idL) -> LStmtLR (GhcPass idL) (GhcPass idR) body -> [IdP (GhcPass idL)]
- collectStmtBinders :: forall (idL :: Pass) (idR :: Pass) body. CollectPass (GhcPass idL) => CollectFlag (GhcPass idL) -> StmtLR (GhcPass idL) (GhcPass idR) body -> [IdP (GhcPass idL)]
- collectPatBinders :: CollectPass p => CollectFlag p -> LPat p -> [IdP p]
- collectPatsBinders :: CollectPass p => CollectFlag p -> [LPat p] -> [IdP p]
- hsGroupBinders :: HsGroup GhcRn -> [Name]
- hsTyClForeignBinders :: [TyClGroup GhcRn] -> [LForeignDecl GhcRn] -> [Name]
- hsLTyClDeclBinders :: forall (p :: Pass). IsPass p => LocatedA (TyClDecl (GhcPass p)) -> ([LocatedA (IdP (GhcPass p))], [LFieldOcc (GhcPass p)])
- hsForeignDeclsBinders :: forall (p :: Pass) a. (UnXRec (GhcPass p), IsSrcSpanAnn p a) => [LForeignDecl (GhcPass p)] -> [LIdP (GhcPass p)]
- hsPatSynSelectors :: forall (p :: Pass). IsPass p => HsValBinds (GhcPass p) -> [FieldOcc (GhcPass p)]
- getPatSynBinds :: UnXRec id => [(RecFlag, LHsBinds id)] -> [PatSynBind id id]
- hsDataFamInstBinders :: forall (p :: Pass). IsPass p => DataFamInstDecl (GhcPass p) -> ([LocatedA (IdP (GhcPass p))], [LFieldOcc (GhcPass p)])
- lStmtsImplicits :: forall (idR :: Pass) (body :: Type -> Type). [LStmtLR GhcRn (GhcPass idR) (LocatedA (body (GhcPass idR)))] -> [(SrcSpan, [Name])]
- hsValBindsImplicits :: forall (idR :: Pass). HsValBindsLR GhcRn (GhcPass idR) -> [(SrcSpan, [Name])]
- lPatImplicits :: LPat GhcRn -> [(SrcSpan, [Name])]
- data DerivStrategy pass
- = StockStrategy (XStockStrategy pass)
- | AnyclassStrategy (XAnyClassStrategy pass)
- | NewtypeStrategy (XNewtypeStrategy pass)
- | ViaStrategy (XViaStrategy pass)
- data InjectivityAnn pass
- = InjectivityAnn (XCInjectivityAnn pass) (LIdP pass) [LIdP pass]
- | XInjectivityAnn !(XXInjectivityAnn pass)
- data RuleBndr pass
- = RuleBndr (XCRuleBndr pass) (LIdP pass)
- | RuleBndrSig (XRuleBndrSig pass) (LIdP pass) (HsPatSigType pass)
- | XRuleBndr !(XXRuleBndr pass)
- type BangType pass = HsType pass
- type Stmt id body = StmtLR id id body
- data Match p body
- data Pat p
- = WildPat (XWildPat p)
- | VarPat (XVarPat p) (LIdP p)
- | LazyPat (XLazyPat p) (LPat p)
- | AsPat (XAsPat p) (LIdP p) !(LHsToken "@" p) (LPat p)
- | ParPat (XParPat p) !(LHsToken "(" p) (LPat p) !(LHsToken ")" p)
- | BangPat (XBangPat p) (LPat p)
- | ListPat (XListPat p) [LPat p]
- | TuplePat (XTuplePat p) [LPat p] Boxity
- | SumPat (XSumPat p) (LPat p) ConTag SumWidth
- | ConPat {
- pat_con_ext :: XConPat p
- pat_con :: XRec p (ConLikeP p)
- pat_args :: HsConPatDetails p
- | ViewPat (XViewPat p) (LHsExpr p) (LPat p)
- | SplicePat (XSplicePat p) (HsUntypedSplice p)
- | LitPat (XLitPat p) (HsLit p)
- | NPat (XNPat p) (XRec p (HsOverLit p)) (Maybe (SyntaxExpr p)) (SyntaxExpr p)
- | NPlusKPat (XNPlusKPat p) (LIdP p) (XRec p (HsOverLit p)) (HsOverLit p) (SyntaxExpr p) (SyntaxExpr p)
- | SigPat (XSigPat p) (LPat p) (HsPatSigType (NoGhcTc p))
- | XPat !(XXPat p)
- data AnnDecl pass
- = HsAnnotation (XHsAnnotation pass) (AnnProvenance pass) (XRec pass (HsExpr pass))
- | XAnnDecl !(XXAnnDecl pass)
- data IE pass
- = IEVar (XIEVar pass) (LIEWrappedName pass)
- | IEThingAbs (XIEThingAbs pass) (LIEWrappedName pass)
- | IEThingAll (XIEThingAll pass) (LIEWrappedName pass)
- | IEThingWith (XIEThingWith pass) (LIEWrappedName pass) IEWildcard [LIEWrappedName pass]
- | IEModuleContents (XIEModuleContents pass) (XRec pass ModuleName)
- | IEGroup (XIEGroup pass) Int (LHsDoc pass)
- | IEDoc (XIEDoc pass) (LHsDoc pass)
- | IEDocNamed (XIEDocNamed pass) String
- | XIE !(XXIE pass)
- data HsExpr p
- = HsVar (XVar p) (LIdP p)
- | HsUnboundVar (XUnboundVar p) RdrName
- | HsRecSel (XRecSel p) (FieldOcc p)
- | HsOverLabel (XOverLabel p) SourceText 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) LamCaseVariant (MatchGroup p (LHsExpr p))
- | HsApp (XApp p) (LHsExpr p) (LHsExpr p)
- | HsAppType (XAppTypeE p) (LHsExpr p) !(LHsToken "@" p) (LHsWcType (NoGhcTc p))
- | OpApp (XOpApp p) (LHsExpr p) (LHsExpr p) (LHsExpr p)
- | NegApp (XNegApp p) (LHsExpr p) (SyntaxExpr p)
- | HsPar (XPar p) !(LHsToken "(" p) (LHsExpr p) !(LHsToken ")" p)
- | SectionL (XSectionL p) (LHsExpr p) (LHsExpr p)
- | SectionR (XSectionR p) (LHsExpr p) (LHsExpr p)
- | ExplicitTuple (XExplicitTuple p) [HsTupArg p] Boxity
- | ExplicitSum (XExplicitSum p) ConTag SumWidth (LHsExpr p)
- | HsCase (XCase p) (LHsExpr p) (MatchGroup p (LHsExpr p))
- | HsIf (XIf p) (LHsExpr p) (LHsExpr p) (LHsExpr p)
- | HsMultiIf (XMultiIf p) [LGRHS p (LHsExpr p)]
- | HsLet (XLet p) !(LHsToken "let" p) (HsLocalBinds p) !(LHsToken "in" p) (LHsExpr p)
- | HsDo (XDo p) HsDoFlavour (XRec p [ExprLStmt p])
- | ExplicitList (XExplicitList p) [LHsExpr p]
- | RecordCon {
- rcon_ext :: XRecordCon p
- rcon_con :: XRec p (ConLikeP p)
- rcon_flds :: HsRecordBinds p
- | RecordUpd {
- rupd_ext :: XRecordUpd p
- rupd_expr :: LHsExpr p
- rupd_flds :: Either [LHsRecUpdField p] [LHsRecUpdProj p]
- | HsGetField { }
- | HsProjection {
- proj_ext :: XProjection p
- proj_flds :: NonEmpty (XRec p (DotFieldOcc p))
- | ExprWithTySig (XExprWithTySig p) (LHsExpr p) (LHsSigWcType (NoGhcTc p))
- | ArithSeq (XArithSeq p) (Maybe (SyntaxExpr p)) (ArithSeqInfo p)
- | HsTypedBracket (XTypedBracket p) (LHsExpr p)
- | HsUntypedBracket (XUntypedBracket p) (HsQuote p)
- | HsTypedSplice (XTypedSplice p) (LHsExpr p)
- | HsUntypedSplice (XUntypedSplice p) (HsUntypedSplice p)
- | HsProc (XProc p) (LPat p) (LHsCmdTop p)
- | HsStatic (XStatic p) (LHsExpr p)
- | HsPragE (XPragE p) (HsPragE p) (LHsExpr p)
- | XExpr !(XXExpr p)
- data NoExtField = NoExtField
- type family NoGhcTc p
- type family XXIEWrappedName p
- type family XIEType p
- type family XIEPattern p
- type family XIEName p
- type family XXIE x
- type family XIEDocNamed x
- type family XIEDoc x
- type family XIEGroup x
- type family XIEModuleContents x
- type family XIEThingWith x
- type family XIEThingAll x
- type family XIEThingAbs x
- type family XIEVar x
- type family ImportDeclPkgQual x
- type family XXImportDecl x
- type family XCImportDecl x
- type family XXFieldOcc x
- type family XCFieldOcc x
- type family XXConDeclField x
- type family XConDeclField x
- type family XXTyVarBndr x
- type family XKindedTyVar x
- type family XUserTyVar x
- type family XXHsForAllTelescope x
- type family XHsForAllInvis x
- type family XHsForAllVis x
- type family XXTyLit x
- type family XCharTy x
- type family XStrTy x
- type family XNumTy x
- type family XXType x
- type family XWildCardTy x
- type family XTyLit x
- type family XExplicitTupleTy x
- type family XExplicitListTy x
- type family XRecTy x
- type family XBangTy x
- type family XDocTy x
- type family XSpliceTy x
- type family XKindSig x
- type family XStarTy x
- type family XIParamTy x
- type family XParTy x
- type family XOpTy x
- type family XSumTy x
- type family XTupleTy x
- type family XListTy x
- type family XFunTy x
- type family XAppKindTy x
- type family XAppTy x
- type family XTyVar x
- type family XQualTy x
- type family XForAllTy x
- type family XXHsPatSigType x
- type family XHsPS x
- type family XXHsWildCardBndrs x b
- type family XHsWC x b
- type family XXHsSigType x
- type family XHsSig x
- type family XXHsOuterTyVarBndrs x
- type family XHsOuterExplicit x flag
- type family XHsOuterImplicit x
- type family XXLHsQTyVars x
- type family XHsQTvs x
- type family XHsFieldBind x
- type family XXPat x
- type family XCoPat x
- type family XSigPat x
- type family XNPlusKPat x
- type family XNPat x
- type family XLitPat x
- type family XSplicePat x
- type family XViewPat x
- type family XConPat x
- type family XSumPat x
- type family XTuplePat x
- type family XListPat x
- type family XBangPat x
- type family XParPat x
- type family XAsPat x
- type family XLazyPat x
- type family XVarPat x
- type family XWildPat x
- type family XXOverLit x
- type family XOverLit x
- type family XXLit x
- type family XHsDoublePrim x
- type family XHsFloatPrim x
- type family XHsRat x
- type family XHsInteger x
- type family XHsWord64Prim x
- type family XHsInt64Prim x
- type family XHsWordPrim x
- type family XHsIntPrim x
- type family XHsInt x
- type family XHsStringPrim x
- type family XHsString x
- type family XHsCharPrim x
- type family XHsChar x
- type family XXApplicativeArg x
- type family XApplicativeArgMany x
- type family XApplicativeArgOne x
- type family XXParStmtBlock x x'
- type family XParStmtBlock x x'
- type family XXCmd x
- type family XCmdWrap x
- type family XCmdDo x
- type family XCmdLet x
- type family XCmdIf x
- type family XCmdLamCase x
- type family XCmdCase x
- type family XCmdPar x
- type family XCmdLam x
- type family XCmdApp x
- type family XCmdArrForm x
- type family XCmdArrApp x
- type family XXStmtLR x x' b
- type family XRecStmt x x' b
- type family XTransStmt x x' b
- type family XParStmt x x' b
- type family XLetStmt x x' b
- type family XBodyStmt x x' b
- type family XApplicativeStmt x x' b
- type family XBindStmt x x' b
- type family XLastStmt x x' b
- type family XXGRHS x b
- type family XCGRHS x b
- type family XXGRHSs x b
- type family XCGRHSs x b
- type family XXMatch x b
- type family XCMatch x b
- type family XXMatchGroup x b
- type family XMG x b
- type family XXCmdTop x
- type family XCmdTop x
- type family XXQuote x
- type family XVarBr x
- type family XTypBr x
- type family XDecBrG x
- type family XDecBrL x
- type family XPatBr x
- type family XExpBr x
- type family XXUntypedSplice x
- type family XQuasiQuote x
- type family XUntypedSpliceExpr x
- type family XXTupArg x
- type family XMissing x
- type family XPresent x
- type family XXAmbiguousFieldOcc x
- type family XAmbiguous x
- type family XUnambiguous x
- type family XXPragE x
- type family XSCC x
- type family XXDotFieldOcc x
- type family XCDotFieldOcc x
- type family XXExpr x
- type family XPragE x
- type family XBinTick x
- type family XTick x
- type family XStatic x
- type family XProc x
- type family XUntypedSplice x
- type family XTypedSplice x
- type family XUntypedBracket x
- type family XTypedBracket x
- type family XArithSeq x
- type family XExprWithTySig x
- type family XProjection x
- type family XGetField x
- type family XRecordUpd x
- type family XRecordCon x
- type family XExplicitList x
- type family XDo x
- type family XLet x
- type family XMultiIf x
- type family XIf x
- type family XCase x
- type family XExplicitSum x
- type family XExplicitTuple x
- type family XSectionR x
- type family XSectionL x
- type family XPar x
- type family XNegApp x
- type family XOpApp x
- type family XAppTypeE x
- type family XApp x
- type family XLamCase x
- type family XLam x
- type family XLitE x
- type family XOverLitE x
- type family XIPVar x
- type family XOverLabel x
- type family XRecSel x
- type family XUnboundVar x
- type family XVar x
- type family XXModule x
- type family XCModule x
- type family XXInjectivityAnn x
- type family XCInjectivityAnn x
- type family XXRoleAnnotDecl x
- type family XCRoleAnnotDecl x
- type family XXAnnDecl x
- type family XHsAnnotation x
- type family XXWarnDecl x
- type family XWarning x
- type family XXWarnDecls x
- type family XWarnings x
- type family XXRuleBndr x
- type family XRuleBndrSig x
- type family XCRuleBndr x
- type family XXRuleDecl x
- type family XHsRule x
- type family XXRuleDecls x
- type family XCRuleDecls x
- type family XXForeignExport x
- type family XCExport x
- type family XXForeignImport x
- type family XCImport x
- type family XXForeignDecl x
- type family XForeignExport x
- type family XForeignImport x
- type family XXDefaultDecl x
- type family XCDefaultDecl x
- type family XViaStrategy x
- type family XNewtypeStrategy x
- type family XAnyClassStrategy x
- type family XStockStrategy x
- type family XXDerivDecl x
- type family XCDerivDecl x
- type family XXInstDecl x
- type family XTyFamInstD x
- type family XDataFamInstD x
- type family XClsInstD x
- type family XXClsInstDecl x
- type family XCClsInstDecl x
- type family XXTyFamInstDecl x
- type family XCTyFamInstDecl x
- type family XXFamEqn x r
- type family XCFamEqn x r
- type family XXConDecl x
- type family XConDeclH98 x
- type family XConDeclGADT x
- type family XXDerivClauseTys x
- type family XDctMulti x
- type family XDctSingle x
- type family XXHsDerivingClause x
- type family XCHsDerivingClause x
- type family XXHsDataDefn x
- type family XCHsDataDefn x
- type family XXFamilyDecl x
- type family XCFamilyDecl x
- type family XXFamilyResultSig x
- type family XTyVarSig x
- type family XCKindSig x
- type family XNoSig x
- type family XXTyClGroup x
- type family XCTyClGroup x
- type family XXFunDep x
- type family XCFunDep x
- type family XXTyClDecl x
- type family XClassDecl x
- type family XDataDecl x
- type family XSynDecl x
- type family XFamDecl x
- type family XXSpliceDecl x
- type family XSpliceDecl x
- type family XXHsGroup x
- type family XCHsGroup x
- type family XXHsDecl x
- type family XRoleAnnotD x
- type family XDocD x
- type family XSpliceD x
- type family XRuleD x
- type family XAnnD x
- type family XWarningD x
- type family XForD x
- type family XDefD x
- type family XKindSigD x
- type family XSigD x
- type family XValD x
- type family XDerivD x
- type family XInstD x
- type family XTyClD x
- type family XXStandaloneKindSig x
- type family XStandaloneKindSig x
- type family XXFixitySig x
- type family XFixitySig x
- type family XXSig x
- type family XCompleteMatchSig x
- type family XSCCFunSig x
- type family XMinimalSig x
- type family XSpecInstSig x
- type family XSpecSig x
- type family XInlineSig x
- type family XFixSig x
- type family XIdSig x
- type family XClassOpSig x
- type family XPatSynSig x
- type family XTypeSig x
- type family XXIPBind x
- type family XCIPBind x
- type family XXHsIPBinds x
- type family XIPBinds x
- type family XXPatSynBind x x'
- type family XPSB x x'
- type family XXHsBindsLR x x'
- type family XPatSynBind x x'
- type family XVarBind x x'
- type family XPatBind x x'
- type family XFunBind x x'
- type family XXValBindsLR x x'
- type family XValBinds x x'
- type family XXHsLocalBindsLR x x'
- type family XEmptyLocalBinds x x'
- type family XHsIPBinds x x'
- type family XHsValBinds x x'
- type LIdP p = XRec p (IdP p)
- type family IdP p
- class WrapXRec p a where
- class MapXRec p where
- class UnXRec p where
- type family Anno a = (b :: Type)
- type family XRec p a = (r :: Type) | r -> a
- data DataConCantHappen
- newtype ModuleName = ModuleName FastString
- data IsBootInterface
- data LayoutInfo pass
- = ExplicitBraces !(LHsToken "{" pass) !(LHsToken "}" pass)
- | VirtualBraces !Int
- | NoLayoutInfo
- data HsUniToken (tok :: Symbol) (utok :: Symbol)
- data HsToken (tok :: Symbol) = HsTok
- type LHsUniToken (tok :: Symbol) (utok :: Symbol) p = XRec p (HsUniToken tok utok)
- type LHsToken (tok :: Symbol) p = XRec p (HsToken tok)
- type LPat p = XRec p (Pat p)
- type LHsExpr p = XRec p (HsExpr p)
- type family SyntaxExpr p
- data GRHSs p body
- = GRHSs {
- grhssExt :: XCGRHSs p body
- grhssGRHSs :: [LGRHS p body]
- grhssLocalBinds :: HsLocalBinds p
- | XGRHSs !(XXGRHSs p body)
- = GRHSs {
- data MatchGroup p body
- = MG { }
- | XMatchGroup !(XXMatchGroup p body)
- data HsUntypedSplice id
- = HsUntypedSpliceExpr (XUntypedSpliceExpr id) (LHsExpr id)
- | HsQuasiQuote (XQuasiQuote id) (IdP id) (XRec id FastString)
- | XUntypedSplice !(XXUntypedSplice id)
- data PromotionFlag
- type LIEWrappedName p = XRec p (IEWrappedName p)
- data IEWrappedName p
- = IEName (XIEName p) (LIdP p)
- | IEPattern (XIEPattern p) (LIdP p)
- | IEType (XIEType p) (LIdP p)
- | XIEWrappedName !(XXIEWrappedName p)
- data IEWildcard
- type LIE pass = XRec pass (IE pass)
- data ImportListInterpretation
- data ImportDecl pass
- = ImportDecl {
- ideclExt :: XCImportDecl pass
- ideclName :: XRec pass ModuleName
- ideclPkgQual :: ImportDeclPkgQual pass
- ideclSource :: IsBootInterface
- ideclSafe :: Bool
- ideclQualified :: ImportDeclQualifiedStyle
- ideclAs :: Maybe (XRec pass ModuleName)
- ideclImportList :: Maybe (ImportListInterpretation, XRec pass [LIE pass])
- | XImportDecl !(XXImportDecl pass)
- = ImportDecl {
- data ImportDeclQualifiedStyle
- type LImportDecl pass = XRec pass (ImportDecl pass)
- data OverLitVal
- data HsOverLit p
- 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 HsSrcBang = HsSrcBang SourceText SrcUnpackedness SrcStrictness
- data AmbiguousFieldOcc pass
- = Unambiguous (XUnambiguous pass) (XRec pass RdrName)
- | Ambiguous (XAmbiguous pass) (XRec pass RdrName)
- | XAmbiguousFieldOcc !(XXAmbiguousFieldOcc pass)
- type LAmbiguousFieldOcc pass = XRec pass (AmbiguousFieldOcc pass)
- data FieldOcc pass
- = FieldOcc {
- foExt :: XCFieldOcc pass
- foLabel :: XRec pass RdrName
- | XFieldOcc !(XXFieldOcc pass)
- = FieldOcc {
- type LFieldOcc pass = XRec pass (FieldOcc pass)
- type LHsTypeArg p = HsArg (LHsType p) (LHsKind p)
- data HsArg tm ty
- data HsConDetails tyarg arg rec
- data ConDeclField pass
- = ConDeclField {
- cd_fld_ext :: XConDeclField pass
- cd_fld_names :: [LFieldOcc pass]
- cd_fld_type :: LBangType pass
- cd_fld_doc :: Maybe (LHsDoc pass)
- | XConDeclField !(XXConDeclField pass)
- = ConDeclField {
- type LConDeclField pass = XRec pass (ConDeclField pass)
- data HsTupleSort
- data HsScaled pass a = HsScaled (HsArrow pass) a
- data HsLinearArrowTokens pass
- = HsPct1 !(LHsToken "%1" pass) !(LHsUniToken "->" "\8594" pass)
- | HsLolly !(LHsToken "\8888" pass)
- data HsArrow pass
- = HsUnrestrictedArrow !(LHsUniToken "->" "\8594" pass)
- | HsLinearArrow !(HsLinearArrowTokens pass)
- | HsExplicitMult !(LHsToken "%" pass) !(LHsType pass) !(LHsUniToken "->" "\8594" pass)
- data HsTyLit pass
- data HsType pass
- = HsForAllTy {
- hst_xforall :: XForAllTy pass
- hst_tele :: HsForAllTelescope pass
- hst_body :: LHsType pass
- | HsQualTy { }
- | HsTyVar (XTyVar pass) PromotionFlag (LIdP pass)
- | HsAppTy (XAppTy pass) (LHsType pass) (LHsType pass)
- | HsAppKindTy (XAppKindTy pass) (LHsType pass) (LHsKind pass)
- | HsFunTy (XFunTy pass) (HsArrow pass) (LHsType pass) (LHsType pass)
- | HsListTy (XListTy pass) (LHsType pass)
- | HsTupleTy (XTupleTy pass) HsTupleSort [LHsType pass]
- | HsSumTy (XSumTy pass) [LHsType pass]
- | HsOpTy (XOpTy pass) PromotionFlag (LHsType pass) (LIdP pass) (LHsType pass)
- | HsParTy (XParTy pass) (LHsType pass)
- | HsIParamTy (XIParamTy pass) (XRec pass HsIPName) (LHsType pass)
- | HsStarTy (XStarTy pass) Bool
- | HsKindSig (XKindSig pass) (LHsType pass) (LHsKind pass)
- | HsSpliceTy (XSpliceTy pass) (HsUntypedSplice pass)
- | HsDocTy (XDocTy pass) (LHsType pass) (LHsDoc pass)
- | HsBangTy (XBangTy pass) HsSrcBang (LHsType pass)
- | HsRecTy (XRecTy pass) [LConDeclField pass]
- | HsExplicitListTy (XExplicitListTy pass) PromotionFlag [LHsType pass]
- | HsExplicitTupleTy (XExplicitTupleTy pass) [LHsType pass]
- | HsTyLit (XTyLit pass) (HsTyLit pass)
- | HsWildCardTy (XWildCardTy pass)
- | XHsType !(XXType pass)
- = HsForAllTy {
- data HsTyVarBndr flag pass
- = UserTyVar (XUserTyVar pass) flag (LIdP pass)
- | KindedTyVar (XKindedTyVar pass) flag (LIdP pass) (LHsKind pass)
- | XTyVarBndr !(XXTyVarBndr pass)
- newtype HsIPName = HsIPName FastString
- data HsSigType pass
- = HsSig { }
- | XHsSigType !(XXHsSigType pass)
- type LHsSigWcType pass = HsWildCardBndrs pass (LHsSigType pass)
- type LHsWcType pass = HsWildCardBndrs pass (LHsType pass)
- type LHsSigType pass = XRec pass (HsSigType pass)
- data HsPatSigType pass
- = HsPS { }
- | XHsPatSigType !(XXHsPatSigType pass)
- data HsWildCardBndrs pass thing
- = HsWC { }
- | XHsWildCardBndrs !(XXHsWildCardBndrs pass thing)
- type HsOuterFamEqnTyVarBndrs = HsOuterTyVarBndrs ()
- type HsOuterSigTyVarBndrs = HsOuterTyVarBndrs Specificity
- data HsOuterTyVarBndrs flag pass
- = HsOuterImplicit {
- hso_ximplicit :: XHsOuterImplicit pass
- | HsOuterExplicit {
- hso_xexplicit :: XHsOuterExplicit pass flag
- hso_bndrs :: [LHsTyVarBndr flag (NoGhcTc pass)]
- | XHsOuterTyVarBndrs !(XXHsOuterTyVarBndrs pass)
- = HsOuterImplicit {
- data LHsQTyVars pass
- = HsQTvs {
- hsq_ext :: XHsQTvs pass
- hsq_explicit :: [LHsTyVarBndr () pass]
- | XLHsQTyVars !(XXLHsQTyVars pass)
- = HsQTvs {
- type LHsTyVarBndr flag pass = XRec pass (HsTyVarBndr flag pass)
- data HsForAllTelescope pass
- = HsForAllVis {
- hsf_xvis :: XHsForAllVis pass
- hsf_vis_bndrs :: [LHsTyVarBndr () pass]
- | HsForAllInvis {
- hsf_xinvis :: XHsForAllInvis pass
- hsf_invis_bndrs :: [LHsTyVarBndr Specificity pass]
- | XHsForAllTelescope !(XXHsForAllTelescope pass)
- = HsForAllVis {
- type LHsKind pass = XRec pass (HsKind pass)
- type HsKind pass = HsType pass
- type LHsType pass = XRec pass (HsType pass)
- type HsContext pass = [LHsType pass]
- type LHsContext pass = XRec pass (HsContext pass)
- type LBangType pass = XRec pass (BangType pass)
- data HsFieldBind lhs rhs = HsFieldBind {}
- type HsRecUpdField p = HsFieldBind (LAmbiguousFieldOcc p) (LHsExpr p)
- type HsRecField p arg = HsFieldBind (LFieldOcc p) arg
- type LHsRecUpdField p = XRec p (HsRecUpdField p)
- type LHsRecField p arg = XRec p (HsRecField p arg)
- type LHsFieldBind p id arg = XRec p (HsFieldBind id arg)
- newtype RecFieldsDotDot = RecFieldsDotDot {}
- data HsRecFields p arg = HsRecFields {
- rec_flds :: [LHsRecField p arg]
- rec_dotdot :: Maybe (XRec p RecFieldsDotDot)
- type HsConPatDetails p = HsConDetails (HsConPatTyArg (NoGhcTc p)) (LPat p) (HsRecFields p (LPat p))
- data HsConPatTyArg p = HsConPatTyArg !(LHsToken "@" p) (HsPatSigType p)
- type family ConLikeP x
- data HsPatSynDir id
- data RecordPatSynField pass = RecordPatSynField {
- recordPatSynField :: FieldOcc pass
- recordPatSynPatVar :: LIdP pass
- type HsPatSynDetails pass = HsConDetails Void (LIdP pass) [RecordPatSynField pass]
- data FixitySig pass
- = FixitySig (XFixitySig pass) [LIdP pass] Fixity
- | XFixitySig !(XXFixitySig pass)
- type LFixitySig pass = XRec pass (FixitySig pass)
- data Sig pass
- = TypeSig (XTypeSig pass) [LIdP pass] (LHsSigWcType pass)
- | PatSynSig (XPatSynSig pass) [LIdP pass] (LHsSigType pass)
- | ClassOpSig (XClassOpSig pass) Bool [LIdP pass] (LHsSigType pass)
- | FixSig (XFixSig pass) (FixitySig pass)
- | InlineSig (XInlineSig pass) (LIdP pass) InlinePragma
- | SpecSig (XSpecSig pass) (LIdP pass) [LHsSigType pass] InlinePragma
- | SpecInstSig (XSpecInstSig pass) (LHsSigType pass)
- | MinimalSig (XMinimalSig pass) (LBooleanFormula (LIdP pass))
- | SCCFunSig (XSCCFunSig pass) (LIdP pass) (Maybe (XRec pass StringLiteral))
- | CompleteMatchSig (XCompleteMatchSig pass) (XRec pass [LIdP pass]) (Maybe (LIdP pass))
- | XSig !(XXSig pass)
- type LSig pass = XRec pass (Sig pass)
- data IPBind id
- type LIPBind id = XRec id (IPBind id)
- data HsIPBinds id
- = IPBinds (XIPBinds id) [LIPBind id]
- | XHsIPBinds !(XXHsIPBinds id)
- data PatSynBind idL idR
- = PSB {
- psb_ext :: XPSB idL idR
- psb_id :: LIdP idL
- psb_args :: HsPatSynDetails idR
- psb_def :: LPat idR
- psb_dir :: HsPatSynDir idR
- | XPatSynBind !(XXPatSynBind idL idR)
- = PSB {
- data HsBindLR idL idR
- = FunBind {
- fun_ext :: XFunBind idL idR
- fun_id :: LIdP idL
- fun_matches :: MatchGroup idR (LHsExpr idR)
- | PatBind { }
- | VarBind { }
- | PatSynBind (XPatSynBind idL idR) (PatSynBind idL idR)
- | XHsBindsLR !(XXHsBindsLR idL idR)
- = FunBind {
- type LHsBindLR idL idR = XRec idL (HsBindLR idL idR)
- type LHsBindsLR idL idR = Bag (LHsBindLR idL idR)
- type HsBind id = HsBindLR id id
- type LHsBinds id = LHsBindsLR id id
- type LHsBind id = LHsBindLR id id
- data HsValBindsLR idL idR
- = ValBinds (XValBinds idL idR) (LHsBindsLR idL idR) [LSig idR]
- | XValBindsLR !(XXValBindsLR idL idR)
- type HsValBinds id = HsValBindsLR id id
- type LHsLocalBindsLR idL idR = XRec idL (HsLocalBindsLR idL idR)
- 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 LHsLocalBinds id = XRec id (HsLocalBinds id)
- type HsLocalBinds id = HsLocalBindsLR id id
- data RoleAnnotDecl pass
- = RoleAnnotDecl (XCRoleAnnotDecl pass) (LIdP pass) [XRec pass (Maybe Role)]
- | XRoleAnnotDecl !(XXRoleAnnotDecl pass)
- type LRoleAnnotDecl pass = XRec pass (RoleAnnotDecl pass)
- data AnnProvenance pass
- = ValueAnnProvenance (LIdP pass)
- | TypeAnnProvenance (LIdP pass)
- | ModuleAnnProvenance
- type LAnnDecl pass = XRec pass (AnnDecl pass)
- data WarnDecl pass
- = Warning (XWarning pass) [LIdP pass] (WarningTxt pass)
- | XWarnDecl !(XXWarnDecl pass)
- type LWarnDecl pass = XRec pass (WarnDecl pass)
- data WarnDecls pass
- = Warnings {
- wd_ext :: XWarnings pass
- wd_warnings :: [LWarnDecl pass]
- | XWarnDecls !(XXWarnDecls pass)
- = Warnings {
- type LWarnDecls pass = XRec pass (WarnDecls pass)
- data DocDecl pass
- = DocCommentNext (LHsDoc pass)
- | DocCommentPrev (LHsDoc pass)
- | DocCommentNamed String (LHsDoc pass)
- | DocGroup Int (LHsDoc pass)
- type LDocDecl pass = XRec pass (DocDecl pass)
- type LRuleBndr pass = XRec pass (RuleBndr pass)
- data RuleDecl pass
- type LRuleDecl pass = XRec pass (RuleDecl pass)
- data RuleDecls pass
- = HsRules {
- rds_ext :: XCRuleDecls pass
- rds_rules :: [LRuleDecl pass]
- | XRuleDecls !(XXRuleDecls pass)
- = HsRules {
- type LRuleDecls pass = XRec pass (RuleDecls pass)
- data ForeignExport pass
- = CExport (XCExport pass) (XRec pass CExportSpec)
- | XForeignExport !(XXForeignExport pass)
- data CImportSpec
- data ForeignImport pass
- = CImport (XCImport pass) (XRec pass CCallConv) (XRec pass Safety) (Maybe Header) CImportSpec
- | XForeignImport !(XXForeignImport pass)
- data ForeignDecl pass
- = ForeignImport {
- fd_i_ext :: XForeignImport pass
- fd_name :: LIdP pass
- fd_sig_ty :: LHsSigType pass
- fd_fi :: ForeignImport pass
- | ForeignExport {
- fd_e_ext :: XForeignExport pass
- fd_name :: LIdP pass
- fd_sig_ty :: LHsSigType pass
- fd_fe :: ForeignExport pass
- | XForeignDecl !(XXForeignDecl pass)
- = ForeignImport {
- type LForeignDecl pass = XRec pass (ForeignDecl pass)
- data DefaultDecl pass
- = DefaultDecl (XCDefaultDecl pass) [LHsType pass]
- | XDefaultDecl !(XXDefaultDecl pass)
- type LDefaultDecl pass = XRec pass (DefaultDecl pass)
- type LDerivStrategy pass = XRec pass (DerivStrategy pass)
- data DerivDecl pass
- = DerivDecl {
- deriv_ext :: XCDerivDecl pass
- deriv_type :: LHsSigWcType pass
- deriv_strategy :: Maybe (LDerivStrategy pass)
- deriv_overlap_mode :: Maybe (XRec pass OverlapMode)
- | XDerivDecl !(XXDerivDecl pass)
- = DerivDecl {
- type LDerivDecl pass = XRec pass (DerivDecl 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 LInstDecl pass = XRec pass (InstDecl 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 (XRec pass OverlapMode)
- | XClsInstDecl !(XXClsInstDecl pass)
- = ClsInstDecl {
- type LClsInstDecl pass = XRec pass (ClsInstDecl pass)
- data FamEqn pass rhs
- = FamEqn {
- feqn_ext :: XCFamEqn pass rhs
- feqn_tycon :: LIdP pass
- feqn_bndrs :: HsOuterFamEqnTyVarBndrs pass
- feqn_pats :: HsTyPats pass
- feqn_fixity :: LexicalFixity
- feqn_rhs :: rhs
- | XFamEqn !(XXFamEqn pass rhs)
- = FamEqn {
- newtype DataFamInstDecl pass = DataFamInstDecl {
- dfid_eqn :: FamEqn pass (HsDataDefn pass)
- type LDataFamInstDecl pass = XRec pass (DataFamInstDecl pass)
- data TyFamInstDecl pass
- = TyFamInstDecl {
- tfid_xtn :: XCTyFamInstDecl pass
- tfid_eqn :: TyFamInstEqn pass
- | XTyFamInstDecl !(XXTyFamInstDecl pass)
- = TyFamInstDecl {
- type LTyFamInstDecl pass = XRec pass (TyFamInstDecl pass)
- type LTyFamDefltDecl pass = XRec pass (TyFamDefltDecl pass)
- type TyFamDefltDecl = TyFamInstDecl
- type TyFamInstEqn pass = FamEqn pass (LHsType pass)
- type HsTyPats pass = [LHsTypeArg pass]
- type LTyFamInstEqn pass = XRec pass (TyFamInstEqn pass)
- data HsConDeclGADTDetails pass
- = PrefixConGADT [HsScaled pass (LBangType pass)]
- | RecConGADT (XRec pass [LConDeclField pass]) (LHsUniToken "->" "\8594" pass)
- type HsConDeclH98Details pass = HsConDetails Void (HsScaled pass (LBangType pass)) (XRec pass [LConDeclField pass])
- data ConDecl pass
- = ConDeclGADT {
- con_g_ext :: XConDeclGADT pass
- con_names :: NonEmpty (LIdP pass)
- con_dcolon :: !(LHsUniToken "::" "\8759" pass)
- con_bndrs :: XRec pass (HsOuterSigTyVarBndrs pass)
- con_mb_cxt :: Maybe (LHsContext pass)
- con_g_args :: HsConDeclGADTDetails pass
- con_res_ty :: LHsType pass
- con_doc :: Maybe (LHsDoc pass)
- | ConDeclH98 {
- con_ext :: XConDeclH98 pass
- con_name :: LIdP pass
- con_forall :: Bool
- con_ex_tvs :: [LHsTyVarBndr Specificity pass]
- con_mb_cxt :: Maybe (LHsContext pass)
- con_args :: HsConDeclH98Details pass
- con_doc :: Maybe (LHsDoc pass)
- | XConDecl !(XXConDecl pass)
- = ConDeclGADT {
- type LConDecl pass = XRec pass (ConDecl pass)
- data DataDefnCons a
- = NewTypeCon a
- | DataTypeCons Bool [a]
- data NewOrData
- data StandaloneKindSig pass
- = StandaloneKindSig (XStandaloneKindSig pass) (LIdP pass) (LHsSigType pass)
- | XStandaloneKindSig !(XXStandaloneKindSig pass)
- type LStandaloneKindSig pass = XRec pass (StandaloneKindSig pass)
- data DerivClauseTys pass
- = DctSingle (XDctSingle pass) (LHsSigType pass)
- | DctMulti (XDctMulti pass) [LHsSigType pass]
- | XDerivClauseTys !(XXDerivClauseTys pass)
- type LDerivClauseTys pass = XRec pass (DerivClauseTys pass)
- data HsDerivingClause pass
- = HsDerivingClause {
- deriv_clause_ext :: XCHsDerivingClause pass
- deriv_clause_strategy :: Maybe (LDerivStrategy pass)
- deriv_clause_tys :: LDerivClauseTys pass
- | XHsDerivingClause !(XXHsDerivingClause pass)
- = HsDerivingClause {
- type LHsDerivingClause pass = XRec pass (HsDerivingClause pass)
- type HsDeriving pass = [LHsDerivingClause pass]
- data HsDataDefn pass
- = HsDataDefn {
- dd_ext :: XCHsDataDefn pass
- dd_ctxt :: Maybe (LHsContext pass)
- dd_cType :: Maybe (XRec pass CType)
- dd_kindSig :: Maybe (LHsKind pass)
- dd_cons :: DataDefnCons (LConDecl pass)
- dd_derivs :: HsDeriving pass
- | XHsDataDefn !(XXHsDataDefn pass)
- = HsDataDefn {
- data FamilyInfo pass
- = DataFamily
- | OpenTypeFamily
- | ClosedTypeFamily (Maybe [LTyFamInstEqn pass])
- type LInjectivityAnn pass = XRec pass (InjectivityAnn pass)
- data FamilyDecl pass
- = FamilyDecl {
- fdExt :: XCFamilyDecl pass
- fdInfo :: FamilyInfo pass
- fdTopLevel :: TopLevelFlag
- fdLName :: LIdP pass
- fdTyVars :: LHsQTyVars pass
- fdFixity :: LexicalFixity
- fdResultSig :: LFamilyResultSig pass
- fdInjectivityAnn :: Maybe (LInjectivityAnn pass)
- | XFamilyDecl !(XXFamilyDecl pass)
- = FamilyDecl {
- type LFamilyDecl pass = XRec pass (FamilyDecl pass)
- data FamilyResultSig pass
- = NoSig (XNoSig pass)
- | KindSig (XCKindSig pass) (LHsKind pass)
- | TyVarSig (XTyVarSig pass) (LHsTyVarBndr () pass)
- | XFamilyResultSig !(XXFamilyResultSig pass)
- type LFamilyResultSig pass = XRec pass (FamilyResultSig pass)
- data TyClGroup pass
- = TyClGroup {
- group_ext :: XCTyClGroup pass
- group_tyclds :: [LTyClDecl pass]
- group_roles :: [LRoleAnnotDecl pass]
- group_kisigs :: [LStandaloneKindSig pass]
- group_instds :: [LInstDecl pass]
- | XTyClGroup !(XXTyClGroup pass)
- = TyClGroup {
- type LHsFunDep pass = XRec pass (FunDep pass)
- data TyClDecl pass
- = FamDecl {
- tcdFExt :: XFamDecl pass
- tcdFam :: FamilyDecl pass
- | SynDecl {
- tcdSExt :: XSynDecl pass
- tcdLName :: LIdP pass
- tcdTyVars :: LHsQTyVars pass
- tcdFixity :: LexicalFixity
- tcdRhs :: LHsType pass
- | DataDecl {
- tcdDExt :: XDataDecl pass
- tcdLName :: LIdP pass
- tcdTyVars :: LHsQTyVars pass
- tcdFixity :: LexicalFixity
- tcdDataDefn :: HsDataDefn pass
- | ClassDecl {
- tcdCExt :: XClassDecl pass
- tcdLayout :: !(LayoutInfo pass)
- tcdCtxt :: Maybe (LHsContext pass)
- tcdLName :: LIdP pass
- tcdTyVars :: LHsQTyVars pass
- tcdFixity :: LexicalFixity
- tcdFDs :: [LHsFunDep pass]
- tcdSigs :: [LSig pass]
- tcdMeths :: LHsBinds pass
- tcdATs :: [LFamilyDecl pass]
- tcdATDefs :: [LTyFamDefltDecl pass]
- tcdDocs :: [LDocDecl pass]
- | XTyClDecl !(XXTyClDecl pass)
- = FamDecl {
- type LTyClDecl pass = XRec pass (TyClDecl pass)
- data SpliceDecoration
- data SpliceDecl p
- = SpliceDecl (XSpliceDecl p) (XRec p (HsUntypedSplice p)) SpliceDecoration
- | XSpliceDecl !(XXSpliceDecl p)
- type LSpliceDecl pass = XRec pass (SpliceDecl pass)
- 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 p]
- | XHsGroup !(XXHsGroup p)
- = HsGroup {
- data HsDecl p
- = TyClD (XTyClD p) (TyClDecl p)
- | InstD (XInstD p) (InstDecl p)
- | DerivD (XDerivD p) (DerivDecl p)
- | ValD (XValD p) (HsBind p)
- | SigD (XSigD p) (Sig p)
- | KindSigD (XKindSigD p) (StandaloneKindSig p)
- | DefD (XDefD p) (DefaultDecl p)
- | ForD (XForD p) (ForeignDecl 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 p)
- | RoleAnnotD (XRoleAnnotD p) (RoleAnnotDecl p)
- | XHsDecl !(XXHsDecl p)
- type LHsDecl p = XRec p (HsDecl p)
- data HsDoFlavour
- = DoExpr (Maybe ModuleName)
- | MDoExpr (Maybe ModuleName)
- | GhciStmtCtxt
- | ListComp
- | MonadComp
- data HsArrowMatchContext
- data HsStmtContext p
- = HsDoStmt HsDoFlavour
- | PatGuard (HsMatchContext p)
- | ParStmtCtxt (HsStmtContext p)
- | TransStmtCtxt (HsStmtContext p)
- | ArrowExpr
- data HsMatchContext p
- data ArithSeqInfo id
- data HsQuote p
- data ApplicativeArg idL
- = ApplicativeArgOne {
- xarg_app_arg_one :: XApplicativeArgOne idL
- app_arg_pattern :: LPat idL
- arg_expr :: LHsExpr idL
- is_body_stmt :: Bool
- | ApplicativeArgMany {
- xarg_app_arg_many :: XApplicativeArgMany idL
- app_stmts :: [ExprLStmt idL]
- final_expr :: HsExpr idL
- bv_pattern :: LPat idL
- stmt_context :: HsDoFlavour
- | XApplicativeArg !(XXApplicativeArg idL)
- = ApplicativeArgOne {
- type FailOperator id = Maybe (SyntaxExpr id)
- data ParStmtBlock idL idR
- = ParStmtBlock (XParStmtBlock idL idR) [ExprLStmt idL] [IdP idR] (SyntaxExpr idR)
- | XParStmtBlock !(XXParStmtBlock idL idR)
- data TransForm
- data StmtLR idL idR body
- = LastStmt (XLastStmt idL idR body) body (Maybe Bool) (SyntaxExpr idR)
- | BindStmt (XBindStmt idL idR body) (LPat idL) body
- | 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) (HsLocalBindsLR idL idR)
- | ParStmt (XParStmt idL idR body) [ParStmtBlock idL idR] (HsExpr idR) (SyntaxExpr idR)
- | TransStmt { }
- | RecStmt {
- recS_ext :: XRecStmt idL idR body
- recS_stmts :: XRec idR [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)
- type GhciStmt id = Stmt id (LHsExpr id)
- type GhciLStmt id = LStmt id (LHsExpr id)
- type GuardStmt id = Stmt id (LHsExpr id)
- type GuardLStmt id = LStmt id (LHsExpr id)
- type ExprStmt id = Stmt id (LHsExpr id)
- type ExprLStmt id = LStmt id (LHsExpr id)
- type CmdStmt id = Stmt id (LHsCmd id)
- type CmdLStmt id = LStmt id (LHsCmd id)
- type LStmtLR idL idR body = XRec idL (StmtLR idL idR body)
- type LStmt id body = XRec id (StmtLR id id body)
- data GRHS p body
- = GRHS (XCGRHS p body) [GuardLStmt p] body
- | XGRHS !(XXGRHS p body)
- type LGRHS id body = XRec id (GRHS id body)
- type LMatch id body = XRec id (Match id body)
- type HsRecordBinds p = HsRecFields p (LHsExpr p)
- data HsCmdTop p
- type LHsCmdTop p = XRec p (HsCmdTop p)
- data HsArrAppType
- 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) !(LHsToken "(" id) (LHsCmd id) !(LHsToken ")" id)
- | HsCmdCase (XCmdCase id) (LHsExpr id) (MatchGroup id (LHsCmd id))
- | HsCmdLamCase (XCmdLamCase id) LamCaseVariant (MatchGroup id (LHsCmd id))
- | HsCmdIf (XCmdIf id) (SyntaxExpr id) (LHsExpr id) (LHsCmd id) (LHsCmd id)
- | HsCmdLet (XCmdLet id) !(LHsToken "let" id) (HsLocalBinds id) !(LHsToken "in" id) (LHsCmd id)
- | HsCmdDo (XCmdDo id) (XRec id [CmdLStmt id])
- | XCmd !(XXCmd id)
- type LHsCmd id = XRec id (HsCmd id)
- data LamCaseVariant
- data HsTupArg id
- type LHsTupArg id = XRec id (HsTupArg id)
- data HsPragE p
- = HsPragSCC (XSCC p) StringLiteral
- | XHsPragE !(XXPragE p)
- data DotFieldOcc p
- = DotFieldOcc {
- dfoExt :: XCDotFieldOcc p
- dfoLabel :: XRec p FieldLabelString
- | XDotFieldOcc !(XXDotFieldOcc p)
- = DotFieldOcc {
- type LHsRecUpdProj p = XRec p (RecUpdProj p)
- type RecUpdProj p = RecProj p (LHsExpr p)
- type LHsRecProj p arg = XRec p (RecProj p arg)
- type RecProj p arg = HsFieldBind (LFieldLabelStrings p) arg
- newtype FieldLabelStrings p = FieldLabelStrings [XRec p (DotFieldOcc p)]
- type LFieldLabelStrings p = XRec p (FieldLabelStrings p)
- data HsModule p
- = HsModule {
- hsmodExt :: XCModule p
- hsmodName :: Maybe (XRec p ModuleName)
- hsmodExports :: Maybe (XRec p [LIE p])
- hsmodImports :: [LImportDecl p]
- hsmodDecls :: [LHsDecl p]
- | XModule !(XXModule p)
- = HsModule {
- pattern XFunDep :: !(XXFunDep pass) -> FunDep pass
- noExtField :: NoExtField
- dataConCantHappen :: DataConCantHappen -> a
- stableModuleNameCmp :: ModuleName -> ModuleName -> Ordering
- moduleNameFS :: ModuleName -> FastString
- moduleNameString :: ModuleName -> String
- mkModuleName :: String -> ModuleName
- mkModuleNameFS :: FastString -> ModuleName
- moduleNameSlashes :: ModuleName -> String
- moduleNameColons :: ModuleName -> String
- parseModuleName :: ReadP ModuleName
- isPromoted :: PromotionFlag -> Bool
- negateOverLitVal :: OverLitVal -> OverLitVal
- hsQTvExplicit :: LHsQTyVars pass -> [LHsTyVarBndr () pass]
- hsPatSigType :: HsPatSigType pass -> LHsType pass
- mapHsOuterImplicit :: (XHsOuterImplicit pass -> XHsOuterImplicit pass) -> HsOuterTyVarBndrs flag pass -> HsOuterTyVarBndrs flag pass
- hsIPNameFS :: HsIPName -> FastString
- isHsKindedTyVar :: HsTyVarBndr flag pass -> Bool
- hsMult :: HsScaled pass a -> HsArrow pass
- hsScaledThing :: HsScaled pass a -> a
- noTypeArgs :: [Void]
- hsConPatArgs :: UnXRec p => HsConPatDetails p -> [LPat p]
- hsRecFields :: UnXRec p => HsRecFields p arg -> [XCFieldOcc p]
- hsRecFieldsArgs :: UnXRec p => HsRecFields p arg -> [arg]
- hsRecFieldSel :: UnXRec p => HsRecField p arg -> XCFieldOcc p
- isFixityLSig :: UnXRec p => LSig p -> Bool
- isTypeLSig :: UnXRec p => LSig p -> Bool
- isSpecLSig :: UnXRec p => LSig p -> Bool
- isSpecInstLSig :: UnXRec p => LSig p -> Bool
- isPragLSig :: UnXRec p => LSig p -> Bool
- isInlineLSig :: UnXRec p => LSig p -> Bool
- isMinimalLSig :: UnXRec p => LSig p -> Bool
- isSCCFunSig :: UnXRec p => LSig p -> Bool
- isCompleteMatchSig :: UnXRec p => LSig p -> Bool
- hsGroupInstDecls :: HsGroup id -> [LInstDecl id]
- isDataDecl :: TyClDecl pass -> Bool
- isSynDecl :: TyClDecl pass -> Bool
- isClassDecl :: TyClDecl pass -> Bool
- isFamilyDecl :: TyClDecl pass -> Bool
- isTypeFamilyDecl :: TyClDecl pass -> Bool
- isOpenTypeFamilyInfo :: FamilyInfo pass -> Bool
- isClosedTypeFamilyInfo :: FamilyInfo pass -> Bool
- isDataFamilyDecl :: TyClDecl pass -> Bool
- tyClDeclTyVars :: TyClDecl pass -> LHsQTyVars pass
- tyClGroupTyClDecls :: [TyClGroup pass] -> [LTyClDecl pass]
- tyClGroupInstDecls :: [TyClGroup pass] -> [LInstDecl pass]
- tyClGroupRoleDecls :: [TyClGroup pass] -> [LRoleAnnotDecl pass]
- tyClGroupKindSigs :: [TyClGroup pass] -> [LStandaloneKindSig pass]
- dataDefnConsNewOrData :: DataDefnCons a -> NewOrData
- isTypeDataDefnCons :: DataDefnCons a -> Bool
- collectRuleBndrSigTys :: [RuleBndr pass] -> [HsPatSigType pass]
- docDeclDoc :: DocDecl pass -> LHsDoc pass
- annProvenanceName_maybe :: UnXRec p => AnnProvenance p -> Maybe (IdP p)
- isInfixMatch :: Match id body -> Bool
- isPatSynCtxt :: HsMatchContext p -> Bool
- qualifiedDoModuleName_maybe :: HsStmtContext p -> Maybe ModuleName
- isComprehensionContext :: HsStmtContext id -> Bool
- isDoComprehensionContext :: HsDoFlavour -> Bool
- isMonadStmtContext :: HsStmtContext id -> Bool
- isMonadDoStmtContext :: HsDoFlavour -> Bool
- isMonadCompContext :: HsStmtContext id -> Bool
- isMonadDoCompContext :: HsDoFlavour -> Bool
- module GHC.Rename.Names
- module GHC.Rename.Splice
- module GHC.Tc.Instance.Family
- module GHC.Tc.Module
- module GHC.Tc.Types
- data Role
- data LeftOrRight
- data CoercionHole
- data QuoteWrapper = QuoteWrapper EvVar Type
- data HoleExprRef = HER (IORef EvTerm) TcType Unique
- data EvCallStack
- data EvTypeable
- type EvExpr = CoreExpr
- data EvTerm
- data EvBind = EvBind {}
- newtype EvBindMap = EvBindMap {}
- data EvBindsVar
- data TcEvBinds
- = TcEvBinds EvBindsVar
- | EvBinds (Bag EvBind)
- data HsWrapper
- type TcMCoercionR = MCoercionR
- type TcMCoercionN = MCoercionN
- type TcMCoercion = MCoercion
- type TcCoercionP = CoercionP
- type TcCoercionR = CoercionR
- type TcCoercionN = CoercionN
- type TcCoercion = Coercion
- pickLR :: LeftOrRight -> (a, a) -> a
- maybeSymCo :: SwapFlag -> TcCoercion -> TcCoercion
- mkWpFun :: HsWrapper -> HsWrapper -> Scaled TcTypeFRR -> TcType -> HsWrapper
- mkWpEta :: [Id] -> HsWrapper -> HsWrapper
- mkWpCastR :: TcCoercionR -> HsWrapper
- mkWpCastN :: TcCoercionN -> HsWrapper
- mkWpTyApps :: [Type] -> HsWrapper
- mkWpEvApps :: [EvTerm] -> HsWrapper
- mkWpEvVarApps :: [EvVar] -> HsWrapper
- mkWpTyLams :: [TyVar] -> HsWrapper
- mkWpEvLams :: [Var] -> HsWrapper
- mkWpLet :: TcEvBinds -> HsWrapper
- idHsWrapper :: HsWrapper
- isIdHsWrapper :: HsWrapper -> Bool
- hsWrapDictBinders :: HsWrapper -> Bag DictId
- collectHsWrapBinders :: HsWrapper -> ([Var], HsWrapper)
- isCoEvBindsVar :: EvBindsVar -> Bool
- emptyEvBindMap :: EvBindMap
- extendEvBinds :: EvBindMap -> EvBind -> EvBindMap
- isEmptyEvBindMap :: EvBindMap -> Bool
- lookupEvBind :: EvBindMap -> EvVar -> Maybe EvBind
- evBindMapBinds :: EvBindMap -> Bag EvBind
- foldEvBindMap :: (EvBind -> a -> a) -> a -> EvBindMap -> a
- nonDetStrictFoldEvBindMap :: (EvBind -> a -> a) -> a -> EvBindMap -> a
- filterEvBindMap :: (EvBind -> Bool) -> EvBindMap -> EvBindMap
- evBindMapToVarSet :: EvBindMap -> VarSet
- varSetMinusEvBindMap :: VarSet -> EvBindMap -> VarSet
- evBindVar :: EvBind -> EvVar
- mkWantedEvBind :: EvVar -> EvTerm -> EvBind
- mkGivenEvBind :: EvVar -> EvTerm -> EvBind
- evId :: EvId -> EvExpr
- evCoercion :: TcCoercion -> EvTerm
- evCast :: EvExpr -> TcCoercion -> EvTerm
- evDFunApp :: DFunId -> [Type] -> [EvExpr] -> EvTerm
- evDataConApp :: DataCon -> [Type] -> [EvExpr] -> EvTerm
- evSelector :: Id -> [Type] -> [EvExpr] -> EvExpr
- evTypeable :: Type -> EvTypeable -> EvTerm
- mkEvCast :: EvExpr -> TcCoercion -> EvTerm
- mkEvScSelectors :: Class -> [TcType] -> [(TcPredType, EvExpr)]
- emptyTcEvBinds :: TcEvBinds
- isEmptyTcEvBinds :: TcEvBinds -> Bool
- evTermCoercion_maybe :: EvTerm -> Maybe TcCoercion
- evTermCoercion :: EvTerm -> TcCoercion
- findNeededEvVars :: EvBindMap -> VarSet -> VarSet
- evVarsOfTerm :: EvTerm -> VarSet
- pprHsWrapper :: HsWrapper -> (Bool -> SDoc) -> SDoc
- unwrapIP :: Type -> CoercionR
- wrapIP :: Type -> CoercionR
- quoteWrapperTyVarTy :: QuoteWrapper -> Type
- applyQuoteWrapper :: QuoteWrapper -> HsWrapper
- module GHC.Tc.Utils.Env
- data Env gbl lcl = Env {}
- data TcGblEnv = TcGblEnv {
- tcg_mod :: Module
- tcg_semantic_mod :: Module
- tcg_src :: HscSource
- tcg_rdr_env :: GlobalRdrEnv
- tcg_default :: Maybe [Type]
- tcg_fix_env :: FixityEnv
- tcg_field_env :: RecFieldEnv
- tcg_type_env :: TypeEnv
- tcg_type_env_var :: KnotVars (IORef TypeEnv)
- tcg_inst_env :: !InstEnv
- tcg_fam_inst_env :: !FamInstEnv
- tcg_ann_env :: AnnEnv
- tcg_exports :: [AvailInfo]
- tcg_imports :: ImportAvails
- tcg_dus :: DefUses
- tcg_used_gres :: TcRef [GlobalRdrElt]
- tcg_keep :: TcRef NameSet
- tcg_th_used :: TcRef Bool
- tcg_th_splice_used :: TcRef Bool
- tcg_th_needed_deps :: TcRef ([Linkable], PkgsLoaded)
- tcg_dfun_n :: TcRef OccSet
- tcg_merged :: [(Module, Fingerprint)]
- tcg_rn_exports :: Maybe [(LIE GhcRn, Avails)]
- tcg_rn_imports :: [LImportDecl GhcRn]
- tcg_rn_decls :: Maybe (HsGroup GhcRn)
- tcg_dependent_files :: TcRef [FilePath]
- tcg_th_topdecls :: TcRef [LHsDecl GhcPs]
- tcg_th_foreign_files :: TcRef [(ForeignSrcLang, FilePath)]
- tcg_th_topnames :: TcRef NameSet
- tcg_th_modfinalizers :: TcRef [(TcLclEnv, ThModFinalizers)]
- tcg_th_coreplugins :: TcRef [String]
- tcg_th_state :: TcRef (Map TypeRep Dynamic)
- tcg_th_remote_state :: TcRef (Maybe (ForeignRef (IORef QState)))
- tcg_th_docs :: TcRef THDocs
- tcg_ev_binds :: Bag EvBind
- tcg_tr_module :: Maybe Id
- tcg_binds :: LHsBinds GhcTc
- tcg_sigs :: NameSet
- tcg_imp_specs :: [LTcSpecPrag]
- tcg_warns :: Warnings GhcRn
- tcg_anns :: [Annotation]
- tcg_tcs :: [TyCon]
- tcg_ksigs :: NameSet
- tcg_insts :: [ClsInst]
- tcg_fam_insts :: [FamInst]
- tcg_rules :: [LRuleDecl GhcTc]
- tcg_fords :: [LForeignDecl GhcTc]
- tcg_patsyns :: [PatSyn]
- tcg_doc_hdr :: Maybe (LHsDoc GhcRn)
- tcg_hpc :: !AnyHpcUsage
- tcg_self_boot :: SelfBootInfo
- tcg_main :: Maybe Name
- tcg_safe_infer :: TcRef Bool
- tcg_safe_infer_reasons :: TcRef (Messages TcRnMessage)
- tcg_tc_plugin_solvers :: [TcPluginSolver]
- tcg_tc_plugin_rewriters :: UniqFM TyCon [TcPluginRewriter]
- tcg_defaulting_plugins :: [FillDefaulting]
- tcg_hf_plugins :: [HoleFitPlugin]
- tcg_top_loc :: RealSrcSpan
- tcg_static_wc :: TcRef WantedConstraints
- tcg_complete_matches :: !CompleteMatches
- tcg_cc_st :: TcRef CostCentreState
- tcg_next_wrapper_num :: TcRef (ModuleEnv Int)
- data ForeignSrcLang
- type CompleteMatches = [CompleteMatch]
- data CompleteMatch
- data TcTyThing
- = AGlobal TyThing
- | ATcId {
- tct_id :: TcId
- tct_info :: IdBindingInfo
- | ATyVar Name TcTyVar
- | ATcTyCon TyCon
- | APromotionErr PromotionErr
- data TcIdSigInfo
- = CompleteSig { }
- | PartialSig { }
- data SelfBootInfo
- = NoSelfBoot
- | SelfBoot {
- sb_mds :: ModDetails
- sb_tcs :: NameSet
- data TcLclEnv = TcLclEnv {
- tcl_loc :: RealSrcSpan
- tcl_ctxt :: [ErrCtxt]
- tcl_in_gen_code :: Bool
- tcl_tclvl :: TcLevel
- tcl_th_ctxt :: ThStage
- tcl_th_bndrs :: ThBindEnv
- tcl_arrow_ctxt :: ArrowCtxt
- tcl_rdr :: LocalRdrEnv
- tcl_env :: TcTypeEnv
- tcl_usage :: TcRef UsageEnv
- tcl_bndrs :: TcBinderStack
- tcl_lie :: TcRef WantedConstraints
- tcl_errs :: TcRef (Messages TcRnMessage)
- data ImportAvails = ImportAvails {}
- data IOEnvFailure = IOEnvFailure
- data IOEnv env a
- data PromotionErr
- data TcRnMessage
- type THDocs = Map DocLoc (HsDoc GhcRn)
- data DocLoc
- type RoleAnnotEnv = NameEnv (LRoleAnnotDecl GhcRn)
- data DefaultingPlugin = DefaultingPlugin {
- dePluginInit :: TcPluginM s
- dePluginRun :: s -> FillDefaulting
- dePluginStop :: s -> TcPluginM ()
- type FillDefaulting = WantedConstraints -> TcPluginM [DefaultingProposal]
- type DefaultingPluginResult = [DefaultingProposal]
- data DefaultingProposal = DefaultingProposal {
- deProposalTyVar :: TcTyVar
- deProposalCandidates :: [Type]
- deProposalCts :: [Ct]
- data TcPluginRewriteResult
- data TcPluginSolveResult where
- TcPluginSolveResult {
- tcPluginInsolubleCts :: [Ct]
- tcPluginSolvedCts :: [(EvTerm, Ct)]
- tcPluginNewCts :: [Ct]
- pattern TcPluginOk :: [(EvTerm, Ct)] -> [Ct] -> TcPluginSolveResult
- pattern TcPluginContradiction :: [Ct] -> TcPluginSolveResult
- TcPluginSolveResult {
- data TcPlugin = TcPlugin {
- tcPluginInit :: TcPluginM s
- tcPluginSolve :: s -> TcPluginSolver
- tcPluginRewrite :: s -> UniqFM TyCon TcPluginRewriter
- tcPluginStop :: s -> TcPluginM ()
- data TcPluginM a
- type TcPluginRewriter = RewriteEnv -> [Ct] -> [TcType] -> TcPluginM TcPluginRewriteResult
- type TcPluginSolver = EvBindsVar -> [Ct] -> [Ct] -> TcPluginM TcPluginSolveResult
- data TcPatSynInfo = TPSI {}
- data TcIdSigInst = TISI {
- sig_inst_sig :: TcIdSigInfo
- sig_inst_skols :: [(Name, InvisTVBinder)]
- sig_inst_theta :: TcThetaType
- sig_inst_tau :: TcSigmaType
- sig_inst_wcs :: [(Name, TcTyVar)]
- sig_inst_wcx :: Maybe TcType
- data TcSigInfo
- type TcSigFun = Name -> Maybe TcSigInfo
- data WhereFrom
- type ClosedTypeId = Bool
- type RhsNames = NameSet
- data IsGroupClosed = IsGroupClosed (NameEnv RhsNames) ClosedTypeId
- data IdBindingInfo
- data ArrowCtxt
- type ThLevel = Int
- data PendingStuff
- data ThStage
- = Splice SpliceType
- | RunSplice (TcRef [ForeignRef (Q ())])
- | Comp
- | Brack ThStage PendingStuff
- data SpliceType
- data TcBinder
- type TcBinderStack = [TcBinder]
- type TcIdSet = IdSet
- type TcId = Id
- type TcRef a = IORef a
- type ThBindEnv = NameEnv (TopLevelFlag, ThLevel)
- type TcTypeEnv = NameEnv TcTyThing
- type ErrCtxt = (Bool, TidyEnv -> TcM (TidyEnv, SDoc))
- type RecFieldEnv = NameEnv [FieldLabel]
- data FrontendResult = FrontendTypecheck TcGblEnv
- data IfLclEnv = IfLclEnv {}
- data IfGblEnv = IfGblEnv {}
- data RewriteEnv = RE {
- re_loc :: !CtLoc
- re_flavour :: !CtFlavour
- re_eq_rel :: !EqRel
- re_rewriters :: !(TcRef RewriterSet)
- type TcM = TcRn
- type RnM = TcRn
- type IfL = IfM IfLclEnv
- type IfG = IfM ()
- type IfM lcl = TcRnIf IfGblEnv lcl
- type TcRn = TcRnIf TcGblEnv TcLclEnv
- type TcRnIf a b = IOEnv (Env a b)
- data NameShape = NameShape {
- ns_mod_name :: ModuleName
- ns_exports :: [AvailInfo]
- ns_map :: OccEnv Name
- data IsExtraConstraint
- newName :: OccName -> TcM Name
- getEnv :: IOEnv env env
- setEnv :: env' -> IOEnv env' a -> IOEnv env a
- foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b
- foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
- mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
- newUnique :: TcRnIf gbl lcl Unique
- newMutVar :: a -> IOEnv env (IORef a)
- readMutVar :: IORef a -> IOEnv env a
- writeMutVar :: IORef a -> a -> IOEnv env ()
- orM :: Monad m => m Bool -> m Bool -> m Bool
- partitionM :: Monad m => (a -> m Bool) -> [a] -> m ([a], [a])
- whenM :: Monad m => m Bool -> m () -> m ()
- unlessM :: Monad m => m Bool -> m () -> m ()
- zipWith3M :: Monad m => (a -> b -> c -> m d) -> [a] -> [b] -> [c] -> m [d]
- zipWith3M_ :: Monad m => (a -> b -> c -> m d) -> [a] -> [b] -> [c] -> m ()
- zipWith4M :: Monad m => (a -> b -> c -> d -> m e) -> [a] -> [b] -> [c] -> [d] -> m [e]
- zipWithAndUnzipM :: Monad m => (a -> b -> m (c, d)) -> [a] -> [b] -> m ([c], [d])
- mapAndUnzip3M :: Monad m => (a -> m (b, c, d)) -> [a] -> m ([b], [c], [d])
- mapAndUnzip4M :: Monad m => (a -> m (b, c, d, e)) -> [a] -> m ([b], [c], [d], [e])
- mapAndUnzip5M :: Monad m => (a -> m (b, c, d, e, f)) -> [a] -> m ([b], [c], [d], [e], [f])
- mapAccumLM :: (Monad m, Traversable t) => (acc -> x -> m (acc, y)) -> acc -> t x -> m (acc, t y)
- mapSndM :: (Applicative m, Traversable f) => (b -> m c) -> f (a, b) -> m (f (a, c))
- foldlM_ :: (Monad m, Foldable t) => (a -> b -> m a) -> a -> t b -> m ()
- filterOutM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
- addErr :: TcRnMessage -> TcRn ()
- lclEnvInGeneratedCode :: TcLclEnv -> Bool
- getLclEnvLoc :: TcLclEnv -> RealSrcSpan
- setLclEnvLoc :: TcLclEnv -> RealSrcSpan -> TcLclEnv
- getLclEnvTcLevel :: TcLclEnv -> TcLevel
- setLclEnvTcLevel :: TcLclEnv -> TcLevel -> TcLclEnv
- failM :: IOEnv env a
- failWithM :: String -> IOEnv env a
- runIOEnv :: env -> IOEnv env a -> IO a
- fixM :: (a -> IOEnv env a) -> IOEnv env a
- tryM :: IOEnv env r -> IOEnv env (Either IOEnvFailure r)
- tryAllM :: IOEnv env r -> IOEnv env (Either SomeException r)
- tryMostM :: IOEnv env r -> IOEnv env (Either SomeException r)
- unsafeInterleaveM :: IOEnv env a -> IOEnv env a
- uninterruptibleMaskM_ :: IOEnv env a -> IOEnv env a
- updMutVar :: IORef a -> (a -> a) -> IOEnv env ()
- updMutVarM :: IORef a -> (a -> IOEnv env a) -> IOEnv env ()
- atomicUpdMutVar :: IORef a -> (a -> (a, b)) -> IOEnv env b
- atomicUpdMutVar' :: IORef a -> (a -> (a, b)) -> IOEnv env b
- updEnv :: (env -> env') -> IOEnv env' a -> IOEnv env a
- pprPECategory :: PromotionErr -> SDoc
- peCategory :: PromotionErr -> String
- getNamePprCtx :: TcRn NamePprCtx
- getSrcSpanM :: TcRn SrcSpan
- tcVisibleOrphanMods :: TcGblEnv -> ModuleSet
- bootExports :: SelfBootInfo -> NameSet
- pushErrCtxt :: CtOrigin -> ErrCtxt -> CtLoc -> CtLoc
- pushErrCtxtSameOrigin :: ErrCtxt -> CtLoc -> CtLoc
- removeBindingShadowing :: HasOccName a => [a] -> [a]
- getPlatform :: TcRnIf a b Platform
- topStage :: ThStage
- topAnnStage :: ThStage
- topSpliceStage :: ThStage
- impLevel :: ThLevel
- outerLevel :: ThLevel
- thLevel :: ThStage -> ThLevel
- tcTyThingTyCon_maybe :: TcTyThing -> Maybe TyCon
- pprTcTyThingCategory :: TcTyThing -> SDoc
- tcTyThingCategory :: TcTyThing -> String
- mkModDeps :: Set (UnitId, ModuleNameWithIsBoot) -> InstalledModuleEnv ModuleNameWithIsBoot
- emptyImportAvails :: ImportAvails
- plusImportAvails :: ImportAvails -> ImportAvails -> ImportAvails
- isPartialSig :: TcIdSigInst -> Bool
- hasCompleteSig :: TcSigFun -> Name -> Bool
- unsafeTcPluginTcM :: TcM a -> TcPluginM a
- mkRoleAnnotEnv :: [LRoleAnnotDecl GhcRn] -> RoleAnnotEnv
- emptyRoleAnnotEnv :: RoleAnnotEnv
- lookupRoleAnnot :: RoleAnnotEnv -> Name -> Maybe (LRoleAnnotDecl GhcRn)
- getRoleAnnots :: [Name] -> RoleAnnotEnv -> [LRoleAnnotDecl GhcRn]
- lintGblEnv :: Logger -> DynFlags -> TcGblEnv -> TcM ()
- getImports :: TcRn ImportAvails
- initTc :: HscEnv -> HscSource -> Bool -> Module -> RealSrcSpan -> TcM r -> IO (Messages TcRnMessage, Maybe r)
- initTcWithGbl :: HscEnv -> TcGblEnv -> RealSrcSpan -> TcM r -> IO (Messages TcRnMessage, Maybe r)
- initTcInteractive :: HscEnv -> TcM a -> IO (Messages TcRnMessage, Maybe a)
- initTcRnIf :: Char -> HscEnv -> gbl -> lcl -> TcRnIf gbl lcl a -> IO a
- discardResult :: TcM a -> TcM ()
- getTopEnv :: TcRnIf gbl lcl HscEnv
- updTopEnv :: (HscEnv -> HscEnv) -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a
- getGblEnv :: TcRnIf gbl lcl gbl
- updGblEnv :: (gbl -> gbl) -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a
- setGblEnv :: gbl' -> TcRnIf gbl' lcl a -> TcRnIf gbl lcl a
- getLclEnv :: TcRnIf gbl lcl lcl
- updLclEnv :: (lcl -> lcl) -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a
- setLclEnv :: lcl' -> TcRnIf gbl lcl' a -> TcRnIf gbl lcl a
- restoreLclEnv :: TcLclEnv -> TcRnIf gbl TcLclEnv a -> TcRnIf gbl TcLclEnv a
- getEnvs :: TcRnIf gbl lcl (gbl, lcl)
- setEnvs :: (gbl', lcl') -> TcRnIf gbl' lcl' a -> TcRnIf gbl lcl a
- updEnvs :: ((gbl, lcl) -> (gbl, lcl)) -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a
- restoreEnvs :: (TcGblEnv, TcLclEnv) -> TcRn a -> TcRn a
- xoptM :: Extension -> TcRnIf gbl lcl Bool
- doptM :: DumpFlag -> TcRnIf gbl lcl Bool
- goptM :: GeneralFlag -> TcRnIf gbl lcl Bool
- woptM :: WarningFlag -> TcRnIf gbl lcl Bool
- setXOptM :: Extension -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a
- unsetXOptM :: Extension -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a
- unsetGOptM :: GeneralFlag -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a
- unsetWOptM :: WarningFlag -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a
- whenDOptM :: DumpFlag -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()
- whenGOptM :: GeneralFlag -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()
- whenWOptM :: WarningFlag -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()
- whenXOptM :: Extension -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()
- unlessXOptM :: Extension -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()
- getGhcMode :: TcRnIf gbl lcl GhcMode
- withoutDynamicNow :: TcRnIf gbl lcl a -> TcRnIf gbl lcl a
- updTopFlags :: (DynFlags -> DynFlags) -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a
- getEpsVar :: TcRnIf gbl lcl (TcRef ExternalPackageState)
- getEps :: TcRnIf gbl lcl ExternalPackageState
- updateEps :: (ExternalPackageState -> (ExternalPackageState, a)) -> TcRnIf gbl lcl a
- updateEps_ :: (ExternalPackageState -> ExternalPackageState) -> TcRnIf gbl lcl ()
- getHpt :: TcRnIf gbl lcl HomePackageTable
- getEpsAndHug :: TcRnIf gbl lcl (ExternalPackageState, HomeUnitGraph)
- withException :: MonadIO m => SDocContext -> m (MaybeErr SDoc a) -> m a
- newArrowScope :: TcM a -> TcM a
- escapeArrowScope :: TcM a -> TcM a
- newUniqueSupply :: TcRnIf gbl lcl UniqSupply
- cloneLocalName :: Name -> TcM Name
- newNameAt :: OccName -> SrcSpan -> TcM Name
- newSysName :: OccName -> TcRnIf gbl lcl Name
- newSysLocalId :: FastString -> Mult -> TcType -> TcRnIf gbl lcl TcId
- newSysLocalIds :: FastString -> [Scaled TcType] -> TcRnIf gbl lcl [TcId]
- newTcRef :: a -> TcRnIf gbl lcl (TcRef a)
- readTcRef :: TcRef a -> TcRnIf gbl lcl a
- writeTcRef :: TcRef a -> a -> TcRnIf gbl lcl ()
- updTcRef :: TcRef a -> (a -> a) -> TcRnIf gbl lcl ()
- traceTc :: String -> SDoc -> TcRn ()
- traceRn :: String -> SDoc -> TcRn ()
- traceOptTcRn :: DumpFlag -> SDoc -> TcRn ()
- dumpOptTcRn :: DumpFlag -> String -> DumpFormat -> SDoc -> TcRn ()
- dumpTcRn :: Bool -> DumpFlag -> String -> DumpFormat -> SDoc -> TcRn ()
- printForUserTcRn :: SDoc -> TcRn ()
- traceIf :: SDoc -> TcRnIf m n ()
- traceOptIf :: DumpFlag -> SDoc -> TcRnIf m n ()
- getIsGHCi :: TcRn Bool
- getGHCiMonad :: TcRn Name
- getInteractivePrintName :: TcRn Name
- tcIsHsBootOrSig :: TcRn Bool
- tcIsHsig :: TcRn Bool
- tcSelfBootInfo :: TcRn SelfBootInfo
- getGlobalRdrEnv :: TcRn GlobalRdrEnv
- getRdrEnvs :: TcRn (GlobalRdrEnv, LocalRdrEnv)
- getFixityEnv :: TcRn FixityEnv
- extendFixityEnv :: [(Name, FixItem)] -> RnM a -> RnM a
- getRecFieldEnv :: TcRn RecFieldEnv
- getDeclaredDefaultTys :: TcRn (Maybe [Type])
- addDependentFiles :: [FilePath] -> TcRn ()
- inGeneratedCode :: TcRn Bool
- setSrcSpan :: SrcSpan -> TcRn a -> TcRn a
- setSrcSpanA :: SrcSpanAnn' ann -> TcRn a -> TcRn a
- addLocM :: (a -> TcM b) -> Located a -> TcM b
- addLocMA :: (a -> TcM b) -> GenLocated (SrcSpanAnn' ann) a -> TcM b
- wrapLocM :: (a -> TcM b) -> Located a -> TcM (Located b)
- wrapLocAM :: (a -> TcM b) -> LocatedAn an a -> TcM (Located b)
- wrapLocMA :: (a -> TcM b) -> GenLocated (SrcSpanAnn' ann) a -> TcRn (GenLocated (SrcSpanAnn' ann) b)
- wrapLocFstM :: (a -> TcM (b, c)) -> Located a -> TcM (Located b, c)
- wrapLocFstMA :: (a -> TcM (b, c)) -> GenLocated (SrcSpanAnn' ann) a -> TcM (GenLocated (SrcSpanAnn' ann) b, c)
- wrapLocSndM :: (a -> TcM (b, c)) -> Located a -> TcM (b, Located c)
- wrapLocSndMA :: (a -> TcM (b, c)) -> GenLocated (SrcSpanAnn' ann) a -> TcM (b, GenLocated (SrcSpanAnn' ann) c)
- wrapLocM_ :: (a -> TcM ()) -> Located a -> TcM ()
- wrapLocMA_ :: (a -> TcM ()) -> LocatedA a -> TcM ()
- getErrsVar :: TcRn (TcRef (Messages TcRnMessage))
- setErrsVar :: TcRef (Messages TcRnMessage) -> TcRn a -> TcRn a
- failWith :: TcRnMessage -> TcRn a
- failAt :: SrcSpan -> TcRnMessage -> TcRn a
- addErrAt :: SrcSpan -> TcRnMessage -> TcRn ()
- mkDetailedMessage :: ErrInfo -> TcRnMessage -> TcRnMessageDetailed
- addErrs :: [(SrcSpan, TcRnMessage)] -> TcRn ()
- checkErr :: Bool -> TcRnMessage -> TcRn ()
- addMessages :: Messages TcRnMessage -> TcRn ()
- discardWarnings :: TcRn a -> TcRn a
- mkTcRnMessage :: SrcSpan -> TcRnMessage -> TcRn (MsgEnvelope TcRnMessage)
- reportDiagnostics :: [MsgEnvelope TcRnMessage] -> TcM ()
- reportDiagnostic :: MsgEnvelope TcRnMessage -> TcRn ()
- checkNoErrs :: TcM r -> TcM r
- whenNoErrs :: TcM () -> TcM ()
- ifErrsM :: TcRn r -> TcRn r -> TcRn r
- failIfErrsM :: TcRn ()
- getErrCtxt :: TcM [ErrCtxt]
- setErrCtxt :: [ErrCtxt] -> TcM a -> TcM a
- addErrCtxt :: SDoc -> TcM a -> TcM a
- addErrCtxtM :: (TidyEnv -> TcM (TidyEnv, SDoc)) -> TcM a -> TcM a
- addLandmarkErrCtxt :: SDoc -> TcM a -> TcM a
- addLandmarkErrCtxtM :: (TidyEnv -> TcM (TidyEnv, SDoc)) -> TcM a -> TcM a
- popErrCtxt :: TcM a -> TcM a
- getCtLocM :: CtOrigin -> Maybe TypeOrKind -> TcM CtLoc
- setCtLocM :: CtLoc -> TcM a -> TcM a
- askNoErrs :: TcRn a -> TcRn (a, Bool)
- tryCaptureConstraints :: TcM a -> TcM (Maybe a, WantedConstraints)
- captureConstraints :: TcM a -> TcM (a, WantedConstraints)
- tcCollectingUsage :: TcM a -> TcM (UsageEnv, a)
- tcScalingUsage :: Mult -> TcM a -> TcM a
- tcEmitBindingUsage :: UsageEnv -> TcM ()
- attemptM :: TcRn r -> TcRn (Maybe r)
- recoverM :: TcRn r -> TcRn r -> TcRn r
- mapAndRecoverM :: (a -> TcRn b) -> [a] -> TcRn [b]
- mapAndReportM :: (a -> TcRn b) -> [a] -> TcRn [b]
- foldAndRecoverM :: (b -> a -> TcRn b) -> b -> [a] -> TcRn b
- tryTc :: TcRn a -> TcRn (Maybe a, Messages TcRnMessage)
- discardErrs :: TcRn a -> TcRn a
- tryTcDiscardingErrs :: TcM r -> TcM r -> TcM r
- addErrTc :: TcRnMessage -> TcM ()
- addErrTcM :: (TidyEnv, TcRnMessage) -> TcM ()
- failWithTc :: TcRnMessage -> TcM a
- failWithTcM :: (TidyEnv, TcRnMessage) -> TcM a
- checkTc :: Bool -> TcRnMessage -> TcM ()
- checkTcM :: Bool -> (TidyEnv, TcRnMessage) -> TcM ()
- failIfTc :: Bool -> TcRnMessage -> TcM ()
- failIfTcM :: Bool -> (TidyEnv, TcRnMessage) -> TcM ()
- warnIf :: Bool -> TcRnMessage -> TcRn ()
- diagnosticTc :: Bool -> TcRnMessage -> TcM ()
- diagnosticTcM :: Bool -> (TidyEnv, TcRnMessage) -> TcM ()
- addDiagnosticTc :: TcRnMessage -> TcM ()
- addDiagnosticTcM :: (TidyEnv, TcRnMessage) -> TcM ()
- addDetailedDiagnostic :: (ErrInfo -> TcRnMessage) -> TcM ()
- addTcRnDiagnostic :: TcRnMessage -> TcM ()
- addDiagnostic :: TcRnMessage -> TcRn ()
- addDiagnosticAt :: SrcSpan -> TcRnMessage -> TcRn ()
- mkErrInfo :: TidyEnv -> [ErrCtxt] -> TcM SDoc
- debugTc :: TcM () -> TcM ()
- addTopEvBinds :: Bag EvBind -> TcM a -> TcM a
- newTcEvBinds :: TcM EvBindsVar
- newNoTcEvBinds :: TcM EvBindsVar
- cloneEvBindsVar :: EvBindsVar -> TcM EvBindsVar
- getTcEvTyCoVars :: EvBindsVar -> TcM TyCoVarSet
- getTcEvBindsMap :: EvBindsVar -> TcM EvBindMap
- setTcEvBindsMap :: EvBindsVar -> EvBindMap -> TcM ()
- addTcEvBind :: EvBindsVar -> EvBind -> TcM ()
- chooseUniqueOccTc :: (OccSet -> OccName) -> TcM OccName
- getConstraintVar :: TcM (TcRef WantedConstraints)
- setConstraintVar :: TcRef WantedConstraints -> TcM a -> TcM a
- emitStaticConstraints :: WantedConstraints -> TcM ()
- emitConstraints :: WantedConstraints -> TcM ()
- emitSimple :: Ct -> TcM ()
- emitSimples :: Cts -> TcM ()
- emitImplication :: Implication -> TcM ()
- emitImplications :: Bag Implication -> TcM ()
- emitInsoluble :: Ct -> TcM ()
- emitDelayedErrors :: Bag DelayedError -> TcM ()
- emitHole :: Hole -> TcM ()
- emitHoles :: Bag Hole -> TcM ()
- emitNotConcreteError :: NotConcreteError -> TcM ()
- discardConstraints :: TcM a -> TcM a
- pushLevelAndCaptureConstraints :: TcM a -> TcM (TcLevel, WantedConstraints, a)
- pushTcLevelM_ :: TcM a -> TcM a
- pushTcLevelM :: TcM a -> TcM (TcLevel, a)
- getTcLevel :: TcM TcLevel
- setTcLevel :: TcLevel -> TcM a -> TcM a
- isTouchableTcM :: TcTyVar -> TcM Bool
- getLclTypeEnv :: TcM TcTypeEnv
- setLclTypeEnv :: TcLclEnv -> TcM a -> TcM a
- traceTcConstraints :: String -> TcM ()
- emitAnonTypeHole :: IsExtraConstraint -> TcTyVar -> TcM ()
- emitNamedTypeHole :: (Name, TcTyVar) -> TcM ()
- recordThUse :: TcM ()
- recordThSpliceUse :: TcM ()
- recordThNeededRuntimeDeps :: [Linkable] -> PkgsLoaded -> TcM ()
- keepAlive :: Name -> TcRn ()
- getStage :: TcM ThStage
- getStageAndBindLevel :: Name -> TcRn (Maybe (TopLevelFlag, ThLevel, ThStage))
- setStage :: ThStage -> TcM a -> TcRn a
- addModFinalizersWithLclEnv :: ThModFinalizers -> TcM ()
- recordUnsafeInfer :: Messages TcRnMessage -> TcM ()
- finalSafeMode :: DynFlags -> TcGblEnv -> IO SafeHaskellMode
- fixSafeInstances :: SafeHaskellMode -> [ClsInst] -> [ClsInst]
- getLocalRdrEnv :: RnM LocalRdrEnv
- setLocalRdrEnv :: LocalRdrEnv -> RnM a -> RnM a
- mkIfLclEnv :: Module -> SDoc -> IsBootInterface -> IfLclEnv
- initIfaceTcRn :: IfG a -> TcRn a
- initIfaceLoad :: HscEnv -> IfG a -> IO a
- initIfaceLoadModule :: HscEnv -> Module -> IfG a -> IO a
- initIfaceCheck :: SDoc -> HscEnv -> IfG a -> IO a
- initIfaceLcl :: Module -> SDoc -> IsBootInterface -> IfL a -> IfM lcl a
- initIfaceLclWithSubst :: Module -> SDoc -> IsBootInterface -> NameShape -> IfL a -> IfM lcl a
- getIfModule :: IfL Module
- failIfM :: SDoc -> IfL a
- forkM :: SDoc -> IfL a -> IfL a
- setImplicitEnvM :: TypeEnv -> IfL a -> IfL a
- getCCIndexM :: (gbl -> TcRef CostCentreState) -> FastString -> TcRnIf gbl lcl CostCentreIndex
- getCCIndexTcM :: FastString -> TcM CostCentreIndex
- module GHC.Types.Basic
- module GHC.Types.Id
- data Name
- class HasOccName name where
- data OccName
- class NamedThing a where
- getOccName :: a -> OccName
- getName :: a -> Name
- type FastStringEnv a = UniqFM FastString a
- type TidyOccEnv = UniqFM FastString Int
- type OccSet = UniqSet OccName
- data OccEnv a
- data NameSpace
- data BuiltInSyntax
- mkVarOccFS :: FastString -> OccName
- mkRecFldSelOcc :: FastString -> OccName
- tidyNameOcc :: Name -> OccName -> Name
- nameOccName :: Name -> OccName
- setNameUnique :: Name -> Unique -> Name
- nameUnique :: Name -> Unique
- emptyFsEnv :: FastStringEnv a
- extendFsEnv :: FastStringEnv a -> FastString -> a -> FastStringEnv a
- lookupFsEnv :: FastStringEnv a -> FastString -> Maybe a
- mkFsEnv :: [(FastString, a)] -> FastStringEnv a
- tcName :: NameSpace
- clsName :: NameSpace
- tcClsName :: NameSpace
- dataName :: NameSpace
- srcDataName :: NameSpace
- tvName :: NameSpace
- isDataConNameSpace :: NameSpace -> Bool
- isTcClsNameSpace :: NameSpace -> Bool
- isTvNameSpace :: NameSpace -> Bool
- isVarNameSpace :: NameSpace -> Bool
- isValNameSpace :: NameSpace -> Bool
- pprNameSpace :: NameSpace -> SDoc
- pprNonVarNameSpace :: NameSpace -> SDoc
- pprNameSpaceBrief :: IsLine doc => NameSpace -> doc
- pprOccName :: IsLine doc => OccName -> doc
- mkOccName :: NameSpace -> String -> OccName
- mkOccNameFS :: NameSpace -> FastString -> OccName
- mkVarOcc :: String -> OccName
- mkDataOcc :: String -> OccName
- mkDataOccFS :: FastString -> OccName
- mkTyVarOcc :: String -> OccName
- mkTyVarOccFS :: FastString -> OccName
- mkTcOcc :: String -> OccName
- mkTcOccFS :: FastString -> OccName
- mkClsOcc :: String -> OccName
- mkClsOccFS :: FastString -> OccName
- demoteOccName :: OccName -> Maybe OccName
- promoteOccName :: OccName -> Maybe OccName
- emptyOccEnv :: OccEnv a
- unitOccEnv :: OccName -> a -> OccEnv a
- extendOccEnv :: OccEnv a -> OccName -> a -> OccEnv a
- extendOccEnvList :: OccEnv a -> [(OccName, a)] -> OccEnv a
- lookupOccEnv :: OccEnv a -> OccName -> Maybe a
- mkOccEnv :: [(OccName, a)] -> OccEnv a
- elemOccEnv :: OccName -> OccEnv a -> Bool
- foldOccEnv :: (a -> b -> b) -> b -> OccEnv a -> b
- nonDetOccEnvElts :: OccEnv a -> [a]
- plusOccEnv :: OccEnv a -> OccEnv a -> OccEnv a
- plusOccEnv_C :: (a -> a -> a) -> OccEnv a -> OccEnv a -> OccEnv a
- extendOccEnv_C :: (a -> a -> a) -> OccEnv a -> OccName -> a -> OccEnv a
- extendOccEnv_Acc :: (a -> b -> b) -> (a -> b) -> OccEnv b -> OccName -> a -> OccEnv b
- mapOccEnv :: (a -> b) -> OccEnv a -> OccEnv b
- mkOccEnv_C :: (a -> a -> a) -> [(OccName, a)] -> OccEnv a
- delFromOccEnv :: OccEnv a -> OccName -> OccEnv a
- delListFromOccEnv :: OccEnv a -> [OccName] -> OccEnv a
- filterOccEnv :: (elt -> Bool) -> OccEnv elt -> OccEnv elt
- alterOccEnv :: (Maybe elt -> Maybe elt) -> OccEnv elt -> OccName -> OccEnv elt
- minusOccEnv :: OccEnv a -> OccEnv b -> OccEnv a
- minusOccEnv_C :: (a -> b -> Maybe a) -> OccEnv a -> OccEnv b -> OccEnv a
- pprOccEnv :: (a -> SDoc) -> OccEnv a -> SDoc
- emptyOccSet :: OccSet
- unitOccSet :: OccName -> OccSet
- mkOccSet :: [OccName] -> OccSet
- extendOccSet :: OccSet -> OccName -> OccSet
- extendOccSetList :: OccSet -> [OccName] -> OccSet
- unionOccSets :: OccSet -> OccSet -> OccSet
- unionManyOccSets :: [OccSet] -> OccSet
- minusOccSet :: OccSet -> OccSet -> OccSet
- elemOccSet :: OccName -> OccSet -> Bool
- isEmptyOccSet :: OccSet -> Bool
- intersectOccSet :: OccSet -> OccSet -> OccSet
- filterOccSet :: (OccName -> Bool) -> OccSet -> OccSet
- occSetToEnv :: OccSet -> OccEnv OccName
- occNameString :: OccName -> String
- setOccNameSpace :: NameSpace -> OccName -> OccName
- isVarOcc :: OccName -> Bool
- isTvOcc :: OccName -> Bool
- isTcOcc :: OccName -> Bool
- isValOcc :: OccName -> Bool
- isDataOcc :: OccName -> Bool
- isDataSymOcc :: OccName -> Bool
- isSymOcc :: OccName -> Bool
- parenSymOcc :: OccName -> SDoc -> SDoc
- startsWithUnderscore :: OccName -> Bool
- isDerivedOccName :: OccName -> Bool
- isDefaultMethodOcc :: OccName -> Bool
- isTypeableBindOcc :: OccName -> Bool
- mkDataConWrapperOcc :: OccName -> OccName
- mkWorkerOcc :: OccName -> OccName
- mkMatcherOcc :: OccName -> OccName
- mkBuilderOcc :: OccName -> OccName
- mkDefaultMethodOcc :: OccName -> OccName
- mkClassOpAuxOcc :: OccName -> OccName
- mkDictOcc :: OccName -> OccName
- mkIPOcc :: OccName -> OccName
- mkSpecOcc :: OccName -> OccName
- mkForeignExportOcc :: OccName -> OccName
- mkRepEqOcc :: OccName -> OccName
- mkClassDataConOcc :: OccName -> OccName
- mkNewTyCoOcc :: OccName -> OccName
- mkInstTyCoOcc :: OccName -> OccName
- mkEqPredCoOcc :: OccName -> OccName
- mkCon2TagOcc :: OccName -> OccName
- mkTag2ConOcc :: OccName -> OccName
- mkMaxTagOcc :: OccName -> OccName
- mkDataTOcc :: OccName -> OccName
- mkDataCOcc :: OccName -> OccName
- mkTyConRepOcc :: OccName -> OccName
- mkGenR :: OccName -> OccName
- mkGen1R :: OccName -> OccName
- mkDataConWorkerOcc :: OccName -> OccName
- mkSuperDictAuxOcc :: Int -> OccName -> OccName
- mkSuperDictSelOcc :: Int -> OccName -> OccName
- mkLocalOcc :: Unique -> OccName -> OccName
- mkInstTyTcOcc :: String -> OccSet -> OccName
- mkDFunOcc :: String -> Bool -> OccSet -> OccName
- mkMethodOcc :: OccName -> OccName
- emptyTidyOccEnv :: TidyOccEnv
- initTidyOccEnv :: [OccName] -> TidyOccEnv
- delTidyOccEnvList :: TidyOccEnv -> [FastString] -> TidyOccEnv
- avoidClashesOccEnv :: TidyOccEnv -> [OccName] -> TidyOccEnv
- tidyOccName :: TidyOccEnv -> OccName -> (TidyOccEnv, OccName)
- nameNameSpace :: Name -> NameSpace
- nameSrcLoc :: Name -> SrcLoc
- nameSrcSpan :: Name -> SrcSpan
- isWiredInName :: Name -> Bool
- isWiredIn :: NamedThing thing => thing -> Bool
- wiredInNameTyThing_maybe :: Name -> Maybe TyThing
- isBuiltInSyntax :: Name -> Bool
- isExternalName :: Name -> Bool
- isInternalName :: Name -> Bool
- isHoleName :: Name -> Bool
- isDynLinkName :: Platform -> Module -> Name -> Bool
- nameModule :: HasDebugCallStack => Name -> Module
- nameModule_maybe :: Name -> Maybe Module
- namePun_maybe :: Name -> Maybe FastString
- nameIsLocalOrFrom :: Module -> Name -> Bool
- nameIsExternalOrFrom :: Module -> Name -> Bool
- nameIsHomePackage :: Module -> Name -> Bool
- nameIsHomePackageImport :: Module -> Name -> Bool
- nameIsFromExternalPackage :: HomeUnit -> Name -> Bool
- isTyVarName :: Name -> Bool
- isTyConName :: Name -> Bool
- isDataConName :: Name -> Bool
- isValName :: Name -> Bool
- isVarName :: Name -> Bool
- isSystemName :: Name -> Bool
- mkInternalName :: Unique -> OccName -> SrcSpan -> Name
- mkClonedInternalName :: Unique -> Name -> Name
- mkDerivedInternalName :: (OccName -> OccName) -> Unique -> Name -> Name
- mkExternalName :: Unique -> Module -> OccName -> SrcSpan -> Name
- mkWiredInName :: Module -> OccName -> Unique -> TyThing -> BuiltInSyntax -> Name
- mkSystemName :: Unique -> OccName -> Name
- mkSystemNameAt :: Unique -> OccName -> SrcSpan -> Name
- mkSystemVarName :: Unique -> FastString -> Name
- mkSysTvName :: Unique -> FastString -> Name
- mkFCallName :: Unique -> FastString -> Name
- setNameLoc :: Name -> SrcSpan -> Name
- localiseName :: Name -> Name
- stableNameCmp :: Name -> Name -> Ordering
- pprName :: IsLine doc => Name -> doc
- pprFullName :: Module -> Name -> SDoc
- pprTickyName :: Module -> Name -> SDoc
- pprNameUnqualified :: Name -> SDoc
- pprModulePrefix :: IsLine doc => PprStyle -> Module -> OccName -> doc
- pprDefinedAt :: Name -> SDoc
- pprNameDefnLoc :: Name -> SDoc
- nameStableString :: Name -> String
- getSrcLoc :: NamedThing a => a -> SrcLoc
- getSrcSpan :: NamedThing a => a -> SrcSpan
- getOccString :: NamedThing a => a -> String
- getOccFS :: NamedThing a => a -> FastString
- pprInfixName :: (Outputable a, NamedThing a) => a -> SDoc
- pprPrefixName :: NamedThing a => a -> SDoc
- module GHC.Types.Name.Set
- module GHC.Types.Name.Cache
- module GHC.Types.Name.Env
- data RdrName
- data GreName
- data ImpItemSpec
- data ImpDeclSpec = ImpDeclSpec {
- is_mod :: ModuleName
- is_as :: ModuleName
- is_qual :: Bool
- is_dloc :: SrcSpan
- data ImportSpec = ImpSpec {}
- data Parent
- data GlobalRdrElt
- type GlobalRdrEnv = OccEnv [GlobalRdrElt]
- data LocalRdrEnv
- greNameSrcSpan :: GreName -> SrcSpan
- rdrNameOcc :: RdrName -> OccName
- rdrNameSpace :: RdrName -> NameSpace
- demoteRdrName :: RdrName -> Maybe RdrName
- promoteRdrName :: RdrName -> Maybe RdrName
- mkRdrUnqual :: OccName -> RdrName
- mkRdrQual :: ModuleName -> OccName -> RdrName
- mkOrig :: Module -> OccName -> RdrName
- mkUnqual :: NameSpace -> FastString -> RdrName
- mkVarUnqual :: FastString -> RdrName
- mkQual :: NameSpace -> (FastString, FastString) -> RdrName
- getRdrName :: NamedThing thing => thing -> RdrName
- nameRdrName :: Name -> RdrName
- isRdrDataCon :: RdrName -> Bool
- isRdrTyVar :: RdrName -> Bool
- isRdrTc :: RdrName -> Bool
- isSrcRdrName :: RdrName -> Bool
- isUnqual :: RdrName -> Bool
- isQual :: RdrName -> Bool
- isQual_maybe :: RdrName -> Maybe (ModuleName, OccName)
- isOrig :: RdrName -> Bool
- isOrig_maybe :: RdrName -> Maybe (Module, OccName)
- isExact :: RdrName -> Bool
- isExact_maybe :: RdrName -> Maybe Name
- emptyLocalRdrEnv :: LocalRdrEnv
- extendLocalRdrEnv :: LocalRdrEnv -> Name -> LocalRdrEnv
- extendLocalRdrEnvList :: LocalRdrEnv -> [Name] -> LocalRdrEnv
- lookupLocalRdrEnv :: LocalRdrEnv -> RdrName -> Maybe Name
- lookupLocalRdrOcc :: LocalRdrEnv -> OccName -> Maybe Name
- elemLocalRdrEnv :: RdrName -> LocalRdrEnv -> Bool
- localRdrEnvElts :: LocalRdrEnv -> [Name]
- inLocalRdrEnvScope :: Name -> LocalRdrEnv -> Bool
- minusLocalRdrEnv :: LocalRdrEnv -> OccEnv a -> LocalRdrEnv
- gresFromAvails :: Maybe ImportSpec -> [AvailInfo] -> [GlobalRdrElt]
- localGREsFromAvail :: AvailInfo -> [GlobalRdrElt]
- gresFromAvail :: (Name -> Maybe ImportSpec) -> AvailInfo -> [GlobalRdrElt]
- greOccName :: GlobalRdrElt -> OccName
- greMangledName :: GlobalRdrElt -> Name
- grePrintableName :: GlobalRdrElt -> Name
- greDefinitionSrcSpan :: GlobalRdrElt -> SrcSpan
- greDefinitionModule :: GlobalRdrElt -> Maybe Module
- greQualModName :: GlobalRdrElt -> ModuleName
- greRdrNames :: GlobalRdrElt -> [RdrName]
- greSrcSpan :: GlobalRdrElt -> SrcSpan
- greParent_maybe :: GlobalRdrElt -> Maybe Name
- gresToAvailInfo :: [GlobalRdrElt] -> [AvailInfo]
- availFromGRE :: GlobalRdrElt -> AvailInfo
- emptyGlobalRdrEnv :: GlobalRdrEnv
- globalRdrEnvElts :: GlobalRdrEnv -> [GlobalRdrElt]
- pprGlobalRdrEnv :: Bool -> GlobalRdrEnv -> SDoc
- lookupGlobalRdrEnv :: GlobalRdrEnv -> OccName -> [GlobalRdrElt]
- lookupGRE_RdrName :: RdrName -> GlobalRdrEnv -> [GlobalRdrElt]
- lookupGRE_RdrName' :: RdrName -> GlobalRdrEnv -> [GlobalRdrElt]
- lookupGRE_Name :: GlobalRdrEnv -> Name -> Maybe GlobalRdrElt
- lookupGRE_GreName :: GlobalRdrEnv -> GreName -> Maybe GlobalRdrElt
- lookupGRE_FieldLabel :: GlobalRdrEnv -> FieldLabel -> Maybe GlobalRdrElt
- lookupGRE_Name_OccName :: GlobalRdrEnv -> Name -> OccName -> Maybe GlobalRdrElt
- getGRE_NameQualifier_maybes :: GlobalRdrEnv -> Name -> [Maybe [ModuleName]]
- isLocalGRE :: GlobalRdrElt -> Bool
- isRecFldGRE :: GlobalRdrElt -> Bool
- isDuplicateRecFldGRE :: GlobalRdrElt -> Bool
- isNoFieldSelectorGRE :: GlobalRdrElt -> Bool
- isFieldSelectorGRE :: GlobalRdrElt -> Bool
- greFieldLabel :: GlobalRdrElt -> Maybe FieldLabel
- unQualOK :: GlobalRdrElt -> Bool
- pickGREs :: RdrName -> [GlobalRdrElt] -> [GlobalRdrElt]
- pickGREsModExp :: ModuleName -> [GlobalRdrElt] -> [(GlobalRdrElt, GlobalRdrElt)]
- plusGlobalRdrEnv :: GlobalRdrEnv -> GlobalRdrEnv -> GlobalRdrEnv
- mkGlobalRdrEnv :: [GlobalRdrElt] -> GlobalRdrEnv
- transformGREs :: (GlobalRdrElt -> GlobalRdrElt) -> [OccName] -> GlobalRdrEnv -> GlobalRdrEnv
- extendGlobalRdrEnv :: GlobalRdrEnv -> GlobalRdrElt -> GlobalRdrEnv
- shadowNames :: GlobalRdrEnv -> OccEnv a -> GlobalRdrEnv
- bestImport :: [ImportSpec] -> ImportSpec
- unQualSpecOK :: ImportSpec -> Bool
- qualSpecOK :: ModuleName -> ImportSpec -> Bool
- importSpecLoc :: ImportSpec -> SrcSpan
- importSpecModule :: ImportSpec -> ModuleName
- isExplicitItem :: ImpItemSpec -> Bool
- pprNameProvenance :: GlobalRdrElt -> SDoc
- opIsAt :: RdrName -> Bool
- data Severity
- emptyMessages :: Messages e
- greNamePrintableName :: GreName -> Name
- data HscSource
- module GHC.Types.SourceText
- module GHC.Types.TyThing
- module GHC.Types.TyThing.Ppr
- module GHC.Types.Unique.Supply
- data Var
- setVarUnique :: Var -> Unique -> Var
- setTyVarUnique :: TyVar -> Unique -> TyVar
- type Module = GenModule Unit
- newtype ModuleName = ModuleName FastString
- data IsBootInterface
- type Unit = GenUnit UnitId
- data GenUnit uid
- = RealUnit !(Definite uid)
- | VirtUnit !(GenInstantiatedUnit uid)
- | HoleUnit
- data GenModule unit = Module !unit !ModuleName
- type ModuleWithIsBoot = GenWithIsBoot Module
- type ModuleNameWithIsBoot = GenWithIsBoot ModuleName
- data GenWithIsBoot mod = GWIB {
- gwib_mod :: mod
- gwib_isBoot :: IsBootInterface
- newtype Definite unit = Definite {
- unDefinite :: unit
- type DefUnitId = Definite UnitId
- type Instantiations = GenInstantiations UnitId
- type GenInstantiations unit = [(ModuleName, GenModule (GenUnit unit))]
- type InstantiatedUnit = GenInstantiatedUnit UnitId
- data GenInstantiatedUnit unit = InstantiatedUnit {
- instUnitFS :: !FastString
- instUnitKey :: !Unique
- instUnitInstanceOf :: !unit
- instUnitInsts :: !(GenInstantiations unit)
- instUnitHoles :: UniqDSet ModuleName
- newtype UnitKey = UnitKey FastString
- class IsUnitId u where
- unitFS :: u -> FastString
- type InstantiatedModule = GenModule InstantiatedUnit
- type HomeUnitModule = GenModule UnitId
- type InstalledModule = GenModule UnitId
- data InstalledModuleEnv elt
- type DModuleNameEnv elt = UniqDFM ModuleName elt
- type ModuleNameEnv elt = UniqFM ModuleName elt
- type ModuleSet = Set NDModule
- data ModuleEnv elt
- class HasModule (m :: Type -> Type) where
- class ContainsModule t where
- extractModule :: t -> Module
- stableModuleNameCmp :: ModuleName -> ModuleName -> Ordering
- moduleNameFS :: ModuleName -> FastString
- moduleNameString :: ModuleName -> String
- mkModuleName :: String -> ModuleName
- mkModuleNameFS :: FastString -> ModuleName
- moduleNameSlashes :: ModuleName -> String
- moduleNameColons :: ModuleName -> String
- parseModuleName :: ReadP ModuleName
- unitIdFS :: UnitId -> FastString
- moduleUnitId :: Module -> UnitId
- mkModule :: u -> ModuleName -> GenModule u
- pprModule :: IsLine doc => Module -> doc
- pprInstantiatedModule :: InstantiatedModule -> SDoc
- isHoleUnit :: GenUnit u -> Bool
- stableUnitCmp :: Unit -> Unit -> Ordering
- pprUnit :: IsLine doc => Unit -> doc
- unitFreeModuleHoles :: GenUnit u -> UniqDSet ModuleName
- moduleFreeHoles :: GenModule (GenUnit u) -> UniqDSet ModuleName
- mkInstantiatedUnit :: IsUnitId u => u -> GenInstantiations u -> GenInstantiatedUnit u
- mkVirtUnit :: IsUnitId u => u -> [(ModuleName, GenModule (GenUnit u))] -> GenUnit u
- mkInstantiatedUnitHash :: IsUnitId u => u -> [(ModuleName, GenModule (GenUnit u))] -> FastString
- fsToUnit :: FastString -> Unit
- unitString :: IsUnitId u => u -> String
- stringToUnit :: String -> Unit
- mapGenUnit :: IsUnitId v => (u -> v) -> GenUnit u -> GenUnit v
- mapInstantiations :: IsUnitId v => (u -> v) -> GenInstantiations u -> GenInstantiations v
- virtualUnitId :: InstantiatedUnit -> UnitId
- unitIsDefinite :: Unit -> Bool
- unitIdString :: UnitId -> String
- stringToUnitId :: String -> UnitId
- primUnitId :: UnitId
- bignumUnitId :: UnitId
- baseUnitId :: UnitId
- rtsUnitId :: UnitId
- thisGhcUnitId :: UnitId
- interactiveUnitId :: UnitId
- thUnitId :: UnitId
- thUnit :: Unit
- primUnit :: Unit
- bignumUnit :: Unit
- baseUnit :: Unit
- rtsUnit :: Unit
- thisGhcUnit :: Unit
- interactiveUnit :: Unit
- mainUnitId :: UnitId
- mainUnit :: Unit
- isInteractiveModule :: Module -> Bool
- wiredInUnitIds :: [UnitId]
- addBootSuffix :: FilePath -> FilePath
- removeBootSuffix :: FilePath -> FilePath
- addBootSuffix_maybe :: IsBootInterface -> FilePath -> FilePath
- addBootSuffixLocn_maybe :: IsBootInterface -> ModLocation -> ModLocation
- addBootSuffixLocn :: ModLocation -> ModLocation
- addBootSuffixLocnOut :: ModLocation -> ModLocation
- filterModuleEnv :: (Module -> a -> Bool) -> ModuleEnv a -> ModuleEnv a
- mapMaybeModuleEnv :: (Module -> a -> Maybe b) -> ModuleEnv a -> ModuleEnv b
- elemModuleEnv :: Module -> ModuleEnv a -> Bool
- extendModuleEnv :: ModuleEnv a -> Module -> a -> ModuleEnv a
- extendModuleEnvWith :: (a -> a -> a) -> ModuleEnv a -> Module -> a -> ModuleEnv a
- extendModuleEnvList :: ModuleEnv a -> [(Module, a)] -> ModuleEnv a
- extendModuleEnvList_C :: (a -> a -> a) -> ModuleEnv a -> [(Module, a)] -> ModuleEnv a
- plusModuleEnv_C :: (a -> a -> a) -> ModuleEnv a -> ModuleEnv a -> ModuleEnv a
- delModuleEnvList :: ModuleEnv a -> [Module] -> ModuleEnv a
- delModuleEnv :: ModuleEnv a -> Module -> ModuleEnv a
- plusModuleEnv :: ModuleEnv a -> ModuleEnv a -> ModuleEnv a
- lookupModuleEnv :: ModuleEnv a -> Module -> Maybe a
- lookupWithDefaultModuleEnv :: ModuleEnv a -> a -> Module -> a
- mapModuleEnv :: (a -> b) -> ModuleEnv a -> ModuleEnv b
- partitionModuleEnv :: (a -> Bool) -> ModuleEnv a -> (ModuleEnv a, ModuleEnv a)
- mkModuleEnv :: [(Module, a)] -> ModuleEnv a
- emptyModuleEnv :: ModuleEnv a
- moduleEnvKeys :: ModuleEnv a -> [Module]
- moduleEnvElts :: ModuleEnv a -> [a]
- moduleEnvToList :: ModuleEnv a -> [(Module, a)]
- unitModuleEnv :: Module -> a -> ModuleEnv a
- isEmptyModuleEnv :: ModuleEnv a -> Bool
- mkModuleSet :: [Module] -> ModuleSet
- extendModuleSet :: ModuleSet -> Module -> ModuleSet
- extendModuleSetList :: ModuleSet -> [Module] -> ModuleSet
- emptyModuleSet :: ModuleSet
- isEmptyModuleSet :: ModuleSet -> Bool
- moduleSetElts :: ModuleSet -> [Module]
- elemModuleSet :: Module -> ModuleSet -> Bool
- intersectModuleSet :: ModuleSet -> ModuleSet -> ModuleSet
- minusModuleSet :: ModuleSet -> ModuleSet -> ModuleSet
- delModuleSet :: ModuleSet -> Module -> ModuleSet
- unionModuleSet :: ModuleSet -> ModuleSet -> ModuleSet
- unionManyModuleSets :: [ModuleSet] -> ModuleSet
- unitModuleSet :: Module -> ModuleSet
- emptyInstalledModuleEnv :: InstalledModuleEnv a
- lookupInstalledModuleEnv :: InstalledModuleEnv a -> InstalledModule -> Maybe a
- extendInstalledModuleEnv :: InstalledModuleEnv a -> InstalledModule -> a -> InstalledModuleEnv a
- filterInstalledModuleEnv :: (InstalledModule -> a -> Bool) -> InstalledModuleEnv a -> InstalledModuleEnv a
- delInstalledModuleEnv :: InstalledModuleEnv a -> InstalledModule -> InstalledModuleEnv a
- installedModuleEnvElts :: InstalledModuleEnv a -> [(InstalledModule, a)]
- mergeInstalledModuleEnv :: (elta -> eltb -> Maybe eltc) -> (InstalledModuleEnv elta -> InstalledModuleEnv eltc) -> (InstalledModuleEnv eltb -> InstalledModuleEnv eltc) -> InstalledModuleEnv elta -> InstalledModuleEnv eltb -> InstalledModuleEnv eltc
- plusInstalledModuleEnv :: (elt -> elt -> elt) -> InstalledModuleEnv elt -> InstalledModuleEnv elt -> InstalledModuleEnv elt
- moduleIsDefinite :: Module -> Bool
- moduleStableString :: Module -> String
- stableModuleCmp :: Module -> Module -> Ordering
- installedModuleEq :: InstalledModule -> Module -> Bool
- getModuleInstantiation :: Module -> (InstalledModule, Maybe InstantiatedModule)
- getUnitInstantiations :: Unit -> (UnitId, Maybe InstantiatedUnit)
- uninstantiateInstantiatedUnit :: InstantiatedUnit -> InstantiatedUnit
- uninstantiateInstantiatedModule :: InstantiatedModule -> InstantiatedModule
- isHoleModule :: GenModule (GenUnit u) -> Bool
- mkHoleModule :: ModuleName -> GenModule (GenUnit u)
- module GHC.Unit.Module.Graph
- data SrcSpanAnn' a
- data HsModule p
- = HsModule {
- hsmodExt :: XCModule p
- hsmodName :: Maybe (XRec p ModuleName)
- hsmodExports :: Maybe (XRec p [LIE p])
- hsmodImports :: [LImportDecl p]
- hsmodDecls :: [LHsDecl p]
- | XModule !(XXModule p)
- = HsModule {
- module GHC.Hs.Binds
- module GHC.Parser
- mkPrelImports :: ModuleName -> SrcSpan -> Bool -> [LImportDecl GhcPs] -> [LImportDecl GhcPs]
- getOptionsFromFile :: ParserOpts -> FilePath -> IO (Messages PsMessage, [Located String])
- getOptions :: ParserOpts -> StringBuffer -> FilePath -> (Messages PsMessage, [Located String])
- toArgs :: RealSrcLoc -> String -> Either String [Located String]
- checkProcessArgsResult :: MonadIO m => [Located String] -> m ()
- data Token
- = ITas
- | ITcase
- | ITclass
- | ITdata
- | ITdefault
- | ITderiving
- | ITdo (Maybe FastString)
- | ITelse
- | IThiding
- | ITforeign
- | ITif
- | ITimport
- | ITin
- | ITinfix
- | ITinfixl
- | ITinfixr
- | ITinstance
- | ITlet
- | ITmodule
- | ITnewtype
- | ITof
- | ITqualified
- | ITthen
- | ITtype
- | ITwhere
- | ITforall IsUnicodeSyntax
- | ITexport
- | ITlabel
- | ITdynamic
- | ITsafe
- | ITinterruptible
- | ITunsafe
- | ITstdcallconv
- | ITccallconv
- | ITcapiconv
- | ITprimcallconv
- | ITjavascriptcallconv
- | ITmdo (Maybe FastString)
- | ITfamily
- | ITrole
- | ITgroup
- | ITby
- | ITusing
- | ITpattern
- | ITstatic
- | ITstock
- | ITanyclass
- | ITvia
- | ITunit
- | ITsignature
- | ITdependency
- | ITrequires
- | ITinline_prag SourceText InlineSpec RuleMatchInfo
- | ITopaque_prag SourceText
- | ITspec_prag SourceText
- | ITspec_inline_prag SourceText Bool
- | ITsource_prag SourceText
- | ITrules_prag SourceText
- | ITwarning_prag SourceText
- | ITdeprecated_prag SourceText
- | ITline_prag SourceText
- | ITcolumn_prag SourceText
- | ITscc_prag SourceText
- | ITunpack_prag SourceText
- | ITnounpack_prag SourceText
- | ITann_prag SourceText
- | ITcomplete_prag SourceText
- | ITclose_prag
- | IToptions_prag String
- | ITinclude_prag String
- | ITlanguage_prag
- | ITminimal_prag SourceText
- | IToverlappable_prag SourceText
- | IToverlapping_prag SourceText
- | IToverlaps_prag SourceText
- | ITincoherent_prag SourceText
- | ITctype SourceText
- | ITcomment_line_prag
- | ITdotdot
- | ITcolon
- | ITdcolon IsUnicodeSyntax
- | ITequal
- | ITlam
- | ITlcase
- | ITlcases
- | ITvbar
- | ITlarrow IsUnicodeSyntax
- | ITrarrow IsUnicodeSyntax
- | ITdarrow IsUnicodeSyntax
- | ITlolly
- | ITminus
- | ITprefixminus
- | ITbang
- | ITtilde
- | ITat
- | ITtypeApp
- | ITpercent
- | ITstar IsUnicodeSyntax
- | ITdot
- | ITproj Bool
- | ITbiglam
- | ITocurly
- | ITccurly
- | ITvocurly
- | ITvccurly
- | ITobrack
- | ITopabrack
- | ITcpabrack
- | ITcbrack
- | IToparen
- | ITcparen
- | IToubxparen
- | ITcubxparen
- | ITsemi
- | ITcomma
- | ITunderscore
- | ITbackquote
- | ITsimpleQuote
- | ITvarid FastString
- | ITconid FastString
- | ITvarsym FastString
- | ITconsym FastString
- | ITqvarid (FastString, FastString)
- | ITqconid (FastString, FastString)
- | ITqvarsym (FastString, FastString)
- | ITqconsym (FastString, FastString)
- | ITdupipvarid FastString
- | ITlabelvarid SourceText FastString
- | ITchar SourceText Char
- | ITstring SourceText FastString
- | ITinteger IntegralLit
- | ITrational FractionalLit
- | ITprimchar SourceText Char
- | ITprimstring SourceText ByteString
- | ITprimint SourceText Integer
- | ITprimword SourceText Integer
- | ITprimfloat FractionalLit
- | ITprimdouble FractionalLit
- | ITopenExpQuote HasE IsUnicodeSyntax
- | ITopenPatQuote
- | ITopenDecQuote
- | ITopenTypQuote
- | ITcloseQuote IsUnicodeSyntax
- | ITopenTExpQuote HasE
- | ITcloseTExpQuote
- | ITdollar
- | ITdollardollar
- | ITtyQuote
- | ITquasiQuote (FastString, FastString, PsSpan)
- | ITqQuasiQuote (FastString, FastString, FastString, PsSpan)
- | ITproc
- | ITrec
- | IToparenbar IsUnicodeSyntax
- | ITcparenbar IsUnicodeSyntax
- | ITlarrowtail IsUnicodeSyntax
- | ITrarrowtail IsUnicodeSyntax
- | ITLarrowtail IsUnicodeSyntax
- | ITRarrowtail IsUnicodeSyntax
- | ITunknown String
- | ITeof
- | ITdocComment HsDocString PsSpan
- | ITdocOptions String PsSpan
- | ITlineComment String PsSpan
- | ITblockComment String PsSpan
- newtype P a = P {
- unP :: PState -> ParseResult a
- class Monad m => MonadP (m :: Type -> Type) where
- addError :: MsgEnvelope PsMessage -> m ()
- addWarning :: MsgEnvelope PsMessage -> m ()
- addFatalError :: MsgEnvelope PsMessage -> m a
- getBit :: ExtBits -> m Bool
- allocateCommentsP :: RealSrcSpan -> m EpAnnComments
- allocatePriorCommentsP :: RealSrcSpan -> m EpAnnComments
- allocateFinalCommentsP :: RealSrcSpan -> m EpAnnComments
- data ExtBits
- = FfiBit
- | InterruptibleFfiBit
- | CApiFfiBit
- | ArrowsBit
- | ThBit
- | ThQuotesBit
- | IpBit
- | OverloadedLabelsBit
- | ExplicitForallBit
- | BangPatBit
- | PatternSynonymsBit
- | HaddockBit
- | MagicHashBit
- | RecursiveDoBit
- | QualifiedDoBit
- | UnicodeSyntaxBit
- | UnboxedParensBit
- | DatatypeContextsBit
- | MonadComprehensionsBit
- | TransformComprehensionsBit
- | QqBit
- | RawTokenStreamBit
- | AlternativeLayoutRuleBit
- | ALRTransitionalBit
- | RelaxedLayoutBit
- | NondecreasingIndentationBit
- | SafeHaskellBit
- | TraditionalRecordSyntaxBit
- | ExplicitNamespacesBit
- | LambdaCaseBit
- | BinaryLiteralsBit
- | NegativeLiteralsBit
- | HexFloatLiteralsBit
- | StaticPointersBit
- | NumericUnderscoresBit
- | StarIsTypeBit
- | BlockArgumentsBit
- | NPlusKPatternsBit
- | DoAndIfThenElseBit
- | MultiWayIfBit
- | GadtSyntaxBit
- | ImportQualifiedPostBit
- | LinearTypesBit
- | NoLexicalNegationBit
- | OverloadedRecordDotBit
- | OverloadedRecordUpdateBit
- | InRulePragBit
- | InNestedCommentBit
- | UsePosPragsBit
- data PState = PState {
- buffer :: StringBuffer
- options :: ParserOpts
- warnings :: Messages PsMessage
- errors :: Messages PsMessage
- tab_first :: Maybe RealSrcSpan
- tab_count :: !Word
- last_tk :: Maybe (PsLocated Token)
- prev_loc :: PsSpan
- prev_loc2 :: PsSpan
- last_loc :: PsSpan
- last_len :: !Int
- loc :: PsLoc
- context :: [LayoutContext]
- lex_state :: [Int]
- srcfiles :: [FastString]
- alr_pending_implicit_tokens :: [PsLocated Token]
- alr_next_token :: Maybe (PsLocated Token)
- alr_last_loc :: PsSpan
- alr_context :: [ALRContext]
- alr_expecting_ocurly :: Maybe ALRLayout
- alr_justClosedExplicitLetBlock :: Bool
- eof_pos :: Maybe (Pair RealSrcSpan RealSrcSpan)
- header_comments :: Maybe [LEpaComment]
- comment_q :: [LEpaComment]
- hdk_comments :: OrdList (PsLocated HdkComment)
- data HdkComment
- data ParserOpts = ParserOpts {
- pExtsBitmap :: !ExtsBitmap
- pDiagOpts :: !DiagOpts
- pSupportedExts :: [String]
- data ParseResult a :: TYPE ('SumRep '['TupleRep '[LiftedRep, LiftedRep], LiftedRep]) where
- pattern PFailed :: PState -> ParseResult a
- pattern POk :: PState -> a -> ParseResult a
- warnopt :: WarningFlag -> ParserOpts -> Bool
- failMsgP :: (SrcSpan -> MsgEnvelope PsMessage) -> P a
- failLocMsgP :: RealSrcLoc -> RealSrcLoc -> (SrcSpan -> MsgEnvelope PsMessage) -> P a
- getPState :: P PState
- setSrcLoc :: RealSrcLoc -> P ()
- getRealSrcLoc :: P RealSrcLoc
- setLastToken :: PsSpan -> Int -> P ()
- adjustChar :: Char -> Word8
- nextIsEOF :: P Bool
- pushLexState :: Int -> P ()
- popLexState :: P Int
- getLexState :: P Int
- activeContext :: P Bool
- xtest :: ExtBits -> ExtsBitmap -> Bool
- xset :: ExtBits -> ExtsBitmap -> ExtsBitmap
- xunset :: ExtBits -> ExtsBitmap -> ExtsBitmap
- mkParserOpts :: EnumSet Extension -> DiagOpts -> [String] -> Bool -> Bool -> Bool -> Bool -> ParserOpts
- disableHaddock :: ParserOpts -> ParserOpts
- initPragState :: ParserOpts -> StringBuffer -> RealSrcLoc -> PState
- getCommentsFor :: MonadP m => SrcSpan -> m EpAnnComments
- getPriorCommentsFor :: MonadP m => SrcSpan -> m EpAnnComments
- getFinalCommentsFor :: MonadP m => SrcSpan -> m EpAnnComments
- getEofPos :: P (Maybe (Pair RealSrcSpan RealSrcSpan))
- addPsMessage :: SrcSpan -> PsMessage -> P ()
- getPsErrorMessages :: PState -> Messages PsMessage
- popContext :: P ()
- pushModuleContext :: P ()
- srcParseFail :: P a
- lexer :: Bool -> (Located Token -> P a) -> P a
- lexerDbg :: Bool -> (Located Token -> P a) -> P a
- lexTokenStream :: ParserOpts -> StringBuffer -> RealSrcLoc -> ParseResult [Located Token]
- mkParensEpAnn :: RealSrcSpan -> (AddEpAnn, AddEpAnn)
- allocateComments :: RealSrcSpan -> [LEpaComment] -> ([LEpaComment], [LEpaComment])
- allocatePriorComments :: RealSrcSpan -> [LEpaComment] -> Maybe [LEpaComment] -> (Maybe [LEpaComment], [LEpaComment], [LEpaComment])
- allocateFinalComments :: RealSrcSpan -> [LEpaComment] -> Maybe [LEpaComment] -> (Maybe [LEpaComment], [LEpaComment], [LEpaComment])
- commentToAnnotation :: RealLocated Token -> LEpaComment
- class (Typeable e, Show e) => Exception e where
- toException :: e -> SomeException
- fromException :: SomeException -> Maybe e
- displayException :: e -> String
- data GhcException
- try :: Exception e => IO a -> IO (Either e a)
- throwTo :: Exception e => ThreadId -> e -> IO ()
- showException :: Exception e => e -> String
- panic :: HasCallStack => String -> a
- sorry :: HasCallStack => String -> a
- pgmError :: HasCallStack => String -> a
- cmdLineError :: String -> a
- cmdLineErrorIO :: String -> IO a
- assertPanic :: String -> Int -> a
- safeShowException :: Exception e => e -> IO String
- showGhcExceptionUnsafe :: GhcException -> ShowS
- showGhcException :: SDocContext -> GhcException -> ShowS
- throwGhcException :: GhcException -> a
- throwGhcExceptionIO :: GhcException -> IO a
- handleGhcException :: ExceptionMonad m => (GhcException -> m a) -> m a -> m a
- pprPanic :: HasCallStack => String -> SDoc -> a
- panicDoc :: String -> SDoc -> a
- sorryDoc :: String -> SDoc -> a
- pgmErrorDoc :: String -> SDoc -> a
- tryMost :: IO a -> IO (Either SomeException a)
- withSignalHandlers :: ExceptionMonad m => m a -> m a
- callStackDoc :: HasCallStack => SDoc
- prettyCallStackDoc :: CallStack -> SDoc
- assertPprPanic :: HasCallStack => SDoc -> a
- assertPpr :: HasCallStack => Bool -> SDoc -> a -> a
- assertPprMaybe :: HasCallStack => Maybe SDoc -> a -> a
- massertPpr :: (HasCallStack, Applicative m) => Bool -> SDoc -> m ()
- assertPprM :: (HasCallStack, Monad m) => m Bool -> SDoc -> m ()
- data CompileReason
- hsc_type_env_vars :: HscEnv -> KnotVars (IORef TypeEnv)
- hscUpdateHUG :: (HomeUnitGraph -> HomeUnitGraph) -> HscEnv -> HscEnv
- hsc_HUG :: HscEnv -> HomeUnitGraph
- data GhcMessage where
- getKey :: Unique -> Int
- module GHC.Driver.Env.KnotVars
- module GHC.Linker.Types
- module GHC.Types.Unique.Map
- module GHC.Utils.TmpFs
- module GHC.Unit.Finder.Types
- module GHC.Unit.Env
- module GHC.Driver.Phases
- data Extension
- = OverlappingInstances
- | UndecidableInstances
- | IncoherentInstances
- | UndecidableSuperClasses
- | MonomorphismRestriction
- | MonoLocalBinds
- | DeepSubsumption
- | RelaxedPolyRec
- | ExtendedDefaultRules
- | ForeignFunctionInterface
- | UnliftedFFITypes
- | InterruptibleFFI
- | CApiFFI
- | GHCForeignImportPrim
- | JavaScriptFFI
- | ParallelArrays
- | Arrows
- | TemplateHaskell
- | TemplateHaskellQuotes
- | QualifiedDo
- | QuasiQuotes
- | ImplicitParams
- | ImplicitPrelude
- | ScopedTypeVariables
- | AllowAmbiguousTypes
- | UnboxedTuples
- | UnboxedSums
- | UnliftedNewtypes
- | UnliftedDatatypes
- | BangPatterns
- | TypeFamilies
- | TypeFamilyDependencies
- | TypeInType
- | OverloadedStrings
- | OverloadedLists
- | NumDecimals
- | DisambiguateRecordFields
- | RecordWildCards
- | NamedFieldPuns
- | ViewPatterns
- | GADTs
- | GADTSyntax
- | NPlusKPatterns
- | DoAndIfThenElse
- | BlockArguments
- | RebindableSyntax
- | ConstraintKinds
- | PolyKinds
- | DataKinds
- | TypeData
- | InstanceSigs
- | ApplicativeDo
- | LinearTypes
- | StandaloneDeriving
- | DeriveDataTypeable
- | AutoDeriveTypeable
- | DeriveFunctor
- | DeriveTraversable
- | DeriveFoldable
- | DeriveGeneric
- | DefaultSignatures
- | DeriveAnyClass
- | DeriveLift
- | DerivingStrategies
- | DerivingVia
- | TypeSynonymInstances
- | FlexibleContexts
- | FlexibleInstances
- | ConstrainedClassMethods
- | MultiParamTypeClasses
- | NullaryTypeClasses
- | FunctionalDependencies
- | UnicodeSyntax
- | ExistentialQuantification
- | MagicHash
- | EmptyDataDecls
- | KindSignatures
- | RoleAnnotations
- | ParallelListComp
- | TransformListComp
- | MonadComprehensions
- | GeneralizedNewtypeDeriving
- | RecursiveDo
- | PostfixOperators
- | TupleSections
- | PatternGuards
- | LiberalTypeSynonyms
- | RankNTypes
- | ImpredicativeTypes
- | TypeOperators
- | ExplicitNamespaces
- | PackageImports
- | ExplicitForAll
- | AlternativeLayoutRule
- | AlternativeLayoutRuleTransitional
- | DatatypeContexts
- | NondecreasingIndentation
- | RelaxedLayout
- | TraditionalRecordSyntax
- | LambdaCase
- | MultiWayIf
- | BinaryLiterals
- | NegativeLiterals
- | HexFloatLiterals
- | DuplicateRecordFields
- | OverloadedLabels
- | EmptyCase
- | PatternSynonyms
- | PartialTypeSignatures
- | NamedWildCards
- | StaticPointers
- | TypeApplications
- | Strict
- | StrictData
- | EmptyDataDeriving
- | NumericUnderscores
- | QuantifiedConstraints
- | StarIsType
- | ImportQualifiedPost
- | CUSKs
- | StandaloneKindSignatures
- | LexicalNegation
- | FieldSelectors
- | OverloadedRecordDot
- | OverloadedRecordUpdate
- mkCgInteractiveGuts :: CgGuts -> CgInteractiveGuts
- justBytecode :: Linkable -> HomeModLinkable
- justObjects :: Linkable -> HomeModLinkable
- emptyHomeModInfoLinkable :: HomeModLinkable
- homeModInfoByteCode :: HomeModInfo -> Maybe Linkable
- homeModInfoObject :: HomeModInfo -> Maybe Linkable
- groupOrigin :: MatchGroup p body -> XMG p body
- isVisibleFunArg :: FunTyFlag -> Bool
Session
Contains not only a collection of GeneralFlags but also a plethora of
information relating to the compilation of a single file or GHC session
extensions :: DynFlags -> [OnOff Extension] #
extensionFlags :: DynFlags -> EnumSet Extension #
targetPlatform :: DynFlags -> Platform #
packageFlags :: DynFlags -> [PackageFlag] #
The -package and -hide-package flags from the command-line.
In *reverse* order that they're specified on the command line.
generalFlags :: DynFlags -> EnumSet GeneralFlag #
warningFlags :: DynFlags -> EnumSet WarningFlag #
importPaths :: DynFlags -> [FilePath] #
useColor :: DynFlags -> OverridingBool #
canUseColor :: DynFlags -> Bool #
useUnicode :: DynFlags -> Bool #
flagsForCompletion :: Bool -> [String] #
Make a list of flags for shell completion. Filter all available flags into two groups, for interactive GHC vs all other.
outputFile :: DynFlags -> Maybe String #
pluginModNames :: DynFlags -> [ModuleName] #
the -fplugin flags given on the command line, in *reverse*
order that they're specified on the command line.
refLevelHoleFits :: DynFlags -> Maybe Int #
Maximum level of refinement for refinement hole fits in typed hole error messages
maxRefHoleFits :: DynFlags -> Maybe Int #
Maximum number of refinement hole fits to show in typed hole error messages
maxValidHoleFits :: DynFlags -> Maybe Int #
Maximum number of hole fits to show in typed hole error messages
lookupType :: HscEnv -> Name -> IO (Maybe TyThing) #
Find the TyThing for the given Name by using all the resources
at our disposal: the compiled modules in the HomePackageTable and the
compiled modules in other packages that live in PackageTypeEnv. Note
that this does NOT look up the TyThing in the module being compiled: you
have to do that yourself, if desired
needWiredInHomeIface :: TyThing -> Bool #
loadWiredInHomeIface :: Name -> IfM lcl () #
An IfM function to load the home interface for a wired-in thing,
so that we're sure that we see its instance declarations and rules
See Note [Loading instances for wired-in things]
loadSysInterface :: SDoc -> Module -> IfM lcl ModIface #
Loads a system interface and throws an exception if it fails
type CommandLineOption = String #
Command line options gathered from the -PModule.Name:stuff syntax are given to you as this type
gopt :: GeneralFlag -> DynFlags -> Bool #
Test whether a GeneralFlag is set
Note that dynamicNow (i.e., dynamic objects built with `-dynamic-too`)
always implicitly enables Opt_PIC, Opt_ExternalDynamicRefs, and disables
Opt_SplitSections.
gopt_set :: DynFlags -> GeneralFlag -> DynFlags #
Set a GeneralFlag
gopt_unset :: DynFlags -> GeneralFlag -> DynFlags #
Unset a GeneralFlag
wopt :: WarningFlag -> DynFlags -> Bool #
Test whether a WarningFlag is set
wopt_set :: DynFlags -> WarningFlag -> DynFlags #
Set a WarningFlag
Constructors
| FlagSpec | |
Fields
| |
data WarningFlag #
Constructors
Instances
data GeneralFlag #
Enumerates the simple on-or-off dynamic flags
Constructors
Instances
| Enum GeneralFlag | |
Defined in GHC.Driver.Flags Methods succ :: GeneralFlag -> GeneralFlag # pred :: GeneralFlag -> GeneralFlag # toEnum :: Int -> GeneralFlag # fromEnum :: GeneralFlag -> Int # enumFrom :: GeneralFlag -> [GeneralFlag] # enumFromThen :: GeneralFlag -> GeneralFlag -> [GeneralFlag] # enumFromTo :: GeneralFlag -> GeneralFlag -> [GeneralFlag] # enumFromThenTo :: GeneralFlag -> GeneralFlag -> GeneralFlag -> [GeneralFlag] # | |
| Show GeneralFlag | |
Defined in GHC.Driver.Flags Methods showsPrec :: Int -> GeneralFlag -> ShowS # show :: GeneralFlag -> String # showList :: [GeneralFlag] -> ShowS # | |
| Eq GeneralFlag | |
Defined in GHC.Driver.Flags | |
data PackageFlag #
Flags for manipulating packages visibility.
Instances
| Show PackageFlag Source # | |
Defined in Development.IDE.GHC.Orphans Methods showsPrec :: Int -> PackageFlag -> ShowS # show :: PackageFlag -> String # showList :: [PackageFlag] -> ShowS # | |
| Outputable PackageFlag | |
Defined in GHC.Driver.Session Methods ppr :: PackageFlag -> SDoc # | |
| Eq PackageFlag | |
Defined in GHC.Driver.Session | |
data PackageArg #
We accept flags which make packages visible, but how they select the package varies; this data type reflects what selection criterion is used.
Constructors
| PackageArg String |
|
| UnitIdArg Unit |
|
Instances
| Show PackageArg | |
Defined in GHC.Driver.Session Methods showsPrec :: Int -> PackageArg -> ShowS # show :: PackageArg -> String # showList :: [PackageArg] -> ShowS # | |
| Outputable PackageArg | |
Defined in GHC.Driver.Session Methods ppr :: PackageArg -> SDoc # | |
| Eq PackageArg | |
Defined in GHC.Driver.Session | |
data ModRenaming #
Represents the renaming that may be associated with an exposed
package, e.g. the rns part of -package "foo (rns)".
Here are some example parsings of the package flags (where
a string literal is punned to be a ModuleName:
Constructors
| ModRenaming | |
Fields
| |
Instances
| Outputable ModRenaming | |
Defined in GHC.Driver.Session Methods ppr :: ModRenaming -> SDoc # | |
| Eq ModRenaming | |
Defined in GHC.Driver.Session | |
pattern ExposePackage :: String -> PackageArg -> ModRenaming -> PackageFlag Source #
Arguments
| :: MonadIO m | |
| => DynFlags | |
| -> [Located String] | |
| -> m (DynFlags, [Located String], [Warn]) | Updated |
Parse dynamic flags from a list of command line arguments. Returns
the parsed DynFlags, the left-over arguments, and a list of warnings.
Throws a UsageError if errors occurred during parsing (such as unknown
flags or missing arguments).
Arguments
| :: MonadIO m | |
| => DynFlags | |
| -> [Located String] | |
| -> m (DynFlags, [Located String], [Warn]) | Updated |
Like parseDynamicFlagsCmdLine but does not allow the package flags
(-package, -hide-package, -ignore-package, -hide-all-packages, -package-db).
Used to parse flags set in a modules pragma.
wWarningFlags :: [FlagSpec WarningFlag] #
These -W<blah> flags can all be reversed with -Wno-<blah>
updOptLevel :: Int -> DynFlags -> DynFlags #
Sets the DynFlags to be appropriate to the optimisation level
setUnsafeGlobalDynFlags :: DynFlags -> IO () #
Linear Haskell
scaledThing :: Scaled a -> a #
Interface Files
type IfaceExport = AvailInfo #
The original names declared of a certain module that are exported
data IfaceTyCon #
Constructors
| IfaceTyCon | |
Fields | |
Instances
| NFData IfaceTyCon | |
Defined in GHC.Iface.Type Methods rnf :: IfaceTyCon -> () # | |
| Binary IfaceTyCon | |
Defined in GHC.Iface.Type Methods put_ :: BinHandle -> IfaceTyCon -> IO () # put :: BinHandle -> IfaceTyCon -> IO (Bin IfaceTyCon) # get :: BinHandle -> IO IfaceTyCon # | |
| Outputable IfaceTyCon | |
Defined in GHC.Iface.Type Methods ppr :: IfaceTyCon -> SDoc # | |
| Eq IfaceTyCon | |
Defined in GHC.Iface.Type | |
data ModIface_ (phase :: ModIfacePhase) #
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.
See Note [Strictness in ModIface] to learn about why some fields are strict and others are not.
Constructors
| ModIface | |
Fields
| |
Instances
| Binary ModIface | |
| (NFData (IfaceBackendExts phase), NFData (IfaceDeclExts phase)) => NFData (ModIface_ phase) | |
Defined in GHC.Unit.Module.ModIface | |
Constructors
| HsSrcFile | .hs file |
| HsBootFile | .hs-boot file |
| HsigFile | .hsig file |
Instances
| Show HscSource | |
| Binary HscSource | |
| Eq HscSource | |
| Ord HscSource | |
Constructors
| ImportByUser IsBootInterface | |
| ImportBySystem | |
| ImportByPlugin |
Instances
| Outputable WhereFrom | |
Defined in GHC.Tc.Types | |
loadModuleInterface :: SDoc -> Module -> TcM ModIface #
Load interface directly for a fully qualified GenModule. (This is a fairly
rare operation, but in particular it is used to load orphan modules
in order to pull their instances into the global package table and to
handle some operations in GHCi).
data RecompileRequired #
Constructors
| UpToDate | everything is up to date, recompilation is not required |
| NeedsRecompile !CompileReason | Need to compile the module |
Instances
| Monoid RecompileRequired | |
Defined in GHC.Iface.Recomp Methods mappend :: RecompileRequired -> RecompileRequired -> RecompileRequired # mconcat :: [RecompileRequired] -> RecompileRequired # | |
| Semigroup RecompileRequired | |
Defined in GHC.Iface.Recomp Methods (<>) :: RecompileRequired -> RecompileRequired -> RecompileRequired # sconcat :: NonEmpty RecompileRequired -> RecompileRequired # stimes :: Integral b => b -> RecompileRequired -> RecompileRequired # | |
| Outputable RecompileRequired | |
Defined in GHC.Iface.Recomp Methods ppr :: RecompileRequired -> SDoc # | |
| Eq RecompileRequired | |
Defined in GHC.Iface.Recomp Methods (==) :: RecompileRequired -> RecompileRequired -> Bool # (/=) :: RecompileRequired -> RecompileRequired -> Bool # | |
mkPartialIface :: HscEnv -> CoreProgram -> ModDetails -> ModSummary -> ModGuts -> PartialModIface #
mkFullIface :: HscEnv -> PartialModIface -> Maybe StgCgInfos -> Maybe CmmCgInfos -> IO ModIface #
Fully instantiate an interface. Adds fingerprints and potentially code generator produced information.
CmmCgInfos is not available when not generating code (-fno-code), or when not generating interface pragmas (-fomit-interface-pragmas). See also Note [Conveying CAF-info and LFInfo between modules] in GHC.StgToCmm.Types.
data IsBootInterface #
Indicates whether a module name is referring to a boot interface (hs-boot file) or regular module (hs file). We need to treat boot modules specially when building compilation graphs, since they break cycles. Regular source files and signature files are treated equivalently.
Instances
Fixity
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
| Data LexicalFixity | |
Defined in GHC.Types.Fixity Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LexicalFixity -> c LexicalFixity # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LexicalFixity # toConstr :: LexicalFixity -> Constr # dataTypeOf :: LexicalFixity -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c LexicalFixity) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LexicalFixity) # gmapT :: (forall b. Data b => b -> b) -> LexicalFixity -> LexicalFixity # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LexicalFixity -> r # gmapQr :: forall r r'. (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 GHC.Types.Fixity Methods ppr :: LexicalFixity -> SDoc # | |
| Eq LexicalFixity | |
Defined in GHC.Types.Fixity Methods (==) :: LexicalFixity -> LexicalFixity -> Bool # (/=) :: LexicalFixity -> LexicalFixity -> Bool # | |
Constructors
| Fixity SourceText Int FixityDirection |
Instances
| Data Fixity | |
Defined in GHC.Types.Fixity Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Fixity -> c Fixity # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Fixity # toConstr :: Fixity -> Constr # dataTypeOf :: Fixity -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Fixity) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity) # gmapT :: (forall b. Data b => b -> b) -> Fixity -> Fixity # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r # gmapQ :: (forall d. Data d => d -> u) -> Fixity -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Fixity -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity # | |
| Binary Fixity | |
| Outputable Fixity | |
Defined in GHC.Types.Fixity | |
| Eq Fixity | |
mi_fix :: ModIface -> OccName -> Fixity #
Lookups up a (possibly cached) fixity from a ModIface. If one cannot be
found, defaultFixity is returned instead.
defaultFixity :: Fixity #
lookupFixityRn :: Name -> RnM Fixity #
ModSummary
data ModSummary #
Data for a module node in a ModuleGraph. Module nodes of the module graph
are one of:
- A regular Haskell source module
- A hi-boot source module
Constructors
| ModSummary | |
Fields
| |
Instances
| Show ModSummary Source # | |
Defined in Development.IDE.GHC.Orphans Methods showsPrec :: Int -> ModSummary -> ShowS # show :: ModSummary -> String # showList :: [ModSummary] -> ShowS # | |
| NFData ModSummary Source # | |
Defined in Development.IDE.GHC.Orphans Methods rnf :: ModSummary -> () # | |
| Outputable ModSummary | |
Defined in GHC.Unit.Module.ModSummary Methods ppr :: ModSummary -> SDoc # | |
HomeModInfo
data HomeModInfo #
Information about modules in the package being compiled
Constructors
| HomeModInfo | |
Fields
| |
Instances
| Show HomeModInfo Source # | |
Defined in Development.IDE.GHC.Orphans Methods showsPrec :: Int -> HomeModInfo -> ShowS # show :: HomeModInfo -> String # showList :: [HomeModInfo] -> ShowS # | |
| NFData HomeModInfo Source # | |
Defined in Development.IDE.GHC.Orphans Methods rnf :: HomeModInfo -> () # | |
ModGuts
A ModGuts is carried through the compiler, accumulating stuff as it goes
There is only one ModGuts at any time, the one for the module
being compiled right now. Once it is compiled, a ModIface and
ModDetails are extracted and the ModGuts is discarded.
Constructors
| ModGuts | |
Fields
| |
A restricted form of ModGuts for code generation purposes
Constructors
| CgGuts | |
Fields
| |
ModDetails
data ModDetails #
The ModDetails is essentially a cache for information in the ModIface
for home modules only. Information relating to packages will be loaded into
global environments in ExternalPackageState.
Constructors
| ModDetails | |
Fields
| |
Instances
| Show ModDetails Source # | |
Defined in Development.IDE.GHC.Orphans Methods showsPrec :: Int -> ModDetails -> ShowS # show :: ModDetails -> String # showList :: [ModDetails] -> ShowS # | |
| NFData ModDetails Source # | |
Defined in Development.IDE.GHC.Orphans Methods rnf :: ModDetails -> () # | |
HsExpr,
Var
Constructors
| TyVarTy Var | Vanilla type or kind variable (*never* a coercion variable) |
| AppTy Type Type | Type application to something other than a 1) Function: must not be a 2) Argument type |
| TyConApp TyCon [KindOrType] | Application of a 1) Type constructor being applied to. 2) Type arguments. Might not have enough type arguments here to saturate the constructor. Even type synonyms are not necessarily saturated; for example unsaturated type synonyms can appear as the right hand side of a type synonym. |
| ForAllTy !ForAllTyBinder Type | A Π type. Note [When we quantify over a coercion variable] INVARIANT: If the binder is a coercion variable, it must be mentioned in the Type. See Note [Unused coercion variable in ForAllTy] |
| LitTy TyLit | Type literals are similar to type constructors. |
| CastTy Type KindCoercion | A kind cast. The coercion is always nominal. INVARIANT: The cast is never reflexive (EQ2) INVARIANT: The Type is not a CastTy (use TransCo instead) (EQ3) INVARIANT: The Type is not a ForAllTy over a tyvar (EQ4) See Note [Respecting definitional equality] |
| CoercionTy Coercion | Injection of a Coercion into a type This should only ever be used in the RHS of an AppTy, in the list of a TyConApp, when applying a promoted GADT data constructor |
Instances
| Data Type | |
Defined in GHC.Core.TyCo.Rep Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Type -> c Type # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Type # 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 :: forall r r'. (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 # | |
| NFData Type Source # | |
Defined in Development.IDE.GHC.Orphans | |
| Outputable Type | |
Defined in GHC.Core.TyCo.Rep | |
| Eq (DeBruijn Type) | |
conPatDetails :: Pat p -> Maybe (HsConPatDetails p) Source #
mapConPatDetail :: (HsConPatDetails p -> Maybe (HsConPatDetails p)) -> Pat p -> Maybe (Pat p) Source #
Specs
data ImpDeclSpec #
Import Declaration Specification
Describes a particular import declaration and is
shared among all the Provenances for that decl
Constructors
| ImpDeclSpec | |
Fields
| |
Instances
| Data ImpDeclSpec | |
Defined in GHC.Types.Name.Reader Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImpDeclSpec -> c ImpDeclSpec # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ImpDeclSpec # toConstr :: ImpDeclSpec -> Constr # dataTypeOf :: ImpDeclSpec -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ImpDeclSpec) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImpDeclSpec) # gmapT :: (forall b. Data b => b -> b) -> ImpDeclSpec -> ImpDeclSpec # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImpDeclSpec -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImpDeclSpec -> r # gmapQ :: (forall d. Data d => d -> u) -> ImpDeclSpec -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ImpDeclSpec -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImpDeclSpec -> m ImpDeclSpec # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImpDeclSpec -> m ImpDeclSpec # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImpDeclSpec -> m ImpDeclSpec # | |
| Eq ImpDeclSpec | |
Defined in GHC.Types.Name.Reader | |
data ImportSpec #
Import Specification
The ImportSpec of something says how it came to be imported
It's quite elaborate so that we can give accurate unused-name warnings.
Constructors
| ImpSpec | |
Fields
| |
Instances
| Data ImportSpec | |
Defined in GHC.Types.Name.Reader Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImportSpec -> c ImportSpec # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ImportSpec # toConstr :: ImportSpec -> Constr # dataTypeOf :: ImportSpec -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ImportSpec) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImportSpec) # gmapT :: (forall b. Data b => b -> b) -> ImportSpec -> ImportSpec # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImportSpec -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImportSpec -> r # gmapQ :: (forall d. Data d => d -> u) -> ImportSpec -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ImportSpec -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImportSpec -> m ImportSpec # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportSpec -> m ImportSpec # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportSpec -> m ImportSpec # | |
| Outputable ImportSpec | |
Defined in GHC.Types.Name.Reader Methods ppr :: ImportSpec -> SDoc # | |
| Eq ImportSpec | |
Defined in GHC.Types.Name.Reader | |
SourceText
data SourceText #
Constructors
| SourceText String | |
| NoSourceText | For when code is generated, e.g. TH, deriving. The pretty printer will then make its own representation of the item. |
Instances
| Data SourceText | |
Defined in GHC.Types.SourceText Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SourceText -> c SourceText # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SourceText # toConstr :: SourceText -> Constr # dataTypeOf :: SourceText -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SourceText) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceText) # gmapT :: (forall b. Data b => b -> b) -> SourceText -> SourceText # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SourceText -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SourceText -> r # gmapQ :: (forall d. Data d => d -> u) -> SourceText -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceText -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SourceText -> m SourceText # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceText -> m SourceText # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceText -> m SourceText # | |
| Show SourceText | |
Defined in GHC.Types.SourceText Methods showsPrec :: Int -> SourceText -> ShowS # show :: SourceText -> String # showList :: [SourceText] -> ShowS # | |
| Binary SourceText | |
Defined in GHC.Types.SourceText Methods put_ :: BinHandle -> SourceText -> IO () # put :: BinHandle -> SourceText -> IO (Bin SourceText) # get :: BinHandle -> IO SourceText # | |
| Outputable SourceText | |
Defined in GHC.Types.SourceText Methods ppr :: SourceText -> SDoc # | |
| Eq SourceText | |
Defined in GHC.Types.SourceText | |
| type Anno (SourceText, RuleName) | |
Defined in GHC.Hs.Decls | |
Ways
A way
Don't change the constructor order as it is used by waysTag to create a
unique tag (e.g. thr_debug_p) which is expected by other tools (e.g. Cabal).
wayGeneralFlags :: Platform -> Way -> [GeneralFlag] #
Turn these flags on when enabling this way
wayUnsetGeneralFlags :: Platform -> Way -> [GeneralFlag] #
Turn these flags off when enabling this way
AvailInfo
Records what things are "available", i.e. in scope
Instances
| Data AvailInfo | |
Defined in GHC.Types.Avail Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AvailInfo -> c AvailInfo # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AvailInfo # toConstr :: AvailInfo -> Constr # dataTypeOf :: AvailInfo -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AvailInfo) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AvailInfo) # gmapT :: (forall b. Data b => b -> b) -> AvailInfo -> AvailInfo # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AvailInfo -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AvailInfo -> r # gmapQ :: (forall d. Data d => d -> u) -> AvailInfo -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> AvailInfo -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> AvailInfo -> m AvailInfo # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AvailInfo -> m AvailInfo # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AvailInfo -> m AvailInfo # | |
| NFData AvailInfo | |
Defined in GHC.Types.Avail | |
| Binary AvailInfo | |
| Outputable AvailInfo | |
Defined in GHC.Types.Avail | |
| Eq AvailInfo | Used when deciding if the interface has changed |
pattern AvailFL :: FieldLabel -> AvailInfo Source #
availName :: AvailInfo -> Name #
Just the main name made available, i.e. not the available pieces
of type or class brought into scope by the AvailInfo
availNames :: AvailInfo -> [Name] #
All names made available by the availability information (excluding overloaded selectors)
availNamesWithSelectors :: AvailInfo -> [Name] #
All names made available by the availability information (including overloaded selectors)
availsToNameSet :: [AvailInfo] -> NameSet #
TcGblEnv
TcGblEnv describes the top-level of the module at the
point at which the typechecker is finished work.
It is this structure that is handed on to the desugarer
For state that needs to be updated during the typechecking
phase and returned at end, use a TcRef (= IORef).
Constructors
| TcGblEnv | |
Fields
| |
Instances
| ContainsModule TcGblEnv | |
Defined in GHC.Tc.Types Methods extractModule :: TcGblEnv -> Module # | |
Parsing and LExer types
Haskell Module
All we actually declare here is the top-level structure for a module.
Constructors
| HsModule | |
Fields
| |
| XModule !(XXModule p) | |
type ParsedSource = Located (HsModule GhcPs) #
type RenamedSource = (HsGroup GhcRn, [LImportDecl GhcRn], Maybe [(LIE GhcRn, Avails)], Maybe (LHsDoc GhcRn)) #
Compilation Main
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--. It's also used
to store the dynamic linker state to allow for multiple linkers in the
same address space.
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.
Instances
| ContainsDynFlags HscEnv | |
Defined in GHC.Driver.Env.Types Methods extractDynFlags :: HscEnv -> DynFlags # | |
Arguments
| :: 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.
The Session is a handle to the complete state of a compilation session. A compilation session consists of a set of modules constituting the current program or library, the context for interactive evaluation, and various caches.
modifySession :: GhcMonad m => (HscEnv -> HscEnv) -> m () #
Set the current session to the result of applying the current session to the argument.
getSession :: GhcMonad m => m HscEnv #
setSessionDynFlags :: (HasCallStack, GhcMonad m) => DynFlags -> m () #
getSessionDynFlags :: GhcMonad m => m DynFlags #
Grabs the DynFlags from the Session
class (Functor m, ExceptionMonad m, HasDynFlags m, HasLogger m) => GhcMonad (m :: Type -> Type) #
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.
Minimal complete definition
Instances
| GhcMonad Ghc | |
Defined in GHC.Driver.Monad | |
| ExceptionMonad m => GhcMonad (GhcT m) | |
Defined in GHC.Driver.Monad | |
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
| MonadFail Ghc | |
Defined in GHC.Driver.Monad | |
| MonadFix Ghc | |
Defined in GHC.Driver.Monad | |
| MonadIO Ghc | |
Defined in GHC.Driver.Monad | |
| Applicative Ghc | |
| Functor Ghc | |
| Monad Ghc | |
| MonadCatch Ghc | |
Defined in GHC.Driver.Monad | |
| MonadMask Ghc | |
Defined in GHC.Driver.Monad Methods mask :: HasCallStack => ((forall a. Ghc a -> Ghc a) -> Ghc b) -> Ghc b # uninterruptibleMask :: HasCallStack => ((forall a. Ghc a -> Ghc a) -> Ghc b) -> Ghc b # generalBracket :: HasCallStack => Ghc a -> (a -> ExitCase b -> Ghc c) -> (a -> Ghc b) -> Ghc (b, c) # | |
| MonadThrow Ghc | |
Defined in GHC.Driver.Monad Methods throwM :: (HasCallStack, Exception e) => e -> Ghc a # | |
| GhcMonad Ghc | |
Defined in GHC.Driver.Monad | |
| HasDynFlags Ghc | |
Defined in GHC.Driver.Monad Methods getDynFlags :: Ghc DynFlags # | |
| HasLogger Ghc | |
Defined in GHC.Driver.Monad | |
Untyped Phase description
Constructors
| Unlit HscSource | |
| Cpp HscSource | |
| HsPp HscSource | |
| Hsc HscSource | |
| Ccxx | |
| Cc | |
| Cobjc | |
| Cobjcxx | |
| HCc | |
| As Bool | |
| LlvmOpt | |
| LlvmLlc | |
| LlvmMangle | |
| CmmCpp | |
| Cmm | |
| MergeForeign | |
| Js | |
| StopLn |
Instances
| Show Phase | |
| Outputable Phase | |
Defined in GHC.Driver.Phases | |
| Eq Phase | |
hscDesugar :: HscEnv -> ModSummary -> TcGblEnv -> IO ModGuts #
Convert a typechecked module to Core
Arguments
| :: HscEnv | |
| -> CgGuts | |
| -> ModLocation | |
| -> FilePath | |
| -> IO (FilePath, Maybe FilePath, [(ForeignSrcLang, FilePath)], Maybe StgCgInfos, Maybe CmmCgInfos) |
|
Compile to hard-code.
hscInteractive :: HscEnv -> CgInteractiveGuts -> ModLocation -> IO (Maybe FilePath, CompiledByteCode, [SptEntry]) #
hscSimplify :: HscEnv -> [String] -> ModGuts -> IO ModGuts #
Run Core2Core simplifier. The list of String is a list of (Core) plugin
module names added via TH (cf addCorePlugin).
hscTypecheckRename :: HscEnv -> ModSummary -> HsParsedModule -> IO (TcGblEnv, RenamedStuff) #
Rename and typecheck a module, additionally returning the renamed syntax
hscUpdateHPT :: (HomePackageTable -> HomePackageTable) -> HscEnv -> HscEnv #
makeSimpleDetails :: HscEnv -> TcGblEnv -> IO ModDetails Source #
Typecheck utils
tcSplitForAllTyVars :: Type -> ([TyVar], Type) #
Like tcSplitPiTys, but splits off only named binders,
returning just the tyvars.
tcSplitForAllTyVarBinder_maybe :: Type -> Maybe (TyVarBinder, Type) #
typecheckIface :: ModIface -> IfG ModDetails #
mkIfaceTc :: HscEnv -> SafeHaskellMode -> ModDetails -> ModSummary -> Maybe CoreProgram -> TcGblEnv -> IO ModIface Source #
mkBootModDetailsTc :: HscEnv -> TcGblEnv -> IO ModDetails Source #
tidyProgram :: TidyOpts -> ModGuts -> IO (CgGuts, ModDetails) #
data ImportedModsVal #
Constructors
| ImportedModsVal | |
Fields
| |
importedByUser :: [ImportedBy] -> [ImportedModsVal] #
type TypecheckedSource = LHsBinds GhcTc #
Source Locations
class HasSrcSpan a Source #
Minimal complete definition
Instances
| HasSrcSpan SrcSpan Source # | |
| HasSrcSpan (SrcSpanAnn' ann) Source # | |
Defined in Development.IDE.GHC.Compat.Core Methods getLoc :: SrcSpanAnn' ann -> SrcSpan Source # | |
| HasSrcSpan (GenLocated (SrcSpanAnn' ann) a) Source # | |
Defined in Development.IDE.GHC.Compat.Core Methods getLoc :: GenLocated (SrcSpanAnn' ann) a -> SrcSpan Source # | |
| HasSrcSpan (GenLocated SrcSpan a) Source # | |
Defined in Development.IDE.GHC.Compat.Core | |
type Located = GenLocated SrcSpan #
unLoc :: GenLocated l e -> e #
getLoc :: HasSrcSpan a => a -> SrcSpan Source #
getLocA :: GenLocated (SrcSpanAnn' a) e -> SrcSpan #
locA :: SrcSpanAnn' a -> SrcSpan #
type LocatedA = GenLocated SrcSpanAnnA #
data AnnListItem #
Annotation for items appearing in a list. They can have one or more trailing punctuations items, such as commas or semicolons.
Constructors
| AnnListItem | |
Fields
| |
Instances
exact print annotations for a RdrName. There are many kinds of
adornment that can be attached to a given RdrName. This type
captures them, as detailed on the individual constructors.
Constructors
| NameAnn | Used for a name with an adornment, so |
Fields | |
| NameAnnCommas | |
Fields | |
| NameAnnBars | Used for |
Fields
| |
| NameAnnOnly | Used for |
Fields | |
| NameAnnRArrow | Used for |
Fields
| |
| NameAnnQuote | Used for an item with a leading |
Fields | |
| NameAnnTrailing | Used when adding a |
Fields
| |
Instances
| Data NameAnn | |
Defined in GHC.Parser.Annotation Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NameAnn -> c NameAnn # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NameAnn # toConstr :: NameAnn -> Constr # dataTypeOf :: NameAnn -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NameAnn) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameAnn) # gmapT :: (forall b. Data b => b -> b) -> NameAnn -> NameAnn # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NameAnn -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NameAnn -> r # gmapQ :: (forall d. Data d => d -> u) -> NameAnn -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NameAnn -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NameAnn -> m NameAnn # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NameAnn -> m NameAnn # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NameAnn -> m NameAnn # | |
| Monoid NameAnn | |
| Semigroup NameAnn | |
| Outputable NameAnn | |
Defined in GHC.Parser.Annotation | |
| Eq NameAnn | |
| HasLoc (LocatedN a) | |
Defined in GHC.Iface.Ext.Ast | |
| ToHie (LBooleanFormula (LocatedN Name)) | |
Defined in GHC.Iface.Ext.Ast | |
| ToHie (Context (Located a)) => ToHie (Context (LocatedN a)) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (LocatedN Name) | |
Defined in GHC.Hs.Binds | |
| type Anno (LocatedN RdrName) | |
Defined in GHC.Hs.Binds | |
| type Anno (LocatedN Id) | |
Defined in GHC.Hs.Binds | |
| type Anno [LocatedN Name] | |
Defined in GHC.Hs.Binds | |
| type Anno [LocatedN RdrName] | |
Defined in GHC.Hs.Binds | |
| type Anno [LocatedN Id] | |
Defined in GHC.Hs.Binds | |
type RealLocated = GenLocated RealSrcSpan #
data GenLocated l e #
We attach SrcSpans to lots of things, so let's have a datatype for it.
Constructors
| L l e |
Instances
Source Span
A SrcSpan identifies either a specific portion of a text file
or a human-readable description of a location.
Constructors
| UnhelpfulSpan !UnhelpfulSpanReason |
Instances
| Data SrcSpan | |
Defined in GHC.Types.SrcLoc Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcSpan -> c SrcSpan # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SrcSpan # toConstr :: SrcSpan -> Constr # dataTypeOf :: SrcSpan -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SrcSpan) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcSpan) # gmapT :: (forall b. Data b => b -> b) -> SrcSpan -> SrcSpan # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcSpan -> r # gmapQr :: forall r r'. (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 # | |
| Show SrcSpan | |
| NFData SrcSpan | |
Defined in GHC.Types.SrcLoc | |
| ToJson SrcSpan | |
Defined in GHC.Types.SrcLoc | |
| Outputable SrcSpan | |
Defined in GHC.Types.SrcLoc | |
| Eq SrcSpan | |
| Ord SrcSpan Source # | |
Defined in Development.IDE.GHC.Orphans | |
| HasSrcSpan SrcSpan Source # | |
| HasLoc (Located a) | |
Defined in GHC.Iface.Ext.Ast | |
| ToHie (LHsDoc GhcRn) | |
| ToHie (Context (Located Name)) | |
| ToHie (Context (Located Var)) | |
| ToHie (Context (Located NoExtField)) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: Context (Located NoExtField) -> HieM [HieAST Type] | |
| ToHie (IEContext (Located FieldLabel)) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: IEContext (Located FieldLabel) -> HieM [HieAST Type] | |
| HiePass p => ToHie (Located (PatSynBind (GhcPass p) (GhcPass p))) | |
Defined in GHC.Iface.Ext.Ast | |
| ToHie (Located [LocatedAn NoEpAnns (HsDerivingClause GhcRn)]) | |
Defined in GHC.Iface.Ext.Ast | |
| NamedThing e => NamedThing (Located e) | |
Defined in GHC.Types.Name | |
| Outputable e => Outputable (Located e) | |
Defined in GHC.Types.SrcLoc | |
| HasSrcSpan (GenLocated SrcSpan a) Source # | |
Defined in Development.IDE.GHC.Compat.Core | |
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
pattern RealSrcSpan :: RealSrcSpan -> Maybe BufSpan -> SrcSpan Source #
data RealSrcLoc #
Real Source Location
Represents a single point within a file
Instances
| Show RealSrcLoc | |
Defined in GHC.Types.SrcLoc Methods showsPrec :: Int -> RealSrcLoc -> ShowS # show :: RealSrcLoc -> String # showList :: [RealSrcLoc] -> ShowS # | |
| Outputable RealSrcLoc | |
Defined in GHC.Types.SrcLoc Methods ppr :: RealSrcLoc -> SDoc # | |
| Eq RealSrcLoc | |
Defined in GHC.Types.SrcLoc | |
| Ord RealSrcLoc | |
Defined in GHC.Types.SrcLoc Methods compare :: RealSrcLoc -> RealSrcLoc -> Ordering # (<) :: RealSrcLoc -> RealSrcLoc -> Bool # (<=) :: RealSrcLoc -> RealSrcLoc -> Bool # (>) :: RealSrcLoc -> RealSrcLoc -> Bool # (>=) :: RealSrcLoc -> RealSrcLoc -> Bool # max :: RealSrcLoc -> RealSrcLoc -> RealSrcLoc # min :: RealSrcLoc -> RealSrcLoc -> RealSrcLoc # | |
pattern RealSrcLoc :: RealSrcLoc -> Maybe BufPos -> SrcLoc Source #
Source Location
Constructors
| UnhelpfulLoc !FastString |
Instances
| Show SrcLoc | |
| Outputable SrcLoc | |
Defined in GHC.Types.SrcLoc | |
| Eq SrcLoc | |
StringBuffer Source Span
Instances
| Data BufSpan | |
Defined in GHC.Types.SrcLoc Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BufSpan -> c BufSpan # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c BufSpan # toConstr :: BufSpan -> Constr # dataTypeOf :: BufSpan -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c BufSpan) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BufSpan) # gmapT :: (forall b. Data b => b -> b) -> BufSpan -> BufSpan # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BufSpan -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BufSpan -> r # gmapQ :: (forall d. Data d => d -> u) -> BufSpan -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> BufSpan -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> BufSpan -> m BufSpan # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BufSpan -> m BufSpan # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BufSpan -> m BufSpan # | |
| Semigroup BufSpan | |
| Show BufSpan | |
| Eq BufSpan | |
| Ord BufSpan | |
type SrcAnn ann = SrcSpanAnn' (EpAnn ann) #
We mostly use 'SrcSpanAnn'' with an 'EpAnn''
containsSpan :: RealSrcSpan -> RealSrcSpan -> Bool #
Tests whether the first span "contains" the other span, meaning that it covers at least as much source code. True where spans are equal.
mkGeneralSrcSpan :: FastString -> SrcSpan #
Create a "bad" SrcSpan that has not location information
mkRealSrcSpan :: RealSrcLoc -> RealSrcLoc -> RealSrcSpan #
Create a SrcSpan between two points in a file
mkRealSrcLoc :: FastString -> Int -> Int -> RealSrcLoc #
getRealSrcSpan :: RealLocated a -> RealSrcSpan #
realSrcLocSpan :: RealSrcLoc -> RealSrcSpan #
realSrcSpanEnd :: RealSrcSpan -> RealSrcLoc #
Arguments
| :: SrcSpan | The span that may be enclosed by the other |
| -> SrcSpan | The span it may be enclosed by |
| -> Bool |
Determines whether a span is enclosed by another one
Built-in "bad" SrcSpans for common sources of location uncertainty
srcSpanStart :: SrcSpan -> SrcLoc #
srcSpanStartLine :: RealSrcSpan -> Int #
srcSpanStartCol :: RealSrcSpan -> Int #
srcSpanEnd :: SrcSpan -> SrcLoc #
srcSpanEndLine :: RealSrcSpan -> Int #
srcSpanEndCol :: RealSrcSpan -> Int #
srcSpanFile :: RealSrcSpan -> FastString #
srcLocCol :: RealSrcLoc -> Int #
Raises an error when used on a "bad" RealSrcLoc
srcLocFile :: RealSrcLoc -> FastString #
Gives the filename of the RealSrcLoc
srcLocLine :: RealSrcLoc -> Int #
Raises an error when used on a "bad" RealSrcLoc
Built-in "bad" RealSrcLoc values for particular locations
mapLoc :: (a -> b) -> GenLocated l a -> GenLocated l b Source #
Finder
data FindResult #
The result of searching for an imported module.
NB: FindResult manages both user source-import lookups
(which can result in GenModule) as well as direct imports
for interfaces (which always result in InstalledModule).
Constructors
| Found ModLocation Module | The module was found |
| NoPackage Unit | The requested unit was not found |
| FoundMultiple [(Module, ModuleOrigin)] | _Error_: both in multiple packages |
| NotFound | Not found |
Fields
| |
mkHomeModLocation :: DynFlags -> ModuleName -> FilePath -> IO ModLocation Source #
findObjectLinkableMaybe :: Module -> ModLocation -> IO (Maybe Linkable) #
data InstalledFindResult #
Module and Package
data ModuleOrigin #
Given a module name, there may be multiple ways it came into scope, possibly simultaneously. This data type tracks all the possible ways it could have come into scope. Warning: don't use the record functions, they're partial!
Constructors
| ModHidden | Module is hidden, and thus never will be available for import. (But maybe the user didn't realize), so we'll still keep track of these modules.) |
| ModUnusable UnusableUnitReason | Module is unavailable because the package is unusable. |
| ModOrigin | Module is public, and could have come from some places. |
Fields
| |
Instances
| Monoid ModuleOrigin | |
Defined in GHC.Unit.State Methods mempty :: ModuleOrigin # mappend :: ModuleOrigin -> ModuleOrigin -> ModuleOrigin # mconcat :: [ModuleOrigin] -> ModuleOrigin # | |
| Semigroup ModuleOrigin | |
Defined in GHC.Unit.State Methods (<>) :: ModuleOrigin -> ModuleOrigin -> ModuleOrigin # sconcat :: NonEmpty ModuleOrigin -> ModuleOrigin # stimes :: Integral b => b -> ModuleOrigin -> ModuleOrigin # | |
| Outputable ModuleOrigin | |
Defined in GHC.Unit.State Methods ppr :: ModuleOrigin -> SDoc # | |
newtype PackageName #
Constructors
| PackageName | |
Fields | |
Instances
| Show PackageName Source # | |
Defined in Development.IDE.GHC.Orphans Methods showsPrec :: Int -> PackageName -> ShowS # show :: PackageName -> String # showList :: [PackageName] -> ShowS # | |
| Uniquable PackageName | |
Defined in GHC.Unit.Info Methods getUnique :: PackageName -> Unique # | |
| Outputable PackageName | |
Defined in GHC.Unit.Info Methods ppr :: PackageName -> SDoc # | |
| Eq PackageName | |
Defined in GHC.Unit.Info | |
Linker
Objects which have yet to be linked by the compiler
Constructors
| DotO ObjFile | An object file (.o) |
| DotA FilePath | Static archive file (.a) |
| DotDLL FilePath | Dynamically linked library file (.so, .dll, .dylib) |
| CoreBindings WholeCoreBindings | Serialised core which we can turn into BCOs (or object files), or used by some other backend See Note [Interface Files with Core Definitions] |
| LoadedBCOs [Unlinked] | A list of BCOs, but hidden behind extra indirection to avoid being too strict. |
| BCOs CompiledByteCode [SptEntry] | A byte-code object, lives only in memory. Also carries some static pointer table entries which should be loaded along with the BCOs. See Note [Grand plan for static forms] in GHC.Iface.Tidy.StaticPtrTable. |
Instances
| NFData Unlinked Source # | |
Defined in Development.IDE.GHC.Orphans | |
| Outputable Unlinked | |
Defined in GHC.Linker.Types | |
Information we can use to dynamically link modules into the compiler
Constructors
| LM | |
Fields
| |
Instances
| Show Linkable Source # | |
| NFData Linkable Source # | |
Defined in Development.IDE.GHC.Orphans | |
| Outputable Linkable | |
Defined in GHC.Linker.Types | |
Hooks
type MetaHook (f :: Type -> Type) = MetaRequest -> LHsExpr GhcTc -> f MetaResult #
data MetaRequest #
The supported metaprogramming result types
Constructors
| MetaE (LHsExpr GhcPs -> MetaResult) | |
| MetaP (LPat GhcPs -> MetaResult) | |
| MetaT (LHsType GhcPs -> MetaResult) | |
| MetaD ([LHsDecl GhcPs] -> MetaResult) | |
| MetaAW (Serialized -> MetaResult) |
metaRequestAW :: Functor f => MetaHook f -> LHsExpr GhcTc -> f Serialized #
HPT
addToHpt :: HomePackageTable -> ModuleName -> HomeModInfo -> HomePackageTable #
addListToHpt :: HomePackageTable -> [(ModuleName, HomeModInfo)] -> HomePackageTable #
Driver-Make
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).
These fields are strict because Targets are long lived.
Constructors
| Target | |
Fields
| |
Instances
| Outputable Target | |
Defined in GHC.Types.Target | |
Constructors
| TargetModule !ModuleName | A module name: search for the file |
| TargetFile !FilePath !(Maybe Phase) | A filename: preprocess & parse it to find the module name. If specified, the Phase indicates how to compile this file (which phase to start from). Nothing indicates the starting phase should be determined from the suffix of the filename. |
GHCi
initObjLinker :: HscEnv -> IO () Source #
data InteractiveImport #
Constructors
| IIDecl (ImportDecl GhcPs) | Bring the exports of a particular module (filtered by an import decl) into scope |
| IIModule ModuleName | Bring into scope the entire top-level envt of of this module, including the things imported into it. |
Instances
| Show InteractiveImport Source # | |
Defined in Development.IDE.GHC.Orphans Methods showsPrec :: Int -> InteractiveImport -> ShowS # show :: InteractiveImport -> String # showList :: [InteractiveImport] -> ShowS # | |
| Outputable InteractiveImport | |
Defined in GHC.Runtime.Context Methods ppr :: InteractiveImport -> SDoc # | |
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
updates the icReaderEnv 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.)
parseImportDecl :: GhcMonad m => String -> m (ImportDecl GhcPs) #
A command-line warning message and the reason it arose
Constructors
| Warn | |
Fields | |
ModLocation
data ModLocation #
Module Location
Where a module lives on the file system: the actual locations of the .hs, .hi, .dyn_hi, .o, .dyn_o and .hie files, if we have them.
For a module in another unit, the ml_hs_file and ml_obj_file components of ModLocation are undefined.
The locations specified by a ModLocation may or may not correspond to actual files yet: for example, even if the object file doesn't exist, the ModLocation still contains the path to where the object file will reside if/when it is created.
The paths of anything which can affect recompilation should be placed inside ModLocation.
When a ModLocation is created none of the filepaths will have -boot suffixes. This is because in --make mode the ModLocation is put in the finder cache which is indexed by ModuleName, when a ModLocation is retrieved from the FinderCache the boot suffixes are appended. The other case is in -c mode, there the ModLocation immediately gets given the boot suffixes in mkOneShotModLocation.
Instances
| Show ModLocation | |
Defined in GHC.Unit.Module.Location Methods showsPrec :: Int -> ModLocation -> ShowS # show :: ModLocation -> String # showList :: [ModLocation] -> ShowS # | |
| Outputable ModLocation | |
Defined in GHC.Unit.Module.Location Methods ppr :: ModLocation -> SDoc # | |
ml_hs_file :: ModLocation -> Maybe FilePath #
The source file, if we have one. Package modules probably don't have source files.
ml_obj_file :: ModLocation -> FilePath #
Where the .o file is, whether or not it exists yet. (might not exist either because the module hasn't been compiled yet, or because it is part of a unit with a .a file)
ml_hi_file :: ModLocation -> FilePath #
Where the .hi file is, whether or not it exists yet. Always of form foo.hi, even if there is an hi-boot file (we add the -boot suffix later)
ml_hie_file :: ModLocation -> FilePath #
Where the .hie file is, whether or not it exists yet.
DataCon
dataConExTyCoVars :: DataCon -> [TyCoVar] #
The existentially-quantified type/coercion variables of the constructor including dependent (kind-) GADT equalities
Role
See Note [Roles] in GHC.Core.Coercion
Order of constructors matters: the Ord instance coincides with the *super*typing relation on roles.
Constructors
| Nominal | |
| Representational | |
| Phantom |
Instances
| Data Role | |
Defined in Language.Haskell.Syntax.Basic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Role -> c Role # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Role # dataTypeOf :: Role -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Role) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Role) # gmapT :: (forall b. Data b => b -> b) -> Role -> Role # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r # gmapQ :: (forall d. Data d => d -> u) -> Role -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Role -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Role -> m Role # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Role -> m Role # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Role -> m Role # | |
| Eq Role | |
| Ord Role | |
| type Anno (Maybe Role) | |
| type Anno (Maybe Role) | |
Panic
data PlainGhcException #
This type is very similar to GhcException, but it omits
the constructors that involve pretty-printing via
SDoc. Due to the implementation of fromException
for GhcException, this type can be caught as a
GhcException.
Note that this should only be used for throwing exceptions, not for
catching, as GhcException will not be converted to this
type when catching.
Instances
| Exception PlainGhcException | |
Defined in GHC.Utils.Panic.Plain Methods toException :: PlainGhcException -> SomeException # | |
| Show PlainGhcException | |
Defined in GHC.Utils.Panic.Plain Methods showsPrec :: Int -> PlainGhcException -> ShowS # show :: PlainGhcException -> String # showList :: [PlainGhcException] -> ShowS # | |
Other
data CoreModule #
A CoreModule consists of just the fields of a ModGuts that are needed for
the compileToCoreModule interface.
Constructors
| CoreModule | |
Fields
| |
Instances
| Show CoreModule Source # | |
Defined in Development.IDE.GHC.Orphans Methods showsPrec :: Int -> CoreModule -> ShowS # show :: CoreModule -> String # showList :: [CoreModule] -> ShowS # | |
| NFData CoreModule Source # | |
Defined in Development.IDE.GHC.Orphans Methods rnf :: CoreModule -> () # | |
| Outputable CoreModule | |
Defined in GHC Methods ppr :: CoreModule -> SDoc # | |
data SafeHaskellMode #
The various Safe Haskell modes
Constructors
| Sf_None | inferred unsafe |
| Sf_Unsafe | declared and checked |
| Sf_Trustworthy | declared and checked |
| Sf_Safe | declared and checked |
| Sf_SafeInferred | inferred as safe |
| Sf_Ignore |
|
Instances
| Show SafeHaskellMode | |
Defined in GHC.Types.SafeHaskell Methods showsPrec :: Int -> SafeHaskellMode -> ShowS # show :: SafeHaskellMode -> String # showList :: [SafeHaskellMode] -> ShowS # | |
| NFData SafeHaskellMode Source # | |
Defined in Development.IDE.GHC.Orphans Methods rnf :: SafeHaskellMode -> () # | |
| Outputable SafeHaskellMode | |
Defined in GHC.Types.SafeHaskell Methods ppr :: SafeHaskellMode -> SDoc # | |
| Eq SafeHaskellMode | |
Defined in GHC.Types.SafeHaskell Methods (==) :: SafeHaskellMode -> SafeHaskellMode -> Bool # (/=) :: SafeHaskellMode -> SafeHaskellMode -> Bool # | |
pattern GRE :: Name -> Parent -> Bool -> [ImportSpec] -> GlobalRdrElt Source #
gre_name :: GlobalRdrElt -> Name Source #
gre_imp :: GlobalRdrElt -> [ImportSpec] Source #
gre_lcl :: GlobalRdrElt -> Bool Source #
gre_par :: GlobalRdrElt -> Parent Source #
collectHsBindsBinders :: CollectPass p => Bag (XRec p (HsBindLR p idR)) -> [IdP p] Source #
Util Module re-exports
Class of things that we can obtain a Unique from
Instances
allNameStringList :: [String] #
mkUnboundName :: OccName -> Name #
isUnboundName :: Name -> Bool #
basicKnownKeyNames :: [Name] #
genericTyConNames :: [Name] #
gHC_CSTRING :: Module #
gHC_CLASSES :: Module #
dATA_EITHER :: Module #
dATA_STRING :: Module #
dATA_FOLDABLE :: Module #
gHC_STABLE :: Module #
mONAD_FAIL :: Module #
gHC_DESUGAR :: Module #
gHC_IS_LIST :: Module #
gHC_GENERICS :: Module #
gHC_TYPEERROR :: Module #
gHC_TYPELITS :: Module #
gHC_TYPENATS :: Module #
dATA_COERCE :: Module #
dEBUG_TRACE :: Module #
uNSAFE_COERCE :: Module #
gHC_SRCLOC :: Module #
gHC_STATICPTR :: Module #
gHC_RECORDS :: Module #
mkInteractiveModule :: Int -> Module #
mAIN_NAME :: ModuleName #
mkPrimModule :: FastString -> Module #
mkBignumModule :: FastString -> Module #
mkBaseModule :: FastString -> Module #
mkBaseModule_ :: ModuleName -> Module #
mkThisGhcModule :: FastString -> Module #
mkThisGhcModule_ :: ModuleName -> Module #
mkMainModule :: FastString -> Module #
mkMainModule_ :: ModuleName -> Module #
compare_RDR :: RdrName #
eqClass_RDR :: RdrName #
numClass_RDR :: RdrName #
ordClass_RDR :: RdrName #
append_RDR :: RdrName #
returnM_RDR :: RdrName #
fromEnum_RDR :: RdrName #
toEnum_RDR :: RdrName #
enumFrom_RDR :: RdrName #
bindIO_RDR :: RdrName #
returnIO_RDR :: RdrName #
fromList_RDR :: RdrName #
toList_RDR :: RdrName #
compose_RDR :: RdrName #
minBound_RDR :: RdrName #
maxBound_RDR :: RdrName #
inRange_RDR :: RdrName #
readList_RDR :: RdrName #
readPrec_RDR :: RdrName #
parens_RDR :: RdrName #
choose_RDR :: RdrName #
expectP_RDR :: RdrName #
symbol_RDR :: RdrName #
unPar1_RDR :: RdrName #
unRec1_RDR :: RdrName #
unComp1_RDR :: RdrName #
selName_RDR :: RdrName #
conName_RDR :: RdrName #
uIntHash_RDR :: RdrName #
replace_RDR :: RdrName #
liftA2_RDR :: RdrName #
foldMap_RDR :: RdrName #
traverse_RDR :: RdrName #
mempty_RDR :: RdrName #
mappend_RDR :: RdrName #
varQual_RDR :: Module -> FastString -> RdrName #
tcQual_RDR :: Module -> FastString -> RdrName #
clsQual_RDR :: Module -> FastString -> RdrName #
dataQual_RDR :: Module -> FastString -> RdrName #
wildCardName :: Name #
runMainIOName :: Name #
specTyConName :: Name #
eitherTyConName :: Name #
leftDataConName :: Name #
voidTyConName :: Name #
v1TyConName :: Name #
u1TyConName :: Name #
par1TyConName :: Name #
rec1TyConName :: Name #
k1TyConName :: Name #
m1TyConName :: Name #
sumTyConName :: Name #
prodTyConName :: Name #
compTyConName :: Name #
rTyConName :: Name #
dTyConName :: Name #
cTyConName :: Name #
sTyConName :: Name #
rec0TyConName :: Name #
d1TyConName :: Name #
c1TyConName :: Name #
s1TyConName :: Name #
repTyConName :: Name #
rep1TyConName :: Name #
uRecTyConName :: Name #
uAddrTyConName :: Name #
uCharTyConName :: Name #
uFloatTyConName :: Name #
uIntTyConName :: Name #
uWordTyConName :: Name #
divIntName :: Name #
modIntName :: Name #
eqStringName :: Name #
inlineIdName :: Name #
eqClassName :: Name #
ordClassName :: Name #
monadClassName :: Name #
returnMName :: Name #
sappendName :: Name #
monoidClassName :: Name #
memptyName :: Name #
mappendName :: Name #
mconcatName :: Name #
joinMIdKey :: Unique #
apAClassOpKey :: Unique #
dollarName :: Name #
otherwiseIdName :: Name #
augmentName :: Name #
appendName :: Name #
assertName :: Name #
fromStringName :: Name #
numClassName :: Name #
fromIntegerName :: Name #
negateName :: Name #
bnbVarQual :: String -> Unique -> Name #
bnnVarQual :: String -> Unique -> Name #
bniVarQual :: String -> Unique -> Name #
bignatEqName :: Name #
naturalAddName :: Name #
naturalSubName :: Name #
naturalMulName :: Name #
naturalQuotName :: Name #
naturalRemName :: Name #
naturalAndName :: Name #
naturalOrName :: Name #
naturalXorName :: Name #
naturalBitName :: Name #
naturalGcdName :: Name #
naturalLcmName :: Name #
naturalLog2Name :: Name #
integerAddName :: Name #
integerMulName :: Name #
integerSubName :: Name #
integerAbsName :: Name #
integerQuotName :: Name #
integerRemName :: Name #
integerDivName :: Name #
integerModName :: Name #
integerGcdName :: Name #
integerLcmName :: Name #
integerAndName :: Name #
integerOrName :: Name #
integerXorName :: Name #
integerBitName :: Name #
ratioTyConName :: Name #
realClassName :: Name #
toIntegerName :: Name #
toRationalName :: Name #
realToFracName :: Name #
ixClassName :: Name #
trNameTyConName :: Name #
typeRepIdName :: Name #
mkTrTypeName :: Name #
mkTrConName :: Name #
mkTrAppName :: Name #
mkTrFunName :: Name #
starKindRepName :: Name #
dataClassName :: Name #
assertErrorName :: Name #
enumClassName :: Name #
enumFromName :: Name #
enumFromToName :: Name #
concatName :: Name #
filterName :: Name #
isListClassName :: Name #
fromListName :: Name #
fromListNName :: Name #
toListName :: Name #
getFieldName :: Name #
setFieldName :: Name #
showClassName :: Name #
readClassName :: Name #
genClassName :: Name #
gen1ClassName :: Name #
genericClassNames :: [Name] #
ghciIoClassName :: Name #
ghciStepIoMName :: Name #
ioTyConName :: Name #
ioDataConName :: Name #
thenIOName :: Name #
bindIOName :: Name #
returnIOName :: Name #
failIOName :: Name #
int8TyConName :: Name #
int16TyConName :: Name #
int32TyConName :: Name #
int64TyConName :: Name #
word8TyConName :: Name #
word16TyConName :: Name #
word32TyConName :: Name #
word64TyConName :: Name #
ptrTyConName :: Name #
funPtrTyConName :: Name #
composeAName :: Name #
firstAName :: Name #
choiceAName :: Name #
guardMName :: Name #
ipClassName :: Name #
pluginTyConName :: Name #
makeStaticName :: Name #
constPtrConName :: Name #
mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name #
enumClassKey :: Unique #
eqClassKey :: Unique #
monadClassKey :: Unique #
dataClassKey :: Unique #
numClassKey :: Unique #
ordClassKey :: Unique #
readClassKey :: Unique #
realClassKey :: Unique #
showClassKey :: Unique #
ixClassKey :: Unique #
genClassKey :: Unique #
gen1ClassKey :: Unique #
ipClassKey :: Unique #
boolTyConKey :: Unique #
charTyConKey :: Unique #
floatTyConKey :: Unique #
fUNTyConKey :: Unique #
intTyConKey :: Unique #
int8TyConKey :: Unique #
int16TyConKey :: Unique #
int32TyConKey :: Unique #
int64TyConKey :: Unique #
listTyConKey :: Unique #
maybeTyConKey :: Unique #
ratioTyConKey :: Unique #
eqTyConKey :: Unique #
heqTyConKey :: Unique #
ioTyConKey :: Unique #
wordTyConKey :: Unique #
word8TyConKey :: Unique #
kindConKey :: Unique #
boxityConKey :: Unique #
typeConKey :: Unique #
ptrTyConKey :: Unique #
voidTyConKey :: Unique #
dictTyConKey :: Unique #
tYPETyConKey :: Unique #
v1TyConKey :: Unique #
u1TyConKey :: Unique #
par1TyConKey :: Unique #
rec1TyConKey :: Unique #
k1TyConKey :: Unique #
m1TyConKey :: Unique #
sumTyConKey :: Unique #
prodTyConKey :: Unique #
compTyConKey :: Unique #
rec0TyConKey :: Unique #
d1TyConKey :: Unique #
c1TyConKey :: Unique #
s1TyConKey :: Unique #
repTyConKey :: Unique #
rep1TyConKey :: Unique #
uRecTyConKey :: Unique #
uAddrTyConKey :: Unique #
uCharTyConKey :: Unique #
uIntTyConKey :: Unique #
uWordTyConKey :: Unique #
specTyConKey :: Unique #
anyTyConKey :: Unique #
intDataConKey :: Unique #
eqDataConKey :: Unique #
nilDataConKey :: Unique #
ioDataConKey :: Unique #
heqDataConKey :: Unique #
inlDataConKey :: Unique #
inrDataConKey :: Unique #
vecCountDataConKeys :: [Unique] #
vecElemDataConKeys :: [Unique] #
oneDataConKey :: Unique #
wildCardKey :: Unique #
augmentIdKey :: Unique #
appendIdKey :: Unique #
buildIdKey :: Unique #
foldrIdKey :: Unique #
eqStringIdKey :: Unique #
patErrorIdKey :: Unique #
voidPrimIdKey :: Unique #
divIntIdKey :: Unique #
modIntIdKey :: Unique #
concatIdKey :: Unique #
filterIdKey :: Unique #
bindIOIdKey :: Unique #
returnIOIdKey :: Unique #
printIdKey :: Unique #
failIOIdKey :: Unique #
nullAddrIdKey :: Unique #
voidArgIdKey :: Unique #
assertIdKey :: Unique #
rootMainKey :: Unique #
runMainKey :: Unique #
thenIOIdKey :: Unique #
oneShotKey :: Unique #
nospecIdKey :: Unique #
inlineIdKey :: Unique #
dollarIdKey :: Unique #
noinlineIdKey :: Unique #
unboundKey :: Unique #
eqClassOpKey :: Unique #
geClassOpKey :: Unique #
composeAIdKey :: Unique #
firstAIdKey :: Unique #
choiceAIdKey :: Unique #
loopAIdKey :: Unique #
guardMIdKey :: Unique #
liftMIdKey :: Unique #
proxyHashKey :: Unique #
mkTyConKey :: Unique #
mkTrTypeKey :: Unique #
mkTrConKey :: Unique #
mkTrAppKey :: Unique #
typeRepIdKey :: Unique #
mkTrFunKey :: Unique #
toDynIdKey :: Unique #
eqSCSelIdKey :: Unique #
heqSCSelIdKey :: Unique #
makeStaticKey :: Unique #
bignatEqIdKey :: Unique #
numericClassKeys :: [Unique] #
fractionalClassKeys :: [Unique] #
standardClassKeys :: [Unique] #
derivableClassKeys :: [Unique] #
interactiveClassNames :: [Name] #
interactiveClassKeys :: [Unique] #
pretendNameIsInScope :: Name -> Bool #
Should this name be considered in-scope, even though it technically isn't?
This ensures that we don't filter out information because, e.g., Data.Kind.Type isn't imported.
See Note [pretendNameIsInScope].
module GHC.Builtin.Types
module GHC.Builtin.Types.Prim
module GHC.Builtin.Utils
module GHC.Core.Class
module GHC.Core.Coercion
module GHC.Core.ConLike
data SrcUnpackedness #
Source Unpackedness
What unpackedness the user requested
Constructors
| SrcUnpack | {-# UNPACK #-} specified |
| SrcNoUnpack | {-# NOUNPACK #-} specified |
| NoSrcUnpack | no unpack pragma |
Instances
| Data SrcUnpackedness | |
Defined in Language.Haskell.Syntax.Basic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcUnpackedness -> c SrcUnpackedness # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SrcUnpackedness # toConstr :: SrcUnpackedness -> Constr # dataTypeOf :: SrcUnpackedness -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SrcUnpackedness) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcUnpackedness) # gmapT :: (forall b. Data b => b -> b) -> SrcUnpackedness -> SrcUnpackedness # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcUnpackedness -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SrcUnpackedness -> r # gmapQ :: (forall d. Data d => d -> u) -> SrcUnpackedness -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcUnpackedness -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SrcUnpackedness -> m SrcUnpackedness # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcUnpackedness -> m SrcUnpackedness # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcUnpackedness -> m SrcUnpackedness # | |
| Eq SrcUnpackedness | |
Defined in Language.Haskell.Syntax.Basic Methods (==) :: SrcUnpackedness -> SrcUnpackedness -> Bool # (/=) :: SrcUnpackedness -> SrcUnpackedness -> Bool # | |
data SrcStrictness #
Source Strictness
What strictness annotation the user wrote
Constructors
| SrcLazy | Lazy, ie |
| SrcStrict | Strict, ie |
| NoSrcStrict | no strictness annotation |
Instances
| Data SrcStrictness | |
Defined in Language.Haskell.Syntax.Basic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcStrictness -> c SrcStrictness # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SrcStrictness # toConstr :: SrcStrictness -> Constr # dataTypeOf :: SrcStrictness -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SrcStrictness) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcStrictness) # gmapT :: (forall b. Data b => b -> b) -> SrcStrictness -> SrcStrictness # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcStrictness -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SrcStrictness -> r # gmapQ :: (forall d. Data d => d -> u) -> SrcStrictness -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcStrictness -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SrcStrictness -> m SrcStrictness # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcStrictness -> m SrcStrictness # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcStrictness -> m SrcStrictness # | |
| Eq SrcStrictness | |
Defined in Language.Haskell.Syntax.Basic Methods (==) :: SrcStrictness -> SrcStrictness -> Bool # (/=) :: SrcStrictness -> SrcStrictness -> Bool # | |
data FieldLabelString #
Field labels are just represented as strings; they are not necessarily unique (even within a module)
Instances
A *one-index* constructor tag
Type of the tags associated with each constructor possibility or superclass selector
data FieldLabel #
Fields in an algebraic record type; see Note [FieldLabel].
Constructors
| FieldLabel | |
Fields
| |
Instances
| Data FieldLabel | |
Defined in GHC.Types.FieldLabel Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FieldLabel -> c FieldLabel # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FieldLabel # toConstr :: FieldLabel -> Constr # dataTypeOf :: FieldLabel -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FieldLabel) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldLabel) # gmapT :: (forall b. Data b => b -> b) -> FieldLabel -> FieldLabel # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FieldLabel -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FieldLabel -> r # gmapQ :: (forall d. Data d => d -> u) -> FieldLabel -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldLabel -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FieldLabel -> m FieldLabel # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldLabel -> m FieldLabel # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldLabel -> m FieldLabel # | |
| NFData FieldLabel | |
Defined in GHC.Types.FieldLabel Methods rnf :: FieldLabel -> () # | |
| HasOccName FieldLabel | |
Defined in GHC.Types.FieldLabel Methods occName :: FieldLabel -> OccName # | |
| Binary Name => Binary FieldLabel | We need the |
Defined in GHC.Types.FieldLabel Methods put_ :: BinHandle -> FieldLabel -> IO () # put :: BinHandle -> FieldLabel -> IO (Bin FieldLabel) # get :: BinHandle -> IO FieldLabel # | |
| Outputable FieldLabel | |
Defined in GHC.Types.FieldLabel Methods ppr :: FieldLabel -> SDoc # | |
| Eq FieldLabel | |
Defined in GHC.Types.FieldLabel | |
| ToHie (IEContext (Located FieldLabel)) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: IEContext (Located FieldLabel) -> HieM [HieAST Type] | |
An EqSpec is a tyvar/type pair representing an equality made in
rejigging a GADT constructor
Instances
| Outputable EqSpec | |
Defined in GHC.Core.DataCon | |
data DataConRep #
Data Constructor Representation See Note [Data constructor workers and wrappers]
Constructors
| NoDataConRep | |
| DCR | |
Fields
| |
A data constructor
Instances
| Data DataCon | |
Defined in GHC.Core.DataCon Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DataCon -> c DataCon # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DataCon # toConstr :: DataCon -> Constr # dataTypeOf :: DataCon -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DataCon) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataCon) # gmapT :: (forall b. Data b => b -> b) -> DataCon -> DataCon # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DataCon -> r # gmapQr :: forall r r'. (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 | |
Defined in GHC.Core.DataCon | |
| Uniquable DataCon | |
Defined in GHC.Core.DataCon | |
| Outputable DataCon | |
Defined in GHC.Core.DataCon | |
| OutputableBndr DataCon | |
Defined in GHC.Core.DataCon Methods pprBndr :: BindingSite -> DataCon -> SDoc # pprPrefixOcc :: DataCon -> SDoc # pprInfixOcc :: DataCon -> SDoc # bndrIsJoin_maybe :: DataCon -> Maybe Int # | |
| Eq DataCon | |
data StrictnessMark #
Constructors
| MarkedStrict | |
| NotMarkedStrict |
Instances
| Binary StrictnessMark | |
Defined in GHC.Core.DataCon Methods put_ :: BinHandle -> StrictnessMark -> IO () # put :: BinHandle -> StrictnessMark -> IO (Bin StrictnessMark) # get :: BinHandle -> IO StrictnessMark # | |
| Outputable StrictnessMark | |
Defined in GHC.Core.DataCon Methods ppr :: StrictnessMark -> SDoc # | |
| Eq StrictnessMark | |
Defined in GHC.Core.DataCon Methods (==) :: StrictnessMark -> StrictnessMark -> Bool # (/=) :: StrictnessMark -> StrictnessMark -> Bool # | |
data HsImplBang #
Haskell Implementation Bang
Bangs of data constructor arguments as generated by the compiler after consulting HsSrcBang, flags, etc.
Constructors
| HsLazy | Lazy field, or one with an unlifted type |
| HsStrict Bool | Strict but not unpacked field True = we could have unpacked, but opted not to because of -O0. See Note [Detecting useless UNPACK pragmas] |
| HsUnpack (Maybe Coercion) | Strict and unpacked field co :: arg-ty ~ product-ty HsBang |
Instances
| Data HsImplBang | |
Defined in GHC.Core.DataCon Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsImplBang -> c HsImplBang # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsImplBang # toConstr :: HsImplBang -> Constr # dataTypeOf :: HsImplBang -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsImplBang) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsImplBang) # gmapT :: (forall b. Data b => b -> b) -> HsImplBang -> HsImplBang # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsImplBang -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsImplBang -> r # gmapQ :: (forall d. Data d => d -> u) -> HsImplBang -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsImplBang -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsImplBang -> m HsImplBang # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImplBang -> m HsImplBang # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImplBang -> m HsImplBang # | |
| Outputable HsImplBang | |
Defined in GHC.Core.DataCon Methods ppr :: HsImplBang -> SDoc # | |
Haskell Source Bang
Bangs on data constructor arguments as the user wrote them in the source code.
(HsSrcBang _ SrcUnpack SrcLazy) and
(HsSrcBang _ SrcUnpack NoSrcStrict) (without StrictData) makes no sense, we
emit a warning (in checkValidDataCon) and treat it like
(HsSrcBang _ NoSrcUnpack SrcLazy)
Constructors
| HsSrcBang SourceText SrcUnpackedness SrcStrictness |
Instances
| Data HsSrcBang | |
Defined in GHC.Core.DataCon Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsSrcBang -> c HsSrcBang # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsSrcBang # toConstr :: HsSrcBang -> Constr # dataTypeOf :: HsSrcBang -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsSrcBang) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsSrcBang) # gmapT :: (forall b. Data b => b -> b) -> HsSrcBang -> HsSrcBang # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsSrcBang -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsSrcBang -> r # gmapQ :: (forall d. Data d => d -> u) -> HsSrcBang -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsSrcBang -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsSrcBang -> m HsSrcBang # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSrcBang -> m HsSrcBang # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSrcBang -> m HsSrcBang # | |
| Outputable HsSrcBang | |
Defined in GHC.Core.DataCon | |
type DataConEnv a = UniqFM DataCon a #
promoteDataCon :: DataCon -> TyCon #
dataConWrapId :: DataCon -> Id #
Returns an Id which looks like the Haskell-source constructor by using
the wrapper if it exists (see dataConWrapId_maybe) and failing over to
the worker (see dataConWorkId)
isTypeDataCon :: DataCon -> Bool #
Is this data constructor in a "type data" declaration? See Note [Type data declarations] in GHC.Rename.Module.
isUnboxedSumDataCon :: DataCon -> Bool #
dataConFullSig :: DataCon -> ([TyVar], [TyCoVar], [EqSpec], ThetaType, [Scaled Type], Type) #
The "full signature" of the DataCon returns, in order:
1) The result of dataConUnivTyVars
2) The result of dataConExTyCoVars
3) The non-dependent GADT equalities. Dependent GADT equalities are implied by coercion variables in return value (2).
4) The other constraints of the data constructor type, excluding GADT equalities
5) The original argument types to the DataCon (i.e. before
any change of the representation of the type) with linearity
annotations
6) The original result type of the DataCon
dataConStupidTheta :: DataCon -> ThetaType #
The "stupid theta" of the DataCon, such as data Eq a in:
data Eq a => T a = ...
See Note [The stupid context].
dataConInstOrigArgTys :: DataCon -> [Type] -> [Scaled Type] #
Returns just the instantiated value argument types of a DataCon,
(excluding dictionary args)
dataConFieldLabels :: DataCon -> [FieldLabel] #
The labels for the fields of this particular DataCon
dataConSourceArity :: DataCon -> Arity #
Source-level arity of the data constructor
dataConUserTyVarBinders :: DataCon -> [InvisTVBinder] #
InvisTVBinders for the type variables of the constructor, in the order the
user wrote them
dataConUserTyVars :: DataCon -> [TyVar] #
The type variables of the constructor, in the order the user wrote them
dataConTyCon :: DataCon -> TyCon #
The type constructor that we are building via this data constructor
dataConWorkId :: DataCon -> Id #
eqSpecTyVar :: EqSpec -> TyVar #
eqSpecType :: EqSpec -> Type #
eqSpecPair :: EqSpec -> (TyVar, Type) #
eqSpecPreds :: [EqSpec] -> ThetaType #
eqHsBang :: HsImplBang -> HsImplBang -> Bool #
Compare strictness annotations
isBanged :: HsImplBang -> Bool #
isSrcStrict :: SrcStrictness -> Bool #
isSrcUnpacked :: SrcUnpackedness -> Bool #
isMarkedStrict :: StrictnessMark -> Bool #
Arguments
| :: Name | |
| -> Bool | Is the constructor declared infix? |
| -> TyConRepName | TyConRepName for the promoted TyCon |
| -> [HsSrcBang] | Strictness/unpack annotations, from user |
| -> [FieldLabel] | Field labels for the constructor, if it is a record, otherwise empty |
| -> [TyVar] | Universals. |
| -> [TyCoVar] | Existentials. |
| -> [InvisTVBinder] | User-written |
| -> [EqSpec] | GADT equalities |
| -> KnotTied ThetaType | Theta-type occurring before the arguments proper |
| -> [KnotTied (Scaled Type)] | Original argument types |
| -> KnotTied Type | Original result type |
| -> PromDataConInfo | See comments on |
| -> KnotTied TyCon | Representation type constructor |
| -> ConTag | Constructor tag |
| -> ThetaType | The "stupid theta", context of the data
declaration e.g. |
| -> Id | Worker Id |
| -> DataConRep | Representation |
| -> DataCon |
Build a new data constructor
dataConTag :: DataCon -> ConTag #
The tag used for ordering DataCons
dataConTagZ :: DataCon -> ConTagZ #
dataConOrigTyCon :: DataCon -> TyCon #
The original type constructor used in the definition of this data constructor. In case of a data family instance, that will be the family type constructor.
dataConRepType :: DataCon -> Type #
The representation type of the data constructor, i.e. the sort type that will represent values of this type at runtime
dataConIsInfix :: DataCon -> Bool #
Should the DataCon be presented infix?
dataConUnivTyVars :: DataCon -> [TyVar] #
The universally-quantified type variables of the constructor
dataConUnivAndExTyCoVars :: DataCon -> [TyCoVar] #
Both the universal and existential type/coercion variables of the constructor
dataConTheta :: DataCon -> ThetaType #
The *full* constraints on the constructor type, including dependent GADT equalities.
dataConWrapId_maybe :: DataCon -> Maybe Id #
Get the Id of the DataCon wrapper: a function that wraps the "actual"
constructor so it has the type visible in the source program: c.f.
dataConWorkId.
Returns Nothing if there is no wrapper, which occurs for an algebraic data
constructor and also for a newtype (whose constructor is inlined
compulsorily)
dataConImplicitTyThings :: DataCon -> [TyThing] #
Find all the Ids implicitly brought into scope by the data constructor. Currently,
the union of the dataConWorkId and the dataConWrapId
dataConFieldType :: DataCon -> FieldLabelString -> Type #
Extract the type for any given labelled field of the DataCon
dataConFieldType_maybe :: DataCon -> FieldLabelString -> Maybe (FieldLabel, Type) #
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
dataConRepArity :: DataCon -> Arity #
Gives the number of value arguments (including zero-width coercions)
stored by the given DataCon's worker in its Core representation. This may
differ from the number of arguments that appear in the source code; see also
Note [DataCon arities]
isNullarySrcDataCon :: DataCon -> Bool #
Return whether there are any argument types for this DataCons original source type
See Note [DataCon arities]
isNullaryRepDataCon :: DataCon -> Bool #
Return whether this DataCon's worker, in its Core representation, takes
any value arguments.
In particular, remember that we include coercion arguments in the arity of
the Core representation of the DataCon -- both lifted and unlifted
coercions, despite the latter having zero-width runtime representation.
See also Note [DataCon arities].
dataConRepStrictness :: DataCon -> [StrictnessMark] #
Give the demands on the arguments of a Core constructor application (Con dc args)
dataConImplBangs :: DataCon -> [HsImplBang] #
dataConBoxer :: DataCon -> Maybe DataConBoxer #
dataConInstSig :: DataCon -> [Type] -> ([TyCoVar], ThetaType, [Type]) #
Instantiate the universal tyvars of a data con, returning ( instantiated existentials , instantiated constraints including dependent GADT equalities which are *also* listed in the instantiated existentials , instantiated args)
dataConOrigResTy :: DataCon -> Type #
dataConWrapperType :: 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.
dataConNonlinearType :: DataCon -> Type #
dataConDisplayType :: Bool -> DataCon -> Type #
Arguments
| :: DataCon | A datacon with no existentials or equality constraints However, it can have a dcTheta (notably it can be a class dictionary, with superclasses) |
| -> [Type] | Instantiated at these types |
| -> [Scaled Type] |
Finds the instantiated types of the arguments required to construct a
DataCon representation
NB: these INCLUDE any dictionary args
but EXCLUDE the data-declaration context, which is discarded
It's all post-flattening etc; this is a representation type
dataConInstUnivs :: DataCon -> [Type] -> [Type] #
Given a data constructor dc with n universally quantified type
variables a_{1}, a_{2}, ..., a_{n}, and given a list of argument
types dc_args of length m where m <= n, then:
dataConInstUnivs dc dc_args
Will return:
[dc_arg_{1}, dc_arg_{2}, ..., dc_arg_{m}, a_{m+1}, ..., a_{n}]
That is, return the list of universal type variables with
a_{1}, a_{2}, ..., a_{m} instantiated with
dc_arg_{1}, dc_arg_{2}, ..., dc_arg_{m}. It is possible for m to
be less than n, in which case the remaining n - m elements will simply
be universal type variables (with their kinds possibly instantiated).
Examples:
- Given the data constructor
D :: forall a b. Foo a banddc_args[Int, Bool], thendataConInstUnivs D dc_argswill return[Int, Bool]. - Given the data constructor
D :: forall a b. Foo a banddc_args[Int], then @dataConInstUnivs D dc_argswill return[Int, b]. - Given the data constructor
E :: forall k (a :: k). Bar k aanddc_args[Type], then @dataConInstUnivs D dc_argswill return[Type, (a :: Type)].
This is primarily used in GHC.Tc.Deriv.* in service of instantiating data
constructors' field types.
See Note [Instantiating field types in stock deriving] for a notable
example of this.
dataConOrigArgTys :: DataCon -> [Scaled Type] #
Returns the argument types of the wrapper, excluding all dictionary arguments and without substituting for any type variables
dataConOtherTheta :: DataCon -> ThetaType #
Returns constraints in the wrapper type, other than those in the dataConEqSpec
dataConRepArgTys :: DataCon -> [Scaled Type] #
Returns the arg types of the worker, including *all* non-dependent evidence, after any flattening has been done and without substituting for any type variables
dataConIdentity :: DataCon -> ByteString #
The string package:module.name identifying a constructor, which is attached
to its info table and used by the GHCi debugger and the heap profiler
isTupleDataCon :: DataCon -> Bool #
isBoxedTupleDataCon :: DataCon -> Bool #
isUnboxedTupleDataCon :: DataCon -> Bool #
isVanillaDataCon :: DataCon -> Bool #
Vanilla DataCons are those that are nice boring Haskell 98 constructors
isNewDataCon :: DataCon -> Bool #
Is this the DataCon of a newtype?
isCovertGadtDataCon :: DataCon -> Bool #
specialPromotedDc :: DataCon -> Bool #
Should this DataCon be allowed in a type even without -XDataKinds? Currently, only Lifted & Unlifted
classDataCon :: Class -> DataCon #
dataConCannotMatch :: [Type] -> DataCon -> Bool #
dataConResRepTyArgs :: DataCon -> [Type] #
Were the type variables of the data con written in a different order than the regular order (universal tyvars followed by existential tyvars)?
This is not a cheap test, so we minimize its use in GHC as much as possible.
Currently, its only call site in the GHC codebase is in mkDataConRep in
MkId, and so dataConUserTyVarsNeedWrapper is only called at most once
during a data constructor's lifetime.
checkDataConTyVars :: DataCon -> Bool #
Extract the type constructor, type argument, data constructor and it's representation argument types from a type if it is a product type.
Precisely, we return Just for any data type that is all of:
- Concrete (i.e. constructors visible)
- Single-constructor
- ... which has no existentials
Whether the type is a data type or a newtype.
data FamInstMatch #
Constructors
| FamInstMatch | |
Instances
| Outputable FamInstMatch | |
Defined in GHC.Core.FamInstEnv Methods ppr :: FamInstMatch -> SDoc # | |
data InjectivityCheckResult #
Result of testing two type family equations for injectiviy.
Constructors
| InjectivityAccepted | Either RHSs are distinct or unification of RHSs leads to unification of LHSs |
| InjectivityUnified CoAxBranch CoAxBranch | RHSs unify but LHSs don't unify under that substitution. Relevant for closed type families where equation after unification might be overlapped (in which case it is OK if they don't unify). Constructor stores axioms after unification. |
data FamInstEnv #
Instances
| Outputable FamInstEnv | |
Defined in GHC.Core.FamInstEnv Methods ppr :: FamInstEnv -> SDoc # | |
type FamInstEnvs = (FamInstEnv, FamInstEnv) #
Constructors
| SynFamilyInst | |
| DataFamilyInst TyCon |
Constructors
| FamInst | |
Instances
| NamedThing FamInst | |
Defined in GHC.Core.FamInstEnv | |
| Outputable FamInst | |
Defined in GHC.Core.FamInstEnv | |
famInstAxiom :: FamInst -> CoAxiom Unbranched #
famInstRHS :: FamInst -> Type #
famInstTyCon :: FamInst -> TyCon #
famInstsRepTyCons :: [FamInst] -> [TyCon] #
famInstRepTyCon_maybe :: FamInst -> Maybe TyCon #
dataFamInstRepTyCon :: FamInst -> TyCon #
orphNamesOfFamInst :: FamInst -> NameSet #
pprFamInsts :: [FamInst] -> SDoc #
mkImportedFamInst :: Name -> [RoughMatchTc] -> CoAxiom Unbranched -> FamInst #
famInstEnvSize :: FamInstEnv -> Int #
emptyFamInstEnvs :: (FamInstEnv, FamInstEnv) #
Create a FamInstEnv from Name indices.
INVARIANTS:
* The fs_tvs are distinct in each FamInst
of a range value of the map (so we can safely unify them)
famInstEnvElts :: FamInstEnv -> [FamInst] #
familyInstances :: (FamInstEnv, FamInstEnv) -> TyCon -> [FamInst] #
familyNameInstances :: (FamInstEnv, FamInstEnv) -> Name -> [FamInst] #
unionFamInstEnv :: FamInstEnv -> FamInstEnv -> FamInstEnv #
Makes no particular effort to detect conflicts.
extendFamInstEnvList :: FamInstEnv -> [FamInst] -> FamInstEnv #
extendFamInstEnv :: FamInstEnv -> FamInst -> FamInstEnv #
compatibleBranches :: CoAxBranch -> CoAxBranch -> Bool #
injectiveBranches :: [Bool] -> CoAxBranch -> CoAxBranch -> InjectivityCheckResult #
Check whether two type family axioms don't violate injectivity annotation.
mkCoAxBranch :: [TyVar] -> [TyVar] -> [CoVar] -> [Type] -> Type -> [Role] -> SrcSpan -> CoAxBranch #
mkBranchedCoAxiom :: Name -> TyCon -> [CoAxBranch] -> CoAxiom Branched #
mkUnbranchedCoAxiom :: Name -> TyCon -> CoAxBranch -> CoAxiom Unbranched #
mkSingleCoAxiom :: Role -> Name -> [TyVar] -> [TyVar] -> [CoVar] -> TyCon -> [Type] -> Type -> CoAxiom Unbranched #
mkNewTypeCoAxiom :: Name -> TyCon -> [TyVar] -> [Role] -> Type -> CoAxiom Unbranched #
lookupFamInstEnvByTyCon :: FamInstEnvs -> TyCon -> [FamInst] #
lookupFamInstEnv :: FamInstEnvs -> TyCon -> [Type] -> [FamInstMatch] #
lookupFamInstEnvConflicts :: FamInstEnvs -> FamInst -> [FamInst] #
lookupFamInstEnvInjectivityConflicts :: [Bool] -> FamInstEnvs -> FamInst -> [CoAxBranch] #
Check whether an open type family equation can be added to already existing instance environment without causing conflicts with supplied injectivity annotations. Returns list of conflicting axioms (type instance declarations).
isDominatedBy :: CoAxBranch -> [CoAxBranch] -> Bool #
reduceTyFamApp_maybe :: FamInstEnvs -> Role -> TyCon -> [Type] -> Maybe Reduction #
Arguments
| :: [Type] | flattened target arguments. Make sure they're flattened! See Note [Flattening type-family applications when matching instances] in GHC.Core.Unify. |
| -> CoAxBranch | the candidate equation we wish to use Precondition: this matches the target |
| -> Bool | True = equation can fire |
Do an apartness check, as described in the "Closed Type Families" paper
(POPL '14). This should be used when determining if an equation
(CoAxBranch) of a closed type family can be used to reduce a certain target
type family application.
topNormaliseType :: FamInstEnvs -> Type -> Type #
topNormaliseType_maybe :: FamInstEnvs -> Type -> Maybe Reduction #
Get rid of *outermost* (or toplevel) * type function redex * data family redex * newtypes returning an appropriate Representational coercion. Specifically, if topNormaliseType_maybe env ty = Just (co, ty') then (a) co :: ty ~R ty' (b) ty' is not a newtype, and is not a type-family or data-family redex
However, ty' can be something like (Maybe (F ty)), where (F ty) is a redex.
Always operates homogeneously: the returned type has the same kind as the original type, and the returned coercion is always homogeneous.
topReduceTyFamApp_maybe :: FamInstEnvs -> TyCon -> [Type] -> Maybe HetReduction #
Try to simplify a type-family application, by *one* step If topReduceTyFamApp_maybe env r F tys = Just (HetReduction (Reduction co rhs) res_co) then co :: F tys ~R# rhs res_co :: typeKind(F tys) ~ typeKind(rhs) Type families and data families; always Representational role
normaliseType :: FamInstEnvs -> Role -> Type -> Reduction #
normaliseTcApp :: FamInstEnvs -> Role -> TyCon -> [Type] -> Reduction #
module GHC.Core.InstEnv
module GHC.Types.Unique.FM
module GHC.Core.PatSyn
module GHC.Core.Predicate
module GHC.Core.TyCon
module GHC.Core.TyCo.Ppr
module GHC.Core.Type
module GHC.Core.Unify
module GHC.Core.Utils
module GHC.HsToCore.Docs
module GHC.HsToCore.Expr
module GHC.HsToCore.Monad
module GHC.Iface.Syntax
module GHC.Iface.Recomp
data DerivStrategy pass #
Which technique the user explicitly requested when deriving an instance.
Constructors
| StockStrategy (XStockStrategy pass) | 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 (XAnyClassStrategy pass) | -XDeriveAnyClass |
| NewtypeStrategy (XNewtypeStrategy pass) | -XGeneralizedNewtypeDeriving |
| ViaStrategy (XViaStrategy pass) | -XDerivingVia |
Instances
| ToHie (RScoped (LocatedAn NoEpAnns (DerivStrategy GhcRn))) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (DerivStrategy (GhcPass p)) | |
Defined in GHC.Hs.Decls | |
data InjectivityAnn pass #
If the user supplied an injectivity annotation it is represented using InjectivityAnn. At the moment this is a single injectivity condition - see Note [Injectivity annotation]. `Located name` stores the LHS of injectivity condition. `[Located name]` stores the RHS of injectivity condition. Example:
type family Foo a b c = r | r -> a c where ...
This will be represented as "InjectivityAnn r [a, c]"
Constructors
| InjectivityAnn (XCInjectivityAnn pass) (LIdP pass) [LIdP pass] | |
| XInjectivityAnn !(XXInjectivityAnn pass) |
Instances
| ToHie (LocatedAn NoEpAnns (InjectivityAnn GhcRn)) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (InjectivityAnn (GhcPass p)) | |
Defined in GHC.Hs.Decls | |
Rule Binder
Constructors
| RuleBndr (XCRuleBndr pass) (LIdP pass) | |
| RuleBndrSig (XRuleBndrSig pass) (LIdP pass) (HsPatSigType pass) | |
| XRuleBndr !(XXRuleBndr pass) |
Annotation Declaration
Constructors
| HsAnnotation (XHsAnnotation pass) (AnnProvenance pass) (XRec pass (HsExpr pass)) | |
| XAnnDecl !(XXAnnDecl pass) |
data RoleAnnotDecl pass #
Role Annotation Declaration
Constructors
| RoleAnnotDecl (XCRoleAnnotDecl pass) (LIdP pass) [XRec pass (Maybe Role)] | |
| XRoleAnnotDecl !(XXRoleAnnotDecl pass) |
Instances
| ToHie (LocatedA (RoleAnnotDecl GhcRn)) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (RoleAnnotDecl (GhcPass p)) | |
Defined in GHC.Hs.Decls | |
type LRoleAnnotDecl pass = XRec pass (RoleAnnotDecl pass) #
Located Role Annotation Declaration
data AnnProvenance pass #
Annotation Provenance
Constructors
| ValueAnnProvenance (LIdP pass) | |
| TypeAnnProvenance (LIdP pass) | |
| ModuleAnnProvenance |
Instances
| ToHie (AnnProvenance GhcRn) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: AnnProvenance GhcRn -> HieM [HieAST Type] | |
Warning pragma Declaration
Constructors
| Warning (XWarning pass) [LIdP pass] (WarningTxt pass) | |
| XWarnDecl !(XXWarnDecl pass) |
Warning pragma Declarations
Constructors
| Warnings | |
Fields
| |
| XWarnDecls !(XXWarnDecls pass) | |
type LWarnDecls pass = XRec pass (WarnDecls pass) #
Located Warning Declarations
Documentation comment Declaration
Constructors
| DocCommentNext (LHsDoc pass) | |
| DocCommentPrev (LHsDoc pass) | |
| DocCommentNamed String (LHsDoc pass) | |
| DocGroup Int (LHsDoc pass) |
Instances
| (Data pass, Data (IdP pass)) => Data (DocDecl pass) | |
Defined in Language.Haskell.Syntax.Decls Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DocDecl pass -> c (DocDecl pass) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DocDecl pass) # toConstr :: DocDecl pass -> Constr # dataTypeOf :: DocDecl pass -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DocDecl pass)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DocDecl pass)) # gmapT :: (forall b. Data b => b -> b) -> DocDecl pass -> DocDecl pass # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DocDecl pass -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DocDecl pass -> r # gmapQ :: (forall d. Data d => d -> u) -> DocDecl pass -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DocDecl pass -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DocDecl pass -> m (DocDecl pass) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DocDecl pass -> m (DocDecl pass) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DocDecl pass -> m (DocDecl pass) # | |
| ToHie (LocatedA (DocDecl GhcRn)) | |
| type Anno (DocDecl (GhcPass p)) | |
Defined in GHC.Hs.Decls | |
Rule Declaration
Constructors
| HsRule | |
Fields
| |
| XRuleDecl !(XXRuleDecl pass) | |
Rule Declarations
Constructors
| HsRules | |
Fields
| |
| XRuleDecls !(XXRuleDecls pass) | |
type LRuleDecls pass = XRec pass (RuleDecls pass) #
Located Rule Declarations
data ForeignExport pass #
Constructors
| CExport (XCExport pass) (XRec pass CExportSpec) | |
| XForeignExport !(XXForeignExport pass) |
Instances
| ToHie (ForeignExport GhcRn) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: ForeignExport GhcRn -> HieM [HieAST Type] | |
data CImportSpec #
Constructors
| CLabel CLabelString | |
| CFunction CCallTarget | |
| CWrapper |
Instances
| Data CImportSpec | |
Defined in Language.Haskell.Syntax.Decls Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CImportSpec -> c CImportSpec # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CImportSpec # toConstr :: CImportSpec -> Constr # dataTypeOf :: CImportSpec -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c CImportSpec) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CImportSpec) # gmapT :: (forall b. Data b => b -> b) -> CImportSpec -> CImportSpec # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CImportSpec -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CImportSpec -> r # gmapQ :: (forall d. Data d => d -> u) -> CImportSpec -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CImportSpec -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CImportSpec -> m CImportSpec # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CImportSpec -> m CImportSpec # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CImportSpec -> m CImportSpec # | |
data ForeignImport pass #
Constructors
| CImport (XCImport pass) (XRec pass CCallConv) (XRec pass Safety) (Maybe Header) CImportSpec | |
| XForeignImport !(XXForeignImport pass) |
Instances
| ToHie (ForeignImport GhcRn) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: ForeignImport GhcRn -> HieM [HieAST Type] | |
data ForeignDecl pass #
Foreign Declaration
Constructors
| ForeignImport | |
Fields
| |
| ForeignExport | |
Fields
| |
| XForeignDecl !(XXForeignDecl pass) | |
Instances
| ToHie (LocatedA (ForeignDecl GhcRn)) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (ForeignDecl (GhcPass p)) | |
Defined in GHC.Hs.Decls | |
type LForeignDecl pass = XRec pass (ForeignDecl pass) #
Located Foreign Declaration
data DefaultDecl pass #
Default Declaration
Constructors
| DefaultDecl (XCDefaultDecl pass) [LHsType pass] | |
| XDefaultDecl !(XXDefaultDecl pass) |
Instances
| ToHie (LocatedA (DefaultDecl GhcRn)) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (DefaultDecl (GhcPass p)) | |
Defined in GHC.Hs.Decls | |
type LDefaultDecl pass = XRec pass (DefaultDecl pass) #
Located Default Declaration
type LDerivStrategy pass = XRec pass (DerivStrategy pass) #
A Located DerivStrategy.
Stand-alone 'deriving instance' declaration
Constructors
| DerivDecl | |
Fields
| |
| XDerivDecl !(XXDerivDecl pass) | |
type LDerivDecl pass = XRec pass (DerivDecl pass) #
Located stand-alone 'deriving instance' declaration
Instance Declaration
Constructors
| ClsInstD | |
Fields
| |
| DataFamInstD | |
Fields
| |
| TyFamInstD | |
Fields
| |
| XInstDecl !(XXInstDecl pass) | |
data ClsInstDecl pass #
Class Instance Declaration
- AnnKeywordId : AnnInstance,
AnnWhere,
AnnOpen,AnnClose,
For details on above see Note [exact print annotations] in GHC.Parser.Annotation
Constructors
| ClsInstDecl | |
Fields
| |
| XClsInstDecl !(XXClsInstDecl pass) | |
Instances
| ToHie (LocatedA (ClsInstDecl GhcRn)) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (ClsInstDecl (GhcPass p)) | |
Defined in GHC.Hs.Decls | |
type LClsInstDecl pass = XRec pass (ClsInstDecl pass) #
Located Class Instance Declaration
Family Equation
One equation in a type family instance declaration, data family instance declaration, or type family default. See Note [Type family instance declarations in HsSyn] See Note [Family instance declaration binders]
Constructors
| FamEqn | |
Fields
| |
| XFamEqn !(XXFamEqn pass rhs) | |
Instances
| ToHie (TScoped (FamEqn GhcRn (LocatedA (HsType GhcRn)))) | |
| ToHie (TScoped (FamEqn GhcRn (HsDataDefn GhcRn))) | |
Defined in GHC.Iface.Ext.Ast | |
| (HasLoc a, HiePass p) => HasLoc (FamEqn (GhcPass p) a) | |
Defined in GHC.Iface.Ext.Ast | |
| (ToHie rhs, HasLoc rhs) => ToHie (FamEqn GhcRn rhs) | |
| type Anno (FamEqn (GhcPass p) _1) | |
Defined in GHC.Hs.Decls | |
| type Anno (FamEqn (GhcPass p) _1) | |
Defined in GHC.Hs.Decls | |
| type Anno (FamEqn p (LocatedA (HsType p))) | |
Defined in GHC.Hs.Decls | |
newtype DataFamInstDecl pass #
Data Family Instance Declaration
Constructors
| DataFamInstDecl | |
Fields
| |
Instances
| ToHie (LocatedA (DataFamInstDecl GhcRn)) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (DataFamInstDecl (GhcPass p)) | |
Defined in GHC.Hs.Decls | |
type LDataFamInstDecl pass = XRec pass (DataFamInstDecl pass) #
Located Data Family Instance Declaration
data TyFamInstDecl pass #
Type Family Instance Declaration
Constructors
| TyFamInstDecl | |
Fields
| |
| XTyFamInstDecl !(XXTyFamInstDecl pass) | |
Instances
| ToHie (LocatedA (TyFamInstDecl GhcRn)) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (TyFamInstDecl (GhcPass p)) | |
Defined in GHC.Hs.Decls | |
type LTyFamInstDecl pass = XRec pass (TyFamInstDecl pass) #
Located Type Family Instance Declaration
type LTyFamDefltDecl pass = XRec pass (TyFamDefltDecl pass) #
Located type family default declarations.
type TyFamDefltDecl = TyFamInstDecl #
Type family default declarations.
A convenient synonym for TyFamInstDecl.
See Note [Type family instance declarations in HsSyn].
type TyFamInstEqn pass = FamEqn pass (LHsType pass) #
Type Family Instance Equation
type HsTyPats pass = [LHsTypeArg pass] #
Haskell Type Patterns
type LTyFamInstEqn pass #
Arguments
| = XRec pass (TyFamInstEqn pass) | May have |
Located Type Family Instance Equation
data HsConDeclGADTDetails pass #
The arguments in a GADT constructor. Unlike Haskell98-style constructors,
GADT constructors cannot be declared with infix syntax. As a result, we do
not use HsConDetails here, as InfixCon would be an unrepresentable
state. (There is a notion of infix GADT constructors for the purposes of
derived Show instances—see Note [Infix GADT constructors] in
GHC.Tc.TyCl—but that is an orthogonal concern.)
Constructors
| PrefixConGADT [HsScaled pass (LBangType pass)] | |
| RecConGADT (XRec pass [LConDeclField pass]) (LHsUniToken "->" "\8594" pass) |
Instances
| ToHie (HsConDeclGADTDetails GhcRn) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: HsConDeclGADTDetails GhcRn -> HieM [HieAST Type] | |
type HsConDeclH98Details pass = HsConDetails Void (HsScaled pass (LBangType pass)) (XRec pass [LConDeclField pass]) #
The arguments in a Haskell98-style data constructor.
data T b = forall a. Eq a => MkT a b
MkT :: forall b a. Eq a => MkT a b
data T b where
MkT1 :: Int -> T Int
data T = Int MkT Int
| MkT2
data T a where
Int MkT Int :: T Int
AnnKeywordIds :AnnOpen,AnnDotdot,AnnCLose,AnnEqual,AnnVbar,AnnDarrow,AnnDarrow,AnnForall,AnnDot
data Constructor Declaration
Constructors
| ConDeclGADT | |
Fields
| |
| ConDeclH98 | |
Fields
| |
| XConDecl !(XXConDecl pass) | |
Arguments
| = XRec pass (ConDecl pass) | May have |
Located data Constructor Declaration
When we only care whether a data-type declaration is `data` or `newtype`, but not what constructors it has
Instances
| Data NewOrData | |
Defined in Language.Haskell.Syntax.Decls Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NewOrData -> c NewOrData # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NewOrData # toConstr :: NewOrData -> Constr # dataTypeOf :: NewOrData -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NewOrData) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NewOrData) # gmapT :: (forall b. Data b => b -> b) -> NewOrData -> NewOrData # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NewOrData -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NewOrData -> r # gmapQ :: (forall d. Data d => d -> u) -> NewOrData -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NewOrData -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NewOrData -> m NewOrData # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NewOrData -> m NewOrData # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NewOrData -> m NewOrData # | |
| Eq NewOrData | |
data StandaloneKindSig pass #
Constructors
| StandaloneKindSig (XStandaloneKindSig pass) (LIdP pass) (LHsSigType pass) | |
| XStandaloneKindSig !(XXStandaloneKindSig pass) |
Instances
| ToHie (LocatedA (StandaloneKindSig GhcRn)) | |
Defined in GHC.Iface.Ext.Ast | |
| ToHie (StandaloneKindSig GhcRn) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: StandaloneKindSig GhcRn -> HieM [HieAST Type] | |
| type Anno (StandaloneKindSig (GhcPass p)) | |
Defined in GHC.Hs.Decls | |
type LStandaloneKindSig pass = XRec pass (StandaloneKindSig pass) #
Located Standalone Kind Signature
data DerivClauseTys pass #
The types mentioned in a single deriving clause. This can come in two
forms, DctSingle or DctMulti, depending on whether the types are
surrounded by enclosing parentheses or not. These parentheses are
semantically different than HsParTy. For example, deriving () means
"derive zero classes" rather than "derive an instance of the 0-tuple".
DerivClauseTys use LHsSigType because deriving clauses can mention
type variables that aren't bound by the datatype, e.g.
data T b = ... deriving (C [a])
should produce a derived instance for C [a] (T b).
Constructors
| DctSingle (XDctSingle pass) (LHsSigType pass) | A Example: |
| DctMulti (XDctMulti pass) [LHsSigType pass] | A Example: |
| XDerivClauseTys !(XXDerivClauseTys pass) |
Instances
| ToHie (LocatedC (DerivClauseTys GhcRn)) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (DerivClauseTys (GhcPass _1)) | |
Defined in GHC.Hs.Decls | |
type LDerivClauseTys pass = XRec pass (DerivClauseTys pass) #
data HsDerivingClause pass #
A single deriving clause of a data declaration.
Constructors
| HsDerivingClause | |
Fields
| |
| XHsDerivingClause !(XXHsDerivingClause pass) | |
Instances
| ToHie (Located [LocatedAn NoEpAnns (HsDerivingClause GhcRn)]) | |
Defined in GHC.Iface.Ext.Ast | |
| ToHie (LocatedAn NoEpAnns (HsDerivingClause GhcRn)) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (HsDerivingClause (GhcPass p)) | |
Defined in GHC.Hs.Decls | |
type LHsDerivingClause pass = XRec pass (HsDerivingClause pass) #
type HsDeriving pass #
Arguments
| = [LHsDerivingClause pass] | The optional The list of |
Haskell Deriving clause
data HsDataDefn pass #
Haskell Data type Definition
Constructors
| HsDataDefn | Declares a data type or newtype, giving its constructors
|
Fields
| |
| XHsDataDefn !(XXHsDataDefn pass) | |
Instances
| HasLoc (HsDataDefn GhcRn) | |
Defined in GHC.Iface.Ext.Ast Methods loc :: HsDataDefn GhcRn -> SrcSpan | |
| ToHie (TScoped (FamEqn GhcRn (HsDataDefn GhcRn))) | |
Defined in GHC.Iface.Ext.Ast | |
| ToHie (HsDataDefn GhcRn) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: HsDataDefn GhcRn -> HieM [HieAST Type] | |
data FamilyInfo pass #
Constructors
| DataFamily | |
| OpenTypeFamily | |
| ClosedTypeFamily (Maybe [LTyFamInstEqn pass]) |
|
Instances
| ToHie (FamilyInfo GhcRn) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: FamilyInfo GhcRn -> HieM [HieAST Type] | |
type LInjectivityAnn pass = XRec pass (InjectivityAnn pass) #
Located Injectivity Annotation
data FamilyDecl pass #
type Family Declaration
Constructors
| FamilyDecl | |
Fields
| |
| XFamilyDecl !(XXFamilyDecl pass) | |
Instances
| ToHie (LocatedA (FamilyDecl GhcRn)) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (FamilyDecl (GhcPass p)) | |
Defined in GHC.Hs.Decls | |
type LFamilyDecl pass = XRec pass (FamilyDecl pass) #
Located type Family Declaration
data FamilyResultSig pass #
type Family Result Signature
Constructors
| NoSig (XNoSig pass) | |
| KindSig (XCKindSig pass) (LHsKind pass) | |
| TyVarSig (XTyVarSig pass) (LHsTyVarBndr () pass) | |
| XFamilyResultSig !(XXFamilyResultSig pass) |
Instances
| ToHie (RScoped (LocatedAn NoEpAnns (FamilyResultSig GhcRn))) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (FamilyResultSig (GhcPass p)) | |
Defined in GHC.Hs.Decls | |
type LFamilyResultSig pass = XRec pass (FamilyResultSig pass) #
Located type Family Result Signature
Type or Class Group
Constructors
| TyClGroup | |
Fields
| |
| XTyClGroup !(XXTyClGroup pass) | |
A type or class declaration.
Constructors
| FamDecl | type/data family T :: *->* |
Fields
| |
| SynDecl |
|
Fields
| |
| DataDecl |
|
Fields
| |
| ClassDecl | |
Fields
| |
| XTyClDecl !(XXTyClDecl pass) | |
data SpliceDecoration #
A splice can appear with various decorations wrapped around it. This data type captures explicitly how it was originally written, for use in the pretty printer.
Constructors
| DollarSplice | $splice |
| BareSplice | bare splice |
Instances
data SpliceDecl p #
Splice Declaration
Constructors
| SpliceDecl (XSpliceDecl p) (XRec p (HsUntypedSplice p)) SpliceDecoration | |
| XSpliceDecl !(XXSpliceDecl p) |
Instances
| ToHie (LocatedA (SpliceDecl GhcRn)) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (SpliceDecl (GhcPass p)) | |
Defined in GHC.Hs.Decls | |
type LSpliceDecl pass = XRec pass (SpliceDecl pass) #
Located Splice Declaration
Constructors
| HsGroup | |
Fields
| |
| XHsGroup !(XXHsGroup p) | |
A Haskell Declaration
Constructors
| TyClD (XTyClD p) (TyClDecl p) | Type or Class Declaration |
| InstD (XInstD p) (InstDecl p) | Instance declaration |
| DerivD (XDerivD p) (DerivDecl p) | Deriving declaration |
| ValD (XValD p) (HsBind p) | Value declaration |
| SigD (XSigD p) (Sig p) | Signature declaration |
| KindSigD (XKindSigD p) (StandaloneKindSig p) | Standalone kind signature |
| DefD (XDefD p) (DefaultDecl p) | 'default' declaration |
| ForD (XForD p) (ForeignDecl p) | Foreign declaration |
| WarningD (XWarningD p) (WarnDecls p) | Warning declaration |
| AnnD (XAnnD p) (AnnDecl p) | Annotation declaration |
| RuleD (XRuleD p) (RuleDecls p) | Rule declaration |
| SpliceD (XSpliceD p) (SpliceDecl p) | Splice declaration (Includes quasi-quotes) |
| DocD (XDocD p) (DocDecl p) | Documentation comment declaration |
| RoleAnnotD (XRoleAnnotD p) (RoleAnnotDecl p) | Role annotation declaration |
| XHsDecl !(XXHsDecl p) |
Instances
| type Anno (HsDecl (GhcPass _1)) | |
Defined in GHC.Hs.Decls | |
Constructors
| HsRuleAnn | |
Fields
| |
Instances
| Data HsRuleAnn | |
Defined in GHC.Hs.Decls Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsRuleAnn -> c HsRuleAnn # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsRuleAnn # toConstr :: HsRuleAnn -> Constr # dataTypeOf :: HsRuleAnn -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsRuleAnn) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsRuleAnn) # gmapT :: (forall b. Data b => b -> b) -> HsRuleAnn -> HsRuleAnn # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsRuleAnn -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsRuleAnn -> r # gmapQ :: (forall d. Data d => d -> u) -> HsRuleAnn -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsRuleAnn -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsRuleAnn -> m HsRuleAnn # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsRuleAnn -> m HsRuleAnn # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsRuleAnn -> m HsRuleAnn # | |
| Eq HsRuleAnn | |
Instances
| Data HsRuleRn | |
Defined in GHC.Hs.Decls Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsRuleRn -> c HsRuleRn # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsRuleRn # toConstr :: HsRuleRn -> Constr # dataTypeOf :: HsRuleRn -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsRuleRn) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsRuleRn) # gmapT :: (forall b. Data b => b -> b) -> HsRuleRn -> HsRuleRn # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsRuleRn -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsRuleRn -> r # gmapQ :: (forall d. Data d => d -> u) -> HsRuleRn -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsRuleRn -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsRuleRn -> m HsRuleRn # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsRuleRn -> m HsRuleRn # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsRuleRn -> m HsRuleRn # | |
data XViaStrategyPs #
Constructors
| XViaStrategyPs (EpAnn [AddEpAnn]) (LHsSigType GhcPs) |
Instances
| Outputable XViaStrategyPs | |
Defined in GHC.Hs.Decls Methods ppr :: XViaStrategyPs -> SDoc # | |
data DataDeclRn #
Constructors
| DataDeclRn | |
Fields
| |
Instances
| Data DataDeclRn | |
Defined in GHC.Hs.Decls Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DataDeclRn -> c DataDeclRn # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DataDeclRn # toConstr :: DataDeclRn -> Constr # dataTypeOf :: DataDeclRn -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DataDeclRn) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataDeclRn) # gmapT :: (forall b. Data b => b -> b) -> DataDeclRn -> DataDeclRn # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DataDeclRn -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DataDeclRn -> r # gmapQ :: (forall d. Data d => d -> u) -> DataDeclRn -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DataDeclRn -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DataDeclRn -> m DataDeclRn # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DataDeclRn -> m DataDeclRn # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DataDeclRn -> m DataDeclRn # | |
hsGroupInstDecls :: HsGroup id -> [LInstDecl id] #
isDataDecl :: TyClDecl pass -> Bool #
True = argument is a data/newtype
declaration.
isClassDecl :: TyClDecl pass -> Bool #
type class
isFamilyDecl :: TyClDecl pass -> Bool #
type/data family declaration
isTypeFamilyDecl :: TyClDecl pass -> Bool #
type family declaration
isOpenTypeFamilyInfo :: FamilyInfo pass -> Bool #
open type family info
isClosedTypeFamilyInfo :: FamilyInfo pass -> Bool #
closed type family info
isDataFamilyDecl :: TyClDecl pass -> Bool #
data family declaration
tyClDeclTyVars :: TyClDecl pass -> LHsQTyVars pass #
tyClGroupTyClDecls :: [TyClGroup pass] -> [LTyClDecl pass] #
tyClGroupInstDecls :: [TyClGroup pass] -> [LInstDecl pass] #
tyClGroupRoleDecls :: [TyClGroup pass] -> [LRoleAnnotDecl pass] #
tyClGroupKindSigs :: [TyClGroup pass] -> [LStandaloneKindSig pass] #
collectRuleBndrSigTys :: [RuleBndr pass] -> [HsPatSigType pass] #
docDeclDoc :: DocDecl pass -> LHsDoc pass #
annProvenanceName_maybe :: UnXRec p => AnnProvenance p -> Maybe (IdP p) #
partitionBindsAndSigs :: [LHsDecl GhcPs] -> (LHsBinds GhcPs, [LSig GhcPs], [LFamilyDecl GhcPs], [LTyFamInstDecl GhcPs], [LDataFamInstDecl GhcPs], [LDocDecl GhcPs]) #
Partition a list of HsDecls into function/pattern bindings, signatures, type family declarations, type family instances, and documentation comments.
Panics when given a declaration that cannot be put into any of the output groups.
The primary use of this function is to implement
cvBindsAndSigs.
emptyRdrGroup :: forall (p :: Pass). HsGroup (GhcPass p) #
emptyRnGroup :: forall (p :: Pass). HsGroup (GhcPass p) #
hsGroupTopLevelFixitySigs :: forall (p :: Pass). HsGroup (GhcPass p) -> [LFixitySig (GhcPass p)] #
The fixity signatures for each top-level declaration and class method
in an HsGroup.
See Note [Top-level fixity signatures in an HsGroup]
appendGroups :: forall (p :: Pass). HsGroup (GhcPass p) -> HsGroup (GhcPass p) -> HsGroup (GhcPass p) #
tyFamInstDeclName :: forall (p :: Pass). Anno (IdGhcP p) ~ SrcSpanAnnN => TyFamInstDecl (GhcPass p) -> IdP (GhcPass p) #
tyFamInstDeclLName :: forall (p :: Pass). Anno (IdGhcP p) ~ SrcSpanAnnN => TyFamInstDecl (GhcPass p) -> LocatedN (IdP (GhcPass p)) #
tyClDeclLName :: forall (p :: Pass). Anno (IdGhcP p) ~ SrcSpanAnnN => TyClDecl (GhcPass p) -> LocatedN (IdP (GhcPass p)) #
tcdName :: forall (p :: Pass). Anno (IdGhcP p) ~ SrcSpanAnnN => TyClDecl (GhcPass p) -> IdP (GhcPass p) #
hsDeclHasCusk :: TyClDecl GhcRn -> Bool #
Does this declaration have a complete, user-supplied kind signature? See Note [CUSKs: complete user-supplied kind signatures]
pp_vanilla_decl_head :: forall (p :: Pass). OutputableBndrId p => XRec (GhcPass p) (IdP (GhcPass p)) -> LHsQTyVars (GhcPass p) -> LexicalFixity -> Maybe (LHsContext (GhcPass p)) -> SDoc #
familyDeclLName :: forall (p :: Pass). FamilyDecl (GhcPass p) -> XRec (GhcPass p) (IdP (GhcPass p)) #
familyDeclName :: forall (p :: Pass). FamilyDecl (GhcPass p) -> IdP (GhcPass p) #
famResultKindSignature :: forall (p :: Pass). FamilyResultSig (GhcPass p) -> Maybe (LHsKind (GhcPass p)) #
resultVariableName :: forall (a :: Pass). FamilyResultSig (GhcPass a) -> Maybe (IdP (GhcPass a)) #
Maybe return name of the result type variable
derivStrategyName :: DerivStrategy a -> SDoc #
A short description of a DerivStrategy'.
standaloneKindSigName :: forall (p :: Pass). StandaloneKindSig (GhcPass p) -> IdP (GhcPass p) #
getRecConArgs_maybe :: ConDecl GhcRn -> Maybe (LocatedL [LConDeclField GhcRn]) #
hsConDeclTheta :: forall (p :: Pass). Maybe (LHsContext (GhcPass p)) -> [LHsType (GhcPass p)] #
ppDataDefnHeader :: forall (p :: Pass). OutputableBndrId p => (Maybe (LHsContext (GhcPass p)) -> SDoc) -> HsDataDefn (GhcPass p) -> SDoc #
pprTyFamInstDecl :: forall (p :: Pass). OutputableBndrId p => TopLevelFlag -> TyFamInstDecl (GhcPass p) -> SDoc #
pprDataFamInstFlavour :: forall (p :: Pass). DataFamInstDecl (GhcPass p) -> SDoc #
pprHsFamInstLHS :: forall (p :: Pass). OutputableBndrId p => IdP (GhcPass p) -> HsOuterFamEqnTyVarBndrs (GhcPass p) -> HsTyPats (GhcPass p) -> LexicalFixity -> Maybe (LHsContext (GhcPass p)) -> SDoc #
instDeclDataFamInsts :: forall (p :: Pass). [LInstDecl (GhcPass p)] -> [DataFamInstDecl (GhcPass p)] #
newOrDataToFlavour :: NewOrData -> TyConFlavour #
Convert a NewOrData to a TyConFlavour
anyLConIsGadt :: Foldable f => f (GenLocated l (ConDecl pass)) -> Bool #
foldDerivStrategy :: forall p (pass :: Pass) r. p ~ GhcPass pass => r -> (XViaStrategy p -> r) -> DerivStrategy p -> r #
Eliminate a DerivStrategy.
mapDerivStrategy :: forall p (pass :: Pass). p ~ GhcPass pass => (XViaStrategy p -> XViaStrategy p) -> DerivStrategy p -> DerivStrategy p #
Map over the via type if dealing with ViaStrategy. Otherwise,
return the DerivStrategy unchanged.
flattenRuleDecls :: forall (p :: Pass). [LRuleDecls (GhcPass p)] -> [LRuleDecl (GhcPass p)] #
pprFullRuleName :: SourceText -> GenLocated a RuleName -> SDoc #
roleAnnotDeclName :: forall (p :: Pass). RoleAnnotDecl (GhcPass p) -> IdP (GhcPass p) #
module GHC.Hs.Expr
module GHC.Hs.Doc
module GHC.Hs.Extension
module GHC.Hs.ImpExp
module GHC.Hs.Pat
module GHC.Hs.Type
class UnXRec p => CollectPass p where #
This class specifies how to collect variable identifiers from extension patterns in the given pass. Consumers of the GHC API that define their own passes should feel free to implement instances in order to make use of functions which depend on it.
In particular, Haddock already makes use of this, with an instance for its DocNameI pass so that
it can reuse the code in GHC for collecting binders.
Methods
collectXXPat :: CollectFlag p -> XXPat p -> [IdP p] -> [IdP p] #
collectXXHsBindsLR :: XXHsBindsLR p pR -> [IdP p] -> [IdP p] #
collectXSplicePat :: CollectFlag p -> XSplicePat p -> [IdP p] -> [IdP p] #
Instances
| IsPass p => CollectPass (GhcPass p) | |
Defined in GHC.Hs.Utils Methods collectXXPat :: CollectFlag (GhcPass p) -> XXPat (GhcPass p) -> [IdP (GhcPass p)] -> [IdP (GhcPass p)] # collectXXHsBindsLR :: XXHsBindsLR (GhcPass p) pR -> [IdP (GhcPass p)] -> [IdP (GhcPass p)] # collectXSplicePat :: CollectFlag (GhcPass p) -> XSplicePat (GhcPass p) -> [IdP (GhcPass p)] -> [IdP (GhcPass p)] # | |
data CollectFlag p where #
Indicate if evidence binders have to be collected.
This type is used as a boolean (should we collect evidence binders or not?) but also to pass an evidence that the AST has been typechecked when we do want to collect evidence binders, otherwise these binders are not available.
See Note [Dictionary binders in ConPatOut]
Constructors
| CollNoDictBinders :: forall p. CollectFlag p | Don't collect evidence binders |
| CollWithDictBinders :: CollectFlag (GhcPass 'Typechecked) | Collect evidence binders |
mkHsAppTy :: forall (p :: Pass). LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) #
mkHsAppKindTy :: forall (p :: Pass). XAppKindTy (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) #
mkSimpleMatch :: forall (p :: Pass) body. (Anno (Match (GhcPass p) (LocatedA (body (GhcPass p)))) ~ SrcSpanAnnA, Anno (GRHS (GhcPass p) (LocatedA (body (GhcPass p)))) ~ SrcAnn NoEpAnns) => HsMatchContext (GhcPass p) -> [LPat (GhcPass p)] -> LocatedA (body (GhcPass p)) -> LMatch (GhcPass p) (LocatedA (body (GhcPass p))) #
unguardedGRHSs :: forall (p :: Pass) body. Anno (GRHS (GhcPass p) (LocatedA (body (GhcPass p)))) ~ SrcAnn NoEpAnns => SrcSpan -> LocatedA (body (GhcPass p)) -> EpAnn GrhsAnn -> GRHSs (GhcPass p) (LocatedA (body (GhcPass p))) #
unguardedRHS :: forall (p :: Pass) body. Anno (GRHS (GhcPass p) (LocatedA (body (GhcPass p)))) ~ SrcAnn NoEpAnns => EpAnn GrhsAnn -> SrcSpan -> LocatedA (body (GhcPass p)) -> [LGRHS (GhcPass p) (LocatedA (body (GhcPass p)))] #
mkMatchGroup :: forall (p :: Pass) body. AnnoBody p body => Origin -> LocatedL [LocatedA (Match (GhcPass p) (LocatedA (body (GhcPass p))))] -> MatchGroup (GhcPass p) (LocatedA (body (GhcPass p))) #
mkLamCaseMatchGroup :: forall (p :: Pass) body. AnnoBody p body => Origin -> LamCaseVariant -> LocatedL [LocatedA (Match (GhcPass p) (LocatedA (body (GhcPass p))))] -> MatchGroup (GhcPass p) (LocatedA (body (GhcPass p))) #
mkLocatedList :: Semigroup a => [GenLocated (SrcAnn a) e2] -> LocatedAn an [GenLocated (SrcAnn a) e2] #
mkHsApp :: forall (id :: Pass). LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #
mkHsAppWith :: forall (id :: Pass). (LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> HsExpr (GhcPass id) -> LHsExpr (GhcPass id)) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #
mkHsApps :: forall (id :: Pass). LHsExpr (GhcPass id) -> [LHsExpr (GhcPass id)] -> LHsExpr (GhcPass id) #
mkHsAppsWith :: forall (id :: Pass). (LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> HsExpr (GhcPass id) -> LHsExpr (GhcPass id)) -> LHsExpr (GhcPass id) -> [LHsExpr (GhcPass id)] -> LHsExpr (GhcPass id) #
mkHsLam :: forall (p :: Pass). (IsPass p, XMG (GhcPass p) (LHsExpr (GhcPass p)) ~ Origin) => [LPat (GhcPass p)] -> LHsExpr (GhcPass p) -> LHsExpr (GhcPass p) #
mkHsCaseAlt :: forall (p :: Pass) body. (Anno (GRHS (GhcPass p) (LocatedA (body (GhcPass p)))) ~ SrcAnn NoEpAnns, Anno (Match (GhcPass p) (LocatedA (body (GhcPass p)))) ~ SrcSpanAnnA) => LPat (GhcPass p) -> LocatedA (body (GhcPass p)) -> LMatch (GhcPass p) (LocatedA (body (GhcPass p))) #
A simple case alternative with a single pattern, no binds, no guards; pre-typechecking
mkLHsPar :: forall (id :: Pass). IsPass id => LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #
Wrap in parens if hsExprNeedsParens appPrecf x becomes (f x), but 3 stays as 3.
mkRecStmt :: forall (idL :: Pass) bodyR. Anno [GenLocated (Anno (StmtLR (GhcPass idL) GhcPs bodyR)) (StmtLR (GhcPass idL) GhcPs bodyR)] ~ SrcSpanAnnL => EpAnn AnnList -> LocatedL [LStmtLR (GhcPass idL) GhcPs bodyR] -> StmtLR (GhcPass idL) GhcPs bodyR #
mkHsIntegral :: IntegralLit -> HsOverLit GhcPs #
mkHsIsString :: SourceText -> FastString -> HsOverLit GhcPs #
mkHsDoAnns :: HsDoFlavour -> LocatedL [ExprLStmt GhcPs] -> EpAnn AnnList -> HsExpr GhcPs #
mkHsCompAnns :: HsDoFlavour -> [ExprLStmt GhcPs] -> LHsExpr GhcPs -> EpAnn AnnList -> HsExpr GhcPs #
mkNPat :: LocatedAn NoEpAnns (HsOverLit GhcPs) -> Maybe (SyntaxExpr GhcPs) -> EpAnn [AddEpAnn] -> Pat GhcPs #
mkNPlusKPat :: LocatedN RdrName -> LocatedAn NoEpAnns (HsOverLit GhcPs) -> EpAnn EpaLocation -> Pat GhcPs #
mkTransformStmt :: EpAnn [AddEpAnn] -> [ExprLStmt GhcPs] -> LHsExpr GhcPs -> StmtLR GhcPs GhcPs (LHsExpr GhcPs) #
mkTransformByStmt :: EpAnn [AddEpAnn] -> [ExprLStmt GhcPs] -> LHsExpr GhcPs -> LHsExpr GhcPs -> StmtLR GhcPs GhcPs (LHsExpr GhcPs) #
mkGroupUsingStmt :: EpAnn [AddEpAnn] -> [ExprLStmt GhcPs] -> LHsExpr GhcPs -> StmtLR GhcPs GhcPs (LHsExpr GhcPs) #
mkGroupByUsingStmt :: EpAnn [AddEpAnn] -> [ExprLStmt GhcPs] -> LHsExpr GhcPs -> LHsExpr GhcPs -> StmtLR GhcPs GhcPs (LHsExpr GhcPs) #
mkLastStmt :: forall (idR :: Pass) bodyR (idL :: Pass). IsPass idR => LocatedA (bodyR (GhcPass idR)) -> StmtLR (GhcPass idL) (GhcPass idR) (LocatedA (bodyR (GhcPass idR))) #
mkBodyStmt :: forall bodyR (idL :: Pass). LocatedA (bodyR GhcPs) -> StmtLR (GhcPass idL) GhcPs (LocatedA (bodyR GhcPs)) #
mkPsBindStmt :: EpAnn [AddEpAnn] -> LPat GhcPs -> LocatedA (bodyR GhcPs) -> StmtLR GhcPs GhcPs (LocatedA (bodyR GhcPs)) #
mkRnBindStmt :: LPat GhcRn -> LocatedA (bodyR GhcRn) -> StmtLR GhcRn GhcRn (LocatedA (bodyR GhcRn)) #
mkTcBindStmt :: LPat GhcTc -> LocatedA (bodyR GhcTc) -> StmtLR GhcTc GhcTc (LocatedA (bodyR GhcTc)) #
emptyRecStmt :: forall (idL :: Pass) bodyR. Anno [GenLocated (Anno (StmtLR (GhcPass idL) GhcPs bodyR)) (StmtLR (GhcPass idL) GhcPs bodyR)] ~ SrcSpanAnnL => StmtLR (GhcPass idL) GhcPs bodyR #
emptyRecStmtName :: Anno [GenLocated (Anno (StmtLR GhcRn GhcRn bodyR)) (StmtLR GhcRn GhcRn bodyR)] ~ SrcSpanAnnL => StmtLR GhcRn GhcRn bodyR #
mkHsOpApp :: LHsExpr GhcPs -> IdP GhcPs -> LHsExpr GhcPs -> HsExpr GhcPs #
A useful function for building OpApps. The operator is always a
variable, and we don't know the fixity yet.
mkHsStringFS :: forall (p :: Pass). FastString -> HsLit (GhcPass p) #
mkHsStringPrimLit :: forall (p :: Pass). FastString -> HsLit (GhcPass p) #
mkConLikeTc :: ConLike -> HsExpr GhcTc #
nlHsApp :: forall (id :: Pass). IsPass id => LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) -> LHsExpr (GhcPass id) #
nlHsSyntaxApps :: SyntaxExprTc -> [LHsExpr GhcTc] -> LHsExpr GhcTc #
nlHsApps :: forall (p :: Pass) a. IsSrcSpanAnn p a => IdP (GhcPass p) -> [LHsExpr (GhcPass p)] -> LHsExpr (GhcPass p) #
nlHsVarApps :: forall (p :: Pass) a. IsSrcSpanAnn p a => IdP (GhcPass p) -> [IdP (GhcPass p)] -> LHsExpr (GhcPass p) #
nlNullaryConPat :: RdrName -> LPat GhcPs #
nlWildConPat :: DataCon -> LPat GhcPs #
nlWildPatName :: LPat GhcRn #
Wildcard pattern - after renaming
nlHsAppTy :: forall (p :: Pass). LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) #
nlHsTyVar :: forall (p :: Pass) a. IsSrcSpanAnn p a => PromotionFlag -> IdP (GhcPass p) -> LHsType (GhcPass p) #
nlHsFunTy :: forall (p :: Pass). LHsType (GhcPass p) -> LHsType (GhcPass p) -> LHsType (GhcPass p) #
nlHsTyConApp :: forall (p :: Pass) a. IsSrcSpanAnn p a => PromotionFlag -> LexicalFixity -> IdP (GhcPass p) -> [LHsTypeArg (GhcPass p)] -> LHsType (GhcPass p) #
nlHsAppKindTy :: forall (p :: Pass). LHsType (GhcPass p) -> LHsKind (GhcPass p) -> LHsType (GhcPass p) #
mkLHsTupleExpr :: forall (p :: Pass). [LHsExpr (GhcPass p)] -> XExplicitTuple (GhcPass p) -> LHsExpr (GhcPass p) #
mkLHsVarTuple :: forall (p :: Pass) a. IsSrcSpanAnn p a => [IdP (GhcPass p)] -> XExplicitTuple (GhcPass p) -> LHsExpr (GhcPass p) #
missingTupArg :: EpAnn EpaLocation -> HsTupArg GhcPs #
mkBigLHsVarTup :: forall (p :: Pass) a. IsSrcSpanAnn p a => [IdP (GhcPass p)] -> XExplicitTuple (GhcPass p) -> LHsExpr (GhcPass p) #
The Big equivalents for the source tuple expressions
mkBigLHsTup :: forall (id :: Pass). [LHsExpr (GhcPass id)] -> XExplicitTuple (GhcPass id) -> LHsExpr (GhcPass id) #
hsTypeToHsSigType :: LHsType GhcPs -> LHsSigType GhcPs #
Convert an LHsType to an LHsSigType.
hsTypeToHsSigWcType :: LHsType GhcPs -> LHsSigWcType GhcPs #
Convert an LHsType to an LHsSigWcType.
mkClassOpSigs :: [LSig GhcPs] -> [LSig GhcPs] #
Convert TypeSig to ClassOpSig.
The former is what is parsed, but the latter is
what we need in class/instance declarations
mkHsWrapCo :: TcCoercionN -> HsExpr GhcTc -> HsExpr GhcTc #
mkHsWrapCoR :: TcCoercionR -> HsExpr GhcTc -> HsExpr GhcTc #
mkLHsWrapCo :: TcCoercionN -> LHsExpr GhcTc -> LHsExpr GhcTc #
mkHsWrapPatCo :: TcCoercionN -> Pat GhcTc -> Type -> Pat GhcTc #
mkFunBind :: Origin -> LocatedN RdrName -> [LMatch GhcPs (LHsExpr GhcPs)] -> HsBind GhcPs #
Not infix, with place holders for coercion and free vars
mkTopFunBind :: Origin -> LocatedN Name -> [LMatch GhcRn (LHsExpr GhcRn)] -> HsBind GhcRn #
In Name-land, with empty bind_fvs
mkPatSynBind :: LocatedN RdrName -> HsPatSynDetails GhcPs -> LPat GhcPs -> HsPatSynDir GhcPs -> EpAnn [AddEpAnn] -> HsBind GhcPs #
isInfixFunBind :: forall id1 id2. UnXRec id2 => HsBindLR id1 id2 -> Bool #
spanHsLocaLBinds :: forall (p :: Pass). HsLocalBinds (GhcPass p) -> SrcSpan #
Return the SrcSpan encompassing the contents of any enclosed binds
mkSimpleGeneratedFunBind :: SrcSpan -> RdrName -> [LPat GhcPs] -> LHsExpr GhcPs -> LHsBind GhcPs #
Convenience function using mkFunBind.
This is for generated bindings only, do not use for user-written code.
mkPrefixFunRhs :: LIdP (NoGhcTc p) -> HsMatchContext p #
Make a prefix, non-strict function HsMatchContext
mkMatch :: forall (p :: Pass). IsPass p => HsMatchContext (GhcPass p) -> [LPat (GhcPass p)] -> LHsExpr (GhcPass p) -> HsLocalBinds (GhcPass p) -> LMatch (GhcPass p) (LHsExpr (GhcPass p)) #
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 checks] is GHC.HsToCore.Binds.
isBangedHsBind :: HsBind GhcTc -> Bool #
Is a binding a strict variable or pattern bind (e.g. !x = ...)?
collectLocalBinders :: forall (idL :: Pass) (idR :: Pass). CollectPass (GhcPass idL) => CollectFlag (GhcPass idL) -> HsLocalBindsLR (GhcPass idL) (GhcPass idR) -> [IdP (GhcPass idL)] #
collectHsIdBinders :: forall (idL :: Pass) (idR :: Pass). CollectPass (GhcPass idL) => CollectFlag (GhcPass idL) -> HsValBindsLR (GhcPass idL) (GhcPass idR) -> [IdP (GhcPass idL)] #
collectHsValBinders :: forall (idL :: Pass) idR. CollectPass (GhcPass idL) => CollectFlag (GhcPass idL) -> HsValBindsLR (GhcPass idL) idR -> [IdP (GhcPass idL)] #
collectHsBindBinders :: CollectPass p => CollectFlag p -> HsBindLR p idR -> [IdP p] #
Collect both Ids and pattern-synonym binders
collectHsBindListBinders :: CollectPass p => CollectFlag p -> [LHsBindLR p idR] -> [IdP p] #
Same as collectHsBindsBinders, but works over a list of bindings
collectMethodBinders :: UnXRec idL => LHsBindsLR idL idR -> [LIdP idL] #
Used exclusively for the bindings of an instance decl which are all
FunBinds
collectLStmtsBinders :: forall (idL :: Pass) (idR :: Pass) body. CollectPass (GhcPass idL) => CollectFlag (GhcPass idL) -> [LStmtLR (GhcPass idL) (GhcPass idR) body] -> [IdP (GhcPass idL)] #
collectStmtsBinders :: forall (idL :: Pass) (idR :: Pass) body. CollectPass (GhcPass idL) => CollectFlag (GhcPass idL) -> [StmtLR (GhcPass idL) (GhcPass idR) body] -> [IdP (GhcPass idL)] #
collectLStmtBinders :: forall (idL :: Pass) (idR :: Pass) body. CollectPass (GhcPass idL) => CollectFlag (GhcPass idL) -> LStmtLR (GhcPass idL) (GhcPass idR) body -> [IdP (GhcPass idL)] #
collectStmtBinders :: forall (idL :: Pass) (idR :: Pass) body. CollectPass (GhcPass idL) => CollectFlag (GhcPass idL) -> StmtLR (GhcPass idL) (GhcPass idR) body -> [IdP (GhcPass idL)] #
collectPatBinders :: CollectPass p => CollectFlag p -> LPat p -> [IdP p] #
collectPatsBinders :: CollectPass p => CollectFlag p -> [LPat p] -> [IdP p] #
hsGroupBinders :: HsGroup GhcRn -> [Name] #
hsTyClForeignBinders :: [TyClGroup GhcRn] -> [LForeignDecl GhcRn] -> [Name] #
hsLTyClDeclBinders :: forall (p :: Pass). IsPass p => LocatedA (TyClDecl (GhcPass p)) -> ([LocatedA (IdP (GhcPass p))], [LFieldOcc (GhcPass p)]) #
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]
hsForeignDeclsBinders :: forall (p :: Pass) a. (UnXRec (GhcPass p), IsSrcSpanAnn p a) => [LForeignDecl (GhcPass p)] -> [LIdP (GhcPass p)] #
See Note [SrcSpan for binders]
hsPatSynSelectors :: forall (p :: Pass). IsPass p => HsValBinds (GhcPass p) -> [FieldOcc (GhcPass p)] #
Collects record pattern-synonym selectors only; the pattern synonym
names are collected by collectHsValBinders.
getPatSynBinds :: UnXRec id => [(RecFlag, LHsBinds id)] -> [PatSynBind id id] #
hsDataFamInstBinders :: forall (p :: Pass). IsPass p => DataFamInstDecl (GhcPass p) -> ([LocatedA (IdP (GhcPass p))], [LFieldOcc (GhcPass p)]) #
the SrcLoc returned are for the whole declarations, not just the names
lStmtsImplicits :: forall (idR :: Pass) (body :: Type -> Type). [LStmtLR GhcRn (GhcPass idR) (LocatedA (body (GhcPass idR)))] -> [(SrcSpan, [Name])] #
hsValBindsImplicits :: forall (idR :: Pass). HsValBindsLR GhcRn (GhcPass idR) -> [(SrcSpan, [Name])] #
data DerivStrategy pass #
Which technique the user explicitly requested when deriving an instance.
Constructors
| StockStrategy (XStockStrategy pass) | 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 (XAnyClassStrategy pass) | -XDeriveAnyClass |
| NewtypeStrategy (XNewtypeStrategy pass) | -XGeneralizedNewtypeDeriving |
| ViaStrategy (XViaStrategy pass) | -XDerivingVia |
Instances
| ToHie (RScoped (LocatedAn NoEpAnns (DerivStrategy GhcRn))) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (DerivStrategy (GhcPass p)) | |
Defined in GHC.Hs.Decls | |
data InjectivityAnn pass #
If the user supplied an injectivity annotation it is represented using InjectivityAnn. At the moment this is a single injectivity condition - see Note [Injectivity annotation]. `Located name` stores the LHS of injectivity condition. `[Located name]` stores the RHS of injectivity condition. Example:
type family Foo a b c = r | r -> a c where ...
This will be represented as "InjectivityAnn r [a, c]"
Constructors
| InjectivityAnn (XCInjectivityAnn pass) (LIdP pass) [LIdP pass] | |
| XInjectivityAnn !(XXInjectivityAnn pass) |
Instances
| ToHie (LocatedAn NoEpAnns (InjectivityAnn GhcRn)) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (InjectivityAnn (GhcPass p)) | |
Defined in GHC.Hs.Decls | |
Rule Binder
Constructors
| RuleBndr (XCRuleBndr pass) (LIdP pass) | |
| RuleBndrSig (XRuleBndrSig pass) (LIdP pass) (HsPatSigType pass) | |
| XRuleBndr !(XXRuleBndr pass) |
Instances
| (HiePass p, Data (body (GhcPass p)), AnnoBody p body, ToHie (LocatedA (body (GhcPass p)))) => ToHie (LocatedA (Match (GhcPass p) (LocatedA (body (GhcPass p))))) | |
| type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))] | |
Defined in GHC.Hs.Expr | |
| type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))] | |
Defined in GHC.Hs.Expr | |
| type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))] | |
Defined in GHC.Parser.PostProcess | |
| type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) | |
Defined in GHC.Hs.Expr | |
| type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) | |
Defined in GHC.Hs.Expr | |
| type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs))) | |
Defined in GHC.Parser.PostProcess | |
Pattern
Constructors
| WildPat (XWildPat p) | Wildcard Pattern The sole reason for a type on a WildPat is to support hsPatType :: Pat Id -> Type |
| VarPat (XVarPat p) (LIdP p) | Variable Pattern |
| LazyPat (XLazyPat p) (LPat p) | Lazy Pattern
^ - |
| AsPat (XAsPat p) (LIdP p) !(LHsToken "@" p) (LPat p) | As pattern
^ - |
| ParPat | |
| 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 SumWidth | Anonymous sum pattern
|
| ConPat | Constructor Pattern |
Fields
| |
| ViewPat | |
| SplicePat |
|
Fields
| |
| LitPat (XLitPat p) (HsLit p) | Literal Pattern Used for *non-overloaded* literal patterns: Int#, Char#, Int, Char, String, etc. |
| NPat (XNPat p) (XRec p (HsOverLit p)) (Maybe (SyntaxExpr p)) (SyntaxExpr p) | Natural Pattern
|
| NPlusKPat (XNPlusKPat p) (LIdP p) (XRec p (HsOverLit p)) (HsOverLit p) (SyntaxExpr p) (SyntaxExpr p) | n+k pattern |
| SigPat | |
Fields
| |
| XPat !(XXPat p) | |
Annotation Declaration
Constructors
| HsAnnotation (XHsAnnotation pass) (AnnProvenance pass) (XRec pass (HsExpr pass)) | |
| XAnnDecl !(XXAnnDecl pass) |
Imported or exported entity.
Constructors
| IEVar (XIEVar pass) (LIEWrappedName pass) | Imported or Exported Variable |
| IEThingAbs (XIEThingAbs pass) (LIEWrappedName pass) | Imported or exported Thing with Absent list The thing is a Class/Type (can't tell)
- |
| IEThingAll (XIEThingAll pass) (LIEWrappedName pass) | Imported or exported Thing with All imported or exported The thing is a ClassType and the All refers to methodsconstructors |
| IEThingWith (XIEThingWith pass) (LIEWrappedName pass) IEWildcard [LIEWrappedName pass] | Imported or exported Thing With given imported or exported The thing is a Class/Type and the imported or exported things are
methods/constructors and record fields; see Note [IEThingWith]
- |
| IEModuleContents (XIEModuleContents pass) (XRec pass ModuleName) | Imported or exported module contents (Export Only) |
| IEGroup (XIEGroup pass) Int (LHsDoc pass) | Doc section heading |
| IEDoc (XIEDoc pass) (LHsDoc pass) | Some documentation |
| IEDocNamed (XIEDocNamed pass) String | Reference to named doc |
| XIE !(XXIE pass) |
A Haskell expression.
Constructors
| HsVar (XVar p) (LIdP p) | Variable See Note [Located RdrNames] |
| HsUnboundVar (XUnboundVar p) RdrName | 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. The (XUnboundVar p) field becomes an HoleExprRef after typechecking; this is where the erroring expression will be written after solving. See Note [Holes] in GHC.Tc.Types.Constraint. |
| HsRecSel (XRecSel p) (FieldOcc p) | Variable pointing to record selector See Note [Non-overloaded record field selectors] and Note [Record selectors in the AST] |
| HsOverLabel (XOverLabel p) SourceText FastString | Overloaded label (Note [Overloaded labels] in GHC.OverloadedLabels) Note [Pragma source text] in GHC.Types.SourceText |
| 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) LamCaseVariant (MatchGroup p (LHsExpr p)) | Lambda-case |
| HsApp (XApp p) (LHsExpr p) (LHsExpr p) | Application |
| HsAppType (XAppTypeE p) (LHsExpr p) !(LHsToken "@" p) (LHsWcType (NoGhcTc 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 |
|
| SectionL (XSectionL p) (LHsExpr p) (LHsExpr p) | |
| SectionR (XSectionR p) (LHsExpr p) (LHsExpr p) | |
| ExplicitTuple (XExplicitTuple p) [HsTupArg p] Boxity | Used for explicit tuples and sections thereof |
| ExplicitSum (XExplicitSum p) ConTag SumWidth (LHsExpr p) | Used for unboxed sum types
There will be multiple |
| HsCase (XCase p) (LHsExpr p) (MatchGroup p (LHsExpr p)) |
|
| HsIf (XIf p) (LHsExpr p) (LHsExpr p) (LHsExpr p) | |
| HsMultiIf (XMultiIf p) [LGRHS p (LHsExpr p)] | Multi-way if |
| HsLet (XLet p) !(LHsToken "let" p) (HsLocalBinds p) !(LHsToken "in" p) (LHsExpr p) | let(rec)
|
| HsDo (XDo p) HsDoFlavour (XRec p [ExprLStmt p]) | |
| ExplicitList (XExplicitList p) [LHsExpr p] | Syntactic list: [a,b,c,...]
|
| RecordCon | Record construction
|
Fields
| |
| RecordUpd | Record update |
Fields
| |
| HsGetField | Record field selection e.g |
| HsProjection | Record field selector. e.g. This case only arises when the OverloadedRecordDot langauge extensions is enabled. See Note [Record selectors in the AST]. |
Fields
| |
| ExprWithTySig (XExprWithTySig p) (LHsExpr p) (LHsSigWcType (NoGhcTc p)) | Expression with an explicit type signature. |
| ArithSeq (XArithSeq p) (Maybe (SyntaxExpr p)) (ArithSeqInfo p) | Arithmetic sequence
|
| HsTypedBracket (XTypedBracket p) (LHsExpr p) | |
| HsUntypedBracket (XUntypedBracket p) (HsQuote p) | |
| HsTypedSplice (XTypedSplice p) (LHsExpr p) | |
| HsUntypedSplice (XUntypedSplice p) (HsUntypedSplice p) | |
| HsProc (XProc p) (LPat p) (LHsCmdTop p) |
|
| HsStatic (XStatic p) (LHsExpr p) | |
| HsPragE (XPragE p) (HsPragE p) (LHsExpr p) | |
| XExpr !(XXExpr p) | |
Instances
data NoExtField #
A placeholder type for TTG extension points that are not currently unused to represent any particular value.
This should not be confused with DataConCantHappen, which are found in unused
extension constructors and therefore should never be inhabited. In
contrast, NoExtField is used in extension points (e.g., as the field of
some constructor), so it must have an inhabitant to construct AST passes
that manipulate fields with that extension point as their type.
Constructors
| NoExtField |
Instances
| Data NoExtField | |
Defined in Language.Haskell.Syntax.Extension Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NoExtField -> c NoExtField # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NoExtField # toConstr :: NoExtField -> Constr # dataTypeOf :: NoExtField -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NoExtField) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NoExtField) # gmapT :: (forall b. Data b => b -> b) -> NoExtField -> NoExtField # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NoExtField -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NoExtField -> r # gmapQ :: (forall d. Data d => d -> u) -> NoExtField -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NoExtField -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NoExtField -> m NoExtField # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NoExtField -> m NoExtField # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NoExtField -> m NoExtField # | |
| Eq NoExtField | |
Defined in Language.Haskell.Syntax.Extension | |
| Ord NoExtField | |
Defined in Language.Haskell.Syntax.Extension Methods compare :: NoExtField -> NoExtField -> Ordering # (<) :: NoExtField -> NoExtField -> Bool # (<=) :: NoExtField -> NoExtField -> Bool # (>) :: NoExtField -> NoExtField -> Bool # (>=) :: NoExtField -> NoExtField -> Bool # max :: NoExtField -> NoExtField -> NoExtField # min :: NoExtField -> NoExtField -> NoExtField # | |
| ToHie (Context (Located NoExtField)) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: Context (Located NoExtField) -> HieM [HieAST Type] | |
See Note [NoGhcTc] in GHC.Hs.Extension. It has to be in this module because it is used like an extension point (in the data definitions of types that should be parameter-agnostic.
Instances
| type NoGhcTc (GhcPass pass) | Marks that a field uses the GhcRn variant even when the pass parameter is GhcTc. Useful for storing HsTypes in GHC.Hs.Exprs, say, because HsType GhcTc should never occur. See Note [NoGhcTc] |
Defined in GHC.Hs.Extension | |
type family XXIEWrappedName p #
Instances
| type XXIEWrappedName (GhcPass _1) | |
Defined in GHC.Hs.ImpExp | |
Instances
| type XIEType (GhcPass _1) | |
Defined in GHC.Hs.ImpExp | |
type family XIEPattern p #
Instances
| type XIEPattern (GhcPass _1) | |
Defined in GHC.Hs.ImpExp | |
Instances
| type XIEName (GhcPass _1) | |
Defined in GHC.Hs.ImpExp | |
Instances
| type XXIE (GhcPass _1) | |
Defined in GHC.Hs.ImpExp | |
type family XIEDocNamed x #
Instances
| type XIEDocNamed (GhcPass _1) | |
Defined in GHC.Hs.ImpExp | |
Instances
| type XIEDoc (GhcPass _1) | |
Defined in GHC.Hs.ImpExp | |
Instances
| type XIEGroup (GhcPass _1) | |
Defined in GHC.Hs.ImpExp | |
type family XIEModuleContents x #
Instances
| type XIEModuleContents GhcPs | |
Defined in GHC.Hs.ImpExp | |
| type XIEModuleContents GhcRn | |
Defined in GHC.Hs.ImpExp | |
| type XIEModuleContents GhcTc | |
Defined in GHC.Hs.ImpExp | |
type family XIEThingWith x #
Instances
| type XIEThingWith (GhcPass 'Parsed) | |
Defined in GHC.Hs.ImpExp | |
| type XIEThingWith (GhcPass 'Renamed) | |
Defined in GHC.Hs.ImpExp | |
| type XIEThingWith (GhcPass 'Typechecked) | |
Defined in GHC.Hs.ImpExp | |
type family XIEThingAll x #
Instances
| type XIEThingAll (GhcPass _1) | |
Defined in GHC.Hs.ImpExp | |
type family XIEThingAbs x #
Instances
| type XIEThingAbs (GhcPass _1) | |
Defined in GHC.Hs.ImpExp | |
Instances
| type XIEVar GhcPs | |
Defined in GHC.Hs.ImpExp | |
| type XIEVar GhcRn | |
Defined in GHC.Hs.ImpExp | |
| type XIEVar GhcTc | |
Defined in GHC.Hs.ImpExp | |
type family ImportDeclPkgQual x #
Instances
| type ImportDeclPkgQual GhcPs | |
Defined in GHC.Hs.ImpExp | |
| type ImportDeclPkgQual GhcRn | |
Defined in GHC.Hs.ImpExp | |
| type ImportDeclPkgQual GhcTc | |
Defined in GHC.Hs.ImpExp | |
type family XXImportDecl x #
Instances
| type XXImportDecl (GhcPass _1) | |
Defined in GHC.Hs.ImpExp | |
type family XCImportDecl x #
Instances
| type XCImportDecl GhcPs | |
Defined in GHC.Hs.ImpExp | |
| type XCImportDecl GhcRn | |
Defined in GHC.Hs.ImpExp | |
| type XCImportDecl GhcTc | |
Defined in GHC.Hs.ImpExp | |
type family XXFieldOcc x #
Instances
| type XXFieldOcc (GhcPass _1) | |
Defined in GHC.Hs.Type | |
type family XCFieldOcc x #
Instances
| type XCFieldOcc GhcPs | |
Defined in GHC.Hs.Type | |
| type XCFieldOcc GhcRn | |
Defined in GHC.Hs.Type | |
| type XCFieldOcc GhcTc | |
Defined in GHC.Hs.Type | |
type family XXConDeclField x #
Instances
| type XXConDeclField (GhcPass _1) | |
Defined in GHC.Hs.Type | |
type family XConDeclField x #
Instances
| type XConDeclField (GhcPass _1) | |
Defined in GHC.Hs.Type | |
type family XXTyVarBndr x #
Instances
| type XXTyVarBndr (GhcPass _1) | |
Defined in GHC.Hs.Type | |
type family XKindedTyVar x #
Instances
| type XKindedTyVar (GhcPass _1) | |
Defined in GHC.Hs.Type | |
type family XUserTyVar x #
Instances
| type XUserTyVar (GhcPass _1) | |
Defined in GHC.Hs.Type | |
type family XXHsForAllTelescope x #
Instances
| type XXHsForAllTelescope (GhcPass _1) | |
Defined in GHC.Hs.Type | |
type family XHsForAllInvis x #
Instances
| type XHsForAllInvis (GhcPass _1) | |
Defined in GHC.Hs.Type | |
type family XHsForAllVis x #
Instances
| type XHsForAllVis (GhcPass _1) | |
Defined in GHC.Hs.Type | |
Instances
| type XXTyLit (GhcPass _1) | |
Defined in GHC.Hs.Type | |
Instances
| type XCharTy (GhcPass _1) | |
Defined in GHC.Hs.Type | |
Instances
| type XStrTy (GhcPass _1) | |
Defined in GHC.Hs.Type | |
Instances
| type XNumTy (GhcPass _1) | |
Defined in GHC.Hs.Type | |
type family XWildCardTy x #
Instances
| type XWildCardTy (GhcPass _1) | |
Defined in GHC.Hs.Type | |
Instances
| type XTyLit (GhcPass _1) | |
Defined in GHC.Hs.Type | |
type family XExplicitTupleTy x #
Instances
| type XExplicitTupleTy GhcPs | |
Defined in GHC.Hs.Type | |
| type XExplicitTupleTy GhcRn | |
Defined in GHC.Hs.Type | |
| type XExplicitTupleTy GhcTc | |
Defined in GHC.Hs.Type | |
type family XExplicitListTy x #
Instances
| type XExplicitListTy GhcPs | |
Defined in GHC.Hs.Type | |
| type XExplicitListTy GhcRn | |
Defined in GHC.Hs.Type | |
| type XExplicitListTy GhcTc | |
Defined in GHC.Hs.Type | |
Instances
| type XRecTy GhcPs | |
Defined in GHC.Hs.Type | |
| type XRecTy GhcRn | |
Defined in GHC.Hs.Type | |
| type XRecTy GhcTc | |
Defined in GHC.Hs.Type | |
Instances
| type XSpliceTy GhcPs | |
Defined in GHC.Hs.Type | |
| type XSpliceTy GhcRn | |
Defined in GHC.Hs.Type | |
| type XSpliceTy GhcTc | |
Defined in GHC.Hs.Type | |
Instances
| type XStarTy (GhcPass _1) | |
Defined in GHC.Hs.Type | |
type family XAppKindTy x #
Instances
| type XAppKindTy (GhcPass _1) | |
Defined in GHC.Hs.Type | |
Instances
| type XAppTy (GhcPass _1) | |
Defined in GHC.Hs.Type | |
Instances
| type XQualTy (GhcPass _1) | |
Defined in GHC.Hs.Type | |
Instances
| type XForAllTy (GhcPass _1) | |
Defined in GHC.Hs.Type | |
type family XXHsPatSigType x #
Instances
| type XXHsPatSigType (GhcPass _1) | |
Defined in GHC.Hs.Type | |
type family XXHsWildCardBndrs x b #
Instances
| type XXHsWildCardBndrs (GhcPass _1) _2 | |
Defined in GHC.Hs.Type | |
Instances
| type XHsWC GhcPs b | |
Defined in GHC.Hs.Type | |
| type XHsWC GhcRn b | |
Defined in GHC.Hs.Type | |
| type XHsWC GhcTc b | |
Defined in GHC.Hs.Type | |
type family XXHsSigType x #
Instances
| type XXHsSigType (GhcPass _1) | |
Defined in GHC.Hs.Type | |
Instances
| type XHsSig (GhcPass _1) | |
Defined in GHC.Hs.Type | |
type family XXHsOuterTyVarBndrs x #
Instances
| type XXHsOuterTyVarBndrs (GhcPass _1) | |
Defined in GHC.Hs.Type | |
type family XHsOuterExplicit x flag #
Instances
| type XHsOuterExplicit GhcPs _1 | |
Defined in GHC.Hs.Type | |
| type XHsOuterExplicit GhcRn _1 | |
Defined in GHC.Hs.Type | |
| type XHsOuterExplicit GhcTc flag | |
Defined in GHC.Hs.Type | |
type family XHsOuterImplicit x #
Instances
| type XHsOuterImplicit GhcPs | |
Defined in GHC.Hs.Type | |
| type XHsOuterImplicit GhcRn | |
Defined in GHC.Hs.Type | |
| type XHsOuterImplicit GhcTc | |
Defined in GHC.Hs.Type | |
type family XXLHsQTyVars x #
Instances
| type XXLHsQTyVars (GhcPass _1) | |
Defined in GHC.Hs.Type | |
Instances
| type XHsQTvs GhcPs | |
Defined in GHC.Hs.Type | |
| type XHsQTvs GhcRn | |
Defined in GHC.Hs.Type | |
| type XHsQTvs GhcTc | |
Defined in GHC.Hs.Type | |
type family XHsFieldBind x #
Instances
| type XHsFieldBind _1 | |
Defined in GHC.Hs.Pat | |
Instances
| type XXPat GhcPs | |
Defined in GHC.Hs.Pat | |
| type XXPat GhcRn | |
Defined in GHC.Hs.Pat | |
| type XXPat GhcTc | |
Defined in GHC.Hs.Pat | |
Instances
| type XSigPat GhcPs | |
Defined in GHC.Hs.Pat | |
| type XSigPat GhcRn | |
Defined in GHC.Hs.Pat | |
| type XSigPat GhcTc | |
Defined in GHC.Hs.Pat | |
type family XNPlusKPat x #
Instances
| type XNPlusKPat GhcPs | |
Defined in GHC.Hs.Pat | |
| type XNPlusKPat GhcRn | |
Defined in GHC.Hs.Pat | |
| type XNPlusKPat GhcTc | |
Defined in GHC.Hs.Pat | |
Instances
| type XLitPat (GhcPass _1) | |
Defined in GHC.Hs.Pat | |
type family XSplicePat x #
Instances
| type XSplicePat GhcPs | |
Defined in GHC.Hs.Pat | |
| type XSplicePat GhcRn | |
Defined in GHC.Hs.Pat | |
| type XSplicePat GhcTc | |
Defined in GHC.Hs.Pat | |
Instances
| type XConPat GhcPs | |
Defined in GHC.Hs.Pat | |
| type XConPat GhcRn | |
Defined in GHC.Hs.Pat | |
| type XConPat GhcTc | |
Defined in GHC.Hs.Pat | |
Instances
| type XSumPat GhcPs | |
Defined in GHC.Hs.Pat | |
| type XSumPat GhcRn | |
Defined in GHC.Hs.Pat | |
| type XSumPat GhcTc | |
Defined in GHC.Hs.Pat | |
Instances
| type XTuplePat GhcPs | |
Defined in GHC.Hs.Pat | |
| type XTuplePat GhcRn | |
Defined in GHC.Hs.Pat | |
| type XTuplePat GhcTc | |
Defined in GHC.Hs.Pat | |
Instances
| type XListPat GhcPs | |
Defined in GHC.Hs.Pat | |
| type XListPat GhcRn | |
Defined in GHC.Hs.Pat | |
| type XListPat GhcTc | |
Defined in GHC.Hs.Pat | |
Instances
| type XBangPat GhcPs | |
Defined in GHC.Hs.Pat | |
| type XBangPat GhcRn | |
Defined in GHC.Hs.Pat | |
| type XBangPat GhcTc | |
Defined in GHC.Hs.Pat | |
Instances
| type XAsPat GhcPs | |
Defined in GHC.Hs.Pat | |
| type XAsPat GhcRn | |
Defined in GHC.Hs.Pat | |
| type XAsPat GhcTc | |
Defined in GHC.Hs.Pat | |
Instances
| type XLazyPat GhcPs | |
Defined in GHC.Hs.Pat | |
| type XLazyPat GhcRn | |
Defined in GHC.Hs.Pat | |
| type XLazyPat GhcTc | |
Defined in GHC.Hs.Pat | |
Instances
| type XVarPat (GhcPass _1) | |
Defined in GHC.Hs.Pat | |
Instances
| type XWildPat GhcPs | |
Defined in GHC.Hs.Pat | |
| type XWildPat GhcRn | |
Defined in GHC.Hs.Pat | |
| type XWildPat GhcTc | |
Defined in GHC.Hs.Pat | |
Instances
| type XXOverLit (GhcPass _1) | |
Defined in GHC.Hs.Lit | |
Instances
| type XOverLit GhcPs | |
Defined in GHC.Hs.Lit | |
| type XOverLit GhcRn | |
Defined in GHC.Hs.Lit | |
| type XOverLit GhcTc | |
Defined in GHC.Hs.Lit | |
Instances
| type XXLit (GhcPass _1) | |
Defined in GHC.Hs.Lit | |
type family XHsDoublePrim x #
Instances
| type XHsDoublePrim (GhcPass _1) | |
Defined in GHC.Hs.Lit | |
type family XHsFloatPrim x #
Instances
| type XHsFloatPrim (GhcPass _1) | |
Defined in GHC.Hs.Lit | |
Instances
| type XHsRat (GhcPass _1) | |
Defined in GHC.Hs.Lit | |
type family XHsInteger x #
Instances
| type XHsInteger (GhcPass _1) | |
Defined in GHC.Hs.Lit | |
type family XHsWord64Prim x #
Instances
| type XHsWord64Prim (GhcPass _1) | |
Defined in GHC.Hs.Lit | |
type family XHsInt64Prim x #
Instances
| type XHsInt64Prim (GhcPass _1) | |
Defined in GHC.Hs.Lit | |
type family XHsWordPrim x #
Instances
| type XHsWordPrim (GhcPass _1) | |
Defined in GHC.Hs.Lit | |
type family XHsIntPrim x #
Instances
| type XHsIntPrim (GhcPass _1) | |
Defined in GHC.Hs.Lit | |
Instances
| type XHsInt (GhcPass _1) | |
Defined in GHC.Hs.Lit | |
type family XHsStringPrim x #
Instances
| type XHsStringPrim (GhcPass _1) | |
Defined in GHC.Hs.Lit | |
Instances
| type XHsString (GhcPass _1) | |
Defined in GHC.Hs.Lit | |
type family XHsCharPrim x #
Instances
| type XHsCharPrim (GhcPass _1) | |
Defined in GHC.Hs.Lit | |
Instances
| type XHsChar (GhcPass _1) | |
Defined in GHC.Hs.Lit | |
type family XXApplicativeArg x #
Instances
| type XXApplicativeArg (GhcPass _1) | |
Defined in GHC.Hs.Expr | |
type family XApplicativeArgMany x #
Instances
| type XApplicativeArgMany (GhcPass _1) | |
Defined in GHC.Hs.Expr | |
type family XApplicativeArgOne x #
Instances
| type XApplicativeArgOne GhcPs | |
Defined in GHC.Hs.Expr | |
| type XApplicativeArgOne GhcRn | |
Defined in GHC.Hs.Expr | |
| type XApplicativeArgOne GhcTc | |
Defined in GHC.Hs.Expr | |
type family XXParStmtBlock x x' #
Instances
| type XXParStmtBlock (GhcPass pL) (GhcPass pR) | |
Defined in GHC.Hs.Expr | |
type family XParStmtBlock x x' #
Instances
| type XParStmtBlock (GhcPass pL) (GhcPass pR) | |
Defined in GHC.Hs.Expr | |
Instances
| type XXCmd GhcPs | |
Defined in GHC.Hs.Expr | |
| type XXCmd GhcRn | |
Defined in GHC.Hs.Expr | |
| type XXCmd GhcTc | |
Defined in GHC.Hs.Expr | |
Instances
| type XCmdWrap (GhcPass _1) | |
Defined in GHC.Hs.Expr | |
Instances
| type XCmdDo GhcPs | |
Defined in GHC.Hs.Expr | |
| type XCmdDo GhcRn | |
Defined in GHC.Hs.Expr | |
| type XCmdDo GhcTc | |
Defined in GHC.Hs.Expr | |
Instances
| type XCmdLet GhcPs | |
Defined in GHC.Hs.Expr | |
| type XCmdLet GhcRn | |
Defined in GHC.Hs.Expr | |
| type XCmdLet GhcTc | |
Defined in GHC.Hs.Expr | |
Instances
| type XCmdIf GhcPs | |
Defined in GHC.Hs.Expr | |
| type XCmdIf GhcRn | |
Defined in GHC.Hs.Expr | |
| type XCmdIf GhcTc | |
Defined in GHC.Hs.Expr | |
type family XCmdLamCase x #
Instances
| type XCmdLamCase (GhcPass _1) | |
Defined in GHC.Hs.Expr | |
Instances
| type XCmdCase GhcPs | |
Defined in GHC.Hs.Expr | |
| type XCmdCase GhcRn | |
Defined in GHC.Hs.Expr | |
| type XCmdCase GhcTc | |
Defined in GHC.Hs.Expr | |
Instances
| type XCmdLam (GhcPass _1) | |
Defined in GHC.Hs.Expr | |
type family XCmdArrForm x #
Instances
| type XCmdArrForm GhcPs | |
Defined in GHC.Hs.Expr | |
| type XCmdArrForm GhcRn | |
Defined in GHC.Hs.Expr | |
| type XCmdArrForm GhcTc | |
Defined in GHC.Hs.Expr | |
type family XCmdArrApp x #
Instances
| type XCmdArrApp GhcPs | |
Defined in GHC.Hs.Expr | |
| type XCmdArrApp GhcRn | |
Defined in GHC.Hs.Expr | |
| type XCmdArrApp GhcTc | |
Defined in GHC.Hs.Expr | |
Instances
| type XXStmtLR (GhcPass _1) (GhcPass _2) b | |
Defined in GHC.Hs.Expr | |
type family XTransStmt x x' b #
Instances
| type XTransStmt (GhcPass _1) GhcPs b | |
Defined in GHC.Hs.Expr | |
| type XTransStmt (GhcPass _1) GhcRn b | |
Defined in GHC.Hs.Expr | |
| type XTransStmt (GhcPass _1) GhcTc b | |
Defined in GHC.Hs.Expr | |
Instances
| type XParStmt (GhcPass _1) GhcPs b | |
Defined in GHC.Hs.Expr | |
| type XParStmt (GhcPass _1) GhcRn b | |
Defined in GHC.Hs.Expr | |
| type XParStmt (GhcPass _1) GhcTc b | |
Defined in GHC.Hs.Expr | |
type family XBodyStmt x x' b #
Instances
| type XBodyStmt (GhcPass _1) GhcPs b | |
Defined in GHC.Hs.Expr | |
| type XBodyStmt (GhcPass _1) GhcRn b | |
Defined in GHC.Hs.Expr | |
| type XBodyStmt (GhcPass _1) GhcTc b | |
Defined in GHC.Hs.Expr | |
type family XApplicativeStmt x x' b #
Instances
| type XApplicativeStmt (GhcPass _1) GhcPs b | |
Defined in GHC.Hs.Expr | |
| type XApplicativeStmt (GhcPass _1) GhcRn b | |
Defined in GHC.Hs.Expr | |
| type XApplicativeStmt (GhcPass _1) GhcTc b | |
Defined in GHC.Hs.Expr | |
type family XLastStmt x x' b #
Instances
| type XLastStmt (GhcPass _1) (GhcPass _2) b | |
Defined in GHC.Hs.Expr | |
Instances
| type XXGRHS (GhcPass _1) b | |
Defined in GHC.Hs.Expr | |
Instances
| type XXGRHSs (GhcPass _1) _2 | |
Defined in GHC.Hs.Expr | |
Instances
| type XCGRHSs (GhcPass _1) _2 | |
Defined in GHC.Hs.Expr | |
Instances
| type XXMatch (GhcPass _1) b | |
Defined in GHC.Hs.Expr | |
type family XXMatchGroup x b #
Instances
| type XXMatchGroup (GhcPass _1) b | |
Defined in GHC.Hs.Expr | |
Instances
| type XMG GhcPs b | |
Defined in GHC.Hs.Expr | |
| type XMG GhcRn b | |
Defined in GHC.Hs.Expr | |
| type XMG GhcTc b | |
Defined in GHC.Hs.Expr | |
Instances
| type XXCmdTop (GhcPass _1) | |
Defined in GHC.Hs.Expr | |
Instances
| type XCmdTop GhcPs | |
Defined in GHC.Hs.Expr | |
| type XCmdTop GhcRn | |
Defined in GHC.Hs.Expr | |
| type XCmdTop GhcTc | |
Defined in GHC.Hs.Expr | |
Instances
| type XXQuote GhcPs | |
Defined in GHC.Hs.Expr | |
| type XXQuote GhcRn | |
Defined in GHC.Hs.Expr | |
| type XXQuote GhcTc | |
Defined in GHC.Hs.Expr | |
Instances
| type XVarBr GhcPs | |
Defined in GHC.Hs.Expr | |
| type XVarBr GhcRn | |
Defined in GHC.Hs.Expr | |
| type XVarBr GhcTc | |
Defined in GHC.Hs.Expr | |
Instances
| type XTypBr GhcPs | |
Defined in GHC.Hs.Expr | |
| type XTypBr GhcRn | |
Defined in GHC.Hs.Expr | |
| type XTypBr GhcTc | |
Defined in GHC.Hs.Expr | |
Instances
| type XDecBrG GhcPs | |
Defined in GHC.Hs.Expr | |
| type XDecBrG GhcRn | |
Defined in GHC.Hs.Expr | |
| type XDecBrG GhcTc | |
Defined in GHC.Hs.Expr | |
Instances
| type XDecBrL GhcPs | |
Defined in GHC.Hs.Expr | |
| type XDecBrL GhcRn | |
Defined in GHC.Hs.Expr | |
| type XDecBrL GhcTc | |
Defined in GHC.Hs.Expr | |
Instances
| type XPatBr GhcPs | |
Defined in GHC.Hs.Expr | |
| type XPatBr GhcRn | |
Defined in GHC.Hs.Expr | |
| type XPatBr GhcTc | |
Defined in GHC.Hs.Expr | |
Instances
| type XExpBr GhcPs | |
Defined in GHC.Hs.Expr | |
| type XExpBr GhcRn | |
Defined in GHC.Hs.Expr | |
| type XExpBr GhcTc | |
Defined in GHC.Hs.Expr | |
type family XXUntypedSplice x #
Instances
| type XXUntypedSplice p | |
Defined in GHC.Hs.Expr | |
type family XQuasiQuote x #
Instances
| type XQuasiQuote p | |
Defined in GHC.Hs.Expr | |
type family XUntypedSpliceExpr x #
Instances
| type XUntypedSpliceExpr GhcPs | |
Defined in GHC.Hs.Expr | |
| type XUntypedSpliceExpr GhcRn | |
Defined in GHC.Hs.Expr | |
| type XUntypedSpliceExpr GhcTc | |
Defined in GHC.Hs.Expr | |
Instances
| type XXTupArg (GhcPass _1) | |
Defined in GHC.Hs.Expr | |
Instances
| type XMissing GhcPs | |
Defined in GHC.Hs.Expr | |
| type XMissing GhcRn | |
Defined in GHC.Hs.Expr | |
| type XMissing GhcTc | |
Defined in GHC.Hs.Expr | |
type family XXAmbiguousFieldOcc x #
Instances
| type XXAmbiguousFieldOcc (GhcPass _1) | |
Defined in GHC.Hs.Type | |
type family XAmbiguous x #
Instances
| type XAmbiguous GhcPs | |
Defined in GHC.Hs.Type | |
| type XAmbiguous GhcRn | |
Defined in GHC.Hs.Type | |
| type XAmbiguous GhcTc | |
Defined in GHC.Hs.Type | |
type family XUnambiguous x #
Instances
| type XUnambiguous GhcPs | |
Defined in GHC.Hs.Type | |
| type XUnambiguous GhcRn | |
Defined in GHC.Hs.Type | |
| type XUnambiguous GhcTc | |
Defined in GHC.Hs.Type | |
Instances
| type XXPragE (GhcPass _1) | |
Defined in GHC.Hs.Expr | |
Instances
| type XSCC (GhcPass _1) | |
Defined in GHC.Hs.Expr | |
type family XXDotFieldOcc x #
Instances
| type XXDotFieldOcc (GhcPass _1) | |
Defined in GHC.Hs.Expr | |
type family XCDotFieldOcc x #
Instances
| type XCDotFieldOcc (GhcPass _1) | |
Defined in GHC.Hs.Expr | |
Instances
| type XXExpr GhcPs | |
Defined in GHC.Hs.Expr | |
| type XXExpr GhcRn | |
Defined in GHC.Hs.Expr | |
| type XXExpr GhcTc | |
Defined in GHC.Hs.Expr | |
Instances
| type XPragE (GhcPass _1) | |
Defined in GHC.Hs.Expr | |
type family XUntypedSplice x #
Instances
| type XUntypedSplice GhcPs | |
Defined in GHC.Hs.Expr | |
| type XUntypedSplice GhcRn | |
Defined in GHC.Hs.Expr | |
| type XUntypedSplice GhcTc | |
Defined in GHC.Hs.Expr | |
type family XTypedSplice x #
Instances
| type XTypedSplice GhcPs | |
Defined in GHC.Hs.Expr | |
| type XTypedSplice GhcRn | |
Defined in GHC.Hs.Expr | |
| type XTypedSplice GhcTc | |
Defined in GHC.Hs.Expr | |
type family XUntypedBracket x #
Instances
| type XUntypedBracket GhcPs | |
Defined in GHC.Hs.Expr | |
| type XUntypedBracket GhcRn | |
Defined in GHC.Hs.Expr | |
| type XUntypedBracket GhcTc | |
Defined in GHC.Hs.Expr | |
type family XTypedBracket x #
Instances
| type XTypedBracket GhcPs | |
Defined in GHC.Hs.Expr | |
| type XTypedBracket GhcRn | |
Defined in GHC.Hs.Expr | |
| type XTypedBracket GhcTc | |
Defined in GHC.Hs.Expr | |
Instances
| type XArithSeq GhcPs | |
Defined in GHC.Hs.Expr | |
| type XArithSeq GhcRn | |
Defined in GHC.Hs.Expr | |
| type XArithSeq GhcTc | |
Defined in GHC.Hs.Expr | |
type family XExprWithTySig x #
Instances
| type XExprWithTySig GhcPs | |
Defined in GHC.Hs.Expr | |
| type XExprWithTySig GhcRn | |
Defined in GHC.Hs.Expr | |
| type XExprWithTySig GhcTc | |
Defined in GHC.Hs.Expr | |
type family XProjection x #
Instances
| type XProjection GhcPs | |
Defined in GHC.Hs.Expr | |
| type XProjection GhcRn | |
Defined in GHC.Hs.Expr | |
| type XProjection GhcTc | |
Defined in GHC.Hs.Expr | |
Instances
| type XGetField GhcPs | |
Defined in GHC.Hs.Expr | |
| type XGetField GhcRn | |
Defined in GHC.Hs.Expr | |
| type XGetField GhcTc | |
Defined in GHC.Hs.Expr | |
type family XRecordUpd x #
Instances
| type XRecordUpd GhcPs | |
Defined in GHC.Hs.Expr | |
| type XRecordUpd GhcRn | |
Defined in GHC.Hs.Expr | |
| type XRecordUpd GhcTc | |
Defined in GHC.Hs.Expr | |
type family XRecordCon x #
Instances
| type XRecordCon GhcPs | |
Defined in GHC.Hs.Expr | |
| type XRecordCon GhcRn | |
Defined in GHC.Hs.Expr | |
| type XRecordCon GhcTc | |
Defined in GHC.Hs.Expr | |
type family XExplicitList x #
Instances
| type XExplicitList GhcPs | |
Defined in GHC.Hs.Expr | |
| type XExplicitList GhcRn | |
Defined in GHC.Hs.Expr | |
| type XExplicitList GhcTc | |
Defined in GHC.Hs.Expr | |
Instances
| type XDo GhcPs | |
Defined in GHC.Hs.Expr | |
| type XDo GhcRn | |
Defined in GHC.Hs.Expr | |
| type XDo GhcTc | |
Defined in GHC.Hs.Expr | |
Instances
| type XLet GhcPs | |
Defined in GHC.Hs.Expr | |
| type XLet GhcRn | |
Defined in GHC.Hs.Expr | |
| type XLet GhcTc | |
Defined in GHC.Hs.Expr | |
Instances
| type XMultiIf GhcPs | |
Defined in GHC.Hs.Expr | |
| type XMultiIf GhcRn | |
Defined in GHC.Hs.Expr | |
| type XMultiIf GhcTc | |
Defined in GHC.Hs.Expr | |
Instances
| type XIf GhcPs | |
Defined in GHC.Hs.Expr | |
| type XIf GhcRn | |
Defined in GHC.Hs.Expr | |
| type XIf GhcTc | |
Defined in GHC.Hs.Expr | |
Instances
| type XCase GhcPs | |
Defined in GHC.Hs.Expr | |
| type XCase GhcRn | |
Defined in GHC.Hs.Expr | |
| type XCase GhcTc | |
Defined in GHC.Hs.Expr | |
type family XExplicitSum x #
Instances
| type XExplicitSum GhcPs | |
Defined in GHC.Hs.Expr | |
| type XExplicitSum GhcRn | |
Defined in GHC.Hs.Expr | |
| type XExplicitSum GhcTc | |
Defined in GHC.Hs.Expr | |
type family XExplicitTuple x #
Instances
| type XExplicitTuple GhcPs | |
Defined in GHC.Hs.Expr | |
| type XExplicitTuple GhcRn | |
Defined in GHC.Hs.Expr | |
| type XExplicitTuple GhcTc | |
Defined in GHC.Hs.Expr | |
Instances
| type XSectionR GhcPs | |
Defined in GHC.Hs.Expr | |
| type XSectionR GhcRn | |
Defined in GHC.Hs.Expr | |
| type XSectionR GhcTc | |
Defined in GHC.Hs.Expr | |
Instances
| type XSectionL GhcPs | |
Defined in GHC.Hs.Expr | |
| type XSectionL GhcRn | |
Defined in GHC.Hs.Expr | |
| type XSectionL GhcTc | |
Defined in GHC.Hs.Expr | |
Instances
| type XNegApp GhcPs | |
Defined in GHC.Hs.Expr | |
| type XNegApp GhcRn | |
Defined in GHC.Hs.Expr | |
| type XNegApp GhcTc | |
Defined in GHC.Hs.Expr | |
Instances
| type XOpApp GhcPs | |
Defined in GHC.Hs.Expr | |
| type XOpApp GhcRn | |
Defined in GHC.Hs.Expr | |
| type XOpApp GhcTc | |
Defined in GHC.Hs.Expr | |
Instances
| type XAppTypeE GhcPs | |
Defined in GHC.Hs.Expr | |
| type XAppTypeE GhcRn | |
Defined in GHC.Hs.Expr | |
| type XAppTypeE GhcTc | |
Defined in GHC.Hs.Expr | |
Instances
| type XLam (GhcPass _1) | |
Defined in GHC.Hs.Expr | |
| type XLam (GhcPass _1) | |
Defined in GHC.Hs.Expr | |
Instances
| type XIPVar GhcPs | |
Defined in GHC.Hs.Expr | |
| type XIPVar GhcRn | |
Defined in GHC.Hs.Expr | |
| type XIPVar GhcTc | |
Defined in GHC.Hs.Expr | |
type family XOverLabel x #
Instances
| type XOverLabel GhcPs | |
Defined in GHC.Hs.Expr | |
| type XOverLabel GhcRn | |
Defined in GHC.Hs.Expr | |
| type XOverLabel GhcTc | |
Defined in GHC.Hs.Expr | |
Instances
| type XRecSel GhcPs | |
Defined in GHC.Hs.Expr | |
| type XRecSel GhcRn | |
Defined in GHC.Hs.Expr | |
| type XRecSel GhcTc | |
Defined in GHC.Hs.Expr | |
type family XUnboundVar x #
Instances
| type XUnboundVar GhcPs | |
Defined in GHC.Hs.Expr | |
| type XUnboundVar GhcRn | |
Defined in GHC.Hs.Expr | |
| type XUnboundVar GhcTc | |
Defined in GHC.Hs.Expr | |
Instances
| type XVar (GhcPass _1) | |
Defined in GHC.Hs.Expr | |
| type XVar (GhcPass _1) | |
Defined in GHC.Hs.Expr | |
type family XXInjectivityAnn x #
Instances
| type XXInjectivityAnn (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XCInjectivityAnn x #
Instances
| type XCInjectivityAnn (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XXRoleAnnotDecl x #
Instances
| type XXRoleAnnotDecl (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XCRoleAnnotDecl x #
Instances
| type XCRoleAnnotDecl GhcPs | |
Defined in GHC.Hs.Decls | |
| type XCRoleAnnotDecl GhcRn | |
Defined in GHC.Hs.Decls | |
| type XCRoleAnnotDecl GhcTc | |
Defined in GHC.Hs.Decls | |
Instances
| type XXAnnDecl (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XHsAnnotation x #
Instances
| type XHsAnnotation (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XXWarnDecl x #
Instances
| type XXWarnDecl (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XXWarnDecls x #
Instances
| type XXWarnDecls (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
Instances
| type XWarnings GhcPs | |
Defined in GHC.Hs.Decls | |
| type XWarnings GhcRn | |
Defined in GHC.Hs.Decls | |
| type XWarnings GhcTc | |
Defined in GHC.Hs.Decls | |
type family XXRuleBndr x #
Instances
| type XXRuleBndr (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XRuleBndrSig x #
Instances
| type XRuleBndrSig (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XCRuleBndr x #
Instances
| type XCRuleBndr (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XXRuleDecl x #
Instances
| type XXRuleDecl (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
Instances
| type XHsRule GhcPs | |
Defined in GHC.Hs.Decls | |
| type XHsRule GhcRn | |
Defined in GHC.Hs.Decls | |
| type XHsRule GhcTc | |
Defined in GHC.Hs.Decls | |
type family XXRuleDecls x #
Instances
| type XXRuleDecls (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XCRuleDecls x #
Instances
| type XCRuleDecls GhcPs | |
Defined in GHC.Hs.Decls | |
| type XCRuleDecls GhcRn | |
Defined in GHC.Hs.Decls | |
| type XCRuleDecls GhcTc | |
Defined in GHC.Hs.Decls | |
type family XXForeignExport x #
Instances
| type XXForeignExport (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
Instances
| type XCExport (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XXForeignImport x #
Instances
| type XXForeignImport (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
Instances
| type XCImport (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XXForeignDecl x #
Instances
| type XXForeignDecl (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XForeignExport x #
Instances
| type XForeignExport GhcPs | |
Defined in GHC.Hs.Decls | |
| type XForeignExport GhcRn | |
Defined in GHC.Hs.Decls | |
| type XForeignExport GhcTc | |
Defined in GHC.Hs.Decls | |
type family XForeignImport x #
Instances
| type XForeignImport GhcPs | |
Defined in GHC.Hs.Decls | |
| type XForeignImport GhcRn | |
Defined in GHC.Hs.Decls | |
| type XForeignImport GhcTc | |
Defined in GHC.Hs.Decls | |
type family XXDefaultDecl x #
Instances
| type XXDefaultDecl (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XCDefaultDecl x #
Instances
| type XCDefaultDecl GhcPs | |
Defined in GHC.Hs.Decls | |
| type XCDefaultDecl GhcRn | |
Defined in GHC.Hs.Decls | |
| type XCDefaultDecl GhcTc | |
Defined in GHC.Hs.Decls | |
type family XViaStrategy x #
Instances
| type XViaStrategy GhcPs | |
Defined in GHC.Hs.Decls | |
| type XViaStrategy GhcRn | |
Defined in GHC.Hs.Decls | |
| type XViaStrategy GhcTc | |
Defined in GHC.Hs.Decls | |
type family XNewtypeStrategy x #
Instances
| type XNewtypeStrategy GhcPs | |
Defined in GHC.Hs.Decls | |
| type XNewtypeStrategy GhcRn | |
Defined in GHC.Hs.Decls | |
| type XNewtypeStrategy GhcTc | |
Defined in GHC.Hs.Decls | |
type family XAnyClassStrategy x #
Instances
| type XAnyClassStrategy GhcPs | |
Defined in GHC.Hs.Decls | |
| type XAnyClassStrategy GhcRn | |
Defined in GHC.Hs.Decls | |
| type XAnyClassStrategy GhcTc | |
Defined in GHC.Hs.Decls | |
type family XStockStrategy x #
Instances
| type XStockStrategy GhcPs | |
Defined in GHC.Hs.Decls | |
| type XStockStrategy GhcRn | |
Defined in GHC.Hs.Decls | |
| type XStockStrategy GhcTc | |
Defined in GHC.Hs.Decls | |
type family XXDerivDecl x #
Instances
| type XXDerivDecl (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XCDerivDecl x #
Instances
| type XCDerivDecl (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XXInstDecl x #
Instances
| type XXInstDecl (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XTyFamInstD x #
Instances
| type XTyFamInstD GhcPs | |
Defined in GHC.Hs.Decls | |
| type XTyFamInstD GhcRn | |
Defined in GHC.Hs.Decls | |
| type XTyFamInstD GhcTc | |
Defined in GHC.Hs.Decls | |
type family XDataFamInstD x #
Instances
| type XDataFamInstD (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
Instances
| type XClsInstD (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XXClsInstDecl x #
Instances
| type XXClsInstDecl (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XCClsInstDecl x #
Instances
| type XCClsInstDecl GhcPs | |
Defined in GHC.Hs.Decls | |
| type XCClsInstDecl GhcRn | |
Defined in GHC.Hs.Decls | |
| type XCClsInstDecl GhcTc | |
Defined in GHC.Hs.Decls | |
type family XXTyFamInstDecl x #
Instances
| type XXTyFamInstDecl (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XCTyFamInstDecl x #
Instances
| type XCTyFamInstDecl (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
Instances
| type XXFamEqn (GhcPass _1) r | |
Defined in GHC.Hs.Decls | |
Instances
| type XXConDecl (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XConDeclH98 x #
Instances
| type XConDeclH98 (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XConDeclGADT x #
Instances
| type XConDeclGADT (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XXDerivClauseTys x #
Instances
| type XXDerivClauseTys (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
Instances
| type XDctMulti (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XDctSingle x #
Instances
| type XDctSingle (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XXHsDerivingClause x #
Instances
| type XXHsDerivingClause (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XCHsDerivingClause x #
Instances
| type XCHsDerivingClause (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XXHsDataDefn x #
Instances
| type XXHsDataDefn (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XCHsDataDefn x #
Instances
| type XCHsDataDefn (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XXFamilyDecl x #
Instances
| type XXFamilyDecl (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XCFamilyDecl x #
Instances
| type XCFamilyDecl (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XXFamilyResultSig x #
Instances
| type XXFamilyResultSig (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
Instances
| type XTyVarSig (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
Instances
| type XCKindSig (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
Instances
| type XNoSig (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XXTyClGroup x #
Instances
| type XXTyClGroup (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XCTyClGroup x #
Instances
| type XCTyClGroup (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
Instances
| type XXFunDep (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XXTyClDecl x #
Instances
| type XXTyClDecl (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XClassDecl x #
Instances
| type XClassDecl GhcPs | |
Defined in GHC.Hs.Decls | |
| type XClassDecl GhcRn | |
Defined in GHC.Hs.Decls | |
| type XClassDecl GhcTc | |
Defined in GHC.Hs.Decls | |
Instances
| type XDataDecl GhcPs | |
Defined in GHC.Hs.Decls | |
| type XDataDecl GhcRn | |
Defined in GHC.Hs.Decls | |
| type XDataDecl GhcTc | |
Defined in GHC.Hs.Decls | |
Instances
| type XFamDecl (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XXSpliceDecl x #
Instances
| type XXSpliceDecl (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XSpliceDecl x #
Instances
| type XSpliceDecl (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
Instances
| type XXHsGroup (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
Instances
| type XCHsGroup (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
Instances
| type XXHsDecl (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XRoleAnnotD x #
Instances
| type XRoleAnnotD (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
Instances
| type XDocD (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
Instances
| type XSpliceD (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
Instances
| type XRuleD (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
Instances
| type XAnnD (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
Instances
| type XWarningD (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
Instances
| type XForD (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
Instances
| type XDefD (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
Instances
| type XKindSigD (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
Instances
| type XSigD (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
Instances
| type XValD (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
Instances
| type XDerivD (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
Instances
| type XInstD (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
Instances
| type XTyClD (GhcPass _1) | |
Defined in GHC.Hs.Decls | |
type family XXStandaloneKindSig x #
Instances
| type XXStandaloneKindSig (GhcPass p) | |
Defined in GHC.Hs.Decls | |
type family XStandaloneKindSig x #
Instances
| type XStandaloneKindSig GhcPs | |
Defined in GHC.Hs.Decls | |
| type XStandaloneKindSig GhcRn | |
Defined in GHC.Hs.Decls | |
| type XStandaloneKindSig GhcTc | |
Defined in GHC.Hs.Decls | |
type family XXFixitySig x #
Instances
| type XXFixitySig (GhcPass p) | |
Defined in GHC.Hs.Binds | |
type family XFixitySig x #
Instances
| type XFixitySig (GhcPass p) | |
Defined in GHC.Hs.Binds | |
Instances
| type XXSig GhcPs | |
Defined in GHC.Hs.Binds | |
| type XXSig GhcRn | |
Defined in GHC.Hs.Binds | |
| type XXSig GhcTc | |
Defined in GHC.Hs.Binds | |
type family XCompleteMatchSig x #
Instances
| type XCompleteMatchSig (GhcPass p) | |
Defined in GHC.Hs.Binds | |
type family XSCCFunSig x #
Instances
| type XSCCFunSig (GhcPass p) | |
Defined in GHC.Hs.Binds | |
type family XMinimalSig x #
Instances
| type XMinimalSig (GhcPass p) | |
Defined in GHC.Hs.Binds | |
type family XSpecInstSig x #
Instances
| type XSpecInstSig (GhcPass p) | |
Defined in GHC.Hs.Binds | |
type family XInlineSig x #
Instances
| type XInlineSig (GhcPass p) | |
Defined in GHC.Hs.Binds | |
type family XClassOpSig x #
Instances
| type XClassOpSig (GhcPass p) | |
Defined in GHC.Hs.Binds | |
type family XPatSynSig x #
Instances
| type XPatSynSig (GhcPass p) | |
Defined in GHC.Hs.Binds | |
Instances
| type XXIPBind (GhcPass p) | |
Defined in GHC.Hs.Binds | |
Instances
| type XCIPBind GhcPs | |
Defined in GHC.Hs.Binds | |
| type XCIPBind GhcRn | |
Defined in GHC.Hs.Binds | |
| type XCIPBind GhcTc | |
Defined in GHC.Hs.Binds | |
type family XXHsIPBinds x #
Instances
| type XXHsIPBinds (GhcPass p) | |
Defined in GHC.Hs.Binds | |
Instances
| type XIPBinds GhcPs | |
Defined in GHC.Hs.Binds | |
| type XIPBinds GhcRn | |
Defined in GHC.Hs.Binds | |
| type XIPBinds GhcTc | |
Defined in GHC.Hs.Binds | |
type family XXPatSynBind x x' #
Instances
| type XXPatSynBind (GhcPass idL) (GhcPass idR) | |
Defined in GHC.Hs.Binds | |
Instances
type family XXHsBindsLR x x' #
Instances
| type XXHsBindsLR GhcPs pR | |
Defined in GHC.Hs.Binds | |
| type XXHsBindsLR GhcRn pR | |
Defined in GHC.Hs.Binds | |
| type XXHsBindsLR GhcTc pR | |
Defined in GHC.Hs.Binds | |
type family XPatSynBind x x' #
Instances
| type XPatSynBind (GhcPass pL) (GhcPass pR) | |
Defined in GHC.Hs.Binds | |
Instances
| type XVarBind (GhcPass pL) (GhcPass pR) | |
Defined in GHC.Hs.Binds | |
Instances
| type XFunBind (GhcPass pL) GhcPs | |
Defined in GHC.Hs.Binds | |
| type XFunBind (GhcPass pL) GhcRn | After the renamer (but before the type-checker), the FunBind extension field contains the locally-bound free variables of this defn. See Note [Bind free vars] |
Defined in GHC.Hs.Binds | |
| type XFunBind (GhcPass pL) GhcTc | After the type-checker, the FunBind extension field contains the ticks to put on the rhs, if any, and a coercion from the type of the MatchGroup to the type of the Id. Example: f :: Int -> forall a. a -> a
f x y = y
Then the MatchGroup will have type (Int -> a' -> a') (with a free type variable a'). The coercion will take a CoreExpr of this type and convert it to a CoreExpr of type Int -> forall a'. a' -> a' Notice that the coercion captures the free a'. |
Defined in GHC.Hs.Binds | |
type family XXValBindsLR x x' #
Instances
| type XXValBindsLR (GhcPass pL) pR | |
Defined in GHC.Hs.Binds | |
Instances
| type XValBinds (GhcPass pL) (GhcPass pR) | |
Defined in GHC.Hs.Binds | |
type family XXHsLocalBindsLR x x' #
Instances
| type XXHsLocalBindsLR (GhcPass pL) (GhcPass pR) | |
Defined in GHC.Hs.Binds | |
type family XEmptyLocalBinds x x' #
Instances
| type XEmptyLocalBinds (GhcPass pL) (GhcPass pR) | |
Defined in GHC.Hs.Binds | |
type family XHsIPBinds x x' #
Instances
| type XHsIPBinds (GhcPass pL) (GhcPass pR) | |
Defined in GHC.Hs.Binds | |
type family XHsValBinds x x' #
Instances
| type XHsValBinds (GhcPass pL) (GhcPass pR) | |
Defined in GHC.Hs.Binds | |
Maps the "normal" id type for a given pass
The trivial wrapper that carries no additional information See Note [XRec and SrcSpans in the AST]
We can map over the underlying type contained in an XRec while preserving
the annotation as is.
We can strip off the XRec to access the underlying data. See Note [XRec and SrcSpans in the AST]
type family Anno a = (b :: Type) #
Instances
type family XRec p a = (r :: Type) | r -> a #
GHC's L prefixed variants wrap their vanilla variant in this type family,
to add SrcLoc info via Located. Other passes than GhcPass not
interested in location information can define this as
type instance XRec NoLocated a = a.
See Note [XRec and SrcSpans in the AST]
Instances
| type XRec (GhcPass p) a | |
Defined in GHC.Hs.Extension | |
data DataConCantHappen #
Instances
newtype ModuleName #
A ModuleName is essentially a simple string, e.g. Data.List.
Constructors
| ModuleName FastString |
Instances
data IsBootInterface #
Indicates whether a module name is referring to a boot interface (hs-boot file) or regular module (hs file). We need to treat boot modules specially when building compilation graphs, since they break cycles. Regular source files and signature files are treated equivalently.
Instances
data LayoutInfo pass #
Layout information for declarations.
Constructors
| ExplicitBraces !(LHsToken "{" pass) !(LHsToken "}" pass) | Explicit braces written by the user. class C a where { foo :: a; bar :: a }
|
| VirtualBraces | Virtual braces inserted by the layout algorithm. class C a where foo :: a bar :: a |
Fields
| |
| NoLayoutInfo | Empty or compiler-generated blocks do not have layout information associated with them. |
Instances
| Typeable p => Data (LayoutInfo (GhcPass p)) | |
Defined in GHC.Hs.Extension Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LayoutInfo (GhcPass p) -> c (LayoutInfo (GhcPass p)) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (LayoutInfo (GhcPass p)) # toConstr :: LayoutInfo (GhcPass p) -> Constr # dataTypeOf :: LayoutInfo (GhcPass p) -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (LayoutInfo (GhcPass p))) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (LayoutInfo (GhcPass p))) # gmapT :: (forall b. Data b => b -> b) -> LayoutInfo (GhcPass p) -> LayoutInfo (GhcPass p) # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LayoutInfo (GhcPass p) -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LayoutInfo (GhcPass p) -> r # gmapQ :: (forall d. Data d => d -> u) -> LayoutInfo (GhcPass p) -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> LayoutInfo (GhcPass p) -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> LayoutInfo (GhcPass p) -> m (LayoutInfo (GhcPass p)) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LayoutInfo (GhcPass p) -> m (LayoutInfo (GhcPass p)) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LayoutInfo (GhcPass p) -> m (LayoutInfo (GhcPass p)) # | |
data HsUniToken (tok :: Symbol) (utok :: Symbol) #
With UnicodeSyntax, there might be multiple ways to write the same
token. For example an arrow could be either -> or →. This choice must be
recorded in order to exactprint such tokens, so instead of HsToken "->" we
introduce HsUniToken "->" "→".
See also IsUnicodeSyntax in GHC.Parser.Annotation; we do not use here to
avoid a dependency.
Constructors
| HsNormalTok | |
| HsUnicodeTok |
Instances
| (KnownSymbol tok, KnownSymbol utok) => Data (HsUniToken tok utok) | |
Defined in Language.Haskell.Syntax.Concrete Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsUniToken tok utok -> c (HsUniToken tok utok) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsUniToken tok utok) # toConstr :: HsUniToken tok utok -> Constr # dataTypeOf :: HsUniToken tok utok -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsUniToken tok utok)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsUniToken tok utok)) # gmapT :: (forall b. Data b => b -> b) -> HsUniToken tok utok -> HsUniToken tok utok # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsUniToken tok utok -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsUniToken tok utok -> r # gmapQ :: (forall d. Data d => d -> u) -> HsUniToken tok utok -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsUniToken tok utok -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsUniToken tok utok -> m (HsUniToken tok utok) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsUniToken tok utok -> m (HsUniToken tok utok) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsUniToken tok utok -> m (HsUniToken tok utok) # | |
| type Anno (HsUniToken tok utok) | |
Defined in GHC.Hs.Extension | |
data HsToken (tok :: Symbol) #
A token stored in the syntax tree. For example, when parsing a
let-expression, we store HsToken "let" and HsToken "in".
The locations of those tokens can be used to faithfully reproduce
(exactprint) the original program text.
Constructors
| HsTok |
Instances
| KnownSymbol tok => Data (HsToken tok) | |
Defined in Language.Haskell.Syntax.Concrete Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsToken tok -> c (HsToken tok) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsToken tok) # toConstr :: HsToken tok -> Constr # dataTypeOf :: HsToken tok -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsToken tok)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsToken tok)) # gmapT :: (forall b. Data b => b -> b) -> HsToken tok -> HsToken tok # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsToken tok -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsToken tok -> r # gmapQ :: (forall d. Data d => d -> u) -> HsToken tok -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsToken tok -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsToken tok -> m (HsToken tok) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsToken tok -> m (HsToken tok) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsToken tok -> m (HsToken tok) # | |
| type Anno (HsToken tok) | |
Defined in GHC.Hs.Extension | |
type LHsUniToken (tok :: Symbol) (utok :: Symbol) p = XRec p (HsUniToken tok utok) #
Arguments
| = XRec p (HsExpr p) | May have |
Located Haskell Expression
type family SyntaxExpr p #
Syntax Expression
SyntaxExpr is represents the function used in interpreting rebindable
syntax. In the parser, we have no information to supply; in the renamer,
we have the name of the function (but see
Note [Monad fail : Rebindable syntax, overloaded strings] for a wrinkle)
and in the type-checker we have a more elaborate structure SyntaxExprTc.
In some contexts, rebindable syntax is not implemented, and so we have constructors to represent that possibility in both the renamer and typechecker instantiations.
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
Instances
| type SyntaxExpr (GhcPass p) | |
Defined in GHC.Hs.Expr | |
Guarded Right-Hand Sides
GRHSs are used both for pattern bindings and for Matches
Constructors
| GRHSs | |
Fields
| |
| XGRHSs !(XXGRHSs p body) | |
data MatchGroup p body #
Constructors
| MG | |
| XMatchGroup !(XXMatchGroup p body) | |
Instances
| (HiePass p, AnnoBody p body, ToHie (LocatedA (body (GhcPass p)))) => ToHie (MatchGroup (GhcPass p) (LocatedA (body (GhcPass p)))) | |
Defined in GHC.Iface.Ext.Ast | |
data HsUntypedSplice id #
Haskell Splice
Constructors
| HsUntypedSpliceExpr (XUntypedSpliceExpr id) (LHsExpr id) | |
| HsQuasiQuote (XQuasiQuote id) (IdP id) (XRec id FastString) | |
| XUntypedSplice !(XXUntypedSplice id) |
Instances
| HiePass p => ToHie (LocatedA (HsUntypedSplice (GhcPass p))) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (HsUntypedSplice (GhcPass p)) | |
Defined in GHC.Hs.Expr | |
data PromotionFlag #
Is a TyCon a promoted data constructor or just a normal type constructor?
Constructors
| NotPromoted | |
| IsPromoted |
Instances
| Data PromotionFlag | |
Defined in Language.Haskell.Syntax.Type Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PromotionFlag -> c PromotionFlag # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PromotionFlag # toConstr :: PromotionFlag -> Constr # dataTypeOf :: PromotionFlag -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PromotionFlag) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PromotionFlag) # gmapT :: (forall b. Data b => b -> b) -> PromotionFlag -> PromotionFlag # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PromotionFlag -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PromotionFlag -> r # gmapQ :: (forall d. Data d => d -> u) -> PromotionFlag -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> PromotionFlag -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PromotionFlag -> m PromotionFlag # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PromotionFlag -> m PromotionFlag # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PromotionFlag -> m PromotionFlag # | |
| Eq PromotionFlag | |
Defined in Language.Haskell.Syntax.Type Methods (==) :: PromotionFlag -> PromotionFlag -> Bool # (/=) :: PromotionFlag -> PromotionFlag -> Bool # | |
type LIEWrappedName p = XRec p (IEWrappedName p) #
Located name with possible adornment
- AnnKeywordIds : AnnType,
AnnPattern
data IEWrappedName p #
A name in an import or export specification which may have
adornments. Used primarily for accurate pretty printing of
ParsedSource, and API Annotation placement. The
Annotation is the location of the adornment in
the original source.
Constructors
| IEName (XIEName p) (LIdP p) | no extra |
| IEPattern (XIEPattern p) (LIdP p) | pattern X |
| IEType (XIEType p) (LIdP p) | type (:+:) |
| XIEWrappedName !(XXIEWrappedName p) |
Instances
| ToHie (IEContext (LocatedA (IEWrappedName GhcRn))) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (IEWrappedName (GhcPass _1)) | |
Defined in GHC.Hs.ImpExp | |
data IEWildcard #
Wildcard in an import or export sublist, like the .. in
import Mod ( T(Mk1, Mk2, ..) ).
Constructors
| NoIEWildcard | no wildcard in this list |
| IEWildcard Int | wildcard after the given # of items in this list
The |
Instances
| Data IEWildcard | |
Defined in Language.Haskell.Syntax.ImpExp Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IEWildcard -> c IEWildcard # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IEWildcard # toConstr :: IEWildcard -> Constr # dataTypeOf :: IEWildcard -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c IEWildcard) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IEWildcard) # gmapT :: (forall b. Data b => b -> b) -> IEWildcard -> IEWildcard # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IEWildcard -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IEWildcard -> r # gmapQ :: (forall d. Data d => d -> u) -> IEWildcard -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> IEWildcard -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> IEWildcard -> m IEWildcard # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IEWildcard -> m IEWildcard # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IEWildcard -> m IEWildcard # | |
| Eq IEWildcard | |
Defined in Language.Haskell.Syntax.ImpExp | |
data ImportListInterpretation #
Whether the import list is exactly what to import, or whether hiding was
used, and therefore everything but what was listed should be imported
Constructors
| Exactly | |
| EverythingBut |
Instances
data ImportDecl pass #
Import Declaration
A single Haskell import declaration.
Constructors
| ImportDecl | |
Fields
| |
| XImportDecl !(XXImportDecl pass) | |
Instances
| NFData (ImportDecl GhcPs) Source # | |
Defined in Development.IDE.GHC.Orphans Methods rnf :: ImportDecl GhcPs -> () # | |
| ToHie (LocatedA (ImportDecl GhcRn)) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (ImportDecl (GhcPass p)) | |
Defined in GHC.Hs.ImpExp | |
data ImportDeclQualifiedStyle #
If/how an import is qualified.
Constructors
| QualifiedPre |
|
| QualifiedPost |
|
| NotQualified | Not qualified. |
Instances
type LImportDecl pass #
Arguments
| = XRec pass (ImportDecl pass) | When in a list this may have |
Located Import Declaration
data OverLitVal #
Overloaded Literal Value
Constructors
| HsIntegral !IntegralLit | Integer-looking literals; |
| HsFractional !FractionalLit | Frac-looking literals |
| HsIsString !SourceText !FastString | String-looking literals |
Instances
| Data OverLitVal | |
Defined in Language.Haskell.Syntax.Lit Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OverLitVal -> c OverLitVal # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OverLitVal # toConstr :: OverLitVal -> Constr # dataTypeOf :: OverLitVal -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OverLitVal) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OverLitVal) # gmapT :: (forall b. Data b => b -> b) -> OverLitVal -> OverLitVal # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OverLitVal -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OverLitVal -> r # gmapQ :: (forall d. Data d => d -> u) -> OverLitVal -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> OverLitVal -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> OverLitVal -> m OverLitVal # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OverLitVal -> m OverLitVal # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OverLitVal -> m OverLitVal # | |
| Eq OverLitVal | |
Defined in Language.Haskell.Syntax.Lit | |
| Ord OverLitVal | |
Defined in Language.Haskell.Syntax.Lit Methods compare :: OverLitVal -> OverLitVal -> Ordering # (<) :: OverLitVal -> OverLitVal -> Bool # (<=) :: OverLitVal -> OverLitVal -> Bool # (>) :: OverLitVal -> OverLitVal -> Bool # (>=) :: OverLitVal -> OverLitVal -> Bool # max :: OverLitVal -> OverLitVal -> OverLitVal # min :: OverLitVal -> OverLitVal -> OverLitVal # | |
Haskell Overloaded Literal
Instances
| Eq (XXOverLit p) => Eq (HsOverLit p) | |
| Ord (XXOverLit p) => Ord (HsOverLit p) | |
Defined in Language.Haskell.Syntax.Lit | |
| type Anno (HsOverLit (GhcPass p)) | |
Haskell Literal
Constructors
| HsChar (XHsChar x) Char | Character |
| HsCharPrim (XHsCharPrim x) Char | Unboxed character |
| HsString (XHsString x) FastString | String |
| HsStringPrim (XHsStringPrim x) !ByteString | Packed bytes |
| HsInt (XHsInt x) IntegralLit | Genuinely an Int; arises from GHC.Tc.Deriv.Generate, and from TRANSLATION |
| 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 Source Bang
Bangs on data constructor arguments as the user wrote them in the source code.
(HsSrcBang _ SrcUnpack SrcLazy) and
(HsSrcBang _ SrcUnpack NoSrcStrict) (without StrictData) makes no sense, we
emit a warning (in checkValidDataCon) and treat it like
(HsSrcBang _ NoSrcUnpack SrcLazy)
Constructors
| HsSrcBang SourceText SrcUnpackedness SrcStrictness |
Instances
| Data HsSrcBang | |
Defined in GHC.Core.DataCon Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsSrcBang -> c HsSrcBang # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsSrcBang # toConstr :: HsSrcBang -> Constr # dataTypeOf :: HsSrcBang -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsSrcBang) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsSrcBang) # gmapT :: (forall b. Data b => b -> b) -> HsSrcBang -> HsSrcBang # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsSrcBang -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsSrcBang -> r # gmapQ :: (forall d. Data d => d -> u) -> HsSrcBang -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsSrcBang -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsSrcBang -> m HsSrcBang # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSrcBang -> m HsSrcBang # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSrcBang -> m HsSrcBang # | |
| Outputable HsSrcBang | |
Defined in GHC.Core.DataCon | |
data AmbiguousFieldOcc pass #
Ambiguous Field Occurrence
Represents an *occurrence* of a field that is potentially
ambiguous after the renamer, with the ambiguity resolved by the
typechecker. We always store the RdrName that the user
originally wrote, and store the selector function after the renamer
(for unambiguous occurrences) or the typechecker (for ambiguous
occurrences).
See Note [HsRecField and HsRecUpdField] in GHC.Hs.Pat. See Note [Located RdrNames] in GHC.Hs.Expr.
Constructors
| Unambiguous (XUnambiguous pass) (XRec pass RdrName) | |
| Ambiguous (XAmbiguous pass) (XRec pass RdrName) | |
| XAmbiguousFieldOcc !(XXAmbiguousFieldOcc pass) |
Instances
| HiePass p => ToHie (RFContext (LocatedAn NoEpAnns (AmbiguousFieldOcc (GhcPass p)))) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (AmbiguousFieldOcc (GhcPass p)) | |
Defined in GHC.Hs.Type | |
type LAmbiguousFieldOcc pass = XRec pass (AmbiguousFieldOcc pass) #
Located Ambiguous Field Occurence
Field Occurrence
Represents an *occurrence* of a field. This may or may not be a
binding occurrence (e.g. this type is used in ConDeclField and
RecordPatSynField which bind their fields, but also in
HsRecField for record construction and patterns, which do not).
We store both the RdrName the user originally wrote, and after
the renamer we use the extension field to store the selector
function.
Constructors
| FieldOcc | |
Fields
| |
| XFieldOcc !(XXFieldOcc pass) | |
type LHsTypeArg p = HsArg (LHsType p) (LHsKind p) #
Arguments in an expression/type after splitting
data HsConDetails tyarg arg rec #
Describes the arguments to a data constructor. This is a common representation for several constructor-related concepts, including:
- The arguments in a Haskell98-style constructor declaration
(see
HsConDeclH98Detailsin GHC.Hs.Decls). - The arguments in constructor patterns in
case/function definitions (seeHsConPatDetailsin GHC.Hs.Pat). - The left-hand side arguments in a pattern synonym binding
(see
HsPatSynDetailsin GHC.Hs.Binds).
One notable exception is the arguments in a GADT constructor, which uses
a separate data type entirely (see HsConDeclGADTDetails in
GHC.Hs.Decls). This is because GADT constructors cannot be declared with
infix syntax, unlike the concepts above (#18844).
Instances
| (Data tyarg, Data rec, Data arg) => Data (HsConDetails tyarg arg rec) | |
Defined in Language.Haskell.Syntax.Type Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsConDetails tyarg arg rec -> c (HsConDetails tyarg arg rec) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsConDetails tyarg arg rec) # toConstr :: HsConDetails tyarg arg rec -> Constr # dataTypeOf :: HsConDetails tyarg arg rec -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsConDetails tyarg arg rec)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsConDetails tyarg arg rec)) # gmapT :: (forall b. Data b => b -> b) -> HsConDetails tyarg arg rec -> HsConDetails tyarg arg rec # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsConDetails tyarg arg rec -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsConDetails tyarg arg rec -> r # gmapQ :: (forall d. Data d => d -> u) -> HsConDetails tyarg arg rec -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsConDetails tyarg arg rec -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsConDetails tyarg arg rec -> m (HsConDetails tyarg arg rec) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDetails tyarg arg rec -> m (HsConDetails tyarg arg rec) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDetails tyarg arg rec -> m (HsConDetails tyarg arg rec) # | |
| (ToHie tyarg, ToHie arg, ToHie rec) => ToHie (HsConDetails tyarg arg rec) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: HsConDetails tyarg arg rec -> HieM [HieAST Type] | |
data ConDeclField pass #
Constructor Declaration Field
Constructors
| ConDeclField | |
Fields
| |
| XConDeclField !(XXConDeclField pass) | |
Instances
| ToHie (LocatedA (ConDeclField GhcRn)) | |
Defined in GHC.Iface.Ext.Ast | |
| ToHie (LocatedL [LocatedA (ConDeclField GhcRn)]) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (ConDeclField (GhcPass p)) | |
Defined in GHC.Hs.Type | |
| type Anno [LocatedA (ConDeclField (GhcPass _1))] | |
Defined in GHC.Hs.Decls | |
type LConDeclField pass #
Arguments
| = XRec pass (ConDeclField pass) | May have |
Located Constructor Declaration Field
data HsTupleSort #
Haskell Tuple Sort
Constructors
| HsUnboxedTuple | |
| HsBoxedOrConstraintTuple |
Instances
| Data HsTupleSort | |
Defined in Language.Haskell.Syntax.Type Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsTupleSort -> c HsTupleSort # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsTupleSort # toConstr :: HsTupleSort -> Constr # dataTypeOf :: HsTupleSort -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsTupleSort) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsTupleSort) # gmapT :: (forall b. Data b => b -> b) -> HsTupleSort -> HsTupleSort # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsTupleSort -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsTupleSort -> r # gmapQ :: (forall d. Data d => d -> u) -> HsTupleSort -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsTupleSort -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsTupleSort -> m HsTupleSort # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTupleSort -> m HsTupleSort # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsTupleSort -> m HsTupleSort # | |
This is used in the syntax. In constructor declaration. It must keep the arrow representation.
data HsLinearArrowTokens pass #
Constructors
| HsPct1 !(LHsToken "%1" pass) !(LHsUniToken "->" "\8594" pass) | |
| HsLolly !(LHsToken "\8888" pass) |
Denotes the type of arrows in the surface language
Constructors
| HsUnrestrictedArrow !(LHsUniToken "->" "\8594" pass) | a -> b or a → b |
| HsLinearArrow !(HsLinearArrowTokens pass) | a %1 -> b or a %1 → b, or a ⊸ b |
| HsExplicitMult !(LHsToken "%" pass) !(LHsType pass) !(LHsUniToken "->" "\8594" pass) | a %m -> b or a %m → b (very much including `a %Many -> b`!
This is how the programmer wrote it). It is stored as an
|
Haskell Type Literal
Haskell Type
Constructors
Instances
data HsTyVarBndr flag pass #
Haskell Type Variable Binder
The flag annotates the binder. It is Specificity in places where
explicit specificity is allowed (e.g. x :: forall {a} b. ...) or
() in other places.
Constructors
| UserTyVar (XUserTyVar pass) flag (LIdP pass) | |
| KindedTyVar (XKindedTyVar pass) flag (LIdP pass) (LHsKind pass) | |
| XTyVarBndr !(XXTyVarBndr pass) |
Instances
| Data flag => ToHie (TVScoped (LocatedA (HsTyVarBndr flag GhcRn))) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (HsTyVarBndr _flag (GhcPass _1)) | |
Defined in GHC.Hs.Type | |
| type Anno (HsTyVarBndr _flag GhcPs) | |
Defined in GHC.Hs.Type | |
| type Anno (HsTyVarBndr _flag GhcRn) | |
Defined in GHC.Hs.Type | |
| type Anno (HsTyVarBndr _flag GhcTc) | |
Defined in GHC.Hs.Type | |
These names are used early on to store the names of implicit parameters. They completely disappear after type-checking.
Constructors
| HsIPName FastString |
Instances
| Data HsIPName | |
Defined in Language.Haskell.Syntax.Type Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsIPName -> c HsIPName # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsIPName # toConstr :: HsIPName -> Constr # dataTypeOf :: HsIPName -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsIPName) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsIPName) # gmapT :: (forall b. Data b => b -> b) -> HsIPName -> HsIPName # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsIPName -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsIPName -> r # gmapQ :: (forall d. Data d => d -> u) -> HsIPName -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsIPName -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsIPName -> m HsIPName # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsIPName -> m HsIPName # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsIPName -> m HsIPName # | |
| Eq HsIPName | |
| ToHie (LocatedAn NoEpAnns HsIPName) | |
| type Anno HsIPName | |
Defined in GHC.Hs.Type | |
A type signature that obeys the forall-or-nothing rule. In other
words, an LHsType that uses an HsOuterSigTyVarBndrs to represent its
outermost type variable quantification.
See Note [Representing type signatures].
Constructors
| HsSig | |
| XHsSigType !(XXHsSigType pass) | |
Instances
| ToHie (TScoped (LocatedA (HsSigType GhcRn))) | |
| ToHie (TScoped (HsWildCardBndrs GhcRn (LocatedA (HsSigType GhcRn)))) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (HsSigType (GhcPass p)) | |
Defined in GHC.Hs.Type | |
type LHsSigWcType pass = HsWildCardBndrs pass (LHsSigType pass) #
Located Haskell Signature Wildcard Type
type LHsWcType pass = HsWildCardBndrs pass (LHsType pass) #
Located Haskell Wildcard Type
type LHsSigType pass = XRec pass (HsSigType pass) #
Located Haskell Signature Type
data HsPatSigType pass #
Types that can appear in pattern signatures, as well as the signatures for
term-level binders in RULES.
See Note [Pattern signature binders and scoping].
This is very similar to HsSigWcType, but with
slightly different semantics: see Note [HsType binders].
See also Note [The wildcard story for types].
Constructors
| HsPS | |
| XHsPatSigType !(XXHsPatSigType pass) | |
Instances
| ToHie (TScoped (HsPatSigType GhcRn)) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: TScoped (HsPatSigType GhcRn) -> HieM [HieAST Type] | |
data HsWildCardBndrs pass thing #
Haskell Wildcard Binders
Constructors
| HsWC | |
| XHsWildCardBndrs !(XXHsWildCardBndrs pass thing) | |
Instances
| ToHie (TScoped (HsWildCardBndrs GhcRn (LocatedA (HsSigType GhcRn)))) | |
Defined in GHC.Iface.Ext.Ast | |
| ToHie (TScoped (HsWildCardBndrs GhcRn (LocatedA (HsType GhcRn)))) | |
Defined in GHC.Iface.Ext.Ast | |
type HsOuterFamEqnTyVarBndrs = HsOuterTyVarBndrs () #
Used for type-family instance equations, e.g.,
type instance forall a. F [a] = Tree a
The notion of specificity is irrelevant in type family equations, so we use
() for the HsOuterTyVarBndrs flag.
type HsOuterSigTyVarBndrs = HsOuterTyVarBndrs Specificity #
Used for signatures, e.g.,
f :: forall a {b}. blah
We use Specificity for the HsOuterTyVarBndrs flag to allow
distinguishing between specified and inferred type variables.
data HsOuterTyVarBndrs flag pass #
The outermost type variables in a type that obeys the forall-or-nothing
rule. See Note [forall-or-nothing rule].
Constructors
| HsOuterImplicit | Implicit forall, e.g.,
|
Fields
| |
| HsOuterExplicit | Explicit forall, e.g.,
|
Fields
| |
| XHsOuterTyVarBndrs !(XXHsOuterTyVarBndrs pass) | |
Instances
| Data flag => ToHie (TVScoped (HsOuterTyVarBndrs flag GhcRn)) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: TVScoped (HsOuterTyVarBndrs flag GhcRn) -> HieM [HieAST Type] | |
| type Anno (HsOuterTyVarBndrs _1 (GhcPass _2)) | |
Defined in GHC.Hs.Type | |
data LHsQTyVars pass #
Located Haskell Quantified Type Variables
Constructors
| HsQTvs | |
Fields
| |
| XLHsQTyVars !(XXLHsQTyVars pass) | |
Instances
| ToHie (TScoped (LHsQTyVars GhcRn)) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: TScoped (LHsQTyVars GhcRn) -> HieM [HieAST Type] | |
type LHsTyVarBndr flag pass = XRec pass (HsTyVarBndr flag pass) #
Located Haskell Type Variable Binder
data HsForAllTelescope pass #
The type variable binders in an HsForAllTy.
See also Note [Variable Specificity and Forall Visibility] in
GHC.Tc.Gen.HsType.
Constructors
| HsForAllVis | A visible |
Fields
| |
| HsForAllInvis | An invisible |
Fields
| |
| XHsForAllTelescope !(XXHsForAllTelescope pass) | |
Arguments
| = XRec pass (HsType pass) | May have |
Located Haskell Type
type LHsContext pass #
Arguments
| = XRec pass (HsContext pass) |
|
Located Haskell Context
data HsFieldBind lhs rhs #
Haskell Field Binding
For details on above see Note [exact print annotations] in GHC.Parser.Annotation
Constructors
| HsFieldBind | |
Instances
| Foldable (HsFieldBind lhs) | |
Defined in Language.Haskell.Syntax.Pat Methods fold :: Monoid m => HsFieldBind lhs m -> m # foldMap :: Monoid m => (a -> m) -> HsFieldBind lhs a -> m # foldMap' :: Monoid m => (a -> m) -> HsFieldBind lhs a -> m # foldr :: (a -> b -> b) -> b -> HsFieldBind lhs a -> b # foldr' :: (a -> b -> b) -> b -> HsFieldBind lhs a -> b # foldl :: (b -> a -> b) -> b -> HsFieldBind lhs a -> b # foldl' :: (b -> a -> b) -> b -> HsFieldBind lhs a -> b # foldr1 :: (a -> a -> a) -> HsFieldBind lhs a -> a # foldl1 :: (a -> a -> a) -> HsFieldBind lhs a -> a # toList :: HsFieldBind lhs a -> [a] # null :: HsFieldBind lhs a -> Bool # length :: HsFieldBind lhs a -> Int # elem :: Eq a => a -> HsFieldBind lhs a -> Bool # maximum :: Ord a => HsFieldBind lhs a -> a # minimum :: Ord a => HsFieldBind lhs a -> a # sum :: Num a => HsFieldBind lhs a -> a # product :: Num a => HsFieldBind lhs a -> a # | |
| Traversable (HsFieldBind lhs) | |
Defined in Language.Haskell.Syntax.Pat Methods traverse :: Applicative f => (a -> f b) -> HsFieldBind lhs a -> f (HsFieldBind lhs b) # sequenceA :: Applicative f => HsFieldBind lhs (f a) -> f (HsFieldBind lhs a) # mapM :: Monad m => (a -> m b) -> HsFieldBind lhs a -> m (HsFieldBind lhs b) # sequence :: Monad m => HsFieldBind lhs (m a) -> m (HsFieldBind lhs a) # | |
| Functor (HsFieldBind lhs) | |
Defined in Language.Haskell.Syntax.Pat Methods fmap :: (a -> b) -> HsFieldBind lhs a -> HsFieldBind lhs b # (<$) :: a -> HsFieldBind lhs b -> HsFieldBind lhs a # | |
| (ToHie (RFContext label), ToHie arg, HasLoc arg, Data arg, Data label) => ToHie (RContext (LocatedA (HsFieldBind label arg))) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: RContext (LocatedA (HsFieldBind label arg)) -> HieM [HieAST Type] | |
| type Anno (HsFieldBind lhs rhs) | |
Defined in GHC.Hs.Pat | |
type HsRecUpdField p = HsFieldBind (LAmbiguousFieldOcc p) (LHsExpr p) #
Haskell Record Update Field
type HsRecField p arg = HsFieldBind (LFieldOcc p) arg #
Haskell Record Field
type LHsRecUpdField p = XRec p (HsRecUpdField p) #
Located Haskell Record Update Field
type LHsRecField p arg = XRec p (HsRecField p arg) #
Located Haskell Record Field
type LHsFieldBind p id arg = XRec p (HsFieldBind id arg) #
Located Haskell Record Field
newtype RecFieldsDotDot #
Newtype to be able to have a specific XRec instance for the Int in rec_dotdot
Constructors
| RecFieldsDotDot | |
Fields | |
Instances
data HsRecFields p arg #
Haskell Record Fields
HsRecFields is used only for patterns and expressions (not data type declarations)
Constructors
| HsRecFields | |
Fields
| |
Instances
| (ToHie arg, HasLoc arg, Data arg, HiePass p) => ToHie (RContext (HsRecFields (GhcPass p) arg)) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: RContext (HsRecFields (GhcPass p) arg) -> HieM [HieAST Type] | |
type HsConPatDetails p = HsConDetails (HsConPatTyArg (NoGhcTc p)) (LPat p) (HsRecFields p (LPat p)) #
Haskell Constructor Pattern Details
data HsConPatTyArg p #
Type argument in a data constructor pattern,
e.g. the @a in f (Just @a x) = ....
Constructors
| HsConPatTyArg !(LHsToken "@" p) (HsPatSigType p) |
data HsPatSynDir id #
Haskell Pattern Synonym Direction
Constructors
| Unidirectional | |
| ImplicitBidirectional | |
| ExplicitBidirectional (MatchGroup id (LHsExpr id)) |
Instances
| HiePass p => ToHie (HsPatSynDir (GhcPass p)) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: HsPatSynDir (GhcPass p) -> HieM [HieAST Type] | |
data RecordPatSynField pass #
Record Pattern Synonym Field
Constructors
| RecordPatSynField | |
Fields
| |
Instances
| HiePass p => ToHie (PatSynFieldContext (RecordPatSynField (GhcPass p))) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: PatSynFieldContext (RecordPatSynField (GhcPass p)) -> HieM [HieAST Type] | |
type HsPatSynDetails pass = HsConDetails Void (LIdP pass) [RecordPatSynField pass] #
Haskell Pattern Synonym Details
Fixity Signature
Constructors
| FixitySig (XFixitySig pass) [LIdP pass] Fixity | |
| XFixitySig !(XXFixitySig pass) |
type LFixitySig pass = XRec pass (FixitySig pass) #
Located Fixity Signature
Signatures and pragmas
Constructors
| TypeSig (XTypeSig pass) [LIdP pass] (LHsSigWcType pass) | An ordinary type signature f :: Num a => a -> a After renaming, this list of Names contains the named
wildcards brought into scope by this signature. For a signature
|
| PatSynSig (XPatSynSig pass) [LIdP pass] (LHsSigType pass) | A pattern synonym type signature pattern Single :: () => (Show a) => a -> [a] |
| ClassOpSig (XClassOpSig pass) Bool [LIdP pass] (LHsSigType pass) | A signature for a class method False: ordinary class-method signature True: generic-default class method signature e.g. class C a where op :: a -> a -- Ordinary default op :: Eq a => a -> a -- Generic default No wildcards allowed here |
| FixSig (XFixSig pass) (FixitySig pass) | An ordinary fixity declaration infixl 8 *** |
| InlineSig (XInlineSig pass) (LIdP pass) InlinePragma | An inline pragma {#- INLINE f #-} |
| SpecSig (XSpecSig pass) (LIdP pass) [LHsSigType pass] InlinePragma | A specialisation pragma {-# SPECIALISE f :: Int -> Int #-} |
| SpecInstSig (XSpecInstSig pass) (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) (LBooleanFormula (LIdP pass)) | A minimal complete definition pragma {-# MINIMAL a | (b, c | (d | e)) #-} |
| SCCFunSig (XSCCFunSig pass) (LIdP pass) (Maybe (XRec pass StringLiteral)) | A "set cost centre" pragma for declarations {-# SCC funName #-}or {-# SCC funName "cost_centre_name" #-} |
| CompleteMatchSig (XCompleteMatchSig pass) (XRec pass [LIdP pass]) (Maybe (LIdP 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) |
Implicit parameter bindings.
type LIPBind id = XRec id (IPBind id) #
Located Implicit Parameter Binding
May have AnnKeywordId : AnnSemi when in a
list
Haskell Implicit Parameter Bindings
Constructors
| IPBinds (XIPBinds id) [LIPBind id] | |
| XHsIPBinds !(XXHsIPBinds id) |
data PatSynBind idL idR #
AnnKeywordId:AnnPattern,AnnEqual,AnnLarrow,AnnWhere,AnnOpen'{',AnnClose'}',
Pattern Synonym binding
Constructors
| PSB | |
Fields
| |
| XPatSynBind !(XXPatSynBind idL idR) | |
Instances
| HiePass p => ToHie (Located (PatSynBind (GhcPass p) (GhcPass p))) | |
Defined in GHC.Iface.Ext.Ast | |
Haskell Binding with separate Left and Right id's
Constructors
| 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 |
Fields
| |
| 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 |
| PatSynBind | Patterns Synonym Binding |
Fields
| |
| XHsBindsLR !(XXHsBindsLR idL idR) | |
type LHsBindLR idL idR = XRec idL (HsBindLR idL idR) #
Located Haskell Binding with separate Left and Right identifier types
type LHsBindsLR idL idR = Bag (LHsBindLR idL idR) #
Located Haskell Bindings with separate Left and Right identifier types
type LHsBinds id = LHsBindsLR id id #
Located Haskell Bindings
data HsValBindsLR idL idR #
Haskell Value bindings with separate Left and Right identifier types (not implicit parameters) Used for both top level and nested bindings May contain pattern synonym bindings
Constructors
| ValBinds (XValBinds idL idR) (LHsBindsLR idL idR) [LSig idR] | Value Bindings In Before renaming RHS; idR is always RdrName Not dependency analysed Recursive by default |
| XValBindsLR !(XXValBindsLR idL idR) | Value Bindings Out After renaming RHS; idR can be Name or Id Dependency analysed, later bindings in the list may depend on earlier ones. |
Instances
| HiePass p => ToHie (RScoped (HsValBindsLR (GhcPass p) (GhcPass p))) | |
Defined in GHC.Iface.Ext.Ast | |
type HsValBinds id = HsValBindsLR id id #
Haskell Value Bindings
type LHsLocalBindsLR idL idR = XRec idL (HsLocalBindsLR idL idR) #
data HsLocalBindsLR idL idR #
Haskell Local Bindings with separate Left and Right identifier types
Bindings in a 'let' expression or a 'where' clause
Constructors
| HsValBinds (XHsValBinds idL idR) (HsValBindsLR idL idR) | Haskell Value Bindings |
| HsIPBinds (XHsIPBinds idL idR) (HsIPBinds idR) | Haskell Implicit Parameter Bindings |
| EmptyLocalBinds (XEmptyLocalBinds idL idR) | Empty Local Bindings |
| XHsLocalBindsLR !(XXHsLocalBindsLR idL idR) |
Instances
| HiePass p => ToHie (RScoped (HsLocalBinds (GhcPass p))) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: RScoped (HsLocalBinds (GhcPass p)) -> HieM [HieAST Type] | |
type LHsLocalBinds id = XRec id (HsLocalBinds id) #
Located Haskell local bindings
type HsLocalBinds id = HsLocalBindsLR id id #
Haskell Local Bindings
data RoleAnnotDecl pass #
Role Annotation Declaration
Constructors
| RoleAnnotDecl (XCRoleAnnotDecl pass) (LIdP pass) [XRec pass (Maybe Role)] | |
| XRoleAnnotDecl !(XXRoleAnnotDecl pass) |
Instances
| ToHie (LocatedA (RoleAnnotDecl GhcRn)) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (RoleAnnotDecl (GhcPass p)) | |
Defined in GHC.Hs.Decls | |
type LRoleAnnotDecl pass = XRec pass (RoleAnnotDecl pass) #
Located Role Annotation Declaration
data AnnProvenance pass #
Annotation Provenance
Constructors
| ValueAnnProvenance (LIdP pass) | |
| TypeAnnProvenance (LIdP pass) | |
| ModuleAnnProvenance |
Instances
| ToHie (AnnProvenance GhcRn) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: AnnProvenance GhcRn -> HieM [HieAST Type] | |
Warning pragma Declaration
Constructors
| Warning (XWarning pass) [LIdP pass] (WarningTxt pass) | |
| XWarnDecl !(XXWarnDecl pass) |
Warning pragma Declarations
Constructors
| Warnings | |
Fields
| |
| XWarnDecls !(XXWarnDecls pass) | |
type LWarnDecls pass = XRec pass (WarnDecls pass) #
Located Warning Declarations
Documentation comment Declaration
Constructors
| DocCommentNext (LHsDoc pass) | |
| DocCommentPrev (LHsDoc pass) | |
| DocCommentNamed String (LHsDoc pass) | |
| DocGroup Int (LHsDoc pass) |
Instances
| (Data pass, Data (IdP pass)) => Data (DocDecl pass) | |
Defined in Language.Haskell.Syntax.Decls Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DocDecl pass -> c (DocDecl pass) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DocDecl pass) # toConstr :: DocDecl pass -> Constr # dataTypeOf :: DocDecl pass -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DocDecl pass)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DocDecl pass)) # gmapT :: (forall b. Data b => b -> b) -> DocDecl pass -> DocDecl pass # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DocDecl pass -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DocDecl pass -> r # gmapQ :: (forall d. Data d => d -> u) -> DocDecl pass -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DocDecl pass -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DocDecl pass -> m (DocDecl pass) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DocDecl pass -> m (DocDecl pass) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DocDecl pass -> m (DocDecl pass) # | |
| ToHie (LocatedA (DocDecl GhcRn)) | |
| type Anno (DocDecl (GhcPass p)) | |
Defined in GHC.Hs.Decls | |
Rule Declaration
Constructors
| HsRule | |
Fields
| |
| XRuleDecl !(XXRuleDecl pass) | |
Rule Declarations
Constructors
| HsRules | |
Fields
| |
| XRuleDecls !(XXRuleDecls pass) | |
type LRuleDecls pass = XRec pass (RuleDecls pass) #
Located Rule Declarations
data ForeignExport pass #
Constructors
| CExport (XCExport pass) (XRec pass CExportSpec) | |
| XForeignExport !(XXForeignExport pass) |
Instances
| ToHie (ForeignExport GhcRn) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: ForeignExport GhcRn -> HieM [HieAST Type] | |
data CImportSpec #
Constructors
| CLabel CLabelString | |
| CFunction CCallTarget | |
| CWrapper |
Instances
| Data CImportSpec | |
Defined in Language.Haskell.Syntax.Decls Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CImportSpec -> c CImportSpec # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CImportSpec # toConstr :: CImportSpec -> Constr # dataTypeOf :: CImportSpec -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c CImportSpec) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CImportSpec) # gmapT :: (forall b. Data b => b -> b) -> CImportSpec -> CImportSpec # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CImportSpec -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CImportSpec -> r # gmapQ :: (forall d. Data d => d -> u) -> CImportSpec -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CImportSpec -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CImportSpec -> m CImportSpec # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CImportSpec -> m CImportSpec # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CImportSpec -> m CImportSpec # | |
data ForeignImport pass #
Constructors
| CImport (XCImport pass) (XRec pass CCallConv) (XRec pass Safety) (Maybe Header) CImportSpec | |
| XForeignImport !(XXForeignImport pass) |
Instances
| ToHie (ForeignImport GhcRn) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: ForeignImport GhcRn -> HieM [HieAST Type] | |
data ForeignDecl pass #
Foreign Declaration
Constructors
| ForeignImport | |
Fields
| |
| ForeignExport | |
Fields
| |
| XForeignDecl !(XXForeignDecl pass) | |
Instances
| ToHie (LocatedA (ForeignDecl GhcRn)) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (ForeignDecl (GhcPass p)) | |
Defined in GHC.Hs.Decls | |
type LForeignDecl pass = XRec pass (ForeignDecl pass) #
Located Foreign Declaration
data DefaultDecl pass #
Default Declaration
Constructors
| DefaultDecl (XCDefaultDecl pass) [LHsType pass] | |
| XDefaultDecl !(XXDefaultDecl pass) |
Instances
| ToHie (LocatedA (DefaultDecl GhcRn)) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (DefaultDecl (GhcPass p)) | |
Defined in GHC.Hs.Decls | |
type LDefaultDecl pass = XRec pass (DefaultDecl pass) #
Located Default Declaration
type LDerivStrategy pass = XRec pass (DerivStrategy pass) #
A Located DerivStrategy.
Stand-alone 'deriving instance' declaration
Constructors
| DerivDecl | |
Fields
| |
| XDerivDecl !(XXDerivDecl pass) | |
type LDerivDecl pass = XRec pass (DerivDecl pass) #
Located stand-alone 'deriving instance' declaration
Instance Declaration
Constructors
| ClsInstD | |
Fields
| |
| DataFamInstD | |
Fields
| |
| TyFamInstD | |
Fields
| |
| XInstDecl !(XXInstDecl pass) | |
data ClsInstDecl pass #
Class Instance Declaration
- AnnKeywordId : AnnInstance,
AnnWhere,
AnnOpen,AnnClose,
For details on above see Note [exact print annotations] in GHC.Parser.Annotation
Constructors
| ClsInstDecl | |
Fields
| |
| XClsInstDecl !(XXClsInstDecl pass) | |
Instances
| ToHie (LocatedA (ClsInstDecl GhcRn)) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (ClsInstDecl (GhcPass p)) | |
Defined in GHC.Hs.Decls | |
type LClsInstDecl pass = XRec pass (ClsInstDecl pass) #
Located Class Instance Declaration
Family Equation
One equation in a type family instance declaration, data family instance declaration, or type family default. See Note [Type family instance declarations in HsSyn] See Note [Family instance declaration binders]
Constructors
| FamEqn | |
Fields
| |
| XFamEqn !(XXFamEqn pass rhs) | |
Instances
| ToHie (TScoped (FamEqn GhcRn (LocatedA (HsType GhcRn)))) | |
| ToHie (TScoped (FamEqn GhcRn (HsDataDefn GhcRn))) | |
Defined in GHC.Iface.Ext.Ast | |
| (HasLoc a, HiePass p) => HasLoc (FamEqn (GhcPass p) a) | |
Defined in GHC.Iface.Ext.Ast | |
| (ToHie rhs, HasLoc rhs) => ToHie (FamEqn GhcRn rhs) | |
| type Anno (FamEqn (GhcPass p) _1) | |
Defined in GHC.Hs.Decls | |
| type Anno (FamEqn (GhcPass p) _1) | |
Defined in GHC.Hs.Decls | |
| type Anno (FamEqn p (LocatedA (HsType p))) | |
Defined in GHC.Hs.Decls | |
newtype DataFamInstDecl pass #
Data Family Instance Declaration
Constructors
| DataFamInstDecl | |
Fields
| |
Instances
| ToHie (LocatedA (DataFamInstDecl GhcRn)) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (DataFamInstDecl (GhcPass p)) | |
Defined in GHC.Hs.Decls | |
type LDataFamInstDecl pass = XRec pass (DataFamInstDecl pass) #
Located Data Family Instance Declaration
data TyFamInstDecl pass #
Type Family Instance Declaration
Constructors
| TyFamInstDecl | |
Fields
| |
| XTyFamInstDecl !(XXTyFamInstDecl pass) | |
Instances
| ToHie (LocatedA (TyFamInstDecl GhcRn)) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (TyFamInstDecl (GhcPass p)) | |
Defined in GHC.Hs.Decls | |
type LTyFamInstDecl pass = XRec pass (TyFamInstDecl pass) #
Located Type Family Instance Declaration
type LTyFamDefltDecl pass = XRec pass (TyFamDefltDecl pass) #
Located type family default declarations.
type TyFamDefltDecl = TyFamInstDecl #
Type family default declarations.
A convenient synonym for TyFamInstDecl.
See Note [Type family instance declarations in HsSyn].
type TyFamInstEqn pass = FamEqn pass (LHsType pass) #
Type Family Instance Equation
type HsTyPats pass = [LHsTypeArg pass] #
Haskell Type Patterns
type LTyFamInstEqn pass #
Arguments
| = XRec pass (TyFamInstEqn pass) | May have |
Located Type Family Instance Equation
data HsConDeclGADTDetails pass #
The arguments in a GADT constructor. Unlike Haskell98-style constructors,
GADT constructors cannot be declared with infix syntax. As a result, we do
not use HsConDetails here, as InfixCon would be an unrepresentable
state. (There is a notion of infix GADT constructors for the purposes of
derived Show instances—see Note [Infix GADT constructors] in
GHC.Tc.TyCl—but that is an orthogonal concern.)
Constructors
| PrefixConGADT [HsScaled pass (LBangType pass)] | |
| RecConGADT (XRec pass [LConDeclField pass]) (LHsUniToken "->" "\8594" pass) |
Instances
| ToHie (HsConDeclGADTDetails GhcRn) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: HsConDeclGADTDetails GhcRn -> HieM [HieAST Type] | |
type HsConDeclH98Details pass = HsConDetails Void (HsScaled pass (LBangType pass)) (XRec pass [LConDeclField pass]) #
The arguments in a Haskell98-style data constructor.
data T b = forall a. Eq a => MkT a b
MkT :: forall b a. Eq a => MkT a b
data T b where
MkT1 :: Int -> T Int
data T = Int MkT Int
| MkT2
data T a where
Int MkT Int :: T Int
AnnKeywordIds :AnnOpen,AnnDotdot,AnnCLose,AnnEqual,AnnVbar,AnnDarrow,AnnDarrow,AnnForall,AnnDot
data Constructor Declaration
Constructors
| ConDeclGADT | |
Fields
| |
| ConDeclH98 | |
Fields
| |
| XConDecl !(XXConDecl pass) | |
Arguments
| = XRec pass (ConDecl pass) | May have |
Located data Constructor Declaration
data DataDefnCons a #
Whether a data-type declaration is data or newtype, and its constructors.
Constructors
| NewTypeCon a | |
| DataTypeCons Bool [a] |
Instances
| Foldable DataDefnCons | |
Defined in Language.Haskell.Syntax.Decls Methods fold :: Monoid m => DataDefnCons m -> m # foldMap :: Monoid m => (a -> m) -> DataDefnCons a -> m # foldMap' :: Monoid m => (a -> m) -> DataDefnCons a -> m # foldr :: (a -> b -> b) -> b -> DataDefnCons a -> b # foldr' :: (a -> b -> b) -> b -> DataDefnCons a -> b # foldl :: (b -> a -> b) -> b -> DataDefnCons a -> b # foldl' :: (b -> a -> b) -> b -> DataDefnCons a -> b # foldr1 :: (a -> a -> a) -> DataDefnCons a -> a # foldl1 :: (a -> a -> a) -> DataDefnCons a -> a # toList :: DataDefnCons a -> [a] # null :: DataDefnCons a -> Bool # length :: DataDefnCons a -> Int # elem :: Eq a => a -> DataDefnCons a -> Bool # maximum :: Ord a => DataDefnCons a -> a # minimum :: Ord a => DataDefnCons a -> a # sum :: Num a => DataDefnCons a -> a # product :: Num a => DataDefnCons a -> a # | |
| Traversable DataDefnCons | |
Defined in Language.Haskell.Syntax.Decls Methods traverse :: Applicative f => (a -> f b) -> DataDefnCons a -> f (DataDefnCons b) # sequenceA :: Applicative f => DataDefnCons (f a) -> f (DataDefnCons a) # mapM :: Monad m => (a -> m b) -> DataDefnCons a -> m (DataDefnCons b) # sequence :: Monad m => DataDefnCons (m a) -> m (DataDefnCons a) # | |
| Functor DataDefnCons | |
Defined in Language.Haskell.Syntax.Decls Methods fmap :: (a -> b) -> DataDefnCons a -> DataDefnCons b # (<$) :: a -> DataDefnCons b -> DataDefnCons a # | |
| Data a => Data (DataDefnCons a) | |
Defined in Language.Haskell.Syntax.Decls Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DataDefnCons a -> c (DataDefnCons a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DataDefnCons a) # toConstr :: DataDefnCons a -> Constr # dataTypeOf :: DataDefnCons a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DataDefnCons a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DataDefnCons a)) # gmapT :: (forall b. Data b => b -> b) -> DataDefnCons a -> DataDefnCons a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DataDefnCons a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DataDefnCons a -> r # gmapQ :: (forall d. Data d => d -> u) -> DataDefnCons a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DataDefnCons a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DataDefnCons a -> m (DataDefnCons a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DataDefnCons a -> m (DataDefnCons a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DataDefnCons a -> m (DataDefnCons a) # | |
| HasLoc a => HasLoc (DataDefnCons a) | |
Defined in GHC.Iface.Ext.Ast Methods loc :: DataDefnCons a -> SrcSpan | |
| ToHie a => ToHie (DataDefnCons a) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: DataDefnCons a -> HieM [HieAST Type] | |
| Eq a => Eq (DataDefnCons a) | |
Defined in Language.Haskell.Syntax.Decls Methods (==) :: DataDefnCons a -> DataDefnCons a -> Bool # (/=) :: DataDefnCons a -> DataDefnCons a -> Bool # | |
When we only care whether a data-type declaration is `data` or `newtype`, but not what constructors it has
Instances
| Data NewOrData | |
Defined in Language.Haskell.Syntax.Decls Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NewOrData -> c NewOrData # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NewOrData # toConstr :: NewOrData -> Constr # dataTypeOf :: NewOrData -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NewOrData) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NewOrData) # gmapT :: (forall b. Data b => b -> b) -> NewOrData -> NewOrData # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NewOrData -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NewOrData -> r # gmapQ :: (forall d. Data d => d -> u) -> NewOrData -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NewOrData -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NewOrData -> m NewOrData # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NewOrData -> m NewOrData # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NewOrData -> m NewOrData # | |
| Eq NewOrData | |
data StandaloneKindSig pass #
Constructors
| StandaloneKindSig (XStandaloneKindSig pass) (LIdP pass) (LHsSigType pass) | |
| XStandaloneKindSig !(XXStandaloneKindSig pass) |
Instances
| ToHie (LocatedA (StandaloneKindSig GhcRn)) | |
Defined in GHC.Iface.Ext.Ast | |
| ToHie (StandaloneKindSig GhcRn) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: StandaloneKindSig GhcRn -> HieM [HieAST Type] | |
| type Anno (StandaloneKindSig (GhcPass p)) | |
Defined in GHC.Hs.Decls | |
type LStandaloneKindSig pass = XRec pass (StandaloneKindSig pass) #
Located Standalone Kind Signature
data DerivClauseTys pass #
The types mentioned in a single deriving clause. This can come in two
forms, DctSingle or DctMulti, depending on whether the types are
surrounded by enclosing parentheses or not. These parentheses are
semantically different than HsParTy. For example, deriving () means
"derive zero classes" rather than "derive an instance of the 0-tuple".
DerivClauseTys use LHsSigType because deriving clauses can mention
type variables that aren't bound by the datatype, e.g.
data T b = ... deriving (C [a])
should produce a derived instance for C [a] (T b).
Constructors
| DctSingle (XDctSingle pass) (LHsSigType pass) | A Example: |
| DctMulti (XDctMulti pass) [LHsSigType pass] | A Example: |
| XDerivClauseTys !(XXDerivClauseTys pass) |
Instances
| ToHie (LocatedC (DerivClauseTys GhcRn)) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (DerivClauseTys (GhcPass _1)) | |
Defined in GHC.Hs.Decls | |
type LDerivClauseTys pass = XRec pass (DerivClauseTys pass) #
data HsDerivingClause pass #
A single deriving clause of a data declaration.
Constructors
| HsDerivingClause | |
Fields
| |
| XHsDerivingClause !(XXHsDerivingClause pass) | |
Instances
| ToHie (Located [LocatedAn NoEpAnns (HsDerivingClause GhcRn)]) | |
Defined in GHC.Iface.Ext.Ast | |
| ToHie (LocatedAn NoEpAnns (HsDerivingClause GhcRn)) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (HsDerivingClause (GhcPass p)) | |
Defined in GHC.Hs.Decls | |
type LHsDerivingClause pass = XRec pass (HsDerivingClause pass) #
type HsDeriving pass #
Arguments
| = [LHsDerivingClause pass] | The optional The list of |
Haskell Deriving clause
data HsDataDefn pass #
Haskell Data type Definition
Constructors
| HsDataDefn | Declares a data type or newtype, giving its constructors
|
Fields
| |
| XHsDataDefn !(XXHsDataDefn pass) | |
Instances
| HasLoc (HsDataDefn GhcRn) | |
Defined in GHC.Iface.Ext.Ast Methods loc :: HsDataDefn GhcRn -> SrcSpan | |
| ToHie (TScoped (FamEqn GhcRn (HsDataDefn GhcRn))) | |
Defined in GHC.Iface.Ext.Ast | |
| ToHie (HsDataDefn GhcRn) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: HsDataDefn GhcRn -> HieM [HieAST Type] | |
data FamilyInfo pass #
Constructors
| DataFamily | |
| OpenTypeFamily | |
| ClosedTypeFamily (Maybe [LTyFamInstEqn pass]) |
|
Instances
| ToHie (FamilyInfo GhcRn) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: FamilyInfo GhcRn -> HieM [HieAST Type] | |
type LInjectivityAnn pass = XRec pass (InjectivityAnn pass) #
Located Injectivity Annotation
data FamilyDecl pass #
type Family Declaration
Constructors
| FamilyDecl | |
Fields
| |
| XFamilyDecl !(XXFamilyDecl pass) | |
Instances
| ToHie (LocatedA (FamilyDecl GhcRn)) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (FamilyDecl (GhcPass p)) | |
Defined in GHC.Hs.Decls | |
type LFamilyDecl pass = XRec pass (FamilyDecl pass) #
Located type Family Declaration
data FamilyResultSig pass #
type Family Result Signature
Constructors
| NoSig (XNoSig pass) | |
| KindSig (XCKindSig pass) (LHsKind pass) | |
| TyVarSig (XTyVarSig pass) (LHsTyVarBndr () pass) | |
| XFamilyResultSig !(XXFamilyResultSig pass) |
Instances
| ToHie (RScoped (LocatedAn NoEpAnns (FamilyResultSig GhcRn))) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (FamilyResultSig (GhcPass p)) | |
Defined in GHC.Hs.Decls | |
type LFamilyResultSig pass = XRec pass (FamilyResultSig pass) #
Located type Family Result Signature
Type or Class Group
Constructors
| TyClGroup | |
Fields
| |
| XTyClGroup !(XXTyClGroup pass) | |
A type or class declaration.
Constructors
| FamDecl | type/data family T :: *->* |
Fields
| |
| SynDecl |
|
Fields
| |
| DataDecl |
|
Fields
| |
| ClassDecl | |
Fields
| |
| XTyClDecl !(XXTyClDecl pass) | |
data SpliceDecoration #
A splice can appear with various decorations wrapped around it. This data type captures explicitly how it was originally written, for use in the pretty printer.
Constructors
| DollarSplice | $splice |
| BareSplice | bare splice |
Instances
data SpliceDecl p #
Splice Declaration
Constructors
| SpliceDecl (XSpliceDecl p) (XRec p (HsUntypedSplice p)) SpliceDecoration | |
| XSpliceDecl !(XXSpliceDecl p) |
Instances
| ToHie (LocatedA (SpliceDecl GhcRn)) | |
Defined in GHC.Iface.Ext.Ast | |
| type Anno (SpliceDecl (GhcPass p)) | |
Defined in GHC.Hs.Decls | |
type LSpliceDecl pass = XRec pass (SpliceDecl pass) #
Located Splice Declaration
Constructors
| HsGroup | |
Fields
| |
| XHsGroup !(XXHsGroup p) | |
A Haskell Declaration
Constructors
| TyClD (XTyClD p) (TyClDecl p) | Type or Class Declaration |
| InstD (XInstD p) (InstDecl p) | Instance declaration |
| DerivD (XDerivD p) (DerivDecl p) | Deriving declaration |
| ValD (XValD p) (HsBind p) | Value declaration |
| SigD (XSigD p) (Sig p) | Signature declaration |
| KindSigD (XKindSigD p) (StandaloneKindSig p) | Standalone kind signature |
| DefD (XDefD p) (DefaultDecl p) | 'default' declaration |
| ForD (XForD p) (ForeignDecl p) | Foreign declaration |
| WarningD (XWarningD p) (WarnDecls p) | Warning declaration |
| AnnD (XAnnD p) (AnnDecl p) | Annotation declaration |
| RuleD (XRuleD p) (RuleDecls p) | Rule declaration |
| SpliceD (XSpliceD p) (SpliceDecl p) | Splice declaration (Includes quasi-quotes) |
| DocD (XDocD p) (DocDecl p) | Documentation comment declaration |
| RoleAnnotD (XRoleAnnotD p) (RoleAnnotDecl p) | Role annotation declaration |
| XHsDecl !(XXHsDecl p) |
Instances
| type Anno (HsDecl (GhcPass _1)) | |
Defined in GHC.Hs.Decls | |
data HsDoFlavour #
Constructors
| DoExpr (Maybe ModuleName) |
|
| MDoExpr (Maybe ModuleName) |
|
| GhciStmtCtxt | A command-line Stmt in GHCi pat <- rhs |
| ListComp | |
| MonadComp |
data HsArrowMatchContext #
Haskell arrow match context.
Constructors
| ProcExpr | A proc expression |
| ArrowCaseAlt | A case alternative inside arrow notation |
| ArrowLamCaseAlt LamCaseVariant | A case or cases alternative inside arrow notation |
| KappaExpr | An arrow kappa abstraction |
data HsStmtContext p #
Haskell Statement Context.
Constructors
| HsDoStmt HsDoFlavour | Context for HsDo (do-notation and comprehensions) |
| PatGuard (HsMatchContext p) | Pattern guard for specified thing |
| ParStmtCtxt (HsStmtContext p) | A branch of a parallel stmt |
| TransStmtCtxt (HsStmtContext p) | A branch of a transform stmt |
| ArrowExpr | do-notation in an arrow-command context |
Instances
| HiePass p => ToHie (HsStmtContext (GhcPass p)) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: HsStmtContext (GhcPass p) -> HieM [HieAST Type] | |
data HsMatchContext p #
Haskell Match Context
Context of a pattern match. This is more subtle than it would seem. See Note [FunBind vs PatBind].
Constructors
| FunRhs | A pattern matching on an argument of a function binding |
Fields
| |
| LambdaExpr | Patterns of a lambda |
| CaseAlt | Patterns and guards in a case alternative |
| LamCaseAlt LamCaseVariant | Patterns and guards in |
| IfAlt | Guards of a multi-way if alternative |
| ArrowMatchCtxt HsArrowMatchContext | A pattern match inside arrow notation |
| 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 GHC.HsToCore.Expr to tell matchWrapper what sort of runtime error message to generate] |
| StmtCtxt (HsStmtContext p) | 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
| HiePass p => ToHie (HsMatchContext (GhcPass p)) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: HsMatchContext (GhcPass p) -> HieM [HieAST Type] | |
data ArithSeqInfo id #
Arithmetic Sequence Information
Constructors
| From (LHsExpr id) | |
| FromThen (LHsExpr id) (LHsExpr id) | |
| FromTo (LHsExpr id) (LHsExpr id) | |
| FromThenTo (LHsExpr id) (LHsExpr id) (LHsExpr id) |
Instances
| ToHie (LHsExpr a) => ToHie (ArithSeqInfo a) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: ArithSeqInfo a -> HieM [HieAST Type] | |
Haskell (Untyped) Quote = Expr + Pat + Type + Var
data ApplicativeArg idL #
Applicative Argument
Constructors
| ApplicativeArgOne | |
Fields
| |
| ApplicativeArgMany | |
Fields
| |
| XApplicativeArg !(XXApplicativeArg idL) | |
Instances
| HiePass p => ToHie (RScoped (ApplicativeArg (GhcPass p))) | |
Defined in GHC.Iface.Ext.Ast Methods toHie :: RScoped (ApplicativeArg (GhcPass p)) -> HieM [HieAST Type] | |
type FailOperator id = Maybe (SyntaxExpr id) #
The fail operator
This is used for `.. <-` "bind statements" in do notation, including non-monadic "binds" in applicative.
The fail operator is 'Just expr' if it potentially fail monadically. if the
pattern match cannot fail, or shouldn't fail monadically (regular incomplete
pattern exception), it is Nothing.
See Note [Monad fail : Rebindable syntax, overloaded strings] for the type of
expression in the Just case, and why it is so.
See Note [Failing pattern matches in Stmts] for which contexts for
'BindStmt's should use the monadic fail and which shouldn't.
data ParStmtBlock idL idR #
Parenthesised Statement Block
Constructors
| ParStmtBlock (XParStmtBlock idL idR) [ExprLStmt idL] [IdP idR] (SyntaxExpr idR) | |
| XParStmtBlock !(XXParStmtBlock idL idR) |
Instances
| Data TransForm | |
Defined in Language.Haskell.Syntax.Expr Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TransForm -> c TransForm # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TransForm # toConstr :: TransForm -> Constr # dataTypeOf :: TransForm -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TransForm) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TransForm) # gmapT :: (forall b. Data b => b -> b) -> TransForm -> TransForm # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TransForm -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TransForm -> r # gmapQ :: (forall d. Data d => d -> u) -> TransForm -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TransForm -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TransForm -> m TransForm # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TransForm -> m TransForm # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TransForm -> m TransForm # | |
Exact print annotations when in qualifier lists or guards
- AnnKeywordId : AnnVbar,
AnnComma,AnnThen,
AnnBy,AnnBy,
AnnGroup,AnnUsing
Constructors
| LastStmt (XLastStmt idL idR body) body (Maybe Bool) (SyntaxExpr idR) | |
| BindStmt | |
Fields | |
| ApplicativeStmt (XApplicativeStmt idL idR body) [(SyntaxExpr idR, ApplicativeArg idL)] (Maybe (SyntaxExpr idR)) |
For full details, see Note [ApplicativeDo] in GHC.Rename.Expr |
| BodyStmt (XBodyStmt idL idR body) body (SyntaxExpr idR) (SyntaxExpr idR) | |
| LetStmt (XLetStmt idL idR body) (HsLocalBindsLR idL idR) |
|
| ParStmt (XParStmt idL idR body) [ParStmtBlock idL idR] (HsExpr idR) (SyntaxExpr idR) | |
| TransStmt | |
| RecStmt | |
Fields
| |
| XStmtLR !(XXStmtLR idL idR body) | |
Instances
type GuardLStmt id = LStmt id (LHsExpr id) #
Guard Located Statement
type LStmtLR idL idR body = XRec idL (StmtLR idL idR body) #
Located Statement with separate Left and Right id's
Guarded Right Hand Side.
Constructors
| GRHS (XCGRHS p body) [GuardLStmt p] body | |
| XGRHS !(XXGRHS p body) |
Instances
| (ToHie (LocatedA (body (GhcPass p))), HiePass p, AnnoBody p body) => ToHie (LocatedAn NoEpAnns (GRHS (GhcPass p) (LocatedA (body (GhcPass p))))) | |
| type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) | |
| type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) | |
| type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs))) | |
Defined in GHC.Parser.PostProcess | |
type LMatch id body = XRec id (Match id body) #
Located Match
May have AnnKeywordId : AnnSemi when in a
list
type HsRecordBinds p = HsRecFields p (LHsExpr p) #
Haskell Record Bindings
Haskell Top-level Command
type LHsCmdTop p = XRec p (HsCmdTop p) #
Top-level command, introducing a new arrow. This may occur inside a proc (where the stack is empty) or as an argument of a command-forming operator.
Located Haskell Top-level Command
data HsArrAppType #
Haskell arrow application type.
Constructors
| HsHigherOrderApp | First order arrow application |
| HsFirstOrderApp | Higher order arrow application |
Instances
| Data HsArrAppType | |
Defined in Language.Haskell.Syntax.Expr Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsArrAppType -> c HsArrAppType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsArrAppType # toConstr :: HsArrAppType -> Constr # dataTypeOf :: HsArrAppType -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsArrAppType) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsArrAppType) # gmapT :: (forall b. Data b => b -> b) -> HsArrAppType -> HsArrAppType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsArrAppType -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsArrAppType -> r # gmapQ :: (forall d. Data d => d -> u) -> HsArrAppType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsArrAppType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsArrAppType -> m HsArrAppType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsArrAppType -> m HsArrAppType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsArrAppType -> m HsArrAppType # | |
Haskell Command (e.g. a "statement" in an Arrow proc block)
Constructors
Instances
data LamCaseVariant #
Which kind of lambda case are we dealing with?
Instances
| Data LamCaseVariant | |
Defined in Language.Haskell.Syntax.Expr Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LamCaseVariant -> c LamCaseVariant # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LamCaseVariant # toConstr :: LamCaseVariant -> Constr # dataTypeOf :: LamCaseVariant -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c LamCaseVariant) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LamCaseVariant) # gmapT :: (forall b. Data b => b -> b) -> LamCaseVariant -> LamCaseVariant # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LamCaseVariant -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LamCaseVariant -> r # gmapQ :: (forall d. Data d => d -> u) -> LamCaseVariant -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> LamCaseVariant -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> LamCaseVariant -> m LamCaseVariant # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LamCaseVariant -> m LamCaseVariant # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LamCaseVariant -> m LamCaseVariant # | |
| Eq LamCaseVariant | |
Defined in Language.Haskell.Syntax.Expr Methods (==) :: LamCaseVariant -> LamCaseVariant -> Bool # (/=) :: LamCaseVariant -> LamCaseVariant -> Bool # | |
Haskell Tuple Argument
type LHsTupArg id = XRec id (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))
A pragma, written as {-# ... #-}, that may appear within an expression.
data DotFieldOcc p #
Constructors
| DotFieldOcc | |
Fields
| |
| XDotFieldOcc !(XXDotFieldOcc p) | |
Instances
| type Anno (DotFieldOcc (GhcPass p)) | |
Defined in GHC.Hs.Expr | |
type LHsRecUpdProj p = XRec p (RecUpdProj p) #
type RecUpdProj p = RecProj p (LHsExpr p) #
type LHsRecProj p arg = XRec p (RecProj p arg) #
type RecProj p arg = HsFieldBind (LFieldLabelStrings p) arg #
newtype FieldLabelStrings p #
Constructors
| FieldLabelStrings [XRec p (DotFieldOcc p)] |
Instances
| type Anno (FieldLabelStrings (GhcPass p)) | |
Defined in GHC.Hs.Expr | |
type LFieldLabelStrings p = XRec p (FieldLabelStrings p) #
RecordDotSyntax field updates
Haskell Module
All we actually declare here is the top-level structure for a module.
Constructors
| HsModule | |
Fields
| |
| XModule !(XXModule p) | |
Used when constructing a term with an unused extension point.
dataConCantHappen :: DataConCantHappen -> a #
Eliminate a DataConCantHappen. See Note [Constructor cannot occur].
stableModuleNameCmp :: ModuleName -> ModuleName -> Ordering #
Compares module names lexically, rather than by their Uniques
moduleNameFS :: ModuleName -> FastString #
moduleNameString :: ModuleName -> String #
mkModuleName :: String -> ModuleName #
mkModuleNameFS :: FastString -> ModuleName #
moduleNameSlashes :: ModuleName -> String #
Returns the string version of the module name, with dots replaced by slashes.
moduleNameColons :: ModuleName -> String #
Returns the string version of the module name, with dots replaced by colons.
isPromoted :: PromotionFlag -> Bool #
hsQTvExplicit :: LHsQTyVars pass -> [LHsTyVarBndr () pass] #
hsPatSigType :: HsPatSigType pass -> LHsType pass #
mapHsOuterImplicit :: (XHsOuterImplicit pass -> XHsOuterImplicit pass) -> HsOuterTyVarBndrs flag pass -> HsOuterTyVarBndrs flag pass #
hsIPNameFS :: HsIPName -> FastString #
isHsKindedTyVar :: HsTyVarBndr flag pass -> Bool #
Does this HsTyVarBndr come with an explicit kind annotation?
hsScaledThing :: HsScaled pass a -> a #
noTypeArgs :: [Void] #
An empty list that can be used to indicate that there are no type arguments allowed in cases where HsConDetails is applied to Void.
hsConPatArgs :: UnXRec p => HsConPatDetails p -> [LPat p] #
hsRecFields :: UnXRec p => HsRecFields p arg -> [XCFieldOcc p] #
hsRecFieldsArgs :: UnXRec p => HsRecFields p arg -> [arg] #
hsRecFieldSel :: UnXRec p => HsRecField p arg -> XCFieldOcc p #
isFixityLSig :: UnXRec p => LSig p -> Bool #
isTypeLSig :: UnXRec p => LSig p -> Bool #
isSpecLSig :: UnXRec p => LSig p -> Bool #
isSpecInstLSig :: UnXRec p => LSig p -> Bool #
isPragLSig :: UnXRec p => LSig p -> Bool #
isInlineLSig :: UnXRec p => LSig p -> Bool #
isMinimalLSig :: UnXRec p => LSig p -> Bool #
isSCCFunSig :: UnXRec p => LSig p -> Bool #
isCompleteMatchSig :: UnXRec p => LSig p -> Bool #
hsGroupInstDecls :: HsGroup id -> [LInstDecl id] #
isDataDecl :: TyClDecl pass -> Bool #
True = argument is a data/newtype
declaration.
isClassDecl :: TyClDecl pass -> Bool #
type class
isFamilyDecl :: TyClDecl pass -> Bool #
type/data family declaration
isTypeFamilyDecl :: TyClDecl pass -> Bool #
type family declaration
isOpenTypeFamilyInfo :: FamilyInfo pass -> Bool #
open type family info
isClosedTypeFamilyInfo :: FamilyInfo pass -> Bool #
closed type family info
isDataFamilyDecl :: TyClDecl pass -> Bool #
data family declaration
tyClDeclTyVars :: TyClDecl pass -> LHsQTyVars pass #
tyClGroupTyClDecls :: [TyClGroup pass] -> [LTyClDecl pass] #
tyClGroupInstDecls :: [TyClGroup pass] -> [LInstDecl pass] #
tyClGroupRoleDecls :: [TyClGroup pass] -> [LRoleAnnotDecl pass] #
tyClGroupKindSigs :: [TyClGroup pass] -> [LStandaloneKindSig pass] #
dataDefnConsNewOrData :: DataDefnCons a -> NewOrData #
isTypeDataDefnCons :: DataDefnCons a -> Bool #
Are the constructors within a type data declaration?
See Note [Type data declarations] in GHC.Rename.Module.
collectRuleBndrSigTys :: [RuleBndr pass] -> [HsPatSigType pass] #
docDeclDoc :: DocDecl pass -> LHsDoc pass #
annProvenanceName_maybe :: UnXRec p => AnnProvenance p -> Maybe (IdP p) #
isInfixMatch :: Match id body -> Bool #
isPatSynCtxt :: HsMatchContext p -> Bool #
isComprehensionContext :: HsStmtContext id -> Bool #
isMonadStmtContext :: HsStmtContext id -> Bool #
Is this a monadic context?
isMonadDoStmtContext :: HsDoFlavour -> Bool #
isMonadCompContext :: HsStmtContext id -> Bool #
isMonadDoCompContext :: HsDoFlavour -> Bool #
module GHC.Rename.Names
module GHC.Rename.Splice
module GHC.Tc.Instance.Family
module GHC.Tc.Module
module GHC.Tc.Types
See Note [Roles] in GHC.Core.Coercion
Order of constructors matters: the Ord instance coincides with the *super*typing relation on roles.
Constructors
| Nominal | |
| Representational | |
| Phantom |
Instances
| Data Role | |
Defined in Language.Haskell.Syntax.Basic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Role -> c Role # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Role # dataTypeOf :: Role -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Role) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Role) # gmapT :: (forall b. Data b => b -> b) -> Role -> Role # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r # gmapQ :: (forall d. Data d => d -> u) -> Role -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Role -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Role -> m Role # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Role -> m Role # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Role -> m Role # | |
| Eq Role | |
| Ord Role | |
| type Anno (Maybe Role) | |
| type Anno (Maybe Role) | |
data LeftOrRight #
Instances
| Data LeftOrRight | |
Defined in GHC.Types.Basic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LeftOrRight -> c LeftOrRight # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LeftOrRight # toConstr :: LeftOrRight -> Constr # dataTypeOf :: LeftOrRight -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c LeftOrRight) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LeftOrRight) # gmapT :: (forall b. Data b => b -> b) -> LeftOrRight -> LeftOrRight # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LeftOrRight -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LeftOrRight -> r # gmapQ :: (forall d. Data d => d -> u) -> LeftOrRight -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> LeftOrRight -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> LeftOrRight -> m LeftOrRight # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LeftOrRight -> m LeftOrRight # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LeftOrRight -> m LeftOrRight # | |
| Binary LeftOrRight | |
Defined in GHC.Types.Basic Methods put_ :: BinHandle -> LeftOrRight -> IO () # put :: BinHandle -> LeftOrRight -> IO (Bin LeftOrRight) # get :: BinHandle -> IO LeftOrRight # | |
| Outputable LeftOrRight | |
Defined in GHC.Types.Basic Methods ppr :: LeftOrRight -> SDoc # | |
| Eq LeftOrRight | |
Defined in GHC.Types.Basic | |
data CoercionHole #
A coercion to be filled in by the type-checker. See Note [Coercion holes]
Instances
| Data CoercionHole | |
Defined in GHC.Core.TyCo.Rep Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CoercionHole -> c CoercionHole # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CoercionHole # toConstr :: CoercionHole -> Constr # dataTypeOf :: CoercionHole -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c CoercionHole) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CoercionHole) # gmapT :: (forall b. Data b => b -> b) -> CoercionHole -> CoercionHole # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CoercionHole -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CoercionHole -> r # gmapQ :: (forall d. Data d => d -> u) -> CoercionHole -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CoercionHole -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CoercionHole -> m CoercionHole # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CoercionHole -> m CoercionHole # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CoercionHole -> m CoercionHole # | |
| Uniquable CoercionHole | |
Defined in GHC.Core.TyCo.Rep Methods getUnique :: CoercionHole -> Unique # | |
| Outputable CoercionHole | |
Defined in GHC.Core.TyCo.Rep Methods ppr :: CoercionHole -> SDoc # | |
data QuoteWrapper #
Constructors
| QuoteWrapper EvVar Type |
Instances
| Data QuoteWrapper | |
Defined in GHC.Tc.Types.Evidence Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> QuoteWrapper -> c QuoteWrapper # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c QuoteWrapper # toConstr :: QuoteWrapper -> Constr # dataTypeOf :: QuoteWrapper -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c QuoteWrapper) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QuoteWrapper) # gmapT :: (forall b. Data b => b -> b) -> QuoteWrapper -> QuoteWrapper # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QuoteWrapper -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QuoteWrapper -> r # gmapQ :: (forall d. Data d => d -> u) -> QuoteWrapper -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> QuoteWrapper -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> QuoteWrapper -> m QuoteWrapper # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> QuoteWrapper -> m QuoteWrapper # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> QuoteWrapper -> m QuoteWrapper # | |
data HoleExprRef #
Where to store evidence for expression holes See Note [Holes] in GHC.Tc.Types.Constraint
Constructors
| HER | |
Instances
| Data HoleExprRef | |
Defined in GHC.Tc.Types.Evidence Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HoleExprRef -> c HoleExprRef # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HoleExprRef # toConstr :: HoleExprRef -> Constr # dataTypeOf :: HoleExprRef -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HoleExprRef) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HoleExprRef) # gmapT :: (forall b. Data b => b -> b) -> HoleExprRef -> HoleExprRef # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HoleExprRef -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HoleExprRef -> r # gmapQ :: (forall d. Data d => d -> u) -> HoleExprRef -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HoleExprRef -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HoleExprRef -> m HoleExprRef # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HoleExprRef -> m HoleExprRef # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HoleExprRef -> m HoleExprRef # | |
| Outputable HoleExprRef | |
Defined in GHC.Tc.Types.Evidence Methods ppr :: HoleExprRef -> SDoc # | |
data EvCallStack #
Evidence for CallStack implicit parameters.
Constructors
| EvCsEmpty | |
| EvCsPushCall FastString RealSrcSpan EvExpr |
|
Instances
| Data EvCallStack | |
Defined in GHC.Tc.Types.Evidence Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> EvCallStack -> c EvCallStack # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c EvCallStack # toConstr :: EvCallStack -> Constr # dataTypeOf :: EvCallStack -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c EvCallStack) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EvCallStack) # gmapT :: (forall b. Data b => b -> b) -> EvCallStack -> EvCallStack # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EvCallStack -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EvCallStack -> r # gmapQ :: (forall d. Data d => d -> u) -> EvCallStack -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> EvCallStack -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> EvCallStack -> m EvCallStack # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> EvCallStack -> m EvCallStack # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> EvCallStack -> m EvCallStack # | |
| Outputable EvCallStack | |
Defined in GHC.Tc.Types.Evidence Methods ppr :: EvCallStack -> SDoc # | |
data EvTypeable #
Instructions on how to make a Typeable dictionary.
See Note [Typeable evidence terms]
Constructors
| EvTypeableTyCon TyCon [EvTerm] | Dictionary for |
| EvTypeableTyApp EvTerm EvTerm | Dictionary for |
| EvTypeableTrFun EvTerm EvTerm EvTerm | Dictionary for |
| EvTypeableTyLit EvTerm | Dictionary for a type literal,
e.g. |
Instances
| Data EvTypeable | |
Defined in GHC.Tc.Types.Evidence Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> EvTypeable -> c EvTypeable # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c EvTypeable # toConstr :: EvTypeable -> Constr # dataTypeOf :: EvTypeable -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c EvTypeable) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EvTypeable) # gmapT :: (forall b. Data b => b -> b) -> EvTypeable -> EvTypeable # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EvTypeable -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EvTypeable -> r # gmapQ :: (forall d. Data d => d -> u) -> EvTypeable -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> EvTypeable -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> EvTypeable -> m EvTypeable # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> EvTypeable -> m EvTypeable # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> EvTypeable -> m EvTypeable # | |
| Outputable EvTypeable | |
Defined in GHC.Tc.Types.Evidence Methods ppr :: EvTypeable -> SDoc # | |
Constructors
| EvExpr EvExpr | |
| EvTypeable Type EvTypeable | |
| EvFun | |
Instances
| Data EvTerm | |
Defined in GHC.Tc.Types.Evidence Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> EvTerm -> c EvTerm # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c EvTerm # toConstr :: EvTerm -> Constr # dataTypeOf :: EvTerm -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c EvTerm) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EvTerm) # gmapT :: (forall b. Data b => b -> b) -> EvTerm -> EvTerm # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EvTerm -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EvTerm -> r # gmapQ :: (forall d. Data d => d -> u) -> EvTerm -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> EvTerm -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> EvTerm -> m EvTerm # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> EvTerm -> m EvTerm # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> EvTerm -> m EvTerm # | |
| Outputable EvTerm | |
Defined in GHC.Tc.Types.Evidence | |
Instances
| Outputable EvBind | |
Defined in GHC.Tc.Types.Evidence | |
Constructors
| EvBindMap | |
Fields | |
Instances
| Outputable EvBindMap | |
Defined in GHC.Tc.Types.Evidence | |
data EvBindsVar #
Constructors
| EvBindsVar | |
| CoEvBindsVar | |
Instances
| Uniquable EvBindsVar | |
Defined in GHC.Tc.Types.Evidence Methods getUnique :: EvBindsVar -> Unique # | |
| Outputable EvBindsVar | |
Defined in GHC.Tc.Types.Evidence Methods ppr :: EvBindsVar -> SDoc # | |
Constructors
| TcEvBinds EvBindsVar | |
| EvBinds (Bag EvBind) |
Instances
| Data TcEvBinds | |
Defined in GHC.Tc.Types.Evidence Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TcEvBinds -> c TcEvBinds # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TcEvBinds # toConstr :: TcEvBinds -> Constr # dataTypeOf :: TcEvBinds -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TcEvBinds) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TcEvBinds) # gmapT :: (forall b. Data b => b -> b) -> TcEvBinds -> TcEvBinds # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TcEvBinds -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TcEvBinds -> r # gmapQ :: (forall d. Data d => d -> u) -> TcEvBinds -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TcEvBinds -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TcEvBinds -> m TcEvBinds # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TcEvBinds -> m TcEvBinds # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TcEvBinds -> m TcEvBinds # | |
| Outputable TcEvBinds | |
Defined in GHC.Tc.Types.Evidence | |
| ToHie (EvBindContext (LocatedA TcEvBinds)) | |
Constructors
Instances
| Data HsWrapper | |
Defined in GHC.Tc.Types.Evidence Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsWrapper -> c HsWrapper # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsWrapper # toConstr :: HsWrapper -> Constr # dataTypeOf :: HsWrapper -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsWrapper) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsWrapper) # gmapT :: (forall b. Data b => b -> b) -> HsWrapper -> HsWrapper # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsWrapper -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsWrapper -> r # gmapQ :: (forall d. Data d => d -> u) -> HsWrapper -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsWrapper -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsWrapper -> m HsWrapper # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsWrapper -> m HsWrapper # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsWrapper -> m HsWrapper # | |
| Monoid HsWrapper | |
| Semigroup HsWrapper | The Semigroup instance is a bit fishy, since (a <> b) <> c ?= a <> (b <> c) >(a `WpCompose` b) `WpCompose` c /= @ a `WpCompose` (b `WpCompose` c) However these two associations are are "semantically equal" in the sense
that they produce equal functions when passed to
|
| Outputable HsWrapper | |
Defined in GHC.Tc.Types.Evidence | |
| ToHie (LocatedA HsWrapper) | |
type TcMCoercionR = MCoercionR #
type TcMCoercionN = MCoercionN #
type TcMCoercion = MCoercion #
type TcCoercionP = CoercionP #
type TcCoercionR = CoercionR #
type TcCoercionN = CoercionN #
type TcCoercion = Coercion #
pickLR :: LeftOrRight -> (a, a) -> a #
maybeSymCo :: SwapFlag -> TcCoercion -> TcCoercion #
mkWpCastR :: TcCoercionR -> HsWrapper #
mkWpCastN :: TcCoercionN -> HsWrapper #
mkWpTyApps :: [Type] -> HsWrapper #
mkWpEvApps :: [EvTerm] -> HsWrapper #
mkWpEvVarApps :: [EvVar] -> HsWrapper #
mkWpTyLams :: [TyVar] -> HsWrapper #
mkWpEvLams :: [Var] -> HsWrapper #
isIdHsWrapper :: HsWrapper -> Bool #
hsWrapDictBinders :: HsWrapper -> Bag DictId #
Identifies the lambda-bound dictionaries of an HsWrapper. This is used
(only) to allow the pattern-match overlap checker to know what Given
dictionaries are in scope.
We specifically do not collect dictionaries bound in a WpLet. These are
either superclasses of lambda-bound ones, or (extremely numerous) results of
binding Wanted dictionaries. We definitely don't want all those cluttering
up the Given dictionaries for pattern-match overlap checking!
collectHsWrapBinders :: HsWrapper -> ([Var], HsWrapper) #
isCoEvBindsVar :: EvBindsVar -> Bool #
extendEvBinds :: EvBindMap -> EvBind -> EvBindMap #
isEmptyEvBindMap :: EvBindMap -> Bool #
evBindMapBinds :: EvBindMap -> Bag EvBind #
foldEvBindMap :: (EvBind -> a -> a) -> a -> EvBindMap -> a #
nonDetStrictFoldEvBindMap :: (EvBind -> a -> a) -> a -> EvBindMap -> a #
evBindMapToVarSet :: EvBindMap -> VarSet #
varSetMinusEvBindMap :: VarSet -> EvBindMap -> VarSet #
mkWantedEvBind :: EvVar -> EvTerm -> EvBind #
mkGivenEvBind :: EvVar -> EvTerm -> EvBind #
evCoercion :: TcCoercion -> EvTerm #
evCast :: EvExpr -> TcCoercion -> EvTerm #
d |> co
evTypeable :: Type -> EvTypeable -> EvTerm #
mkEvCast :: EvExpr -> TcCoercion -> EvTerm #
mkEvScSelectors :: Class -> [TcType] -> [(TcPredType, EvExpr)] #
isEmptyTcEvBinds :: TcEvBinds -> Bool #
evTermCoercion :: EvTerm -> TcCoercion #
findNeededEvVars :: EvBindMap -> VarSet -> VarSet #
evVarsOfTerm :: EvTerm -> VarSet #
quoteWrapperTyVarTy :: QuoteWrapper -> Type #
applyQuoteWrapper :: QuoteWrapper -> HsWrapper #
Convert the QuoteWrapper into a normal HsWrapper which can be used to apply its contents.
module GHC.Tc.Utils.Env
Instances
| ContainsHooks (Env gbl lcl) | |
Defined in GHC.Tc.Types Methods extractHooks :: Env gbl lcl -> Hooks # | |
| ContainsDynFlags (Env gbl lcl) | |
Defined in GHC.Tc.Types Methods extractDynFlags :: Env gbl lcl -> DynFlags # | |
| ContainsModule gbl => ContainsModule (Env gbl lcl) | |
Defined in GHC.Tc.Types Methods extractModule :: Env gbl lcl -> Module # | |
| ContainsLogger (Env gbl lcl) | |
Defined in GHC.Tc.Types Methods extractLogger :: Env gbl lcl -> Logger # | |
TcGblEnv describes the top-level of the module at the
point at which the typechecker is finished work.
It is this structure that is handed on to the desugarer
For state that needs to be updated during the typechecking
phase and returned at end, use a TcRef (= IORef).
Constructors
| TcGblEnv | |
Fields
| |
Instances
| ContainsModule TcGblEnv | |
Defined in GHC.Tc.Types Methods extractModule :: TcGblEnv -> Module # | |
data ForeignSrcLang #
Foreign formats supported by GHC via TH
Constructors
| LangC | C |
| LangCxx | C++ |
| LangObjc | Objective C |
| LangObjcxx | Objective C++ |
| LangAsm | Assembly language (.s) |
| LangJs | JavaScript |
| RawObject | Object (.o) |
Instances
type CompleteMatches = [CompleteMatch] #
data CompleteMatch #
A list of conlikes which represents a complete pattern match.
These arise from COMPLETE signatures.
See also Note [Implementation of COMPLETE pragmas].
Instances
| Outputable CompleteMatch | |
Defined in GHC.Types.CompleteMatch Methods ppr :: CompleteMatch -> SDoc # | |
A typecheckable thing available in a local context. Could be
AGlobal TyThing, but also lexically scoped variables, etc.
See GHC.Tc.Utils.Env for how to retrieve a TyThing given a Name.
Constructors
| AGlobal TyThing | |
| ATcId | |
Fields
| |
| ATyVar Name TcTyVar | |
| ATcTyCon TyCon | |
| APromotionErr PromotionErr | |
Instances
| Outputable TcTyThing | |
Defined in GHC.Tc.Types | |
data TcIdSigInfo #
Constructors
| CompleteSig | |
| PartialSig | |
Fields
| |
Instances
| Outputable TcIdSigInfo | |
Defined in GHC.Tc.Types Methods ppr :: TcIdSigInfo -> SDoc # | |
data SelfBootInfo #
Constructors
| NoSelfBoot | |
| SelfBoot | |
Fields
| |
Constructors
| TcLclEnv | |
Fields
| |
data ImportAvails #
ImportAvails summarises what was imported from where, irrespective of
whether the imported things are actually used or not. It is used:
- when processing the export list,
- when constructing usage info for the interface file,
- to identify the list of directly imported modules for initialisation purposes and for optimised overlap checking of family instances,
- when figuring out what things are really unused
Constructors
| ImportAvails | |
Fields
| |
data IOEnvFailure #
Constructors
| IOEnvFailure |
Instances
| Exception IOEnvFailure | |
Defined in GHC.Data.IOEnv Methods toException :: IOEnvFailure -> SomeException # fromException :: SomeException -> Maybe IOEnvFailure # displayException :: IOEnvFailure -> String # | |
| Show IOEnvFailure | |
Defined in GHC.Data.IOEnv Methods showsPrec :: Int -> IOEnvFailure -> ShowS # show :: IOEnvFailure -> String # showList :: [IOEnvFailure] -> ShowS # | |
Instances
data PromotionErr #
Constructors
| TyConPE | |
| ClassPE | |
| FamDataConPE | |
| ConstrainedDataConPE PredType | |
| PatSynPE | |
| RecDataConPE | |
| TermVariablePE | |
| NoDataKindsDC |
Instances
| Outputable PromotionErr | |
Defined in GHC.Tc.Errors.Types Methods ppr :: PromotionErr -> SDoc # | |
data TcRnMessage #
An error which might arise during typechecking/renaming.
Instances
type THDocs = Map DocLoc (HsDoc GhcRn) #
The current collection of docs that Template Haskell has built up via putDoc.
This is a mirror of Template Haskell's DocLoc, but the TH names are resolved to GHC names.
type RoleAnnotEnv = NameEnv (LRoleAnnotDecl GhcRn) #
data DefaultingPlugin #
A plugin for controlling defaulting.
Constructors
| DefaultingPlugin | |
Fields
| |
type FillDefaulting = WantedConstraints -> TcPluginM [DefaultingProposal] #
type DefaultingPluginResult = [DefaultingProposal] #
data DefaultingProposal #
A collection of candidate default types for a type variable.
Constructors
| DefaultingProposal | |
Fields
| |
Instances
| Outputable DefaultingProposal | |
Defined in GHC.Tc.Types Methods ppr :: DefaultingProposal -> SDoc # | |
data TcPluginRewriteResult #
Constructors
| TcPluginNoRewrite | The plugin does not rewrite the type family application. |
| TcPluginRewriteTo | The plugin rewrites the type family application
providing a rewriting together with evidence: a The plugin can also emit additional Wanted constraints. |
Fields
| |
data TcPluginSolveResult #
Result of running a solver plugin.
Constructors
| TcPluginSolveResult | |
Fields
| |
Bundled Patterns
| pattern TcPluginOk :: [(EvTerm, Ct)] -> [Ct] -> TcPluginSolveResult | The plugin has not found any contradictions, The first field is for constraints that were solved. The second field contains new work, that should be processed by the constraint solver. |
| pattern TcPluginContradiction :: [Ct] -> TcPluginSolveResult | The plugin found a contradiction. The returned constraints are removed from the inert set, and recorded as insoluble. The returned list of constraints should never be empty. |
Constructors
| TcPlugin | |
Fields
| |
TcPluginM is the monad in which type-checking plugins operate.
Instances
type TcPluginRewriter #
Arguments
| = RewriteEnv | Rewriter environment |
| -> [Ct] | Givens |
| -> [TcType] | type family arguments |
| -> TcPluginM TcPluginRewriteResult |
For rewriting type family applications, a type-checking plugin provides
a function of this type for each type family TyCon.
The function is provided with the current set of Given constraints, together with the arguments to the type family. The type family application will always be fully saturated.
type TcPluginSolver #
Arguments
| = EvBindsVar | |
| -> [Ct] | Givens |
| -> [Ct] | Wanteds |
| -> TcPluginM TcPluginSolveResult |
The solve function of a type-checking plugin takes in Given
and Wanted constraints, and should return a TcPluginSolveResult
indicating which Wanted constraints it could solve, or whether any are
insoluble.
data TcPatSynInfo #
Constructors
| TPSI | |
Fields | |
Instances
| Outputable TcPatSynInfo | |
Defined in GHC.Tc.Types Methods ppr :: TcPatSynInfo -> SDoc # | |
data TcIdSigInst #
Constructors
| TISI | |
Fields
| |
Instances
| Outputable TcIdSigInst | |
Defined in GHC.Tc.Types Methods ppr :: TcIdSigInst -> SDoc # | |
Constructors
| TcIdSig TcIdSigInfo | |
| TcPatSynSig TcPatSynInfo |
Instances
| Outputable TcSigInfo | |
Defined in GHC.Tc.Types | |
Constructors
| ImportByUser IsBootInterface | |
| ImportBySystem | |
| ImportByPlugin |
Instances
| Outputable WhereFrom | |
Defined in GHC.Tc.Types | |
type ClosedTypeId = Bool #
data IsGroupClosed #
IsGroupClosed describes a group of mutually-recursive bindings
Constructors
| IsGroupClosed (NameEnv RhsNames) ClosedTypeId |
data IdBindingInfo #
IdBindingInfo describes how an Id is bound.
It is used for the following purposes:
a) for static forms in checkClosedInStaticForm and
b) to figure out when a nested binding can be generalised,
in decideGeneralisationPlan.
Constructors
| NotLetBound | |
| ClosedLet | |
| NonClosedLet RhsNames ClosedTypeId |
Instances
| Outputable IdBindingInfo | |
Defined in GHC.Tc.Types Methods ppr :: IdBindingInfo -> SDoc # | |
Constructors
| NoArrowCtxt | |
| ArrowCtxt LocalRdrEnv (TcRef WantedConstraints) |
data PendingStuff #
Constructors
| RnPendingUntyped (TcRef [PendingRnSplice]) | |
| RnPendingTyped | |
| TcPending (TcRef [PendingTcSplice]) (TcRef WantedConstraints) QuoteWrapper |
Constructors
| Splice SpliceType | |
| RunSplice (TcRef [ForeignRef (Q ())]) | |
| Comp | |
| Brack ThStage PendingStuff |
Instances
| Outputable ThStage | |
Defined in GHC.Tc.Types | |
data SpliceType #
Constructors
| TcIdBndr TcId TopLevelFlag | |
| TcIdBndr_ExpType Name ExpType TopLevelFlag | |
| TcTvBndr Name TyVar |
Instances
| HasOccName TcBinder | |
Defined in GHC.Tc.Types | |
| Outputable TcBinder | |
Defined in GHC.Tc.Types | |
type TcBinderStack = [TcBinder] #
type ThBindEnv = NameEnv (TopLevelFlag, ThLevel) #
type RecFieldEnv = NameEnv [FieldLabel] #
data FrontendResult #
FrontendResult describes the result of running the frontend of a Haskell
module. Currently one always gets a FrontendTypecheck, since running the
frontend involves typechecking a program. hs-sig merges are not handled here.
This data type really should be in GHC.Driver.Env, but it needs to have a TcGblEnv which is only defined here.
Constructors
| FrontendTypecheck TcGblEnv |
Constructors
| IfLclEnv | |
Fields
| |
data RewriteEnv #
A RewriteEnv carries the necessary context for performing rewrites
(i.e. type family reductions and following filled-in metavariables)
in the solver.
Constructors
| RE | |
Fields
| |
A NameShape is a substitution on Names that can be used
to refine the identities of a hole while we are renaming interfaces
(see GHC.Iface.Rename). Specifically, a NameShape for
ns_module_name A, defines a mapping from {A.T}
(for some OccName T) to some arbitrary other Name.
The most intriguing thing about a NameShape, however, is
how it's constructed. A NameShape is *implied* by the
exported AvailInfos of the implementor of an interface:
if an implementor of signature <H> exports M.T, you implicitly
define a substitution from {H.T} to M.T. So a NameShape
is computed from the list of AvailInfos that are exported
by the implementation of a module, or successively merged
together by the export lists of signatures which are joining
together.
It's not the most obvious way to go about doing this, but it does seem to work!
NB: Can't boot this and put it in NameShape because then we start pulling in too many DynFlags things.
Constructors
| NameShape | |
Fields
| |
data IsExtraConstraint #
Constructors
| YesExtraConstraint | |
| NoExtraConstraint |
Instances
| Outputable IsExtraConstraint | |
Defined in GHC.Tc.Utils.Monad Methods ppr :: IsExtraConstraint -> SDoc # | |
foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b #
Right-to-left monadic fold over the elements of a structure.
Given a structure t with elements (a, b, c, ..., x, y), the result of
a fold with an operator function f is equivalent to:
foldrM f z t = do
yy <- f y z
xx <- f x yy
...
bb <- f b cc
aa <- f a bb
return aa -- Just @return z@ when the structure is emptyFor a Monad m, given two functions f1 :: a -> m b and f2 :: b -> m c,
their Kleisli composition (f1 >=> f2) :: a -> m c is defined by:
(f1 >=> f2) a = f1 a >>= f2
Another way of thinking about foldrM is that it amounts to an application
to z of a Kleisli composition:
foldrM f z t = f y >=> f x >=> ... >=> f b >=> f a $ z
The monadic effects of foldrM are sequenced from right to left, and e.g.
folds of infinite lists will diverge.
If at some step the bind operator ( short-circuits (as with, e.g.,
>>=)mzero in a MonadPlus), the evaluated effects will be from a tail of the
element sequence. If you want to evaluate the monadic effects in
left-to-right order, or perhaps be able to short-circuit after an initial
sequence of elements, you'll need to use foldlM instead.
If the monadic effects don't short-circuit, the outermost application of
f is to the leftmost element a, so that, ignoring effects, the result
looks like a right fold:
a `f` (b `f` (c `f` (... (x `f` (y `f` z))))).
Examples
Basic usage:
>>>let f i acc = do { print i ; return $ i : acc }>>>foldrM f [] [0..3]3 2 1 0 [0,1,2,3]
foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b #
Left-to-right monadic fold over the elements of a structure.
Given a structure t with elements (a, b, ..., w, x, y), the result of
a fold with an operator function f is equivalent to:
foldlM f z t = do
aa <- f z a
bb <- f aa b
...
xx <- f ww x
yy <- f xx y
return yy -- Just @return z@ when the structure is emptyFor a Monad m, given two functions f1 :: a -> m b and f2 :: b -> m c,
their Kleisli composition (f1 >=> f2) :: a -> m c is defined by:
(f1 >=> f2) a = f1 a >>= f2
Another way of thinking about foldlM is that it amounts to an application
to z of a Kleisli composition:
foldlM f z t =
flip f a >=> flip f b >=> ... >=> flip f x >=> flip f y $ zThe monadic effects of foldlM are sequenced from left to right.
If at some step the bind operator ( short-circuits (as with, e.g.,
>>=)mzero in a MonadPlus), the evaluated effects will be from an initial
segment of the element sequence. If you want to evaluate the monadic
effects in right-to-left order, or perhaps be able to short-circuit after
processing a tail of the sequence of elements, you'll need to use foldrM
instead.
If the monadic effects don't short-circuit, the outermost application of
f is to the rightmost element y, so that, ignoring effects, the result
looks like a left fold:
((((z `f` a) `f` b) ... `f` w) `f` x) `f` y
Examples
Basic usage:
>>>let f a e = do { print e ; return $ e : a }>>>foldlM f [] [0..3]0 1 2 3 [3,2,1,0]
mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c]) #
The mapAndUnzipM function maps its first argument over a list, returning
the result as a pair of lists. This function is mainly used with complicated
data structures or a state monad.
readMutVar :: IORef a -> IOEnv env a #
writeMutVar :: IORef a -> a -> IOEnv env () #
partitionM :: Monad m => (a -> m Bool) -> [a] -> m ([a], [a]) #
Monadic version of partition
whenM :: Monad m => m Bool -> m () -> m () #
Monadic version of when, taking the condition in the monad
unlessM :: Monad m => m Bool -> m () -> m () #
Monadic version of unless, taking the condition in the monad
zipWith3M_ :: Monad m => (a -> b -> c -> m d) -> [a] -> [b] -> [c] -> m () #
zipWithAndUnzipM :: Monad m => (a -> b -> m (c, d)) -> [a] -> [b] -> m ([c], [d]) #
mapAndUnzip3M :: Monad m => (a -> m (b, c, d)) -> [a] -> m ([b], [c], [d]) #
mapAndUnzipM for triples
mapAndUnzip4M :: Monad m => (a -> m (b, c, d, e)) -> [a] -> m ([b], [c], [d], [e]) #
mapAndUnzip5M :: Monad m => (a -> m (b, c, d, e, f)) -> [a] -> m ([b], [c], [d], [e], [f]) #
Arguments
| :: (Monad m, Traversable t) | |
| => (acc -> x -> m (acc, y)) | combining function |
| -> acc | initial state |
| -> t x | inputs |
| -> m (acc, t y) | final state, outputs |
Monadic version of mapAccumL
mapSndM :: (Applicative m, Traversable f) => (b -> m c) -> f (a, b) -> m (f (a, c)) #
Monadic version of mapSnd
foldlM_ :: (Monad m, Foldable t) => (a -> b -> m a) -> a -> t b -> m () #
Monadic version of foldl that discards its result
filterOutM :: Applicative m => (a -> m Bool) -> [a] -> m [a] #
Like filterM, only it reverses the sense of the test.
addErr :: TcRnMessage -> TcRn () #
lclEnvInGeneratedCode :: TcLclEnv -> Bool #
getLclEnvLoc :: TcLclEnv -> RealSrcSpan #
setLclEnvLoc :: TcLclEnv -> RealSrcSpan -> TcLclEnv #
getLclEnvTcLevel :: TcLclEnv -> TcLevel #
setLclEnvTcLevel :: TcLclEnv -> TcLevel -> TcLclEnv #
unsafeInterleaveM :: IOEnv env a -> IOEnv env a #
uninterruptibleMaskM_ :: IOEnv env a -> IOEnv env a #
updMutVarM :: IORef a -> (a -> IOEnv env a) -> IOEnv env () #
atomicUpdMutVar :: IORef a -> (a -> (a, b)) -> IOEnv env b #
Atomically update the reference. Does not force the evaluation of the
new variable contents. For strict update, use atomicUpdMutVar'.
atomicUpdMutVar' :: IORef a -> (a -> (a, b)) -> IOEnv env b #
Strict variant of atomicUpdMutVar.
updEnv :: (env -> env') -> IOEnv env' a -> IOEnv env a #
Perform a computation with an altered environment
pprPECategory :: PromotionErr -> SDoc #
peCategory :: PromotionErr -> String #
getSrcSpanM :: TcRn SrcSpan #
bootExports :: SelfBootInfo -> NameSet #
pushErrCtxtSameOrigin :: ErrCtxt -> CtLoc -> CtLoc #
removeBindingShadowing :: HasOccName a => [a] -> [a] #
getPlatform :: TcRnIf a b Platform #
Get target platform
topAnnStage :: ThStage #
outerLevel :: ThLevel #
pprTcTyThingCategory :: TcTyThing -> SDoc #
tcTyThingCategory :: TcTyThing -> String #
plusImportAvails :: ImportAvails -> ImportAvails -> ImportAvails #
Union two ImportAvails
This function is a key part of Import handling, basically for each import we create a separate ImportAvails structure and then union them all together with this function.
isPartialSig :: TcIdSigInst -> Bool #
hasCompleteSig :: TcSigFun -> Name -> Bool #
No signature or a partial signature
unsafeTcPluginTcM :: TcM a -> TcPluginM a #
mkRoleAnnotEnv :: [LRoleAnnotDecl GhcRn] -> RoleAnnotEnv #
lookupRoleAnnot :: RoleAnnotEnv -> Name -> Maybe (LRoleAnnotDecl GhcRn) #
getRoleAnnots :: [Name] -> RoleAnnotEnv -> [LRoleAnnotDecl GhcRn] #
lintGblEnv :: Logger -> DynFlags -> TcGblEnv -> TcM () #
Check the TcGblEnv for consistency. Currently, only checks
axioms, but should check other aspects, too.
initTc :: HscEnv -> HscSource -> Bool -> Module -> RealSrcSpan -> TcM r -> IO (Messages TcRnMessage, Maybe r) #
Setup the initial typechecking environment
initTcWithGbl :: HscEnv -> TcGblEnv -> RealSrcSpan -> TcM r -> IO (Messages TcRnMessage, Maybe r) #
Run a TcM action in the context of an existing GblEnv.
initTcInteractive :: HscEnv -> TcM a -> IO (Messages TcRnMessage, Maybe a) #
discardResult :: TcM a -> TcM () #
goptM :: GeneralFlag -> TcRnIf gbl lcl Bool #
woptM :: WarningFlag -> TcRnIf gbl lcl Bool #
unsetXOptM :: Extension -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a #
unsetGOptM :: GeneralFlag -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a #
unsetWOptM :: WarningFlag -> TcRnIf gbl lcl a -> TcRnIf gbl lcl a #
whenGOptM :: GeneralFlag -> TcRnIf gbl lcl () -> TcRnIf gbl lcl () #
whenWOptM :: WarningFlag -> TcRnIf gbl lcl () -> TcRnIf gbl lcl () #
unlessXOptM :: Extension -> TcRnIf gbl lcl () -> TcRnIf gbl lcl () #
getGhcMode :: TcRnIf gbl lcl GhcMode #
withoutDynamicNow :: TcRnIf gbl lcl a -> TcRnIf gbl lcl a #
getEpsVar :: TcRnIf gbl lcl (TcRef ExternalPackageState) #
getEps :: TcRnIf gbl lcl ExternalPackageState #
updateEps :: (ExternalPackageState -> (ExternalPackageState, a)) -> TcRnIf gbl lcl a #
Update the external package state. Returns the second result of the modifier function.
This is an atomic operation and forces evaluation of the modified EPS in order to avoid space leaks.
updateEps_ :: (ExternalPackageState -> ExternalPackageState) -> TcRnIf gbl lcl () #
Update the external package state.
This is an atomic operation and forces evaluation of the modified EPS in order to avoid space leaks.
getHpt :: TcRnIf gbl lcl HomePackageTable #
getEpsAndHug :: TcRnIf gbl lcl (ExternalPackageState, HomeUnitGraph) #
withException :: MonadIO m => SDocContext -> m (MaybeErr SDoc a) -> m a #
A convenient wrapper for taking a MaybeErr SDoc a and throwing
an exception if it is an error.
newArrowScope :: TcM a -> TcM a #
escapeArrowScope :: TcM a -> TcM a #
newUniqueSupply :: TcRnIf gbl lcl UniqSupply #
cloneLocalName :: Name -> TcM Name #
newSysName :: OccName -> TcRnIf gbl lcl Name #
newSysLocalId :: FastString -> Mult -> TcType -> TcRnIf gbl lcl TcId #
newSysLocalIds :: FastString -> [Scaled TcType] -> TcRnIf gbl lcl [TcId] #
writeTcRef :: TcRef a -> a -> TcRnIf gbl lcl () #
traceOptTcRn :: DumpFlag -> SDoc -> TcRn () #
dumpOptTcRn :: DumpFlag -> String -> DumpFormat -> SDoc -> TcRn () #
Dump if the given DumpFlag is set.
printForUserTcRn :: SDoc -> TcRn () #
Like logInfoTcRn, but for user consumption
traceOptIf :: DumpFlag -> SDoc -> TcRnIf m n () #
getGHCiMonad :: TcRn Name #
tcIsHsBootOrSig :: TcRn Bool #
getRdrEnvs :: TcRn (GlobalRdrEnv, LocalRdrEnv) #
getDeclaredDefaultTys :: TcRn (Maybe [Type]) #
addDependentFiles :: [FilePath] -> TcRn () #
inGeneratedCode :: TcRn Bool #
setSrcSpan :: SrcSpan -> TcRn a -> TcRn a #
setSrcSpanA :: SrcSpanAnn' ann -> TcRn a -> TcRn a #
addLocMA :: (a -> TcM b) -> GenLocated (SrcSpanAnn' ann) a -> TcM b #
wrapLocMA :: (a -> TcM b) -> GenLocated (SrcSpanAnn' ann) a -> TcRn (GenLocated (SrcSpanAnn' ann) b) #
wrapLocFstMA :: (a -> TcM (b, c)) -> GenLocated (SrcSpanAnn' ann) a -> TcM (GenLocated (SrcSpanAnn' ann) b, c) #
wrapLocSndMA :: (a -> TcM (b, c)) -> GenLocated (SrcSpanAnn' ann) a -> TcM (b, GenLocated (SrcSpanAnn' ann) c) #
wrapLocMA_ :: (a -> TcM ()) -> LocatedA a -> TcM () #
getErrsVar :: TcRn (TcRef (Messages TcRnMessage)) #
setErrsVar :: TcRef (Messages TcRnMessage) -> TcRn a -> TcRn a #
failWith :: TcRnMessage -> TcRn a #
failAt :: SrcSpan -> TcRnMessage -> TcRn a #
addErrAt :: SrcSpan -> TcRnMessage -> TcRn () #
addErrs :: [(SrcSpan, TcRnMessage)] -> TcRn () #
checkErr :: Bool -> TcRnMessage -> TcRn () #
addMessages :: Messages TcRnMessage -> TcRn () #
discardWarnings :: TcRn a -> TcRn a #
mkTcRnMessage :: SrcSpan -> TcRnMessage -> TcRn (MsgEnvelope TcRnMessage) #
reportDiagnostics :: [MsgEnvelope TcRnMessage] -> TcM () #
reportDiagnostic :: MsgEnvelope TcRnMessage -> TcRn () #
checkNoErrs :: TcM r -> TcM r #
whenNoErrs :: TcM () -> TcM () #
failIfErrsM :: TcRn () #
getErrCtxt :: TcM [ErrCtxt] #
setErrCtxt :: [ErrCtxt] -> TcM a -> TcM a #
addErrCtxt :: SDoc -> TcM a -> TcM a #
Add a fixed message to the error context. This message should not do any tidying.
addErrCtxtM :: (TidyEnv -> TcM (TidyEnv, SDoc)) -> TcM a -> TcM a #
Add a message to the error context. This message may do tidying.
addLandmarkErrCtxt :: SDoc -> TcM a -> TcM a #
Add a fixed landmark message to the error context. A landmark message is always sure to be reported, even if there is a lot of context. It also doesn't count toward the maximum number of contexts reported.
addLandmarkErrCtxtM :: (TidyEnv -> TcM (TidyEnv, SDoc)) -> TcM a -> TcM a #
Variant of addLandmarkErrCtxt that allows for monadic operations
and tidying.
popErrCtxt :: TcM a -> TcM a #
tryCaptureConstraints :: TcM a -> TcM (Maybe a, WantedConstraints) #
captureConstraints :: TcM a -> TcM (a, WantedConstraints) #
tcCollectingUsage :: TcM a -> TcM (UsageEnv, a) #
tcCollectingUsage thing_inside runs thing_inside and returns the usage
information which was collected as part of the execution of
thing_inside. Careful: tcCollectingUsage thing_inside itself does not
report any usage information, it's up to the caller to incorporate the
returned usage information into the larger context appropriately.
tcScalingUsage :: Mult -> TcM a -> TcM a #
tcScalingUsage mult thing_inside runs thing_inside and scales all the
usage information by mult.
tcEmitBindingUsage :: UsageEnv -> TcM () #
mapAndRecoverM :: (a -> TcRn b) -> [a] -> TcRn [b] #
Drop elements of the input that fail, so the result list can be shorter than the argument list
mapAndReportM :: (a -> TcRn b) -> [a] -> TcRn [b] #
Apply the function to all elements on the input list If all succeed, return the list of results Otherwise fail, propagating all errors
foldAndRecoverM :: (b -> a -> TcRn b) -> b -> [a] -> TcRn b #
The accumulator is not updated if the action fails
discardErrs :: TcRn a -> TcRn a #
tryTcDiscardingErrs :: TcM r -> TcM r -> TcM r #
addErrTc :: TcRnMessage -> TcM () #
addErrTcM :: (TidyEnv, TcRnMessage) -> TcM () #
failWithTc :: TcRnMessage -> TcM a #
failWithTcM :: (TidyEnv, TcRnMessage) -> TcM a #
checkTc :: Bool -> TcRnMessage -> TcM () #
failIfTc :: Bool -> TcRnMessage -> TcM () #
warnIf :: Bool -> TcRnMessage -> TcRn () #
Display a warning if a condition is met.
diagnosticTc :: Bool -> TcRnMessage -> TcM () #
Display a warning if a condition is met.
diagnosticTcM :: Bool -> (TidyEnv, TcRnMessage) -> TcM () #
Display a diagnostic if a condition is met.
addDiagnosticTc :: TcRnMessage -> TcM () #
Display a diagnostic in the current context.
addDiagnosticTcM :: (TidyEnv, TcRnMessage) -> TcM () #
Display a diagnostic in a given context.
addDetailedDiagnostic :: (ErrInfo -> TcRnMessage) -> TcM () #
A variation of addDiagnostic that takes a function to produce a TcRnDsMessage
given some additional context about the diagnostic.
addTcRnDiagnostic :: TcRnMessage -> TcM () #
addDiagnostic :: TcRnMessage -> TcRn () #
Display a diagnostic for the current source location, taken from
the TcRn monad.
addDiagnosticAt :: SrcSpan -> TcRnMessage -> TcRn () #
Display a diagnostic for a given source location.
newNoTcEvBinds :: TcM EvBindsVar #
Creates an EvBindsVar incapable of holding any bindings. It still tracks covar usages (see comments on ebv_tcvs in GHC.Tc.Types.Evidence), thus must be made monadically
cloneEvBindsVar :: EvBindsVar -> TcM EvBindsVar #
getTcEvTyCoVars :: EvBindsVar -> TcM TyCoVarSet #
getTcEvBindsMap :: EvBindsVar -> TcM EvBindMap #
setTcEvBindsMap :: EvBindsVar -> EvBindMap -> TcM () #
addTcEvBind :: EvBindsVar -> EvBind -> TcM () #
setConstraintVar :: TcRef WantedConstraints -> TcM a -> TcM a #
emitStaticConstraints :: WantedConstraints -> TcM () #
emitConstraints :: WantedConstraints -> TcM () #
emitSimple :: Ct -> TcM () #
emitSimples :: Cts -> TcM () #
emitImplication :: Implication -> TcM () #
emitImplications :: Bag Implication -> TcM () #
emitInsoluble :: Ct -> TcM () #
emitDelayedErrors :: Bag DelayedError -> TcM () #
emitNotConcreteError :: NotConcreteError -> TcM () #
discardConstraints :: TcM a -> TcM a #
Throw out any constraints emitted by the thing_inside
pushLevelAndCaptureConstraints :: TcM a -> TcM (TcLevel, WantedConstraints, a) #
The name says it all. The returned TcLevel is the *inner* TcLevel.
pushTcLevelM_ :: TcM a -> TcM a #
pushTcLevelM :: TcM a -> TcM (TcLevel, a) #
getTcLevel :: TcM TcLevel #
setTcLevel :: TcLevel -> TcM a -> TcM a #
isTouchableTcM :: TcTyVar -> TcM Bool #
setLclTypeEnv :: TcLclEnv -> TcM a -> TcM a #
traceTcConstraints :: String -> TcM () #
emitAnonTypeHole :: IsExtraConstraint -> TcTyVar -> TcM () #
emitNamedTypeHole :: (Name, TcTyVar) -> TcM () #
recordThUse :: TcM () #
recordThSpliceUse :: TcM () #
recordThNeededRuntimeDeps :: [Linkable] -> PkgsLoaded -> TcM () #
getStageAndBindLevel :: Name -> TcRn (Maybe (TopLevelFlag, ThLevel, ThStage)) #
addModFinalizersWithLclEnv :: ThModFinalizers -> TcM () #
Adds the given modFinalizers to the global environment and set them to use the current local environment.
recordUnsafeInfer :: Messages TcRnMessage -> TcM () #
Mark that safe inference has failed See Note [Safe Haskell Overlapping Instances Implementation] although this is used for more than just that failure case.
finalSafeMode :: DynFlags -> TcGblEnv -> IO SafeHaskellMode #
Figure out the final correct safe haskell mode
fixSafeInstances :: SafeHaskellMode -> [ClsInst] -> [ClsInst] #
Switch instances to safe instances if we're in Safe mode.
setLocalRdrEnv :: LocalRdrEnv -> RnM a -> RnM a #
mkIfLclEnv :: Module -> SDoc -> IsBootInterface -> IfLclEnv #
initIfaceTcRn :: IfG a -> TcRn a #
initIfaceLoad :: HscEnv -> IfG a -> IO a #
initIfaceLoad can be used when there's no chance that the action will
call typecheckIface when inside a module loop and hence tcIfaceGlobal.
initIfaceLoadModule :: HscEnv -> Module -> IfG a -> IO a #
This is used when we are doing to call typecheckModule on an ModIface,
if it's part of a loop with some other modules then we need to use their
IORef TypeEnv vars when typechecking but crucially not our own.
initIfaceLcl :: Module -> SDoc -> IsBootInterface -> IfL a -> IfM lcl a #
initIfaceLclWithSubst :: Module -> SDoc -> IsBootInterface -> NameShape -> IfL a -> IfM lcl a #
getIfModule :: IfL Module #
forkM :: SDoc -> IfL a -> IfL a #
Run thing_inside in an interleaved thread. It shares everything with the parent thread, so this is DANGEROUS.
It throws an error if the computation fails
It's used for lazily type-checking interface signatures, which is pretty benign.
See Note [Masking exceptions in forkM]
setImplicitEnvM :: TypeEnv -> IfL a -> IfL a #
getCCIndexM :: (gbl -> TcRef CostCentreState) -> FastString -> TcRnIf gbl lcl CostCentreIndex #
Get the next cost centre index associated with a given name.
getCCIndexTcM :: FastString -> TcM CostCentreIndex #
See getCCIndexM.
module GHC.Types.Basic
module GHC.Types.Id
A unique, unambiguous name for something, containing information about where that thing originated.
Instances
| Data Name | |
Defined in GHC.Types.Name Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Name -> c Name # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Name # 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 :: forall r r'. (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 # | |
| NFData Name | |
Defined in GHC.Types.Name | |
| ModifyState Name | |
Defined in GHC.Iface.Ext.Ast Methods addSubstitution :: Name -> Name -> HieState -> HieState | |
| NamedThing Name | |
Defined in GHC.Types.Name | |
| HasOccName Name | |
Defined in GHC.Types.Name | |
| Uniquable Name | |
Defined in GHC.Types.Name | |
| Binary Name | Assumes that the |
| Outputable Name | |
Defined in GHC.Types.Name | |
| OutputableBndr Name | |
Defined in GHC.Types.Name Methods pprBndr :: BindingSite -> Name -> SDoc # pprPrefixOcc :: Name -> SDoc # pprInfixOcc :: Name -> SDoc # bndrIsJoin_maybe :: Name -> Maybe Int # | |
| Eq Name | |
| Ord Name | Caution: This instance is implemented via See |
| ToHie (LBooleanFormula (LocatedN Name)) | |
Defined in GHC.Iface.Ext.Ast | |
| ToHie (Context (Located Name)) | |
| NFData (UniqFM Name [Name]) Source # | |
| type Anno Name | |
Defined in GHC.Hs.Extension | |
| type Anno (LocatedN Name) | |
Defined in GHC.Hs.Binds | |
| type Anno [LocatedN Name] | |
Defined in GHC.Hs.Binds | |
class HasOccName name where #
Other names in the compiler add additional information to an OccName. This class provides a consistent way to access the underlying OccName.
Instances
| HasOccName IfaceClassOp | |
Defined in GHC.Iface.Syntax Methods occName :: IfaceClassOp -> OccName # | |
| HasOccName IfaceConDecl | |
Defined in GHC.Iface.Syntax Methods occName :: IfaceConDecl -> OccName # | |
| HasOccName IfaceDecl | |
Defined in GHC.Iface.Syntax | |
| HasOccName HoleFitCandidate | |
Defined in GHC.Tc.Errors.Hole.FitTypes Methods occName :: HoleFitCandidate -> OccName # | |
| HasOccName TcBinder | |
Defined in GHC.Tc.Types | |
| HasOccName GreName | |
Defined in GHC.Types.Avail | |
| HasOccName FieldLabel | |
Defined in GHC.Types.FieldLabel Methods occName :: FieldLabel -> OccName # | |
| HasOccName Name | |
Defined in GHC.Types.Name | |
| HasOccName OccName | |
Defined in GHC.Types.Name.Occurrence | |
| HasOccName GlobalRdrElt | |
Defined in GHC.Types.Name.Reader Methods occName :: GlobalRdrElt -> OccName # | |
| HasOccName RdrName | |
Defined in GHC.Types.Name.Reader | |
| HasOccName Var | |
Defined in GHC.Types.Var | |
Occurrence Name
In this context that means: "classified (i.e. as a type name, value name, etc) but not qualified and not yet resolved"
Instances
| Data OccName | |
Defined in GHC.Types.Name.Occurrence Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OccName -> c OccName # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OccName # toConstr :: OccName -> Constr # dataTypeOf :: OccName -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OccName) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OccName) # gmapT :: (forall b. Data b => b -> b) -> OccName -> OccName # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OccName -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OccName -> r # gmapQ :: (forall d. Data d => d -> u) -> OccName -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> OccName -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> OccName -> m OccName # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OccName -> m OccName # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OccName -> m OccName # | |
| Show OccName Source # | |
| NFData OccName | |
Defined in GHC.Types.Name.Occurrence | |
| HasOccName OccName | |
Defined in GHC.Types.Name.Occurrence | |
| Uniquable OccName | |
Defined in GHC.Types.Name.Occurrence | |
| Binary OccName | |
| Outputable OccName | |
Defined in GHC.Types.Name.Occurrence | |
| OutputableBndr OccName | |
Defined in GHC.Types.Name.Occurrence Methods pprBndr :: BindingSite -> OccName -> SDoc # pprPrefixOcc :: OccName -> SDoc # pprInfixOcc :: OccName -> SDoc # bndrIsJoin_maybe :: OccName -> Maybe Int # | |
| Eq OccName | |
| Ord OccName | |
Defined in GHC.Types.Name.Occurrence | |
| Hashable OccName Source # | |
Defined in Development.IDE.GHC.Orphans | |
class NamedThing a where #
A class allowing convenient access to the Name of various datatypes
Minimal complete definition
Instances
| NamedThing Class | |
Defined in GHC.Core.Class | |
| NamedThing ConLike | |
Defined in GHC.Core.ConLike | |
| NamedThing DataCon | |
Defined in GHC.Core.DataCon | |
| NamedThing FamInst | |
Defined in GHC.Core.FamInstEnv | |
| NamedThing ClsInst | |
Defined in GHC.Core.InstEnv | |
| NamedThing PatSyn | |
Defined in GHC.Core.PatSyn | |
| NamedThing TyCon | |
Defined in GHC.Core.TyCon | |
| NamedThing IfaceClassOp | |
Defined in GHC.Iface.Syntax | |
| NamedThing IfaceConDecl | |
Defined in GHC.Iface.Syntax | |
| NamedThing IfaceDecl | |
Defined in GHC.Iface.Syntax | |
| NamedThing HoleFitCandidate | |
Defined in GHC.Tc.Errors.Hole.FitTypes | |
| NamedThing Name | |
Defined in GHC.Types.Name | |
| NamedThing TyThing | |
Defined in GHC.Types.TyThing | |
| NamedThing Var | |
Defined in GHC.Types.Var | |
| NamedThing (CoAxiom br) | |
Defined in GHC.Core.Coercion.Axiom | |
| NamedThing e => NamedThing (Located e) | |
Defined in GHC.Types.Name | |
| NamedThing (Located a) => NamedThing (LocatedAn an a) | |
Defined in GHC.Parser.Annotation | |
| NamedThing tv => NamedThing (VarBndr tv flag) | |
Defined in GHC.Types.Var | |
type FastStringEnv a = UniqFM FastString a #
A non-deterministic set of FastStrings. See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM for explanation why it's not deterministic and why it matters. Use DFastStringEnv if the set eventually gets converted into a list or folded over in a way where the order changes the generated code.
type TidyOccEnv = UniqFM FastString Int #
Instances
| Data a => Data (OccEnv a) | |
Defined in GHC.Types.Name.Occurrence Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OccEnv a -> c (OccEnv a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (OccEnv a) # toConstr :: OccEnv a -> Constr # dataTypeOf :: OccEnv a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (OccEnv a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (OccEnv a)) # gmapT :: (forall b. Data b => b -> b) -> OccEnv a -> OccEnv a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OccEnv a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OccEnv a -> r # gmapQ :: (forall d. Data d => d -> u) -> OccEnv a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> OccEnv a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> OccEnv a -> m (OccEnv a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OccEnv a -> m (OccEnv a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OccEnv a -> m (OccEnv a) # | |
| Outputable a => Outputable (OccEnv a) | |
Defined in GHC.Types.Name.Occurrence | |
Instances
| Binary NameSpace | |
| Eq NameSpace | |
| Ord NameSpace | |
data BuiltInSyntax #
BuiltInSyntax is for things like (:), [] and tuples,
which have special syntactic forms. They aren't in scope
as such.
Constructors
| BuiltInSyntax | |
| UserSyntax |
mkVarOccFS :: FastString -> OccName #
mkRecFldSelOcc :: FastString -> OccName #
tidyNameOcc :: Name -> OccName -> Name #
nameOccName :: Name -> OccName #
setNameUnique :: Name -> Unique -> Name #
nameUnique :: Name -> Unique #
emptyFsEnv :: FastStringEnv a #
extendFsEnv :: FastStringEnv a -> FastString -> a -> FastStringEnv a #
lookupFsEnv :: FastStringEnv a -> FastString -> Maybe a #
mkFsEnv :: [(FastString, a)] -> FastStringEnv a #
isDataConNameSpace :: NameSpace -> Bool #
isTcClsNameSpace :: NameSpace -> Bool #
isTvNameSpace :: NameSpace -> Bool #
isVarNameSpace :: NameSpace -> Bool #
isValNameSpace :: NameSpace -> Bool #
pprNameSpace :: NameSpace -> SDoc #
pprNonVarNameSpace :: NameSpace -> SDoc #
pprNameSpaceBrief :: IsLine doc => NameSpace -> doc #
pprOccName :: IsLine doc => OccName -> doc #
mkOccNameFS :: NameSpace -> FastString -> OccName #
mkDataOccFS :: FastString -> OccName #
mkTyVarOcc :: String -> OccName #
mkTyVarOccFS :: FastString -> OccName #
mkTcOccFS :: FastString -> OccName #
mkClsOccFS :: FastString -> OccName #
demoteOccName :: OccName -> Maybe OccName #
promoteOccName :: OccName -> Maybe OccName #
emptyOccEnv :: OccEnv a #
unitOccEnv :: OccName -> a -> OccEnv a #
extendOccEnv :: OccEnv a -> OccName -> a -> OccEnv a #
extendOccEnvList :: OccEnv a -> [(OccName, a)] -> OccEnv a #
lookupOccEnv :: OccEnv a -> OccName -> Maybe a #
elemOccEnv :: OccName -> OccEnv a -> Bool #
foldOccEnv :: (a -> b -> b) -> b -> OccEnv a -> b #
nonDetOccEnvElts :: OccEnv a -> [a] #
plusOccEnv :: OccEnv a -> OccEnv a -> OccEnv a #
plusOccEnv_C :: (a -> a -> a) -> OccEnv a -> OccEnv a -> OccEnv a #
extendOccEnv_C :: (a -> a -> a) -> OccEnv a -> OccName -> a -> OccEnv a #
extendOccEnv_Acc :: (a -> b -> b) -> (a -> b) -> OccEnv b -> OccName -> a -> OccEnv b #
mkOccEnv_C :: (a -> a -> a) -> [(OccName, a)] -> OccEnv a #
delFromOccEnv :: OccEnv a -> OccName -> OccEnv a #
delListFromOccEnv :: OccEnv a -> [OccName] -> OccEnv a #
filterOccEnv :: (elt -> Bool) -> OccEnv elt -> OccEnv elt #
minusOccEnv :: OccEnv a -> OccEnv b -> OccEnv a #
minusOccEnv_C :: (a -> b -> Maybe a) -> OccEnv a -> OccEnv b -> OccEnv a #
Alters (replaces or removes) those elements of the map that are mentioned in the second map
emptyOccSet :: OccSet #
unitOccSet :: OccName -> OccSet #
extendOccSet :: OccSet -> OccName -> OccSet #
extendOccSetList :: OccSet -> [OccName] -> OccSet #
unionOccSets :: OccSet -> OccSet -> OccSet #
unionManyOccSets :: [OccSet] -> OccSet #
minusOccSet :: OccSet -> OccSet -> OccSet #
elemOccSet :: OccName -> OccSet -> Bool #
isEmptyOccSet :: OccSet -> Bool #
intersectOccSet :: OccSet -> OccSet -> OccSet #
occSetToEnv :: OccSet -> OccEnv OccName #
Converts an OccSet to an OccEnv (operationally the identity)
occNameString :: OccName -> String #
setOccNameSpace :: NameSpace -> OccName -> OccName #
Value OccNamess are those that are either in
the variable or data constructor namespaces
isDataSymOcc :: OccName -> Bool #
Test if the OccName is a data constructor that starts with
a symbol (e.g. :, or [])
Test if the OccName is that for any operator (whether
it is a data constructor or variable or whatever)
parenSymOcc :: OccName -> SDoc -> SDoc #
Wrap parens around an operator
startsWithUnderscore :: OccName -> Bool #
Haskell 98 encourages compilers to suppress warnings about unused
names in a pattern if they start with _: this implements that test
isDerivedOccName :: OccName -> Bool #
Test for definitions internally generated by GHC. This predicate is used to suppress printing of internal definitions in some debug prints
isDefaultMethodOcc :: OccName -> Bool #
isTypeableBindOcc :: OccName -> Bool #
Is an OccName one of a Typeable TyCon or Module binding?
This is needed as these bindings are renamed differently.
See Note [Grand plan for Typeable] in GHC.Tc.Instance.Typeable.
mkDataConWrapperOcc :: OccName -> OccName #
mkWorkerOcc :: OccName -> OccName #
mkMatcherOcc :: OccName -> OccName #
mkBuilderOcc :: OccName -> OccName #
mkDefaultMethodOcc :: OccName -> OccName #
mkClassOpAuxOcc :: OccName -> OccName #
mkForeignExportOcc :: OccName -> OccName #
mkRepEqOcc :: OccName -> OccName #
mkClassDataConOcc :: OccName -> OccName #
mkNewTyCoOcc :: OccName -> OccName #
mkInstTyCoOcc :: OccName -> OccName #
mkEqPredCoOcc :: OccName -> OccName #
mkCon2TagOcc :: OccName -> OccName #
mkTag2ConOcc :: OccName -> OccName #
mkMaxTagOcc :: OccName -> OccName #
mkDataTOcc :: OccName -> OccName #
mkDataCOcc :: OccName -> OccName #
mkTyConRepOcc :: OccName -> OccName #
mkDataConWorkerOcc :: OccName -> OccName #
mkSuperDictAuxOcc :: Int -> OccName -> OccName #
Derive a name for the representation type constructor of a
data/newtype instance.
mkMethodOcc :: OccName -> OccName #
initTidyOccEnv :: [OccName] -> TidyOccEnv #
delTidyOccEnvList :: TidyOccEnv -> [FastString] -> TidyOccEnv #
avoidClashesOccEnv :: TidyOccEnv -> [OccName] -> TidyOccEnv #
tidyOccName :: TidyOccEnv -> OccName -> (TidyOccEnv, OccName) #
nameNameSpace :: Name -> NameSpace #
nameSrcLoc :: Name -> SrcLoc #
nameSrcSpan :: Name -> SrcSpan #
isWiredInName :: Name -> Bool #
isWiredIn :: NamedThing thing => thing -> Bool #
isBuiltInSyntax :: Name -> Bool #
isExternalName :: Name -> Bool #
isInternalName :: Name -> Bool #
isHoleName :: Name -> Bool #
isDynLinkName :: Platform -> Module -> Name -> Bool #
Will the Name come from a dynamically linked package?
nameModule :: HasDebugCallStack => Name -> Module #
nameModule_maybe :: Name -> Maybe Module #
namePun_maybe :: Name -> Maybe FastString #
nameIsLocalOrFrom :: Module -> Name -> Bool #
Returns True if the name is
(a) Internal
(b) External but from the specified module
(c) External but from the interactive package
The key idea is that False means: the entity is defined in some other module you can find the details (type, fixity, instances) in some interface file those details will be stored in the EPT or HPT
True means: the entity is defined in this module or earlier in the GHCi session you can find details (type, fixity, instances) in the TcGblEnv or TcLclEnv
The isInteractiveModule part is because successive interactions of a GHCi session
each give rise to a fresh module (Ghci1, Ghci2, etc), but they all come
from the magic interactive package; and all the details are kept in the
TcLclEnv, TcGblEnv, NOT in the HPT or EPT.
See Note [The interactive package] in GHC.Runtime.Context
nameIsExternalOrFrom :: Module -> Name -> Bool #
Returns True if the name is external or from the interactive package
See documentation of nameIsLocalOrFrom function
nameIsHomePackage :: Module -> Name -> Bool #
nameIsHomePackageImport :: Module -> Name -> Bool #
nameIsFromExternalPackage :: HomeUnit -> Name -> Bool #
Returns True if the Name comes from some other package: neither this package nor the interactive package.
isTyVarName :: Name -> Bool #
isTyConName :: Name -> Bool #
isDataConName :: Name -> Bool #
isSystemName :: Name -> Bool #
mkClonedInternalName :: Unique -> Name -> Name #
mkExternalName :: Unique -> Module -> OccName -> SrcSpan -> Name #
Create a name which definitely originates in the given module
mkWiredInName :: Module -> OccName -> Unique -> TyThing -> BuiltInSyntax -> Name #
Create a name which is actually defined by the compiler itself
mkSystemName :: Unique -> OccName -> Name #
Create a name brought into being by the compiler
mkSystemVarName :: Unique -> FastString -> Name #
mkSysTvName :: Unique -> FastString -> Name #
mkFCallName :: Unique -> FastString -> Name #
Make a name for a foreign call
setNameLoc :: Name -> SrcSpan -> Name #
localiseName :: Name -> Name #
Make the Name into an internal name, regardless of what it was to begin with
stableNameCmp :: Name -> Name -> Ordering #
Compare Names lexicographically This only works for Names that originate in the source code or have been tidied.
pprFullName :: Module -> Name -> SDoc #
Print fully qualified name (with unit-id, module and unique)
pprTickyName :: Module -> Name -> SDoc #
Print a ticky ticky styled name
Module argument is the module to use for internal and system names. When printing the name in a ticky profile, the module name is included even for local things. However, ticky uses the format "x (M)" rather than "M.x". Hence, this function provides a separation from normal styling.
pprNameUnqualified :: Name -> SDoc #
Print the string of Name unqualifiedly directly.
pprDefinedAt :: Name -> SDoc #
pprNameDefnLoc :: Name -> SDoc #
nameStableString :: Name -> String #
Get a string representation of a Name that's unique and stable
across recompilations. Used for deterministic generation of binds for
derived instances.
eg. "$aeson_70dylHtv1FFGeai1IoxcQr$Data.Aeson.Types.Internal$String"
getSrcLoc :: NamedThing a => a -> SrcLoc #
getSrcSpan :: NamedThing a => a -> SrcSpan #
getOccString :: NamedThing a => a -> String #
getOccFS :: NamedThing a => a -> FastString #
pprInfixName :: (Outputable a, NamedThing a) => a -> SDoc #
pprPrefixName :: NamedThing a => a -> SDoc #
module GHC.Types.Name.Set
module GHC.Types.Name.Cache
module GHC.Types.Name.Env
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'`',AnnValAnnTilde,
Constructors
| 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 |
| Orig Module OccName | Original name An original name; the module is the defining module.
This is used when GHC generates code that will be fed
into the renamer (e.g. from deriving clauses), but where
we want to say "Use Prelude.map dammit". One of these
can be created with |
| Exact Name | Exact name We know exactly the
Such a |
Instances
Used where we may have an ordinary name or a record field label. See Note [GreNames] in GHC.Types.Name.Reader.
Constructors
| NormalGreName Name | |
| FieldGreName FieldLabel |
Instances
| Data GreName | |
Defined in GHC.Types.Avail Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GreName -> c GreName # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c GreName # toConstr :: GreName -> Constr # dataTypeOf :: GreName -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c GreName) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GreName) # gmapT :: (forall b. Data b => b -> b) -> GreName -> GreName # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GreName -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GreName -> r # gmapQ :: (forall d. Data d => d -> u) -> GreName -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> GreName -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> GreName -> m GreName # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GreName -> m GreName # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GreName -> m GreName # | |
| NFData GreName | |
Defined in GHC.Types.Avail | |
| HasOccName GreName | |
Defined in GHC.Types.Avail | |
| Binary GreName | |
| Outputable GreName | |
Defined in GHC.Types.Avail | |
| Eq GreName | |
| Ord GreName | |
data ImpItemSpec #
Import Item Specification
Describes import info a particular Name
Constructors
| ImpAll | The import had no import list, or had a hiding list |
| ImpSome | The import had an import list.
The import C( T(..) ) Here the constructors of |
Fields
| |
Instances
| Data ImpItemSpec | |
Defined in GHC.Types.Name.Reader Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImpItemSpec -> c ImpItemSpec # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ImpItemSpec # toConstr :: ImpItemSpec -> Constr # dataTypeOf :: ImpItemSpec -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ImpItemSpec) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImpItemSpec) # gmapT :: (forall b. Data b => b -> b) -> ImpItemSpec -> ImpItemSpec # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImpItemSpec -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImpItemSpec -> r # gmapQ :: (forall d. Data d => d -> u) -> ImpItemSpec -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ImpItemSpec -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImpItemSpec -> m ImpItemSpec # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImpItemSpec -> m ImpItemSpec # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImpItemSpec -> m ImpItemSpec # | |
| Eq ImpItemSpec | |
Defined in GHC.Types.Name.Reader | |
data ImpDeclSpec #
Import Declaration Specification
Describes a particular import declaration and is
shared among all the Provenances for that decl
Constructors
| ImpDeclSpec | |
Fields
| |
Instances
| Data ImpDeclSpec | |
Defined in GHC.Types.Name.Reader Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImpDeclSpec -> c ImpDeclSpec # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ImpDeclSpec # toConstr :: ImpDeclSpec -> Constr # dataTypeOf :: ImpDeclSpec -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ImpDeclSpec) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImpDeclSpec) # gmapT :: (forall b. Data b => b -> b) -> ImpDeclSpec -> ImpDeclSpec # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImpDeclSpec -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImpDeclSpec -> r # gmapQ :: (forall d. Data d => d -> u) -> ImpDeclSpec -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ImpDeclSpec -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImpDeclSpec -> m ImpDeclSpec # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImpDeclSpec -> m ImpDeclSpec # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImpDeclSpec -> m ImpDeclSpec # | |
| Eq ImpDeclSpec | |
Defined in GHC.Types.Name.Reader | |
data ImportSpec #
Import Specification
The ImportSpec of something says how it came to be imported
It's quite elaborate so that we can give accurate unused-name warnings.
Constructors
| ImpSpec | |
Fields
| |
Instances
| Data ImportSpec | |
Defined in GHC.Types.Name.Reader Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImportSpec -> c ImportSpec # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ImportSpec # toConstr :: ImportSpec -> Constr # dataTypeOf :: ImportSpec -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ImportSpec) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImportSpec) # gmapT :: (forall b. Data b => b -> b) -> ImportSpec -> ImportSpec # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImportSpec -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImportSpec -> r # gmapQ :: (forall d. Data d => d -> u) -> ImportSpec -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ImportSpec -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImportSpec -> m ImportSpec # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportSpec -> m ImportSpec # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportSpec -> m ImportSpec # | |
| Outputable ImportSpec | |
Defined in GHC.Types.Name.Reader Methods ppr :: ImportSpec -> SDoc # | |
| Eq ImportSpec | |
Defined in GHC.Types.Name.Reader | |
See Note [Parents]
Instances
| Data Parent | |
Defined in GHC.Types.Name.Reader Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Parent -> c Parent # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Parent # toConstr :: Parent -> Constr # dataTypeOf :: Parent -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Parent) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Parent) # gmapT :: (forall b. Data b => b -> b) -> Parent -> Parent # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Parent -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Parent -> r # gmapQ :: (forall d. Data d => d -> u) -> Parent -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Parent -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Parent -> m Parent # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Parent -> m Parent # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Parent -> m Parent # | |
| Outputable Parent | |
Defined in GHC.Types.Name.Reader | |
| Eq Parent | |
data GlobalRdrElt #
Global Reader Element
An element of the GlobalRdrEnv
Instances
| Data GlobalRdrElt | |
Defined in GHC.Types.Name.Reader Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GlobalRdrElt -> c GlobalRdrElt # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c GlobalRdrElt # toConstr :: GlobalRdrElt -> Constr # dataTypeOf :: GlobalRdrElt -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c GlobalRdrElt) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GlobalRdrElt) # gmapT :: (forall b. Data b => b -> b) -> GlobalRdrElt -> GlobalRdrElt # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GlobalRdrElt -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GlobalRdrElt -> r # gmapQ :: (forall d. Data d => d -> u) -> GlobalRdrElt -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> GlobalRdrElt -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> GlobalRdrElt -> m GlobalRdrElt # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GlobalRdrElt -> m GlobalRdrElt # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GlobalRdrElt -> m GlobalRdrElt # | |
| HasOccName GlobalRdrElt | |
Defined in GHC.Types.Name.Reader Methods occName :: GlobalRdrElt -> OccName # | |
| Outputable GlobalRdrElt | |
Defined in GHC.Types.Name.Reader Methods ppr :: GlobalRdrElt -> SDoc # | |
type GlobalRdrEnv = OccEnv [GlobalRdrElt] #
Global Reader Environment
Keyed by OccName; when looking up a qualified name
we look up the OccName part, and then check the Provenance
to see if the appropriate qualification is valid. This
saves routinely doubling the size of the env by adding both
qualified and unqualified names to the domain.
The list in the codomain is required because there may be name clashes These only get reported on lookup, not on construction
INVARIANT 1: All the members of the list have distinct
gre_name fields; that is, no duplicate Names
INVARIANT 2: Imported provenance => Name is an ExternalName However LocalDefs can have an InternalName. This happens only when type-checking a [d| ... |] Template Haskell quotation; see this note in GHC.Rename.Names Note [Top-level Names in Template Haskell decl quotes]
INVARIANT 3: If the GlobalRdrEnv maps [occ -> gre], then greOccName gre = occ
NB: greOccName gre is usually the same as nameOccName (greMangledName gre), but not always in the case of record selectors; see Note [GreNames]
data LocalRdrEnv #
Local Reader Environment See Note [LocalRdrEnv]
Instances
| Outputable LocalRdrEnv | |
Defined in GHC.Types.Name.Reader Methods ppr :: LocalRdrEnv -> SDoc # | |
greNameSrcSpan :: GreName -> SrcSpan #
rdrNameOcc :: RdrName -> OccName #
rdrNameSpace :: RdrName -> NameSpace #
demoteRdrName :: RdrName -> Maybe RdrName #
promoteRdrName :: RdrName -> Maybe RdrName #
mkRdrUnqual :: OccName -> RdrName #
mkRdrQual :: ModuleName -> OccName -> RdrName #
mkUnqual :: NameSpace -> FastString -> RdrName #
mkVarUnqual :: FastString -> RdrName #
mkQual :: NameSpace -> (FastString, FastString) -> RdrName #
Make a qualified RdrName in the given namespace and where the ModuleName and
the OccName are taken from the first and second elements of the tuple respectively
getRdrName :: NamedThing thing => thing -> RdrName #
nameRdrName :: Name -> RdrName #
isRdrDataCon :: RdrName -> Bool #
isRdrTyVar :: RdrName -> Bool #
isSrcRdrName :: RdrName -> Bool #
isQual_maybe :: RdrName -> Maybe (ModuleName, OccName) #
isExact_maybe :: RdrName -> Maybe Name #
extendLocalRdrEnv :: LocalRdrEnv -> Name -> LocalRdrEnv #
extendLocalRdrEnvList :: LocalRdrEnv -> [Name] -> LocalRdrEnv #
lookupLocalRdrEnv :: LocalRdrEnv -> RdrName -> Maybe Name #
lookupLocalRdrOcc :: LocalRdrEnv -> OccName -> Maybe Name #
elemLocalRdrEnv :: RdrName -> LocalRdrEnv -> Bool #
localRdrEnvElts :: LocalRdrEnv -> [Name] #
inLocalRdrEnvScope :: Name -> LocalRdrEnv -> Bool #
minusLocalRdrEnv :: LocalRdrEnv -> OccEnv a -> LocalRdrEnv #
gresFromAvails :: Maybe ImportSpec -> [AvailInfo] -> [GlobalRdrElt] #
make a GlobalRdrEnv where all the elements point to the same
Provenance (useful for "hiding" imports, or imports with no details).
localGREsFromAvail :: AvailInfo -> [GlobalRdrElt] #
gresFromAvail :: (Name -> Maybe ImportSpec) -> AvailInfo -> [GlobalRdrElt] #
greOccName :: GlobalRdrElt -> OccName #
See Note [GreNames]
greMangledName :: GlobalRdrElt -> Name #
A Name for the GRE for internal use. Careful: the OccName of this
Name is not necessarily the same as the greOccName (see Note [GreNames]).
grePrintableName :: GlobalRdrElt -> Name #
A Name for the GRE suitable for output to the user. Its OccName will
be the greOccName (see Note [GreNames]).
greDefinitionSrcSpan :: GlobalRdrElt -> SrcSpan #
The SrcSpan of the name pointed to by the GRE.
greDefinitionModule :: GlobalRdrElt -> Maybe Module #
The module in which the name pointed to by the GRE is defined.
greRdrNames :: GlobalRdrElt -> [RdrName] #
greSrcSpan :: GlobalRdrElt -> SrcSpan #
greParent_maybe :: GlobalRdrElt -> Maybe Name #
gresToAvailInfo :: [GlobalRdrElt] -> [AvailInfo] #
Takes a list of distinct GREs and folds them
into AvailInfos. This is more efficient than mapping each individual
GRE to an AvailInfo and the folding using plusAvail but needs the
uniqueness assumption.
availFromGRE :: GlobalRdrElt -> AvailInfo #
globalRdrEnvElts :: GlobalRdrEnv -> [GlobalRdrElt] #
pprGlobalRdrEnv :: Bool -> GlobalRdrEnv -> SDoc #
lookupGlobalRdrEnv :: GlobalRdrEnv -> OccName -> [GlobalRdrElt] #
lookupGRE_RdrName :: RdrName -> GlobalRdrEnv -> [GlobalRdrElt] #
Look for this RdrName in the global environment. Omits record fields
without selector functions (see Note [NoFieldSelectors] in GHC.Rename.Env).
lookupGRE_RdrName' :: RdrName -> GlobalRdrEnv -> [GlobalRdrElt] #
Look for this RdrName in the global environment. Includes record fields
without selector functions (see Note [NoFieldSelectors] in GHC.Rename.Env).
lookupGRE_Name :: GlobalRdrEnv -> Name -> Maybe GlobalRdrElt #
lookupGRE_GreName :: GlobalRdrEnv -> GreName -> Maybe GlobalRdrElt #
lookupGRE_FieldLabel :: GlobalRdrEnv -> FieldLabel -> Maybe GlobalRdrElt #
Look for a particular record field selector in the environment, where the selector name and field label may be different: the GlobalRdrEnv is keyed on the label. See Note [GreNames] for why this happens.
lookupGRE_Name_OccName :: GlobalRdrEnv -> Name -> OccName -> Maybe GlobalRdrElt #
Look for precisely this Name in the environment, but with an OccName
that might differ from that of the Name. See lookupGRE_FieldLabel and
Note [GreNames].
getGRE_NameQualifier_maybes :: GlobalRdrEnv -> Name -> [Maybe [ModuleName]] #
isLocalGRE :: GlobalRdrElt -> Bool #
isRecFldGRE :: GlobalRdrElt -> Bool #
isDuplicateRecFldGRE :: GlobalRdrElt -> Bool #
Is this a record field defined with DuplicateRecordFields? (See Note [GreNames])
isNoFieldSelectorGRE :: GlobalRdrElt -> Bool #
Is this a record field defined with NoFieldSelectors? (See Note [NoFieldSelectors] in GHC.Rename.Env)
isFieldSelectorGRE :: GlobalRdrElt -> Bool #
Is this a record field defined with FieldSelectors? (See Note [NoFieldSelectors] in GHC.Rename.Env)
greFieldLabel :: GlobalRdrElt -> Maybe FieldLabel #
Returns the field label of this GRE, if it has one
unQualOK :: GlobalRdrElt -> Bool #
Test if an unqualified version of this thing would be in scope
pickGREs :: RdrName -> [GlobalRdrElt] -> [GlobalRdrElt] #
Takes a list of GREs which have the right OccName x
Pick those GREs that are in scope
* Qualified, as x if want_qual is Qual M _
* Unqualified, as x if want_unqual is Unqual _
Return each such GRE, with its ImportSpecs filtered, to reflect how it is in scope qualified or unqualified respectively. See Note [GRE filtering]
pickGREsModExp :: ModuleName -> [GlobalRdrElt] -> [(GlobalRdrElt, GlobalRdrElt)] #
Pick GREs that are in scope *both* qualified *and* unqualified Return each GRE that is, as a pair (qual_gre, unqual_gre) These two GREs are the original GRE with imports filtered to express how it is in scope qualified an unqualified respectively
Used only for the 'module M' item in export list;
see exports_from_avail
mkGlobalRdrEnv :: [GlobalRdrElt] -> GlobalRdrEnv #
transformGREs :: (GlobalRdrElt -> GlobalRdrElt) -> [OccName] -> GlobalRdrEnv -> GlobalRdrEnv #
Apply a transformation function to the GREs for these OccNames
shadowNames :: GlobalRdrEnv -> OccEnv a -> GlobalRdrEnv #
bestImport :: [ImportSpec] -> ImportSpec #
unQualSpecOK :: ImportSpec -> Bool #
Is in scope unqualified?
qualSpecOK :: ModuleName -> ImportSpec -> Bool #
Is in scope qualified with the given module?
importSpecLoc :: ImportSpec -> SrcSpan #
isExplicitItem :: ImpItemSpec -> Bool #
pprNameProvenance :: GlobalRdrElt -> SDoc #
Print out one place where the name was define/imported (With -dppr-debug, print them all)
Used to describe warnings and errors
o The message has a file/line/column heading,
plus "warning:" or "error:",
added by mkLocMessage
o With SevIgnore the message is suppressed
o Output is intended for end users
Constructors
| SevIgnore | Ignore this message, for example in case of suppression of warnings users don't want to see. See Note [Suppressing Messages] |
| SevWarning | |
| SevError |
Instances
| Show Severity | |
| ToJson Severity | |
Defined in GHC.Types.Error | |
| Outputable Severity | |
Defined in GHC.Types.Error | |
| Eq Severity | |
emptyMessages :: Messages e #
greNamePrintableName :: GreName -> Name #
Constructors
| HsSrcFile | .hs file |
| HsBootFile | .hs-boot file |
| HsigFile | .hsig file |
Instances
| Show HscSource | |
| Binary HscSource | |
| Eq HscSource | |
| Ord HscSource | |
module GHC.Types.SourceText
module GHC.Types.TyThing
module GHC.Types.TyThing.Ppr
module GHC.Types.Unique.Supply
Variable
Essentially a typed Name, that may also contain some additional information
about the Var and its use sites.
Instances
| Data Var | |
Defined in GHC.Types.Var Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Var -> c Var # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Var # dataTypeOf :: Var -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Var) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Var) # gmapT :: (forall b. Data b => b -> b) -> Var -> Var # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r # gmapQ :: (forall d. Data d => d -> u) -> Var -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Var -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Var -> m Var # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Var -> m Var # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Var -> m Var # | |
| ModifyState Id | |
Defined in GHC.Iface.Ext.Ast Methods addSubstitution :: Id -> Id -> HieState -> HieState | |
| NamedThing Var | |
Defined in GHC.Types.Var | |
| HasOccName Var | |
Defined in GHC.Types.Var | |
| Uniquable Var | |
Defined in GHC.Types.Var | |
| Outputable Var | |
Defined in GHC.Types.Var | |
| Eq Var | |
| Ord Var | |
| ToHie (Context (Located Var)) | |
| Eq (DeBruijn Var) | |
| OutputableBndr (Id, TagSig) | |
Defined in GHC.Stg.InferTags.TagSig | |
| type Anno Id | |
Defined in GHC.Hs.Extension | |
| type Anno (LocatedN Id) | |
Defined in GHC.Hs.Binds | |
| type Anno [LocatedN Id] | |
Defined in GHC.Hs.Binds | |
setVarUnique :: Var -> Unique -> Var #
setTyVarUnique :: TyVar -> Unique -> TyVar #
newtype ModuleName #
A ModuleName is essentially a simple string, e.g. Data.List.
Constructors
| ModuleName FastString |
Instances
data IsBootInterface #
Indicates whether a module name is referring to a boot interface (hs-boot file) or regular module (hs file). We need to treat boot modules specially when building compilation graphs, since they break cycles. Regular source files and signature files are treated equivalently.
Instances
A unit identifier identifies a (possibly partially) instantiated library.
It is primarily used as part of GenModule, which in turn is used in Name,
which is used to give names to entities when typechecking.
There are two possible forms for a Unit:
1) It can be a RealUnit, in which case we just have a DefUnitId that
uniquely identifies some fully compiled, installed library we have on disk.
2) It can be an VirtUnit. 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
GenInstantiatedUnit, which explicitly records the instantiation, so that we
can substitute over it.
Constructors
| RealUnit !(Definite uid) | Installed definite unit (either a fully instantiated unit or a closed unit) |
| VirtUnit !(GenInstantiatedUnit uid) | Virtual unit instantiated on-the-fly. It may be definite if all the holes are instantiated but we don't have code objects for it. |
| HoleUnit | Fake hole unit |
Instances
| Data Unit | |
Defined in GHC.Unit.Types Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Unit -> c Unit # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Unit # dataTypeOf :: Unit -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Unit) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Unit) # gmapT :: (forall b. Data b => b -> b) -> Unit -> Unit # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Unit -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Unit -> r # gmapQ :: (forall d. Data d => d -> u) -> Unit -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Unit -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Unit -> m Unit # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Unit -> m Unit # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Unit -> m Unit # | |
| Show Module Source # | |
| Show Unit | |
| NFData Unit | |
Defined in GHC.Unit.Types | |
| Uniquable Module | |
Defined in GHC.Unit.Types | |
| Binary Unit | |
| Outputable Module | |
Defined in GHC.Unit.Types | |
| Outputable Unit | |
Defined in GHC.Unit.Types | |
| Ord Unit | |
| IsUnitId u => Uniquable (GenUnit u) | |
Defined in GHC.Unit.Types | |
| IsUnitId u => IsUnitId (GenUnit u) | |
Defined in GHC.Unit.Types Methods unitFS :: GenUnit u -> FastString # | |
| IsUnitId u => Eq (GenUnit u) | |
A generic module is a pair of a unit identifier and a ModuleName.
Constructors
| Module !unit !ModuleName |
Instances
| Functor GenModule | |
| Show Module Source # | |
| Uniquable Module | |
Defined in GHC.Unit.Types | |
| Outputable InstalledModule | |
Defined in GHC.Unit.Types Methods ppr :: InstalledModule -> SDoc # | |
| Outputable InstantiatedModule | |
Defined in GHC.Unit.Types Methods ppr :: InstantiatedModule -> SDoc # | |
| Outputable Module | |
Defined in GHC.Unit.Types | |
| Data unit => Data (GenModule unit) | |
Defined in GHC.Unit.Types Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GenModule unit -> c (GenModule unit) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GenModule unit) # toConstr :: GenModule unit -> Constr # dataTypeOf :: GenModule unit -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GenModule unit)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GenModule unit)) # gmapT :: (forall b. Data b => b -> b) -> GenModule unit -> GenModule unit # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GenModule unit -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GenModule unit -> r # gmapQ :: (forall d. Data d => d -> u) -> GenModule unit -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> GenModule unit -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> GenModule unit -> m (GenModule unit) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GenModule unit -> m (GenModule unit) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GenModule unit -> m (GenModule unit) # | |
| NFData (GenModule a) | |
Defined in GHC.Unit.Types | |
| Binary a => Binary (GenModule a) | |
| Eq unit => Eq (GenModule unit) | |
| Ord unit => Ord (GenModule unit) | |
Defined in GHC.Unit.Types Methods compare :: GenModule unit -> GenModule unit -> Ordering # (<) :: GenModule unit -> GenModule unit -> Bool # (<=) :: GenModule unit -> GenModule unit -> Bool # (>) :: GenModule unit -> GenModule unit -> Bool # (>=) :: GenModule unit -> GenModule unit -> Bool # | |
type ModuleWithIsBoot = GenWithIsBoot Module #
data GenWithIsBoot mod #
This data type just pairs a value mod with an IsBootInterface flag. In
practice, mod is usually a Module or ModuleName'.
Constructors
| GWIB | |
Fields
| |
Instances
A definite unit (i.e. without any free module hole)
Constructors
| Definite | |
Fields
| |
Instances
| Functor Definite | |
| Uniquable unit => Uniquable (Definite unit) | |
Defined in GHC.Unit.Types | |
| IsUnitId unit => IsUnitId (Definite unit) | |
Defined in GHC.Unit.Types Methods unitFS :: Definite unit -> FastString # | |
| Binary unit => Binary (Definite unit) | |
| Outputable unit => Outputable (Definite unit) | |
Defined in GHC.Unit.Types | |
| Eq unit => Eq (Definite unit) | |
| Ord unit => Ord (Definite unit) | |
Defined in GHC.Unit.Types Methods compare :: Definite unit -> Definite unit -> Ordering # (<) :: Definite unit -> Definite unit -> Bool # (<=) :: Definite unit -> Definite unit -> Bool # (>) :: Definite unit -> Definite unit -> Bool # (>=) :: Definite unit -> Definite unit -> Bool # | |
type Instantiations = GenInstantiations UnitId #
type GenInstantiations unit = [(ModuleName, GenModule (GenUnit unit))] #
data GenInstantiatedUnit unit #
An instantiated unit.
It identifies an indefinite library (with holes) that has been instantiated.
This unit may be indefinite or not (i.e. with remaining holes or not). If it is definite, we don't know if it has already been compiled and installed in a database. Nevertheless, we have a mechanism called "improvement" to try to match a fully instantiated unit with existing compiled and installed units: see Note [VirtUnit to RealUnit improvement].
An indefinite unit identifier pretty-prints to something like
p[H=H,A=aimpl:A>] (p is the UnitId, and the
brackets enclose the module substitution).
Constructors
| InstantiatedUnit | |
Fields
| |
Instances
A unit key in the database
Constructors
| UnitKey FastString |
Instances
| IsUnitId UnitKey | |
Defined in GHC.Unit.Types Methods unitFS :: UnitKey -> FastString # | |
Class for types that are used as unit identifiers (UnitKey, UnitId, Unit)
We need this class because we create new unit ids for virtual units (see VirtUnit) and they have to to be made from units with different kinds of identifiers.
Methods
unitFS :: u -> FastString #
Instances
| IsUnitId UnitId | |
Defined in GHC.Unit.Types Methods unitFS :: UnitId -> FastString # | |
| IsUnitId UnitKey | |
Defined in GHC.Unit.Types Methods unitFS :: UnitKey -> FastString # | |
| IsUnitId unit => IsUnitId (Definite unit) | |
Defined in GHC.Unit.Types Methods unitFS :: Definite unit -> FastString # | |
| IsUnitId u => IsUnitId (GenUnit u) | |
Defined in GHC.Unit.Types Methods unitFS :: GenUnit u -> FastString # | |
type InstantiatedModule = GenModule InstantiatedUnit #
An InstantiatedModule is a GenModule whose unit is identified with an GenInstantiatedUnit.
type HomeUnitModule = GenModule UnitId #
A HomeUnitModule is like an InstalledModule but we expect to find it in
one of the home units rather than the package database.
type InstalledModule = GenModule UnitId #
A InstalledModule is a GenModule whose unit is identified with an
UnitId.
data InstalledModuleEnv elt #
A map keyed off of InstalledModule
Instances
| Outputable elt => Outputable (InstalledModuleEnv elt) | |
Defined in GHC.Unit.Module.Env Methods ppr :: InstalledModuleEnv elt -> SDoc # | |
type DModuleNameEnv elt = UniqDFM ModuleName elt #
A map keyed off of ModuleNames (actually, their Uniques)
Has deterministic folds and can be deterministically converted to a list
type ModuleNameEnv elt = UniqFM ModuleName elt #
A map keyed off of ModuleNames (actually, their Uniques)
A map keyed off of GenModules
Instances
| Outputable a => Outputable (ModuleEnv a) | |
Defined in GHC.Unit.Module.Env | |
class HasModule (m :: Type -> Type) where #
Instances
| HasModule TcS | |
Defined in GHC.Tc.Solver.Monad | |
| ContainsModule env => HasModule (IOEnv env) | |
Defined in GHC.Data.IOEnv | |
class ContainsModule t where #
Methods
extractModule :: t -> Module #
Instances
| ContainsModule DsGblEnv | |
Defined in GHC.HsToCore.Types Methods extractModule :: DsGblEnv -> Module # | |
| ContainsModule TcGblEnv | |
Defined in GHC.Tc.Types Methods extractModule :: TcGblEnv -> Module # | |
| ContainsModule gbl => ContainsModule (Env gbl lcl) | |
Defined in GHC.Tc.Types Methods extractModule :: Env gbl lcl -> Module # | |
stableModuleNameCmp :: ModuleName -> ModuleName -> Ordering #
Compares module names lexically, rather than by their Uniques
moduleNameFS :: ModuleName -> FastString #
moduleNameString :: ModuleName -> String #
mkModuleName :: String -> ModuleName #
mkModuleNameFS :: FastString -> ModuleName #
moduleNameSlashes :: ModuleName -> String #
Returns the string version of the module name, with dots replaced by slashes.
moduleNameColons :: ModuleName -> String #
Returns the string version of the module name, with dots replaced by colons.
unitIdFS :: UnitId -> FastString #
The full hashed unit identifier, including the component id and the hash.
moduleUnitId :: Module -> UnitId #
mkModule :: u -> ModuleName -> GenModule u #
isHoleUnit :: GenUnit u -> Bool #
stableUnitCmp :: Unit -> Unit -> Ordering #
Compares unit ids lexically, rather than by their Uniques
unitFreeModuleHoles :: GenUnit u -> UniqDSet ModuleName #
Retrieve the set of free module holes of a Unit.
moduleFreeHoles :: GenModule (GenUnit u) -> UniqDSet ModuleName #
Calculate the free holes of a GenModule. If this set is non-empty,
this module was defined in an indefinite library that had required
signatures.
If a module has free holes, that means that substitutions can operate on it; if it has no free holes, substituting over a module has no effect.
mkInstantiatedUnit :: IsUnitId u => u -> GenInstantiations u -> GenInstantiatedUnit u #
Create a new GenInstantiatedUnit given an explicit module substitution.
mkVirtUnit :: IsUnitId u => u -> [(ModuleName, GenModule (GenUnit u))] -> GenUnit u #
Smart constructor for instantiated GenUnit
mkInstantiatedUnitHash :: IsUnitId u => u -> [(ModuleName, GenModule (GenUnit u))] -> FastString #
Generate a uniquely identifying hash (internal unit-id) for an instantiated unit.
This is a one-way function. If the indefinite unit has not been instantiated at all, we return its unit-id.
This hash is completely internal to GHC and is not used for symbol names or file paths. It is different from the hash Cabal would produce for the same instantiated unit.
fsToUnit :: FastString -> Unit #
Create a new simple unit identifier from a FastString. Internally,
this is primarily used to specify wired-in unit identifiers.
unitString :: IsUnitId u => u -> String #
stringToUnit :: String -> Unit #
mapInstantiations :: IsUnitId v => (u -> v) -> GenInstantiations u -> GenInstantiations v #
Map over the unit identifier of unit instantiations.
virtualUnitId :: InstantiatedUnit -> UnitId #
Return the virtual UnitId of an on-the-fly instantiated unit.
unitIsDefinite :: Unit -> Bool #
A Unit is definite if it has no free holes.
unitIdString :: UnitId -> String #
stringToUnitId :: String -> UnitId #
primUnitId :: UnitId #
bignumUnitId :: UnitId #
baseUnitId :: UnitId #
thisGhcUnitId :: UnitId #
bignumUnit :: Unit #
thisGhcUnit :: Unit #
interactiveUnit :: Unit #
mainUnitId :: UnitId #
This is the package Id for the current program. It is the default package Id if you don't specify a package name. We don't add this prefix to symbol names, since there can be only one main package per program.
isInteractiveModule :: Module -> Bool #
wiredInUnitIds :: [UnitId] #
addBootSuffix :: FilePath -> FilePath #
Add the -boot suffix to .hs, .hi and .o files
removeBootSuffix :: FilePath -> FilePath #
Remove the -boot suffix to .hs, .hi and .o files
addBootSuffix_maybe :: IsBootInterface -> FilePath -> FilePath #
Add the -boot suffix if the Bool argument is True
addBootSuffixLocn :: ModLocation -> ModLocation #
Add the -boot suffix to all file paths associated with the module
addBootSuffixLocnOut :: ModLocation -> ModLocation #
Add the -boot suffix to all output file paths associated with the
module, not including the input file itself
elemModuleEnv :: Module -> ModuleEnv a -> Bool #
extendModuleEnv :: ModuleEnv a -> Module -> a -> ModuleEnv a #
extendModuleEnvWith :: (a -> a -> a) -> ModuleEnv a -> Module -> a -> ModuleEnv a #
extendModuleEnvList :: ModuleEnv a -> [(Module, a)] -> ModuleEnv a #
extendModuleEnvList_C :: (a -> a -> a) -> ModuleEnv a -> [(Module, a)] -> ModuleEnv a #
plusModuleEnv_C :: (a -> a -> a) -> ModuleEnv a -> ModuleEnv a -> ModuleEnv a #
delModuleEnvList :: ModuleEnv a -> [Module] -> ModuleEnv a #
delModuleEnv :: ModuleEnv a -> Module -> ModuleEnv a #
plusModuleEnv :: ModuleEnv a -> ModuleEnv a -> ModuleEnv a #
lookupModuleEnv :: ModuleEnv a -> Module -> Maybe a #
lookupWithDefaultModuleEnv :: ModuleEnv a -> a -> Module -> a #
mapModuleEnv :: (a -> b) -> ModuleEnv a -> ModuleEnv b #
mkModuleEnv :: [(Module, a)] -> ModuleEnv a #
emptyModuleEnv :: ModuleEnv a #
moduleEnvKeys :: ModuleEnv a -> [Module] #
moduleEnvElts :: ModuleEnv a -> [a] #
moduleEnvToList :: ModuleEnv a -> [(Module, a)] #
unitModuleEnv :: Module -> a -> ModuleEnv a #
isEmptyModuleEnv :: ModuleEnv a -> Bool #
mkModuleSet :: [Module] -> ModuleSet #
extendModuleSet :: ModuleSet -> Module -> ModuleSet #
extendModuleSetList :: ModuleSet -> [Module] -> ModuleSet #
isEmptyModuleSet :: ModuleSet -> Bool #
moduleSetElts :: ModuleSet -> [Module] #
elemModuleSet :: Module -> ModuleSet -> Bool #
intersectModuleSet :: ModuleSet -> ModuleSet -> ModuleSet #
minusModuleSet :: ModuleSet -> ModuleSet -> ModuleSet #
delModuleSet :: ModuleSet -> Module -> ModuleSet #
unionModuleSet :: ModuleSet -> ModuleSet -> ModuleSet #
unionManyModuleSets :: [ModuleSet] -> ModuleSet #
unitModuleSet :: Module -> ModuleSet #
lookupInstalledModuleEnv :: InstalledModuleEnv a -> InstalledModule -> Maybe a #
extendInstalledModuleEnv :: InstalledModuleEnv a -> InstalledModule -> a -> InstalledModuleEnv a #
filterInstalledModuleEnv :: (InstalledModule -> a -> Bool) -> InstalledModuleEnv a -> InstalledModuleEnv a #
installedModuleEnvElts :: InstalledModuleEnv a -> [(InstalledModule, a)] #
mergeInstalledModuleEnv :: (elta -> eltb -> Maybe eltc) -> (InstalledModuleEnv elta -> InstalledModuleEnv eltc) -> (InstalledModuleEnv eltb -> InstalledModuleEnv eltc) -> InstalledModuleEnv elta -> InstalledModuleEnv eltb -> InstalledModuleEnv eltc #
plusInstalledModuleEnv :: (elt -> elt -> elt) -> InstalledModuleEnv elt -> InstalledModuleEnv elt -> InstalledModuleEnv elt #
moduleIsDefinite :: Module -> Bool #
A GenModule is definite if it has no free holes.
moduleStableString :: Module -> String #
Get a string representation of a GenModule that's unique and stable
across recompilations.
eg. "$aeson_70dylHtv1FFGeai1IoxcQr$Data.Aeson.Types.Internal"
stableModuleCmp :: Module -> Module -> Ordering #
This gives a stable ordering, as opposed to the Ord instance which
gives an ordering based on the Uniques of the components, which may
not be stable from run to run of the compiler.
installedModuleEq :: InstalledModule -> Module -> Bool #
Test if a GenModule corresponds to a given InstalledModule,
modulo instantiation.
getModuleInstantiation :: Module -> (InstalledModule, Maybe InstantiatedModule) #
Given a possibly on-the-fly instantiated module, split it into
a GenModule that we definitely can find on-disk, as well as an
instantiation if we need to instantiate it on the fly. If the
instantiation is Nothing no on-the-fly renaming is needed.
getUnitInstantiations :: Unit -> (UnitId, Maybe InstantiatedUnit) #
Return the unit-id this unit is an instance of and the module instantiations (if any).
uninstantiateInstantiatedUnit :: InstantiatedUnit -> InstantiatedUnit #
Remove instantiations of the given instantiated unit
uninstantiateInstantiatedModule :: InstantiatedModule -> InstantiatedModule #
Remove instantiations of the given module instantiated unit
isHoleModule :: GenModule (GenUnit u) -> Bool #
Test if a Module is not instantiated
mkHoleModule :: ModuleName -> GenModule (GenUnit u) #
Create a hole Module
module GHC.Unit.Module.Graph
Syntax re-exports
data SrcSpanAnn' a #
The 'SrcSpanAnn'' type wraps a normal SrcSpan, together with
an extra annotation type. This is mapped to a specific GenLocated
usage in the AST through the XRec and Anno type families.
Instances
Haskell Module
All we actually declare here is the top-level structure for a module.
Constructors
| HsModule | |
Fields
| |
| XModule !(XXModule p) | |
module GHC.Hs.Binds
module GHC.Parser
mkPrelImports :: ModuleName -> SrcSpan -> Bool -> [LImportDecl GhcPs] -> [LImportDecl GhcPs] #
Arguments
| :: ParserOpts | |
| -> FilePath | Input file |
| -> IO (Messages PsMessage, [Located String]) | Parsed options, if any. |
Parse OPTIONS and LANGUAGE pragmas of the source file.
Throws a SourceError if flag parsing fails (including unsupported flags.)
Arguments
| :: ParserOpts | |
| -> StringBuffer | Input Buffer |
| -> FilePath | Source filename. Used for location info. |
| -> (Messages PsMessage, [Located String]) | warnings and parsed options. |
Parse OPTIONS and LANGUAGE pragmas of the source file.
Throws a SourceError if flag parsing fails (including unsupported flags.)
checkProcessArgsResult :: MonadIO m => [Located String] -> m () #
Complain about non-dynamic flags in OPTIONS pragmas.
Throws a SourceError if the input list is non-empty claiming that the
input flags are unknown.
Constructors
The parsing monad, isomorphic to StateT PState Maybe.
Constructors
| P | |
Fields
| |
Instances
| Applicative P | |
| Functor P | |
| Monad P | |
| MonadP P | |
Defined in GHC.Parser.Lexer Methods addError :: MsgEnvelope PsMessage -> P () # addWarning :: MsgEnvelope PsMessage -> P () # addFatalError :: MsgEnvelope PsMessage -> P a # allocateCommentsP :: RealSrcSpan -> P EpAnnComments # | |
class Monad m => MonadP (m :: Type -> Type) where #
An mtl-style class for monads that support parsing-related operations. For example, sometimes we make a second pass over the parsing results to validate, disambiguate, or rearrange them, and we do so in the PV monad which cannot consume input but can report parsing errors, check for extension bits, and accumulate parsing annotations. Both P and PV are instances of MonadP.
MonadP grants us convenient overloading. The other option is to have separate operations for each monad: addErrorP vs addErrorPV, getBitP vs getBitPV, and so on.
Methods
addError :: MsgEnvelope PsMessage -> m () #
Add a non-fatal error. Use this when the parser can produce a result despite the error.
For example, when GHC encounters a forall in a type,
but -XExplicitForAll is disabled, the parser constructs ForAllTy
as if -XExplicitForAll was enabled, adding a non-fatal error to
the accumulator.
Control flow wise, non-fatal errors act like warnings: they are added to the accumulator and parsing continues. This allows GHC to report more than one parse error per file.
addWarning :: MsgEnvelope PsMessage -> m () #
Add a warning to the accumulator.
Use getPsMessages to get the accumulated warnings.
addFatalError :: MsgEnvelope PsMessage -> m a #
Add a fatal error. This will be the last error reported by the parser, and
the parser will not produce any result, ending in a PFailed state.
Check if a given flag is currently set in the bitmap.
allocateCommentsP :: RealSrcSpan -> m EpAnnComments #
Go through the comment_q in PState and remove all comments
that belong within the given span
allocatePriorCommentsP :: RealSrcSpan -> m EpAnnComments #
Go through the comment_q in PState and remove all comments
that come before or within the given span
allocateFinalCommentsP :: RealSrcSpan -> m EpAnnComments #
Go through the comment_q in PState and remove all comments
that come after the given span
Instances
| MonadP P | |
Defined in GHC.Parser.Lexer Methods addError :: MsgEnvelope PsMessage -> P () # addWarning :: MsgEnvelope PsMessage -> P () # addFatalError :: MsgEnvelope PsMessage -> P a # allocateCommentsP :: RealSrcSpan -> P EpAnnComments # | |
| MonadP PV | |
Defined in GHC.Parser.PostProcess Methods addError :: MsgEnvelope PsMessage -> PV () # addWarning :: MsgEnvelope PsMessage -> PV () # addFatalError :: MsgEnvelope PsMessage -> PV a # getBit :: ExtBits -> PV Bool # allocateCommentsP :: RealSrcSpan -> PV EpAnnComments # | |
Various boolean flags, mostly language extensions, that impact lexing and parsing. Note that a handful of these can change during lexing/parsing.
Constructors
| FfiBit | |
| InterruptibleFfiBit | |
| CApiFfiBit | |
| ArrowsBit | |
| ThBit | |
| ThQuotesBit | |
| IpBit | |
| OverloadedLabelsBit | |
| ExplicitForallBit | |
| BangPatBit | |
| PatternSynonymsBit | |
| HaddockBit | |
| MagicHashBit | |
| RecursiveDoBit | |
| QualifiedDoBit | |
| UnicodeSyntaxBit | |
| UnboxedParensBit | |
| DatatypeContextsBit | |
| MonadComprehensionsBit | |
| TransformComprehensionsBit | |
| QqBit | |
| RawTokenStreamBit | |
| AlternativeLayoutRuleBit | |
| ALRTransitionalBit | |
| RelaxedLayoutBit | |
| NondecreasingIndentationBit | |
| SafeHaskellBit | |
| TraditionalRecordSyntaxBit | |
| ExplicitNamespacesBit | |
| LambdaCaseBit | |
| BinaryLiteralsBit | |
| NegativeLiteralsBit | |
| HexFloatLiteralsBit | |
| StaticPointersBit | |
| NumericUnderscoresBit | |
| StarIsTypeBit | |
| BlockArgumentsBit | |
| NPlusKPatternsBit | |
| DoAndIfThenElseBit | |
| MultiWayIfBit | |
| GadtSyntaxBit | |
| ImportQualifiedPostBit | |
| LinearTypesBit | |
| NoLexicalNegationBit | |
| OverloadedRecordDotBit | |
| OverloadedRecordUpdateBit | |
| InRulePragBit | |
| InNestedCommentBit | |
| UsePosPragsBit | If this is enabled, '{-# LINE ... -#}' and '{-# COLUMN ... #-}' update the internal position. Otherwise, those pragmas are lexed as tokens of their own. |
Constructors
| PState | |
Fields
| |
data HdkComment #
Haddock comment as produced by the lexer. These are accumulated in PState
and then processed in GHC.Parser.PostProcess.Haddock. The location of the
HsDocStrings spans over the contents of the docstring - i.e. it does not
include the decorator ("-- |", "{-|" etc.)
Constructors
| HdkCommentNext HsDocString | |
| HdkCommentPrev HsDocString | |
| HdkCommentNamed String HsDocString | |
| HdkCommentSection Int HsDocString |
Instances
| Show HdkComment | |
Defined in GHC.Parser.Lexer Methods showsPrec :: Int -> HdkComment -> ShowS # show :: HdkComment -> String # showList :: [HdkComment] -> ShowS # | |
data ParserOpts #
Parser options.
See mkParserOpts to construct this.
Constructors
| ParserOpts | |
Fields
| |
data ParseResult a :: TYPE ('SumRep '['TupleRep '[LiftedRep, LiftedRep], LiftedRep]) where #
The result of running a parser.
Bundled Patterns
| pattern PFailed :: PState -> ParseResult a | The parser has consumed a (possibly empty) prefix of the input and failed. The carried parsing state can be used to resume parsing. It is the state
right before failure, including the fatal parse error. |
| pattern POk :: PState -> a -> ParseResult a | The parser has consumed a (possibly empty) prefix of the input and produced
a result. Use The carried parsing state can be used to resume parsing. |
warnopt :: WarningFlag -> ParserOpts -> Bool #
Test whether a WarningFlag is set
failLocMsgP :: RealSrcLoc -> RealSrcLoc -> (SrcSpan -> MsgEnvelope PsMessage) -> P a #
setSrcLoc :: RealSrcLoc -> P () #
setLastToken :: PsSpan -> Int -> P () #
adjustChar :: Char -> Word8 #
pushLexState :: Int -> P () #
popLexState :: P Int #
getLexState :: P Int #
activeContext :: P Bool #
Arguments
| :: EnumSet Extension | permitted language extensions enabled |
| -> DiagOpts | diagnostic options |
| -> [String] | Supported Languages and Extensions |
| -> Bool | are safe imports on? |
| -> Bool | keeping Haddock comment tokens |
| -> Bool | keep regular comment tokens |
| -> Bool | If this is enabled, '{-# LINE ... -#}' and '{-# COLUMN ... #-}' update
the internal position kept by the parser. Otherwise, those pragmas are
lexed as |
| -> ParserOpts |
Given exactly the information needed, set up the ParserOpts
disableHaddock :: ParserOpts -> ParserOpts #
initPragState :: ParserOpts -> StringBuffer -> RealSrcLoc -> PState #
Set parser options for parsing OPTIONS pragmas
getCommentsFor :: MonadP m => SrcSpan -> m EpAnnComments #
getPriorCommentsFor :: MonadP m => SrcSpan -> m EpAnnComments #
getFinalCommentsFor :: MonadP m => SrcSpan -> m EpAnnComments #
getEofPos :: P (Maybe (Pair RealSrcSpan RealSrcSpan)) #
addPsMessage :: SrcSpan -> PsMessage -> P () #
getPsErrorMessages :: PState -> Messages PsMessage #
Get a bag of the errors that have been accumulated so far. Does not take -Werror into account.
popContext :: P () #
pushModuleContext :: P () #
srcParseFail :: P a #
lexTokenStream :: ParserOpts -> StringBuffer -> RealSrcLoc -> ParseResult [Located Token] #
mkParensEpAnn :: RealSrcSpan -> (AddEpAnn, AddEpAnn) #
Given a RealSrcSpan that surrounds a HsPar or HsParTy, generate
AddEpAnn values for the opening and closing bordering on the start
and end of the span
allocateComments :: RealSrcSpan -> [LEpaComment] -> ([LEpaComment], [LEpaComment]) #
allocatePriorComments :: RealSrcSpan -> [LEpaComment] -> Maybe [LEpaComment] -> (Maybe [LEpaComment], [LEpaComment], [LEpaComment]) #
allocateFinalComments :: RealSrcSpan -> [LEpaComment] -> Maybe [LEpaComment] -> (Maybe [LEpaComment], [LEpaComment], [LEpaComment]) #
class (Typeable e, Show e) => Exception e where #
Any type that you wish to throw or catch as an exception must be an
instance of the Exception class. The simplest case is a new exception
type directly below the root:
data MyException = ThisException | ThatException
deriving Show
instance Exception MyExceptionThe default method definitions in the Exception class do what we need
in this case. You can now throw and catch ThisException and
ThatException as exceptions:
*Main> throw ThisException `catch` \e -> putStrLn ("Caught " ++ show (e :: MyException))
Caught ThisException
In more complicated examples, you may wish to define a whole hierarchy of exceptions:
---------------------------------------------------------------------
-- Make the root exception type for all the exceptions in a compiler
data SomeCompilerException = forall e . Exception e => SomeCompilerException e
instance Show SomeCompilerException where
show (SomeCompilerException e) = show e
instance Exception SomeCompilerException
compilerExceptionToException :: Exception e => e -> SomeException
compilerExceptionToException = toException . SomeCompilerException
compilerExceptionFromException :: Exception e => SomeException -> Maybe e
compilerExceptionFromException x = do
SomeCompilerException a <- fromException x
cast a
---------------------------------------------------------------------
-- Make a subhierarchy for exceptions in the frontend of the compiler
data SomeFrontendException = forall e . Exception e => SomeFrontendException e
instance Show SomeFrontendException where
show (SomeFrontendException e) = show e
instance Exception SomeFrontendException where
toException = compilerExceptionToException
fromException = compilerExceptionFromException
frontendExceptionToException :: Exception e => e -> SomeException
frontendExceptionToException = toException . SomeFrontendException
frontendExceptionFromException :: Exception e => SomeException -> Maybe e
frontendExceptionFromException x = do
SomeFrontendException a <- fromException x
cast a
---------------------------------------------------------------------
-- Make an exception type for a particular frontend compiler exception
data MismatchedParentheses = MismatchedParentheses
deriving Show
instance Exception MismatchedParentheses where
toException = frontendExceptionToException
fromException = frontendExceptionFromExceptionWe can now catch a MismatchedParentheses exception as
MismatchedParentheses, SomeFrontendException or
SomeCompilerException, but not other types, e.g. IOException:
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: MismatchedParentheses))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: SomeFrontendException))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: SomeCompilerException))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` \e -> putStrLn ("Caught " ++ show (e :: IOException))
*** Exception: MismatchedParentheses
Minimal complete definition
Nothing
Methods
toException :: e -> SomeException #
fromException :: SomeException -> Maybe e #
displayException :: e -> String #
Render this exception value in a human-friendly manner.
Default implementation: show
Since: base-4.8.0.0
Instances
data GhcException #
GHC's own exception type error messages all take the form:
<location>: <error>
If the location is on the command line, or in GHC itself, then <location>="ghc". All of the error types below correspond to a <location> of "ghc", except for ProgramError (where the string is assumed to contain a location already, so we don't print one).
Constructors
| Signal Int | Some other fatal signal (SIGHUP,SIGTERM) |
| UsageError String | Prints the short usage msg after the error |
| CmdLineError String | A problem with the command line arguments, but don't print usage. |
| Panic String | The |
| 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
| Exception GhcException | |
Defined in GHC.Utils.Panic Methods toException :: GhcException -> SomeException # fromException :: SomeException -> Maybe GhcException # displayException :: GhcException -> String # | |
| Show GhcException | |
Defined in GHC.Utils.Panic Methods showsPrec :: Int -> GhcException -> ShowS # show :: GhcException -> String # showList :: [GhcException] -> ShowS # | |
try :: Exception e => IO a -> IO (Either e a) #
Similar to catch, but returns an Either result which is
( if no exception of type Right a)e was raised, or (
if an exception of type Left ex)e was raised and its value is ex.
If any other type of exception is raised then it will be propagated
up to the next enclosing exception handler.
try a = catch (Right `liftM` a) (return . Left)
throwTo :: Exception e => ThreadId -> e -> IO () #
throwTo raises an arbitrary exception in the target thread (GHC only).
Exception delivery synchronizes between the source and target thread:
throwTo does not return until the exception has been raised in the
target thread. The calling thread can thus be certain that the target
thread has received the exception. Exception delivery is also atomic
with respect to other exceptions. Atomicity is a useful property to have
when dealing with race conditions: e.g. if there are two threads that
can kill each other, it is guaranteed that only one of the threads
will get to kill the other.
Whatever work the target thread was doing when the exception was raised is not lost: the computation is suspended until required by another thread.
If the target thread is currently making a foreign call, then the
exception will not be raised (and hence throwTo will not return)
until the call has completed. This is the case regardless of whether
the call is inside a mask or not. However, in GHC a foreign call
can be annotated as interruptible, in which case a throwTo will
cause the RTS to attempt to cause the call to return; see the GHC
documentation for more details.
Important note: the behaviour of throwTo differs from that described in
the paper "Asynchronous exceptions in Haskell"
(http://research.microsoft.com/~simonpj/Papers/asynch-exns.htm).
In the paper, throwTo is non-blocking; but the library implementation adopts
a more synchronous design in which throwTo does not return until the exception
is received by the target thread. The trade-off is discussed in Section 9 of the paper.
Like any blocking operation, throwTo is therefore interruptible (see Section 5.3 of
the paper). Unlike other interruptible operations, however, throwTo
is always interruptible, even if it does not actually block.
There is no guarantee that the exception will be delivered promptly,
although the runtime will endeavour to ensure that arbitrary
delays don't occur. In GHC, an exception can only be raised when a
thread reaches a safe point, where a safe point is where memory
allocation occurs. Some loops do not perform any memory allocation
inside the loop and therefore cannot be interrupted by a throwTo.
If the target of throwTo is the calling thread, then the behaviour
is the same as throwIO, except that the exception
is thrown as an asynchronous exception. This means that if there is
an enclosing pure computation, which would be the case if the current
IO operation is inside unsafePerformIO or unsafeInterleaveIO, that
computation is not permanently replaced by the exception, but is
suspended as if it had received an asynchronous exception.
Note that if throwTo is called with the current thread as the
target, the exception will be thrown even if the thread is currently
inside mask or uninterruptibleMask.
showException :: Exception e => e -> String #
Show an exception as a string.
panic :: HasCallStack => String -> a #
Panics and asserts.
sorry :: HasCallStack => String -> a #
Panics and asserts.
pgmError :: HasCallStack => String -> a #
Panics and asserts.
cmdLineError :: String -> a #
cmdLineErrorIO :: String -> IO a #
assertPanic :: String -> Int -> a #
Throw a failed assertion exception for a given filename and line number.
safeShowException :: Exception e => e -> IO String #
Show an exception which can possibly throw other exceptions. Used when displaying exception thrown within TH code.
showGhcExceptionUnsafe :: GhcException -> ShowS #
Append a description of the given exception to this string.
Note that this uses defaultSDocContext, which doesn't use the options
set by the user via DynFlags.
showGhcException :: SDocContext -> GhcException -> ShowS #
Append a description of the given exception to this string.
throwGhcException :: GhcException -> a #
throwGhcExceptionIO :: GhcException -> IO a #
handleGhcException :: ExceptionMonad m => (GhcException -> m a) -> m a -> m a #
pprPanic :: HasCallStack => String -> SDoc -> a #
Throw an exception saying "bug in GHC" with a callstack
pgmErrorDoc :: String -> SDoc -> a #
Throw an exception saying "bug in pgm being compiled" (used for unusual program errors)
tryMost :: IO a -> IO (Either SomeException a) #
Like try, but pass through UserInterrupt and Panic exceptions. Used when we want soft failures when reading interface files, for example. TODO: I'm not entirely sure if this is catching what we really want to catch
withSignalHandlers :: ExceptionMonad m => m a -> m a #
Temporarily install standard signal handlers for catching ^C, which just throw an exception in the current thread.
callStackDoc :: HasCallStack => SDoc #
prettyCallStackDoc :: CallStack -> SDoc #
assertPprPanic :: HasCallStack => SDoc -> a #
Panic with an assertion failure, recording the given file and line number. Should typically be accessed with the ASSERT family of macros
assertPpr :: HasCallStack => Bool -> SDoc -> a -> a #
assertPprMaybe :: HasCallStack => Maybe SDoc -> a -> a #
massertPpr :: (HasCallStack, Applicative m) => Bool -> SDoc -> m () #
assertPprM :: (HasCallStack, Monad m) => m Bool -> SDoc -> m () #
data CompileReason #
Constructors
| MustCompile | The .hs file has been touched, or the .o/.hi file does not exist |
| RecompBecause !RecompReason | The .o/.hi files are up to date, but something else has changed to force recompilation; the String says what (one-line summary) |
Instances
| Outputable CompileReason | |
Defined in GHC.Iface.Recomp Methods ppr :: CompileReason -> SDoc # | |
| Eq CompileReason | |
Defined in GHC.Iface.Recomp Methods (==) :: CompileReason -> CompileReason -> Bool # (/=) :: CompileReason -> CompileReason -> Bool # | |
hsc_type_env_vars :: HscEnv -> KnotVars (IORef TypeEnv) #
Used for one-shot compilation only, to initialise
the IfGblEnv. See tcg_type_env_var for
TcGblEnv. See also Note [hsc_type_env_var hack]
hscUpdateHUG :: (HomeUnitGraph -> HomeUnitGraph) -> HscEnv -> HscEnv #
hsc_HUG :: HscEnv -> HomeUnitGraph #
data GhcMessage where #
The umbrella type that encompasses all the different messages that GHC might output during the different compilation stages. See Note [GhcMessage].
Constructors
| GhcPsMessage :: PsMessage -> GhcMessage | A message from the parsing phase. |
| GhcTcRnMessage :: TcRnMessage -> GhcMessage | A message from typecheck/renaming phase. |
| GhcDsMessage :: DsMessage -> GhcMessage | A message from the desugaring (HsToCore) phase. |
| GhcDriverMessage :: DriverMessage -> GhcMessage | A message from the driver. |
| GhcUnknownMessage :: UnknownDiagnostic -> GhcMessage | An "escape" hatch which can be used when we don't know the source of
the message or if the message is not one of the typed ones. The
|
Instances
module GHC.Driver.Env.KnotVars
module GHC.Linker.Types
module GHC.Types.Unique.Map
module GHC.Utils.TmpFs
module GHC.Unit.Finder.Types
module GHC.Unit.Env
module GHC.Driver.Phases
The language extensions known to GHC.
Note that there is an orphan Binary instance for this type supplied by
the GHC.LanguageExtensions module provided by ghc-boot. We can't provide
here as this would require adding transitive dependencies to the
template-haskell package, which must have a minimal dependency set.
Constructors
Instances
| Bounded Extension | |
| Enum Extension | |
Defined in GHC.LanguageExtensions.Type Methods succ :: Extension -> Extension # pred :: Extension -> Extension # fromEnum :: Extension -> Int # enumFrom :: Extension -> [Extension] # enumFromThen :: Extension -> Extension -> [Extension] # enumFromTo :: Extension -> Extension -> [Extension] # enumFromThenTo :: Extension -> Extension -> Extension -> [Extension] # | |
| Generic Extension | |
| Show Extension | |
| NFData Extension Source # | |
Defined in Development.IDE.GHC.Orphans | |
| Outputable Extension | |
Defined in GHC.Utils.Outputable | |
| Eq Extension | |
| Ord Extension | |
| type Rep Extension | |
Defined in GHC.LanguageExtensions.Type type Rep Extension = D1 ('MetaData "Extension" "GHC.LanguageExtensions.Type" "ghc-boot-th-9.6.3" 'False) ((((((C1 ('MetaCons "Cpp" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "OverlappingInstances" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "UndecidableInstances" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "IncoherentInstances" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "UndecidableSuperClasses" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "MonomorphismRestriction" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MonoLocalBinds" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "DeepSubsumption" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "RelaxedPolyRec" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "ExtendedDefaultRules" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ForeignFunctionInterface" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "UnliftedFFITypes" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "InterruptibleFFI" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "CApiFFI" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "GHCForeignImportPrim" 'PrefixI 'False) (U1 :: Type -> Type))))) :+: ((((C1 ('MetaCons "JavaScriptFFI" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ParallelArrays" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Arrows" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TemplateHaskell" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "TemplateHaskellQuotes" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "QualifiedDo" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "QuasiQuotes" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ImplicitParams" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "ImplicitPrelude" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ScopedTypeVariables" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "AllowAmbiguousTypes" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "UnboxedTuples" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "UnboxedSums" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "UnliftedNewtypes" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "UnliftedDatatypes" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "BangPatterns" 'PrefixI 'False) (U1 :: Type -> Type)))))) :+: (((((C1 ('MetaCons "TypeFamilies" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TypeFamilyDependencies" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "TypeInType" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "OverloadedStrings" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "OverloadedLists" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NumDecimals" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "DisambiguateRecordFields" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "RecordWildCards" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "NamedFieldPuns" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ViewPatterns" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "GADTs" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "GADTSyntax" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "NPlusKPatterns" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DoAndIfThenElse" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "BlockArguments" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "RebindableSyntax" 'PrefixI 'False) (U1 :: Type -> Type))))) :+: ((((C1 ('MetaCons "ConstraintKinds" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "PolyKinds" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "DataKinds" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TypeData" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "InstanceSigs" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ApplicativeDo" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "LinearTypes" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "StandaloneDeriving" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "DeriveDataTypeable" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "AutoDeriveTypeable" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "DeriveFunctor" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DeriveTraversable" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "DeriveFoldable" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DeriveGeneric" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "DefaultSignatures" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DeriveAnyClass" 'PrefixI 'False) (U1 :: Type -> Type))))))) :+: (((((C1 ('MetaCons "DeriveLift" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "DerivingStrategies" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DerivingVia" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "TypeSynonymInstances" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "FlexibleContexts" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "FlexibleInstances" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ConstrainedClassMethods" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "MultiParamTypeClasses" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NullaryTypeClasses" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "FunctionalDependencies" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "UnicodeSyntax" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "ExistentialQuantification" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MagicHash" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "EmptyDataDecls" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "KindSignatures" 'PrefixI 'False) (U1 :: Type -> Type))))) :+: ((((C1 ('MetaCons "RoleAnnotations" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ParallelListComp" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "TransformListComp" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MonadComprehensions" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "GeneralizedNewtypeDeriving" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "RecursiveDo" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "PostfixOperators" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TupleSections" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "PatternGuards" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "LiberalTypeSynonyms" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "RankNTypes" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ImpredicativeTypes" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "TypeOperators" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ExplicitNamespaces" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "PackageImports" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ExplicitForAll" 'PrefixI 'False) (U1 :: Type -> Type)))))) :+: (((((C1 ('MetaCons "AlternativeLayoutRule" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "AlternativeLayoutRuleTransitional" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "DatatypeContexts" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NondecreasingIndentation" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "RelaxedLayout" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TraditionalRecordSyntax" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "LambdaCase" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MultiWayIf" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "BinaryLiterals" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NegativeLiterals" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "HexFloatLiterals" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DuplicateRecordFields" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "OverloadedLabels" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "EmptyCase" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "PatternSynonyms" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "PartialTypeSignatures" 'PrefixI 'False) (U1 :: Type -> Type))))) :+: ((((C1 ('MetaCons "NamedWildCards" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "StaticPointers" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "TypeApplications" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Strict" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "StrictData" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "EmptyDataDeriving" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "NumericUnderscores" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "QuantifiedConstraints" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "StarIsType" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ImportQualifiedPost" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "CUSKs" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "StandaloneKindSignatures" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "LexicalNegation" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "FieldSelectors" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "OverloadedRecordDot" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "OverloadedRecordUpdate" 'PrefixI 'False) (U1 :: Type -> Type)))))))) | |
justBytecode :: Linkable -> HomeModLinkable #
justObjects :: Linkable -> HomeModLinkable #
groupOrigin :: MatchGroup p body -> XMG p body Source #
isVisibleFunArg :: FunTyFlag -> Bool Source #