Safe Haskell	Safe-Inferred
Language	GHC2021

AutoInstrument.Internal.GhcFacade

Synopsis

data Levity
- = Lifted
- | Unlifted
data TyCon
type Module = GenModule Unit
data Type
class (Typeable e, Show e) => Exception e where
- toException :: e -> SomeException
- fromException :: SomeException -> Maybe e
- displayException :: e -> String
data Fingerprint = Fingerprint !Word64 !Word64
data SrcLoc
- = RealSrcLoc !RealSrcLoc !(Maybe BufPos)
- | UnhelpfulLoc !FastString
type HasCallStack = ?callStack :: CallStack
data Version = Version {
- versionBranch :: [Int]
- versionTags :: [String]
}
data FractionalExponentBase
- = Base2
- | Base10
data Coercion
data Alt b = Alt AltCon [b] (Expr b)
data Option
- = FileOption String String
- | Option String
data Unique
type Arg b = Expr b
type Unit = GenUnit UnitId
data GhcException
- = Signal Int
- | UsageError String
- | CmdLineError String
- | Panic String
- | PprPanic String SDoc
- | Sorry String
- | PprSorry String SDoc
- | InstallationError String
- | ProgramError String
- | PprProgramError String SDoc
data SDoc
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 Annotation = Annotation {
- ann_target :: CoreAnnTarget
- ann_value :: AnnPayload
}
type Kind = Type
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 {
  - gf_ext :: XGetField p
  - gf_expr :: LHsExpr p
  - gf_field :: XRec p (DotFieldOcc p)
  }
- | 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 RdrName
- = Unqual OccName
- | Qual ModuleName OccName
- | Orig Module OccName
- | Exact Name
type Id = Var
data Subst = Subst InScopeSet IdSubstEnv TvSubstEnv CvSubstEnv
data NoExtField = NoExtField
data FloatOutSwitches = FloatOutSwitches {
- floatOutLambdas :: Maybe Int
- floatOutConstants :: Bool
- floatOutOverSatApps :: Bool
- floatToTopLevelOnly :: Bool
}
data DynFlags = DynFlags {
- ghcMode :: GhcMode
- ghcLink :: GhcLink
- backend :: !Backend
- ghcNameVersion :: !GhcNameVersion
- fileSettings :: !FileSettings
- targetPlatform :: Platform
- toolSettings :: !ToolSettings
- platformMisc :: !PlatformMisc
- rawSettings :: [(String, String)]
- tmpDir :: TempDir
- llvmOptLevel :: Int
- verbosity :: Int
- debugLevel :: Int
- simplPhases :: Int
- maxSimplIterations :: Int
- ruleCheck :: Maybe String
- strictnessBefore :: [Int]
- parMakeCount :: Maybe Int
- enableTimeStats :: Bool
- ghcHeapSize :: Maybe Int
- maxRelevantBinds :: Maybe Int
- maxValidHoleFits :: Maybe Int
- maxRefHoleFits :: Maybe Int
- refLevelHoleFits :: Maybe Int
- maxUncoveredPatterns :: Int
- maxPmCheckModels :: Int
- simplTickFactor :: Int
- dmdUnboxWidth :: !Int
- specConstrThreshold :: Maybe Int
- specConstrCount :: Maybe Int
- specConstrRecursive :: Int
- binBlobThreshold :: Maybe Word
- liberateCaseThreshold :: Maybe Int
- floatLamArgs :: Maybe Int
- liftLamsRecArgs :: Maybe Int
- liftLamsNonRecArgs :: Maybe Int
- liftLamsKnown :: Bool
- cmmProcAlignment :: Maybe Int
- historySize :: Int
- importPaths :: [FilePath]
- mainModuleNameIs :: ModuleName
- mainFunIs :: Maybe String
- reductionDepth :: IntWithInf
- solverIterations :: IntWithInf
- homeUnitId_ :: UnitId
- homeUnitInstanceOf_ :: Maybe UnitId
- homeUnitInstantiations_ :: [(ModuleName, Module)]
- workingDirectory :: Maybe FilePath
- thisPackageName :: Maybe String
- hiddenModules :: Set ModuleName
- reexportedModules :: Set ModuleName
- targetWays_ :: Ways
- splitInfo :: Maybe (String, Int)
- objectDir :: Maybe String
- dylibInstallName :: Maybe String
- hiDir :: Maybe String
- hieDir :: Maybe String
- stubDir :: Maybe String
- dumpDir :: Maybe String
- objectSuf_ :: String
- hcSuf :: String
- hiSuf_ :: String
- hieSuf :: String
- dynObjectSuf_ :: String
- dynHiSuf_ :: String
- outputFile_ :: Maybe String
- dynOutputFile_ :: Maybe String
- outputHi :: Maybe String
- dynOutputHi :: Maybe String
- dynLibLoader :: DynLibLoader
- dynamicNow :: !Bool
- dumpPrefix :: FilePath
- dumpPrefixForce :: Maybe FilePath
- ldInputs :: [Option]
- includePaths :: IncludeSpecs
- libraryPaths :: [String]
- frameworkPaths :: [String]
- cmdlineFrameworks :: [String]
- rtsOpts :: Maybe String
- rtsOptsEnabled :: RtsOptsEnabled
- rtsOptsSuggestions :: Bool
- hpcDir :: String
- pluginModNames :: [ModuleName]
- pluginModNameOpts :: [(ModuleName, String)]
- frontendPluginOpts :: [String]
- externalPluginSpecs :: [ExternalPluginSpec]
- depMakefile :: FilePath
- depIncludePkgDeps :: Bool
- depIncludeCppDeps :: Bool
- depExcludeMods :: [ModuleName]
- depSuffixes :: [String]
- packageDBFlags :: [PackageDBFlag]
- ignorePackageFlags :: [IgnorePackageFlag]
- packageFlags :: [PackageFlag]
- pluginPackageFlags :: [PackageFlag]
- trustFlags :: [TrustFlag]
- packageEnv :: Maybe FilePath
- dumpFlags :: EnumSet DumpFlag
- generalFlags :: EnumSet GeneralFlag
- warningFlags :: EnumSet WarningFlag
- fatalWarningFlags :: EnumSet WarningFlag
- language :: Maybe Language
- safeHaskell :: SafeHaskellMode
- safeInfer :: Bool
- safeInferred :: Bool
- thOnLoc :: SrcSpan
- newDerivOnLoc :: SrcSpan
- deriveViaOnLoc :: SrcSpan
- overlapInstLoc :: SrcSpan
- incoherentOnLoc :: SrcSpan
- pkgTrustOnLoc :: SrcSpan
- warnSafeOnLoc :: SrcSpan
- warnUnsafeOnLoc :: SrcSpan
- trustworthyOnLoc :: SrcSpan
- extensions :: [OnOff Extension]
- extensionFlags :: EnumSet Extension
- unfoldingOpts :: !UnfoldingOpts
- maxWorkerArgs :: Int
- ghciHistSize :: Int
- flushOut :: FlushOut
- ghcVersionFile :: Maybe FilePath
- haddockOptions :: Maybe String
- ghciScripts :: [String]
- pprUserLength :: Int
- pprCols :: Int
- useUnicode :: Bool
- useColor :: OverridingBool
- canUseColor :: Bool
- colScheme :: Scheme
- profAuto :: ProfAuto
- callerCcFilters :: [CallerCcFilter]
- interactivePrint :: Maybe String
- sseVersion :: Maybe SseVersion
- bmiVersion :: Maybe BmiVersion
- avx :: Bool
- avx2 :: Bool
- avx512cd :: Bool
- avx512er :: Bool
- avx512f :: Bool
- avx512pf :: Bool
- rtldInfo :: IORef (Maybe LinkerInfo)
- rtccInfo :: IORef (Maybe CompilerInfo)
- rtasmInfo :: IORef (Maybe CompilerInfo)
- maxInlineAllocSize :: Int
- maxInlineMemcpyInsns :: Int
- maxInlineMemsetInsns :: Int
- reverseErrors :: Bool
- maxErrors :: Maybe Int
- initialUnique :: Word
- uniqueIncrement :: Int
- cfgWeights :: Weights
}
newtype SourceError = SourceError (Messages GhcMessage)
data Plugin = Plugin {
- installCoreToDos :: CorePlugin
- tcPlugin :: TcPlugin
- defaultingPlugin :: DefaultingPlugin
- holeFitPlugin :: HoleFitPlugin
- driverPlugin :: [CommandLineOption] -> HscEnv -> IO HscEnv
- pluginRecompile :: [CommandLineOption] -> IO PluginRecompile
- parsedResultAction :: [CommandLineOption] -> ModSummary -> ParsedResult -> Hsc ParsedResult
- renamedResultAction :: [CommandLineOption] -> TcGblEnv -> HsGroup GhcRn -> TcM (TcGblEnv, HsGroup GhcRn)
- typeCheckResultAction :: [CommandLineOption] -> ModSummary -> TcGblEnv -> TcM TcGblEnv
- spliceRunAction :: [CommandLineOption] -> LHsExpr GhcTc -> TcM (LHsExpr GhcTc)
- interfaceLoadAction :: forall lcl. [CommandLineOption] -> ModIface -> IfM lcl ModIface
}
data FrontendPlugin = FrontendPlugin {
- frontend :: FrontendPluginAction
}
data GenericUnitInfo srcpkgid srcpkgname uid modulename mod = GenericUnitInfo {
- unitId :: uid
- unitInstanceOf :: uid
- unitInstantiations :: [(modulename, mod)]
- unitPackageId :: srcpkgid
- unitPackageName :: srcpkgname
- unitPackageVersion :: Version
- unitComponentName :: Maybe srcpkgname
- unitAbiHash :: ShortText
- unitDepends :: [uid]
- unitAbiDepends :: [(uid, ShortText)]
- unitImportDirs :: [FilePathST]
- unitLibraries :: [ShortText]
- unitExtDepLibsSys :: [ShortText]
- unitExtDepLibsGhc :: [ShortText]
- unitLibraryDirs :: [FilePathST]
- unitLibraryDynDirs :: [FilePathST]
- unitExtDepFrameworks :: [ShortText]
- unitExtDepFrameworkDirs :: [FilePathST]
- unitLinkerOptions :: [ShortText]
- unitCcOptions :: [ShortText]
- unitIncludes :: [ShortText]
- unitIncludeDirs :: [FilePathST]
- unitHaddockInterfaces :: [FilePathST]
- unitHaddockHTMLs :: [FilePathST]
- unitExposedModules :: [(modulename, Maybe mod)]
- unitHiddenModules :: [modulename]
- unitIsIndefinite :: Bool
- unitIsExposed :: Bool
- unitIsTrusted :: Bool
}
data ForeignSrcLang
- = LangC
- | LangCxx
- | LangObjc
- | LangObjcxx
- | LangAsm
- | LangJs
- | RawObject
type HasDebugCallStack = ()
data Direction
- = Forwards
- | Backwards
type Suffix = String
data PtrString = PtrString !(Ptr Word8) !Int
newtype LexicalFastString = LexicalFastString FastString
newtype NonDetFastString = NonDetFastString FastString
data FastString = FastString {
- uniq :: !Int
- n_chars :: !Int
- fs_sbs :: !ShortByteString
- fs_zenc :: FastZString
}
data FastZString
data SrcUnpackedness
- = SrcUnpack
- | SrcNoUnpack
- | NoSrcUnpack
data SrcStrictness
- = SrcLazy
- | SrcStrict
- | NoSrcStrict
data Role
- = Nominal
- | Representational
- | Phantom
data FieldLabelString
type ConTag = Int
data Boxity
- = Boxed
- | Unboxed
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
- wrapXRec :: a -> XRec p a
class MapXRec p where
- mapXRec :: Anno a ~ Anno b => (a -> b) -> XRec p a -> XRec p b
class UnXRec p where
- unXRec :: XRec p a -> a
type family Anno a = (b :: Type)
type family XRec p a = (r :: Type) | r -> a
data DataConCantHappen
newtype ModuleName = ModuleName FastString
class HasOccName name where
- occName :: name -> OccName
data OccName
data IsBootInterface
- = NotBoot
- | IsBoot
data GenUnit uid
- = RealUnit !(Definite uid)
- | VirtUnit !(GenInstantiatedUnit uid)
- | HoleUnit
data GenModule unit = Module {
- moduleUnit :: !unit
- moduleName :: !ModuleName
}
newtype UnitId = UnitId {
- unitIdFS :: FastString
}
class (IsOutput doc, IsLine (Line doc)) => IsDoc doc where
- type Line doc = (r :: Type) | r -> doc
- line :: Line doc -> doc
- ($$) :: doc -> doc -> doc
- lines_ :: [Line doc] -> doc
- vcat :: [doc] -> doc
- dualDoc :: SDoc -> HDoc -> doc
type family Line doc = (r :: Type) | r -> doc
class IsOutput doc => IsLine doc where
- char :: Char -> doc
- text :: String -> doc
- ftext :: FastString -> doc
- ztext :: FastZString -> doc
- (<>) :: doc -> doc -> doc
- (<+>) :: doc -> doc -> doc
- sep :: [doc] -> doc
- fsep :: [doc] -> doc
- hcat :: [doc] -> doc
- hsep :: [doc] -> doc
- dualLine :: SDoc -> HLine -> doc
class IsOutput doc where
- empty :: doc
- docWithContext :: (SDocContext -> doc) -> doc
data HDoc
data HLine
class Outputable a => OutputableBndr a where
- pprBndr :: BindingSite -> a -> SDoc
- pprPrefixOcc :: a -> SDoc
- pprInfixOcc :: a -> SDoc
- bndrIsJoin_maybe :: a -> Maybe Int
data BindingSite
- = LambdaBind
- | CaseBind
- | CasePatBind
- | LetBind
newtype PDoc a = PDoc a
class OutputableP env a where
- pdoc :: env -> a -> SDoc
class Outputable a where
- ppr :: a -> SDoc
data SDocContext = SDC {
- sdocStyle :: !PprStyle
- sdocColScheme :: !Scheme
- sdocLastColour :: !PprColour
- sdocShouldUseColor :: !Bool
- sdocDefaultDepth :: !Int
- sdocLineLength :: !Int
- sdocCanUseUnicode :: !Bool
- sdocHexWordLiterals :: !Bool
- sdocPprDebug :: !Bool
- sdocPrintUnicodeSyntax :: !Bool
- sdocPrintCaseAsLet :: !Bool
- sdocPrintTypecheckerElaboration :: !Bool
- sdocPrintAxiomIncomps :: !Bool
- sdocPrintExplicitKinds :: !Bool
- sdocPrintExplicitCoercions :: !Bool
- sdocPrintExplicitRuntimeReps :: !Bool
- sdocPrintExplicitForalls :: !Bool
- sdocPrintPotentialInstances :: !Bool
- sdocPrintEqualityRelations :: !Bool
- sdocSuppressTicks :: !Bool
- sdocSuppressTypeSignatures :: !Bool
- sdocSuppressTypeApplications :: !Bool
- sdocSuppressIdInfo :: !Bool
- sdocSuppressCoercions :: !Bool
- sdocSuppressCoercionTypes :: !Bool
- sdocSuppressUnfoldings :: !Bool
- sdocSuppressVarKinds :: !Bool
- sdocSuppressUniques :: !Bool
- sdocSuppressModulePrefixes :: !Bool
- sdocSuppressStgExts :: !Bool
- sdocSuppressStgReps :: !Bool
- sdocErrorSpans :: !Bool
- sdocStarIsType :: !Bool
- sdocLinearTypes :: !Bool
- sdocListTuplePuns :: !Bool
- sdocPrintTypeAbbreviations :: !Bool
- sdocUnitIdForUser :: !(FastString -> SDoc)
}
data QualifyName
- = NameUnqual
- | NameQual ModuleName
- | NameNotInScope1
- | NameNotInScope2
newtype IsEmptyOrSingleton = IsEmptyOrSingleton Bool
data PromotedItem
- = PromotedItemListSyntax IsEmptyOrSingleton
- | PromotedItemTupleSyntax
- | PromotedItemDataCon OccName
data PromotionTickContext = PromTickCtx {
- ptcListTuplePuns :: !Bool
- ptcPrintRedundantPromTicks :: !Bool
}
type QueryPromotionTick = PromotedItem -> Bool
type QueryQualifyPackage = Unit -> Bool
type QueryQualifyModule = Module -> Bool
type QueryQualifyName = Module -> OccName -> QualifyName
data NamePprCtx = QueryQualify {
- queryQualifyName :: QueryQualifyName
- queryQualifyModule :: QueryQualifyModule
- queryQualifyPackage :: QueryQualifyPackage
- queryPromotionTick :: QueryPromotionTick
}
data Depth
- = AllTheWay
- | PartWay Int
- | DefaultDepth
data PprStyle
- = PprUser NamePprCtx Depth Coloured
- | PprDump NamePprCtx
- | PprCode
data IdDetails
- = VanillaId
- | RecSelId {
  - sel_tycon :: RecSelParent
  - sel_naughty :: Bool
  }
- | DataConWorkId DataCon
- | DataConWrapId DataCon
- | ClassOpId Class
- | PrimOpId PrimOp Bool
- | FCallId ForeignCall
- | TickBoxOpId TickBoxOp
- | DFunId Bool
- | CoVarId
- | JoinId JoinArity (Maybe [CbvMark])
- | WorkerLikeId [CbvMark]
data IdInfo
data StaticPlugin = StaticPlugin {
- spPlugin :: PluginWithArgs
}
data LoadedPlugin = LoadedPlugin {
- lpPlugin :: PluginWithArgs
- lpModule :: ModIface
}
data Plugins = Plugins {
- staticPlugins :: ![StaticPlugin]
- externalPlugins :: ![ExternalPlugin]
- loadedPlugins :: ![LoadedPlugin]
- loadedPluginDeps :: !([Linkable], PkgsLoaded)
}
class Uniquable a where
- getUnique :: a -> Unique
class NamedThing a where
- getOccName :: a -> OccName
- getName :: a -> Name
data Name
type InvisTVBinder = VarBndr TyVar Specificity
type TcTyVar = Var
type TyCoVar = Id
type TyVar = Var
data Specificity
- = InferredSpec
- | SpecifiedSpec
data VarBndr var argf = Bndr var argf
data Var
data FunTyFlag
- = FTF_T_T
- | FTF_T_C
- | FTF_C_T
- | FTF_C_C
data ForAllTyFlag where
- Invisible Specificity
- Required
- pattern Specified :: ForAllTyFlag
- pattern Inferred :: ForAllTyFlag
type CoreExpr = Expr CoreBndr
type CoreBndr = Var
data Expr b
- = Var Id
- | Lit Literal
- | App (Expr b) (Arg b)
- | Lam b (Expr b)
- | Let (Bind b) (Expr b)
- | Case (Expr b) b Type [Alt b]
- | Cast (Expr b) CoercionR
- | Tick CoreTickish (Expr b)
- | Type Type
- | Coercion Coercion
type TyConRepName = Name
type MCoercionN = MCoercion
type CoercionN = Coercion
type ThetaType = [PredType]
type RuntimeRepType = Type
type PredType = Type
type Mult = Type
data Scaled a
data MCoercion
- = MRefl
- | MCo Coercion
data UnivCoProvenance
data CoSel
- = SelTyCon Int Role
- | SelFun FunSel
- | SelForAll
newtype NonDetUniqFM key ele = NonDetUniqFM {
- getNonDet :: UniqFM key ele
}
data UniqFM key ele
class Monad m => MonadUnique (m :: Type -> Type) where
- getUniqueSupplyM :: m UniqSupply
- getUniqueM :: m Unique
- getUniquesM :: m [Unique]
data UniqSM result
data UniqSupply
data LayoutInfo pass
- = ExplicitBraces !(LHsToken "{" pass) !(LHsToken "}" pass)
- | VirtualBraces !Int
- | NoLayoutInfo
data HsUniToken (tok :: Symbol) (utok :: Symbol)
- = HsNormalTok
- | HsUnicodeTok
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)
data ProfAuto
- = NoProfAuto
- | ProfAutoAll
- | ProfAutoTop
- | ProfAutoExports
- | ProfAutoCalls
type PsLocated = GenLocated PsSpan
data PsSpan = PsSpan {
- psRealSpan :: !RealSrcSpan
- psBufSpan :: !BufSpan
}
data PsLoc = PsLoc {
- psRealLoc :: !RealSrcLoc
- psBufPos :: !BufPos
}
type RealLocated = GenLocated RealSrcSpan
type Located = GenLocated SrcSpan
data GenLocated l e = L l e
data UnhelpfulSpanReason
- = UnhelpfulNoLocationInfo
- | UnhelpfulWiredIn
- | UnhelpfulInteractive
- | UnhelpfulGenerated
- | UnhelpfulOther !FastString
data SrcSpan
- = RealSrcSpan !RealSrcSpan !(Maybe BufSpan)
- | UnhelpfulSpan !UnhelpfulSpanReason
data RealSrcSpan
data BufSpan = BufSpan {
- bufSpanStart :: !BufPos
- bufSpanEnd :: !BufPos
}
data RealSrcLoc
newtype BufPos = BufPos {
- bufPos :: Int
}
type FastStringEnv a = UniqFM FastString a
data UniqSet a
data StringLiteral = StringLiteral {
- sl_st :: SourceText
- sl_fs :: FastString
- sl_tc :: Maybe RealSrcSpan
}
data FractionalLit = FL {
- fl_text :: SourceText
- fl_neg :: Bool
- fl_signi :: Rational
- fl_exp :: Integer
- fl_exp_base :: FractionalExponentBase
}
data IntegralLit = IL {
- il_text :: SourceText
- il_neg :: Bool
- il_value :: Integer
}
data SourceText
- = SourceText String
- | NoSourceText
data FieldLabel = FieldLabel {
- flLabel :: FieldLabelString
- flHasDuplicateRecordFields :: DuplicateRecordFields
- flHasFieldSelector :: FieldSelectors
- flSelector :: Name
}
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 DumpFlag
- = Opt_D_dump_cmm
- | Opt_D_dump_cmm_from_stg
- | Opt_D_dump_cmm_raw
- | Opt_D_dump_cmm_verbose_by_proc
- | Opt_D_dump_cmm_verbose
- | Opt_D_dump_cmm_cfg
- | Opt_D_dump_cmm_cbe
- | Opt_D_dump_cmm_switch
- | Opt_D_dump_cmm_proc
- | Opt_D_dump_cmm_sp
- | Opt_D_dump_cmm_sink
- | Opt_D_dump_cmm_caf
- | Opt_D_dump_cmm_procmap
- | Opt_D_dump_cmm_split
- | Opt_D_dump_cmm_info
- | Opt_D_dump_cmm_cps
- | Opt_D_dump_cmm_thread_sanitizer
- | Opt_D_dump_cfg_weights
- | Opt_D_dump_asm
- | Opt_D_dump_asm_native
- | Opt_D_dump_asm_liveness
- | Opt_D_dump_asm_regalloc
- | Opt_D_dump_asm_regalloc_stages
- | Opt_D_dump_asm_conflicts
- | Opt_D_dump_asm_stats
- | Opt_D_dump_c_backend
- | Opt_D_dump_llvm
- | Opt_D_dump_js
- | Opt_D_dump_core_stats
- | Opt_D_dump_deriv
- | Opt_D_dump_ds
- | Opt_D_dump_ds_preopt
- | Opt_D_dump_foreign
- | Opt_D_dump_inlinings
- | Opt_D_dump_verbose_inlinings
- | Opt_D_dump_rule_firings
- | Opt_D_dump_rule_rewrites
- | Opt_D_dump_simpl_trace
- | Opt_D_dump_occur_anal
- | Opt_D_dump_parsed
- | Opt_D_dump_parsed_ast
- | Opt_D_dump_rn
- | Opt_D_dump_rn_ast
- | Opt_D_dump_simpl
- | Opt_D_dump_simpl_iterations
- | Opt_D_dump_spec
- | Opt_D_dump_prep
- | Opt_D_dump_late_cc
- | Opt_D_dump_stg_from_core
- | Opt_D_dump_stg_unarised
- | Opt_D_dump_stg_cg
- | Opt_D_dump_stg_tags
- | Opt_D_dump_stg_final
- | Opt_D_dump_call_arity
- | Opt_D_dump_exitify
- | Opt_D_dump_stranal
- | Opt_D_dump_str_signatures
- | Opt_D_dump_cpranal
- | Opt_D_dump_cpr_signatures
- | Opt_D_dump_tc
- | Opt_D_dump_tc_ast
- | Opt_D_dump_hie
- | Opt_D_dump_types
- | Opt_D_dump_rules
- | Opt_D_dump_cse
- | Opt_D_dump_worker_wrapper
- | Opt_D_dump_rn_trace
- | Opt_D_dump_rn_stats
- | Opt_D_dump_opt_cmm
- | Opt_D_dump_simpl_stats
- | Opt_D_dump_cs_trace
- | Opt_D_dump_tc_trace
- | Opt_D_dump_ec_trace
- | Opt_D_dump_if_trace
- | Opt_D_dump_splices
- | Opt_D_th_dec_file
- | Opt_D_dump_BCOs
- | Opt_D_dump_ticked
- | Opt_D_dump_rtti
- | Opt_D_source_stats
- | Opt_D_verbose_stg2stg
- | Opt_D_dump_hi
- | Opt_D_dump_hi_diffs
- | Opt_D_dump_mod_cycles
- | Opt_D_dump_mod_map
- | Opt_D_dump_timings
- | Opt_D_dump_view_pattern_commoning
- | Opt_D_verbose_core2core
- | Opt_D_dump_debug
- | Opt_D_dump_json
- | Opt_D_ppr_debug
- | Opt_D_no_debug_output
- | Opt_D_dump_faststrings
- | Opt_D_faststring_stats
- | Opt_D_ipe_stats
data Language
- = Haskell98
- | Haskell2010
- | GHC2021
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 ModLocation = ModLocation {
- ml_hs_file :: Maybe FilePath
- ml_hi_file :: FilePath
- ml_dyn_hi_file :: FilePath
- ml_obj_file :: FilePath
- ml_dyn_obj_file :: FilePath
- ml_hie_file :: FilePath
}
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
- getModule :: m Module
class ContainsModule t where
- extractModule :: t -> Module
type HomeUnit = GenHomeUnit UnitId
data GenHomeUnit u
- = DefiniteHomeUnit UnitId (Maybe (u, GenInstantiations u))
- | IndefiniteHomeUnit UnitId (GenInstantiations u)
data PkgQual
- = NoPkgQual
- | ThisPkg UnitId
- | OtherPkg UnitId
data RawPkgQual
- = NoRawPkgQual
- | RawPkgQual StringLiteral
type LPat p = XRec p (Pat p)
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)
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)
data MatchGroup p body
- = MG {
  - mg_ext :: XMG p body
  - mg_alts :: XRec p [LMatch p body]
  }
- | 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
- = NotPromoted
- | IsPromoted
data DefaultingStrategy
- = DefaultKindVars
- | NonStandardDefaulting NonStandardDefaultingStrategy
data NonStandardDefaultingStrategy
- = DefaultNonStandardTyVars
- | TryNotToDefaultNonStandardTyVars
data TypeOrConstraint
- = TypeLike
- | ConstraintLike
data TypeOrKind
- = TypeLevel
- | KindLevel
data IntWithInf
data UnfoldingSource
- = VanillaSrc
- | StableUserSrc
- | StableSystemSrc
- | CompulsorySrc
data InlineSpec
- = Inline SourceText
- | Inlinable SourceText
- | NoInline SourceText
- | Opaque SourceText
- | NoUserInlinePrag
data RuleMatchInfo
- = ConLike
- | FunLike
data InlinePragma = InlinePragma {
- inl_src :: SourceText
- inl_inline :: InlineSpec
- inl_sat :: Maybe Arity
- inl_act :: Activation
- inl_rule :: RuleMatchInfo
}
data Activation
- = AlwaysActive
- | ActiveBefore SourceText PhaseNum
- | ActiveAfter SourceText PhaseNum
- | FinalActive
- | NeverActive
data CompilerPhase
- = InitialPhase
- | Phase PhaseNum
- | FinalPhase
type PhaseNum = Int
data SuccessFlag
- = Succeeded
- | Failed
data DefMethSpec ty
- = VanillaDM
- | GenericDM ty
data TailCallInfo
- = AlwaysTailCalled JoinArity
- | NoTailCallInfo
data InsideLam
- = IsInsideLam
- | NotInsideLam
data InterestingCxt
- = IsInteresting
- | NotInteresting
type BranchCount = Int
data OccInfo
- = ManyOccs {
  - occ_tail :: !TailCallInfo
  }
- | IAmDead
- | OneOcc {
  - occ_in_lam :: !InsideLam
  - occ_n_br :: !BranchCount
  - occ_int_cxt :: !InterestingCxt
  - occ_tail :: !TailCallInfo
  }
- | IAmALoopBreaker {
  - occ_rules_only :: !RulesOnly
  - occ_tail :: !TailCallInfo
  }
data EP a = EP {
- fromEP :: a
- toEP :: a
}
data UnboxedTupleOrSum
- = UnboxedTupleType
- | UnboxedSumType
data TupleSort
- = BoxedTuple
- | UnboxedTuple
- | ConstraintTuple
newtype PprPrec = PprPrec Int
data OverlapMode
- = NoOverlap SourceText
- | Overlappable SourceText
- | Overlapping SourceText
- | Overlaps SourceText
- | Incoherent SourceText
data OverlapFlag = OverlapFlag {
- overlapMode :: OverlapMode
- isSafeOverlap :: Bool
}
data Origin
- = FromSource
- | Generated
data RecFlag
- = Recursive
- | NonRecursive
data CbvMark
- = MarkedCbv
- | NotMarkedCbv
data TopLevelFlag
- = TopLevel
- | NotTopLevel
type RuleName = FastString
data FunctionOrData
- = IsFunction
- | IsData
data SwapFlag
- = NotSwapped
- | IsSwapped
data OneShotInfo
- = NoOneShotInfo
- | OneShotLam
data Alignment
type ConTagZ = Int
type FullArgCount = Int
type JoinArity = Int
type RepArity = Int
type Arity = Int
data LeftOrRight
- = CLeft
- | CRight
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
type TidyOccEnv = UniqFM FastString Int
type OccSet = UniqSet OccName
data OccEnv a
data NameSpace
data PlatformMisc = PlatformMisc {
- platformMisc_targetPlatformString :: String
- platformMisc_ghcWithInterpreter :: Bool
- platformMisc_libFFI :: Bool
- platformMisc_llvmTarget :: String
}
data BuiltInSyntax
- = BuiltInSyntax
- | UserSyntax
type PiTyVarBinder = PiTyBinder
data PiTyBinder
- = Named ForAllTyBinder
- | Anon (Scaled Type) FunTyFlag
type ReqTVBinder = VarBndr TyVar ()
type TyVarBinder = VarBndr TyVar ForAllTyFlag
type ReqTyBinder = VarBndr TyCoVar ()
type InvisTyBinder = VarBndr TyCoVar Specificity
type ForAllTyBinder = VarBndr TyCoVar ForAllTyFlag
type OutId = Id
type OutCoVar = CoVar
type OutTyVar = TyVar
type OutVar = Var
type InId = Id
type InCoVar = CoVar
type InTyVar = TyVar
type InVar = Var
type JoinId = Id
type EqVar = EvId
type IpId = EvId
type DictId = EvId
type DFunId = Id
type EvVar = EvId
type EvId = Id
type KindVar = Var
type TypeVar = Var
type TKVar = Var
type NcId = Id
type CoVar = Id
type DTyCoVarSet = UniqDSet TyCoVar
type DTyVarSet = UniqDSet TyVar
type DIdSet = UniqDSet Id
type DVarSet = UniqDSet Var
type TyCoVarSet = UniqSet TyCoVar
type CoVarSet = UniqSet CoVar
type TyVarSet = UniqSet TyVar
type IdSet = UniqSet Id
type VarSet = UniqSet Var
type InterestingVarFun = Var -> Bool
type DTyVarEnv elt = UniqDFM TyVar elt
type DIdEnv elt = UniqDFM Var elt
type DVarEnv elt = UniqDFM Var elt
type CoVarEnv elt = UniqFM CoVar elt
type TyCoVarEnv elt = UniqFM TyCoVar elt
type TyVarEnv elt = UniqFM Var elt
type IdEnv elt = UniqFM Id elt
type VarEnv elt = UniqFM Var elt
type TidyEnv = (TidyOccEnv, VarEnv Var)
data RnEnv2
newtype InScopeSet = InScope VarSet
newtype NonCaffySet = NonCaffySet {
- ncs_nameSet :: NameSet
}
type DefUses = OrdList DefUse
type DefUse = (Maybe Defs, Uses)
type Uses = NameSet
type Defs = NameSet
type FreeVars = NameSet
type NameSet = UniqSet Name
type DNameEnv a = UniqDFM Name a
type NameEnv a = UniqFM Name a
data GreName
- = NormalGreName Name
- | FieldGreName FieldLabel
data ImpItemSpec
- = ImpAll
- | ImpSome {
  - is_explicit :: Bool
  - is_iloc :: SrcSpan
  }
data ImpDeclSpec = ImpDeclSpec {
- is_mod :: ModuleName
- is_as :: ModuleName
- is_qual :: Bool
- is_dloc :: SrcSpan
}
data ImportSpec = ImpSpec {
- is_decl :: ImpDeclSpec
- is_item :: ImpItemSpec
}
data Parent
- = NoParent
- | ParentIs {
  - par_is :: Name
  }
data GlobalRdrElt = GRE {
- gre_name :: !GreName
- gre_par :: !Parent
- gre_lcl :: !Bool
- gre_imp :: !(Bag ImportSpec)
}
type GlobalRdrEnv = OccEnv [GlobalRdrElt]
data LocalRdrEnv
type SrcSpanAnnA = SrcAnn AnnListItem
data SrcSpanAnn' a = SrcSpanAnn {
- ann :: !a
- locA :: !SrcSpan
}
type OutputableBndrId (pass :: Pass) = (OutputableBndr (IdGhcP pass), OutputableBndr (IdGhcP (NoGhcTcPass pass)), Outputable (GenLocated (Anno (IdGhcP pass)) (IdGhcP pass)), Outputable (GenLocated (Anno (IdGhcP (NoGhcTcPass pass))) (IdGhcP (NoGhcTcPass pass))), IsPass pass)
type family NoGhcTcPass (p :: Pass) :: Pass where ...
type family IdGhcP (pass :: Pass) where ...
class (NoGhcTcPass (NoGhcTcPass p) ~ NoGhcTcPass p, IsPass (NoGhcTcPass p)) => IsPass (p :: Pass) where
- ghcPass :: GhcPass p
type GhcTc = GhcPass 'Typechecked
type GhcRn = GhcPass 'Renamed
type GhcPs = GhcPass 'Parsed
data Pass
- = Parsed
- | Renamed
- | Typechecked
data GhcPass (c :: Pass) where
- GhcPs :: GhcPass 'Parsed
- GhcRn :: GhcPass 'Renamed
- GhcTc :: GhcPass 'Typechecked
type IsSrcSpanAnn (p :: Pass) a = (Anno (IdGhcP p) ~ SrcSpanAnn' (EpAnn a), IsPass p)
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
- = NoIEWildcard
- | IEWildcard Int
type LIE pass = XRec pass (IE pass)
data ImportListInterpretation
- = Exactly
- | EverythingBut
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)
data ImportDeclQualifiedStyle
- = QualifiedPre
- | QualifiedPost
- | NotQualified
type LImportDecl pass = XRec pass (ImportDecl pass)
data AnnEnv
type CoreAnnTarget = AnnTarget Name
data AnnTarget name
- = NamedTarget name
- | ModuleTarget Module
type AnnPayload = Serialized
data RuleOpts
data GhcNameVersion = GhcNameVersion {
- ghcNameVersion_programName :: String
- ghcNameVersion_projectVersion :: String
}
data FileSettings = FileSettings {
- fileSettings_ghcUsagePath :: FilePath
- fileSettings_ghciUsagePath :: FilePath
- fileSettings_toolDir :: Maybe FilePath
- fileSettings_topDir :: FilePath
- fileSettings_globalPackageDatabase :: FilePath
}
data Settings = Settings {
- sGhcNameVersion :: !GhcNameVersion
- sFileSettings :: !FileSettings
- sTargetPlatform :: Platform
- sToolSettings :: !ToolSettings
- sPlatformMisc :: !PlatformMisc
- sRawSettings :: [(String, String)]
}
newtype PackageName = PackageName {
- unPackageName :: FastString
}
newtype PackageId = PackageId FastString
type UnitInfo = GenUnitInfo UnitId
type UnitKeyInfo = GenUnitInfo UnitKey
type GenUnitInfo unit = GenericUnitInfo PackageId PackageName unit ModuleName (GenModule (GenUnit unit))
newtype Hsc a = Hsc (HscEnv -> Messages GhcMessage -> IO (a, Messages GhcMessage))
data LiftingContext = LC Subst LiftCoEnv
data FunDep pass
- = FunDep (XCFunDep pass) [LIdP pass] [LIdP pass]
- | XFunDep !(XXFunDep pass)
data TyConFlavour
- = ClassFlavour
- | TupleFlavour Boxity
- | SumFlavour
- | DataTypeFlavour
- | NewtypeFlavour
- | AbstractTypeFlavour
- | DataFamilyFlavour (Maybe TyCon)
- | OpenTypeFamilyFlavour (Maybe TyCon)
- | ClosedTypeFamilyFlavour
- | TypeSynonymFlavour
- | BuiltInTypeFlavour
- | PromotedDataConFlavour
data ExpandSynResult tyco
- = NoExpansion
- | ExpandsSyn [(TyVar, tyco)] Type [tyco]
data PrimElemRep
- = Int8ElemRep
- | Int16ElemRep
- | Int32ElemRep
- | Int64ElemRep
- | Word8ElemRep
- | Word16ElemRep
- | Word32ElemRep
- | Word64ElemRep
- | FloatElemRep
- | DoubleElemRep
data PrimRep
- = VoidRep
- | LiftedRep
- | UnliftedRep
- | Int8Rep
- | Int16Rep
- | Int32Rep
- | Int64Rep
- | IntRep
- | Word8Rep
- | Word16Rep
- | Word32Rep
- | Word64Rep
- | WordRep
- | AddrRep
- | FloatRep
- | DoubleRep
- | VecRep Int PrimElemRep
data FamTyConFlav
- = DataFamilyTyCon TyConRepName
- | OpenSynFamilyTyCon
- | ClosedSynFamilyTyCon (Maybe (CoAxiom Branched))
- | AbstractClosedSynFamilyTyCon
- | BuiltInSynFamTyCon BuiltInSynFamily
data Injectivity
- = NotInjective
- | Injective [Bool]
data AlgTyConFlav
- = VanillaAlgTyCon TyConRepName
- | UnboxedSumTyCon
- | ClassTyCon Class TyConRepName
- | DataFamInstTyCon (CoAxiom Unbranched) TyCon [Type]
data PromDataConInfo
- = NoPromInfo
- | RuntimeRep ([Type] -> [PrimRep])
- | VecCount Int
- | VecElem PrimElemRep
- | Levity Levity
data AlgTyConRhs
- = AbstractTyCon
- | DataTyCon {
  - data_cons :: [DataCon]
  - data_cons_size :: Int
  - is_enum :: Bool
  - is_type_data :: Bool
  - data_fixed_lev :: Bool
  }
- | TupleTyCon {
  - data_con :: DataCon
  - tup_sort :: TupleSort
  }
- | SumTyCon {
  - data_cons :: [DataCon]
  - data_cons_size :: Int
  }
- | NewTyCon {
  - data_con :: DataCon
  - nt_rhs :: Type
  - nt_etad_rhs :: ([TyVar], Type)
  - nt_co :: CoAxiom Unbranched
  - nt_fixed_rep :: Bool
  }
data TyConBndrVis
- = NamedTCB ForAllTyFlag
- | AnonTCB FunTyFlag
type TyConPiTyBinder = VarBndr TyCoVar TyConBndrVis
type TyConBinder = VarBndr TyVar TyConBndrVis
data TyCoFolder env a = TyCoFolder {
- tcf_view :: Type -> Maybe Type
- tcf_tyvar :: env -> TyVar -> a
- tcf_covar :: env -> CoVar -> a
- tcf_hole :: env -> CoercionHole -> a
- tcf_tycobinder :: env -> TyCoVar -> ForAllTyFlag -> env
}
data CoercionHole = CoercionHole {
- ch_co_var :: CoVar
- ch_ref :: IORef (Maybe Coercion)
}
type MCoercionR = MCoercion
type CoercionP = Coercion
type CoercionR = Coercion
data FunSel
- = SelMult
- | SelArg
- | SelRes
type KnotTied ty = ty
type FRRType = Type
type KindOrType = Type
type CvSubstEnv = CoVarEnv Coercion
type TvSubstEnv = TyVarEnv Type
type IdSubstEnv = IdEnv CoreExpr
data TyCoMapper env (m :: Type -> Type) = TyCoMapper {
- tcm_tyvar :: env -> TyVar -> m Type
- tcm_covar :: env -> CoVar -> m Coercion
- tcm_hole :: env -> CoercionHole -> m Coercion
- tcm_tycobinder :: env -> TyCoVar -> ForAllTyFlag -> m (env, TyCoVar)
- tcm_tycon :: TyCon -> m TyCon
}
data OverLitVal
- = HsIntegral !IntegralLit
- | HsFractional !FractionalLit
- | HsIsString !SourceText !FastString
data HsOverLit p
- = OverLit {
  - ol_ext :: XOverLit p
  - ol_val :: OverLitVal
  }
- | XOverLit !(XXOverLit 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 LitNumType
- = LitNumBigNat
- | LitNumInt
- | LitNumInt8
- | LitNumInt16
- | LitNumInt32
- | LitNumInt64
- | LitNumWord
- | LitNumWord8
- | LitNumWord16
- | LitNumWord32
- | LitNumWord64
data Literal
- = LitChar Char
- | LitNumber !LitNumType !Integer
- | LitString !ByteString
- | LitNullAddr
- | LitRubbish TypeOrConstraint RuntimeRepType
- | LitFloat Rational
- | LitDouble Rational
- | LitLabel FastString (Maybe Int) FunctionOrData
type LiftCoEnv = VarEnv Coercion
data NormaliseStepResult ev
- = NS_Done
- | NS_Abort
- | NS_Step RecTcChecker Type ev
type NormaliseStepper ev = RecTcChecker -> TyCon -> [Type] -> NormaliseStepResult ev
data GhcHint
- = (Outputable a, Typeable a) => UnknownHint a
- | SuggestExtension !LanguageExtensionHint
- | SuggestCorrectPragmaName ![String]
- | SuggestMissingDo
- | SuggestLetInDo
- | SuggestAddSignatureCabalFile !ModuleName
- | SuggestSignatureInstantiations !ModuleName [InstantiationSuggestion]
- | SuggestUseSpaces
- | SuggestUseWhitespaceAfter !OperatorWhitespaceSymbol
- | SuggestUseWhitespaceAround !String !OperatorWhitespaceOccurrence
- | SuggestParentheses
- | SuggestIncreaseMaxPmCheckModels
- | SuggestAddTypeSignatures AvailableBindings
- | SuggestBindToWildcard !(LHsExpr GhcTc)
- | SuggestAddInlineOrNoInlinePragma !Var !Activation
- | SuggestAddPhaseToCompetingRule !RuleName
- | SuggestAddToHSigExportList !Name !(Maybe Module)
- | SuggestIncreaseSimplifierIterations
- | SuggestUseTypeFromDataKind (Maybe RdrName)
- | SuggestQualifiedAfterModuleName
- | SuggestThQuotationSyntax
- | SuggestRoles [Role]
- | SuggestQualifyStarOperator
- | SuggestTypeSignatureForm
- | SuggestFixOrphanInstance
- | SuggestAddStandaloneDerivation
- | SuggestFillInWildcardConstraint
- | SuggestRenameForall
- | SuggestAppropriateTHTick NameSpace
- | SuggestDumpSlices
- | SuggestAddTick UntickedPromotedThing
- | SuggestMoveToDeclarationSite SDoc RdrName
- | SuggestSimilarNames RdrName (NonEmpty SimilarName)
- | RemindFieldSelectorSuppressed {
  - suppressed_selector :: RdrName
  - suppressed_parents :: [Name]
  }
- | ImportSuggestion ImportSuggestion
- | SuggestImportingDataCon
- | SuggestPlacePragmaInHeader
- | SuggestPatternMatchingSyntax
- | SuggestSpecialiseVisibilityHints Name
- | LoopySuperclassSolveHint PredType ClsInstOrQC
data LanguageExtensionHint
- = SuggestSingleExtension !SDoc !Extension
- | SuggestAnyExtension !SDoc [Extension]
- | SuggestExtensions !SDoc [Extension]
- | SuggestExtensionInOrderTo !SDoc !Extension
data AvailableBindings
- = NamedBindings (NonEmpty Name)
- | UnnamedBinding
data DiagnosticCode = DiagnosticCode {
- diagnosticCodeNameSpace :: String
- diagnosticCodeNumber :: Natural
}
data Severity
- = SevIgnore
- | SevWarning
- | SevError
data MessageClass
- = MCOutput
- | MCFatal
- | MCInteractive
- | MCDump
- | MCInfo
- | MCDiagnostic Severity DiagnosticReason (Maybe DiagnosticCode)
data MsgEnvelope e = MsgEnvelope {
- errMsgSpan :: SrcSpan
- errMsgContext :: NamePprCtx
- errMsgDiagnostic :: e
- errMsgSeverity :: Severity
}
data DiagnosticReason
- = WarningWithoutFlag
- | WarningWithFlag !WarningFlag
- | ErrorWithoutFlag
data DiagnosticMessage = DiagnosticMessage {
- diagMessage :: !DecoratedSDoc
- diagReason :: !DiagnosticReason
- diagHints :: [GhcHint]
}
data DiagnosticHint = DiagnosticHint !SDoc
data NoDiagnosticOpts = NoDiagnosticOpts
data UnknownDiagnostic where
- UnknownDiagnostic :: forall a. (DiagnosticOpts a ~ NoDiagnosticOpts, Diagnostic a, Typeable a) => a -> UnknownDiagnostic
class Diagnostic a where
- type DiagnosticOpts a
- defaultDiagnosticOpts :: DiagnosticOpts a
- diagnosticMessage :: DiagnosticOpts a -> a -> DecoratedSDoc
- diagnosticReason :: a -> DiagnosticReason
- diagnosticHints :: a -> [GhcHint]
- diagnosticCode :: a -> Maybe DiagnosticCode
type family DiagnosticOpts a
data DecoratedSDoc
data Messages e
type Validity = Validity' SDoc
data Validity' a
- = IsValid
- | NotValid a
data DiagOpts = DiagOpts {
- diag_warning_flags :: !(EnumSet WarningFlag)
- diag_fatal_warning_flags :: !(EnumSet WarningFlag)
- diag_warn_is_error :: !Bool
- diag_reverse_errors :: !Bool
- diag_max_errors :: !(Maybe Int)
- diag_ppr_ctx :: !SDocContext
}
data Tick
- = PreInlineUnconditionally Id
- | PostInlineUnconditionally Id
- | UnfoldingDone Id
- | RuleFired FastString
- | LetFloatFromLet
- | EtaExpansion Id
- | EtaReduction Id
- | BetaReduction Id
- | CaseOfCase Id
- | KnownBranch Id
- | CaseMerge Id
- | AltMerge Id
- | CaseElim Id
- | CaseIdentity Id
- | FillInCaseDefault Id
- | SimplifierDone
data SimplCount
data StrictnessMark
- = MarkedStrict
- | NotMarkedStrict
data HsImplBang
- = HsLazy
- | HsStrict Bool
- | HsUnpack (Maybe Coercion)
data HsSrcBang = HsSrcBang SourceText SrcUnpackedness SrcStrictness
type DataConEnv a = UniqFM DataCon a
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)
type LFieldOcc pass = XRec pass (FieldOcc pass)
type LHsTypeArg p = HsArg (LHsType p) (LHsKind p)
data HsArg tm ty
- = HsValArg tm
- | HsTypeArg SrcSpan ty
- | HsArgPar SrcSpan
data HsConDetails tyarg arg rec
- = PrefixCon [tyarg] [arg]
- | RecCon rec
- | InfixCon arg arg
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)
type LConDeclField pass = XRec pass (ConDeclField pass)
data HsTupleSort
- = HsUnboxedTuple
- | HsBoxedOrConstraintTuple
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
- = HsNumTy (XNumTy pass) Integer
- | HsStrTy (XStrTy pass) FastString
- | HsCharTy (XCharTy pass) Char
- | XTyLit !(XXTyLit pass)
data HsType pass
- = HsForAllTy {
  - hst_xforall :: XForAllTy pass
  - hst_tele :: HsForAllTelescope pass
  - hst_body :: LHsType pass
  }
- | HsQualTy {
  - hst_xqual :: XQualTy pass
  - hst_ctxt :: LHsContext pass
  - hst_body :: LHsType pass
  }
- | 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)
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 {
  - sig_ext :: XHsSig pass
  - sig_bndrs :: HsOuterSigTyVarBndrs pass
  - sig_body :: LHsType pass
  }
- | 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 {
  - hsps_ext :: XHsPS pass
  - hsps_body :: LHsType pass
  }
- | XHsPatSigType !(XXHsPatSigType pass)
data HsWildCardBndrs pass thing
- = HsWC {
  - hswc_ext :: XHsWC pass thing
  - hswc_body :: thing
  }
- | 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)
data LHsQTyVars pass
- = HsQTvs {
  - hsq_ext :: XHsQTvs pass
  - hsq_explicit :: [LHsTyVarBndr () pass]
  }
- | XLHsQTyVars !(XXLHsQTyVars pass)
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)
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 BangType pass = HsType pass
type LBangType pass = XRec pass (BangType pass)
data HsFieldBind lhs rhs = HsFieldBind {
- hfbAnn :: XHsFieldBind lhs
- hfbLHS :: lhs
- hfbRHS :: rhs
- hfbPun :: Bool
}
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 {
- unRecFieldsDotDot :: Int
}
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
- = Unidirectional
- | ImplicitBidirectional
- | ExplicitBidirectional (MatchGroup id (LHsExpr 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
- = IPBind (XCIPBind id) (XRec id HsIPName) (LHsExpr id)
- | XIPBind !(XXIPBind 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)
data HsBindLR idL idR
- = FunBind {
  - fun_ext :: XFunBind idL idR
  - fun_id :: LIdP idL
  - fun_matches :: MatchGroup idR (LHsExpr idR)
  }
- | PatBind {
  - pat_ext :: XPatBind idL idR
  - pat_lhs :: LPat idL
  - pat_rhs :: GRHSs idR (LHsExpr idR)
  }
- | VarBind {
  - var_ext :: XVarBind idL idR
  - var_id :: IdP idL
  - var_rhs :: LHsExpr idR
  }
- | PatSynBind (XPatSynBind idL idR) (PatSynBind idL idR)
- | XHsBindsLR !(XXHsBindsLR idL idR)
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)
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)
data RuleBndr pass
- = RuleBndr (XCRuleBndr pass) (LIdP pass)
- | RuleBndrSig (XRuleBndrSig pass) (LIdP pass) (HsPatSigType pass)
- | XRuleBndr !(XXRuleBndr pass)
type LRuleBndr pass = XRec pass (RuleBndr pass)
data RuleDecl pass
- = HsRule {
  - rd_ext :: XHsRule pass
  - rd_name :: XRec pass RuleName
  - rd_act :: Activation
  - rd_tyvs :: Maybe [LHsTyVarBndr () (NoGhcTc pass)]
  - rd_tmvs :: [LRuleBndr pass]
  - rd_lhs :: XRec pass (HsExpr pass)
  - rd_rhs :: XRec pass (HsExpr pass)
  }
- | XRuleDecl !(XXRuleDecl pass)
type LRuleDecl pass = XRec pass (RuleDecl pass)
data RuleDecls pass
- = HsRules {
  - rds_ext :: XCRuleDecls pass
  - rds_rules :: [LRuleDecl pass]
  }
- | XRuleDecls !(XXRuleDecls pass)
type LRuleDecls pass = XRec pass (RuleDecls pass)
data ForeignExport pass
- = CExport (XCExport pass) (XRec pass CExportSpec)
- | XForeignExport !(XXForeignExport pass)
data CImportSpec
- = CLabel CLabelString
- | CFunction CCallTarget
- | CWrapper
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)
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)
data DerivStrategy pass
- = StockStrategy (XStockStrategy pass)
- | AnyclassStrategy (XAnyClassStrategy pass)
- | NewtypeStrategy (XNewtypeStrategy pass)
- | ViaStrategy (XViaStrategy 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)
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)
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)
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)
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)
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)
type LConDecl pass = XRec pass (ConDecl pass)
data DataDefnCons a
- = NewTypeCon a
- | DataTypeCons Bool [a]
data NewOrData
- = NewType
- | DataType
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)
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)
data FamilyInfo pass
- = DataFamily
- | OpenTypeFamily
- | ClosedTypeFamily (Maybe [LTyFamInstEqn pass])
data InjectivityAnn pass
- = InjectivityAnn (XCInjectivityAnn pass) (LIdP pass) [LIdP pass]
- | XInjectivityAnn !(XXInjectivityAnn 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)
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)
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)
type LTyClDecl pass = XRec pass (TyClDecl pass)
data SpliceDecoration
- = DollarSplice
- | BareSplice
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)
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
- = ProcExpr
- | ArrowCaseAlt
- | ArrowLamCaseAlt LamCaseVariant
- | KappaExpr
data HsStmtContext p
- = HsDoStmt HsDoFlavour
- | PatGuard (HsMatchContext p)
- | ParStmtCtxt (HsStmtContext p)
- | TransStmtCtxt (HsStmtContext p)
- | ArrowExpr
data HsMatchContext p
- = FunRhs {
  - mc_fun :: LIdP (NoGhcTc p)
  - mc_fixity :: LexicalFixity
  - mc_strictness :: SrcStrictness
  }
- | LambdaExpr
- | CaseAlt
- | LamCaseAlt LamCaseVariant
- | IfAlt
- | ArrowMatchCtxt HsArrowMatchContext
- | PatBindRhs
- | PatBindGuards
- | RecUpd
- | StmtCtxt (HsStmtContext p)
- | ThPatSplice
- | ThPatQuote
- | PatSyn
data ArithSeqInfo id
- = From (LHsExpr id)
- | FromThen (LHsExpr id) (LHsExpr id)
- | FromTo (LHsExpr id) (LHsExpr id)
- | FromThenTo (LHsExpr id) (LHsExpr id) (LHsExpr id)
data HsQuote p
- = ExpBr (XExpBr p) (LHsExpr p)
- | PatBr (XPatBr p) (LPat p)
- | DecBrL (XDecBrL p) [LHsDecl p]
- | DecBrG (XDecBrG p) (HsGroup p)
- | TypBr (XTypBr p) (LHsType p)
- | VarBr (XVarBr p) Bool (LIdP p)
- | XQuote !(XXQuote 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)
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
- = ThenForm
- | GroupForm
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 {
  - trS_ext :: XTransStmt idL idR body
  - trS_form :: TransForm
  - trS_stmts :: [ExprLStmt idL]
  - trS_bndrs :: [(IdP idR, IdP idR)]
  - trS_using :: LHsExpr idR
  - trS_by :: Maybe (LHsExpr idR)
  - trS_ret :: SyntaxExpr idR
  - trS_bind :: SyntaxExpr idR
  - trS_fmap :: HsExpr idR
  }
- | RecStmt {
  - recS_ext :: XRecStmt idL idR body
  - recS_stmts :: 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 Stmt id body = StmtLR id id body
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)
data Match p body
- = Match {
  - m_ext :: XCMatch p body
  - m_ctxt :: HsMatchContext p
  - m_pats :: [LPat p]
  - m_grhss :: GRHSs p body
  }
- | XMatch !(XXMatch p body)
type LMatch id body = XRec id (Match id body)
type HsRecordBinds p = HsRecFields p (LHsExpr p)
data HsCmdTop p
- = HsCmdTop (XCmdTop p) (LHsCmd p)
- | XCmdTop !(XXCmdTop p)
type LHsCmdTop p = XRec p (HsCmdTop p)
data HsArrAppType
- = HsHigherOrderApp
- | HsFirstOrderApp
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
- = LamCase
- | LamCases
data HsTupArg id
- = Present (XPresent id) (LHsExpr id)
- | Missing (XMissing id)
- | XTupArg !(XXTupArg 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)
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)
data AnnBind bndr annot
- = AnnNonRec bndr (AnnExpr bndr annot)
- | AnnRec [(bndr, AnnExpr bndr annot)]
data AnnAlt bndr annot = AnnAlt AltCon [bndr] (AnnExpr bndr annot)
data AnnExpr' bndr annot
- = AnnVar Id
- | AnnLit Literal
- | AnnLam bndr (AnnExpr bndr annot)
- | AnnApp (AnnExpr bndr annot) (AnnExpr bndr annot)
- | AnnCase (AnnExpr bndr annot) bndr Type [AnnAlt bndr annot]
- | AnnLet (AnnBind bndr annot) (AnnExpr bndr annot)
- | AnnCast (AnnExpr bndr annot) (annot, Coercion)
- | AnnTick CoreTickish (AnnExpr bndr annot)
- | AnnType Type
- | AnnCoercion Coercion
type AnnExpr bndr annot = (annot, AnnExpr' bndr annot)
type TaggedAlt t = Alt (TaggedBndr t)
type TaggedArg t = Arg (TaggedBndr t)
type TaggedExpr t = Expr (TaggedBndr t)
type TaggedBind t = Bind (TaggedBndr t)
data TaggedBndr t = TB CoreBndr t
type CoreAlt = Alt CoreBndr
type CoreBind = Bind CoreBndr
type CoreArg = Arg CoreBndr
type CoreProgram = [CoreBind]
data UnfoldingGuidance
- = UnfWhen {
  - ug_arity :: Arity
  - ug_unsat_ok :: Bool
  - ug_boring_ok :: Bool
  }
- | UnfIfGoodArgs {
  - ug_args :: [Int]
  - ug_size :: Int
  - ug_res :: Int
  }
- | UnfNever
data UnfoldingCache = UnfoldingCache {
- uf_is_value :: !Bool
- uf_is_conlike :: !Bool
- uf_is_work_free :: !Bool
- uf_expandable :: !Bool
}
data Unfolding
- = NoUnfolding
- | BootUnfolding
- | OtherCon [AltCon]
- | DFunUnfolding {
  - df_bndrs :: [Var]
  - df_con :: DataCon
  - df_args :: [CoreExpr]
  }
- | CoreUnfolding {
  - uf_tmpl :: CoreExpr
  - uf_src :: UnfoldingSource
  - uf_is_top :: Bool
  - uf_cache :: UnfoldingCache
  - uf_guidance :: UnfoldingGuidance
  }
type IdUnfoldingFun = Id -> Unfolding
data InScopeEnv = ISE InScopeSet IdUnfoldingFun
type RuleFun = RuleOpts -> InScopeEnv -> Id -> [CoreExpr] -> Maybe CoreExpr
data CoreRule
- = Rule {
  - ru_name :: RuleName
  - ru_act :: Activation
  - ru_fn :: !Name
  - ru_rough :: [Maybe Name]
  - ru_bndrs :: [CoreBndr]
  - ru_args :: [CoreExpr]
  - ru_rhs :: CoreExpr
  - ru_auto :: Bool
  - ru_origin :: !Module
  - ru_orphan :: !IsOrphan
  - ru_local :: Bool
  }
- | BuiltinRule {
  - ru_name :: RuleName
  - ru_fn :: Name
  - ru_nargs :: Int
  - ru_try :: RuleFun
  }
data IsOrphan
- = IsOrphan
- | NotOrphan !OccName
type MOutCoercion = MCoercion
type OutArg = CoreArg
type OutAlt = CoreAlt
type OutExpr = CoreExpr
type OutBind = CoreBind
type OutCoercion = Coercion
type OutKind = Kind
type OutType = Type
type OutBndr = CoreBndr
type InCoercion = Coercion
type InArg = CoreArg
type InAlt = CoreAlt
type InExpr = CoreExpr
type InBind = CoreBind
type InKind = Kind
type InType = Type
type InBndr = CoreBndr
data Bind b
- = NonRec b (Expr b)
- | Rec [(b, Expr b)]
data AltCon
- = DataAlt DataCon
- | LitAlt Literal
- | DEFAULT
data LambdaFormInfo
data TickBoxOp = TickBox Module !TickBoxId
type TickBoxId = Int
data CafInfo
- = MayHaveCafRefs
- | NoCafRefs
data RuleInfo = RuleInfo [CoreRule] DVarSet
type InlinePragInfo = InlinePragma
type ArityInfo = Arity
data RecSelParent
- = RecSelData TyCon
- | RecSelPatSyn PatSyn
data BoxingInfo b
- = BI_NoBoxNeeded
- | BI_NoBoxAvailable
- | BI_Box {
  - bi_data_con :: DataCon
  - bi_inst_con :: Expr b
  - bi_boxed_type :: Type
  }
type CoreAltWithFVs = AnnAlt Id FVAnn
type CoreExprWithFVs' = AnnExpr' Id FVAnn
type CoreExprWithFVs = AnnExpr Id FVAnn
type CoreBindWithFVs = AnnBind Id FVAnn
type FVAnn = DVarSet
type CheapAppFun = Id -> Arity -> Bool
data FloatBind
- = FloatLet CoreBind
- | FloatCase CoreExpr Id AltCon [Var]
data MkStringIds = MkStringIds {
- unpackCStringId :: !Id
- unpackCStringUtf8Id :: !Id
}
data CompilerInfo
- = GCC
- | Clang
- | AppleClang
- | AppleClang51
- | Emscripten
- | UnknownCC
data LinkerInfo
- = GnuLD [Option]
- | GnuGold [Option]
- | LlvmLLD [Option]
- | DarwinLD [Option]
- | SolarisLD [Option]
- | AixLD [Option]
- | UnknownLD
data PkgDbRef
- = GlobalPkgDb
- | UserPkgDb
- | PkgDbPath FilePath
data FlagSpec flag = FlagSpec {
- flagSpecName :: String
- flagSpecFlag :: flag
- flagSpecAction :: TurnOnFlag -> DynP ()
- flagSpecGhcMode :: GhcFlagMode
}
type TurnOnFlag = Bool
newtype CmdLineP s a = CmdLineP (forall (m :: Type -> Type). Monad m => StateT s m a)
data OnOff a
- = On a
- | Off a
newtype FlushOut = FlushOut (IO ())
type FatalMessager = String -> IO ()
data DynamicTooState
- = DT_Dont
- | DT_OK
- | DT_Dyn
data RtsOptsEnabled
- = RtsOptsNone
- | RtsOptsIgnore
- | RtsOptsIgnoreAll
- | RtsOptsSafeOnly
- | RtsOptsAll
data DynLibLoader
- = Deployable
- | SystemDependent
data PackageDBFlag
- = PackageDB PkgDbRef
- | NoUserPackageDB
- | NoGlobalPackageDB
- | ClearPackageDBs
data PackageFlag
- = ExposePackage String PackageArg ModRenaming
- | HidePackage String
data TrustFlag
- = TrustPackage String
- | DistrustPackage String
newtype IgnorePackageFlag = IgnorePackage String
data ModRenaming = ModRenaming {
- modRenamingWithImplicit :: Bool
- modRenamings :: [(ModuleName, ModuleName)]
}
data PackageArg
- = PackageArg String
- | UnitIdArg Unit
data GhcLink
- = NoLink
- | LinkBinary
- | LinkInMemory
- | LinkDynLib
- | LinkStaticLib
- | LinkMergedObj
data GhcMode
- = CompManager
- | OneShot
- | MkDepend
class ContainsDynFlags t where
- extractDynFlags :: t -> DynFlags
class HasDynFlags (m :: Type -> Type) where
- getDynFlags :: m DynFlags
data IncludeSpecs = IncludeSpecs {
- includePathsQuote :: [String]
- includePathsGlobal :: [String]
- includePathsQuoteImplicit :: [String]
}
data HoleFit
- = HoleFit {
  - hfId :: Id
  - hfCand :: HoleFitCandidate
  - hfType :: TcType
  - hfRefLvl :: Int
  - hfWrap :: [TcType]
  - hfMatches :: [TcType]
  - hfDoc :: Maybe [HsDocString]
  }
- | RawHoleFit SDoc
data HoleFitPlugin = HoleFitPlugin {
- candPlugin :: CandPlugin
- fitPlugin :: FitPlugin
}
data HoleFitCandidate
- = IdHFCand Id
- | NameHFCand Name
- | GreHFCand GlobalRdrElt
type ShHoleSubst = ModuleNameEnv Module
data UnitErr
- = CloseUnitErr !UnitId !(Maybe UnitId)
- | PackageFlagErr !PackageFlag ![(UnitInfo, UnusableUnitReason)]
- | TrustFlagErr !TrustFlag ![(UnitInfo, UnusableUnitReason)]
data ModuleSuggestion
- = SuggestVisible ModuleName Module ModuleOrigin
- | SuggestHidden ModuleName Module ModuleOrigin
data LookupResult
- = LookupFound Module (UnitInfo, ModuleOrigin)
- | LookupMultiple [(Module, ModuleOrigin)]
- | LookupHidden [(Module, ModuleOrigin)] [(Module, ModuleOrigin)]
- | LookupUnusable [(Module, ModuleOrigin)]
- | LookupNotFound [ModuleSuggestion]
data UnusableUnitReason
- = IgnoredWithFlag
- | BrokenDependencies [UnitId]
- | CyclicDependencies [UnitId]
- | IgnoredDependencies [UnitId]
- | ShadowedDependencies [UnitId]
type UnitInfoMap = Map UnitId UnitInfo
data UnitDatabase unit = UnitDatabase {
- unitDatabasePath :: FilePath
- unitDatabaseUnits :: [GenUnitInfo unit]
}
data UnitState = UnitState {
- unitInfoMap :: UnitInfoMap
- preloadClosure :: PreloadUnitClosure
- packageNameMap :: UniqFM PackageName UnitId
- wireMap :: Map UnitId UnitId
- unwireMap :: Map UnitId UnitId
- preloadUnits :: [UnitId]
- explicitUnits :: [(Unit, Maybe PackageArg)]
- homeUnitDepends :: [UnitId]
- moduleNameProvidersMap :: !ModuleNameProvidersMap
- pluginModuleNameProvidersMap :: !ModuleNameProvidersMap
- requirementContext :: Map ModuleName [InstantiatedModule]
- allowVirtualUnits :: !Bool
}
type PreloadUnitClosure = UniqSet UnitId
data ModuleOrigin
- = ModHidden
- | ModUnusable UnusableUnitReason
- | ModOrigin {
  - fromOrigUnit :: Maybe Bool
  - fromExposedReexport :: [UnitInfo]
  - fromHiddenReexport :: [UnitInfo]
  - fromPackageFlag :: Bool
  }
data FinderOpts = FinderOpts {
- finder_importPaths :: [FilePath]
- finder_lookupHomeInterfaces :: Bool
- finder_bypassHiFileCheck :: Bool
- finder_ways :: Ways
- finder_enableSuggestions :: Bool
- finder_workingDirectory :: Maybe FilePath
- finder_thisPackageName :: Maybe FastString
- finder_hiddenModules :: Set ModuleName
- finder_reexportedModules :: Set ModuleName
- finder_hieDir :: Maybe FilePath
- finder_hieSuf :: String
- finder_hiDir :: Maybe FilePath
- finder_hiSuf :: String
- finder_dynHiSuf :: String
- finder_objectDir :: Maybe FilePath
- finder_objectSuf :: String
- finder_dynObjectSuf :: String
- finder_stubDir :: Maybe FilePath
}
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]
  }
data InstalledFindResult
- = InstalledFound ModLocation InstalledModule
- | InstalledNoPackage UnitId
- | InstalledNotFound [FilePath] (Maybe UnitId)
data FinderCache
data HsParsedModule = HsParsedModule {
- hpm_module :: Located (HsModule GhcPs)
- hpm_src_files :: [FilePath]
}
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 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 RuleEnv = RuleEnv {
- re_local_rules :: !RuleBase
- re_home_rules :: !RuleBase
- re_eps_rules :: !RuleBase
- re_visible_orphs :: !ModuleSet
}
type RuleBase = NameEnv [CoreRule]
type WhetherHasFamInst = Bool
type WhetherHasOrphans = Bool
type IfaceExport = AvailInfo
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
}
type ModIface = ModIface_ 'ModIfaceFinal
type family IfaceBackendExts (phase :: ModIfacePhase) = (bk :: Type) | bk -> phase where ...
type family IfaceDeclExts (phase :: ModIfacePhase) = (decl :: Type) | decl -> phase where ...
data ModIfaceBackend = ModIfaceBackend {
- mi_iface_hash :: !Fingerprint
- mi_mod_hash :: !Fingerprint
- mi_flag_hash :: !Fingerprint
- mi_opt_hash :: !Fingerprint
- mi_hpc_hash :: !Fingerprint
- mi_plugin_hash :: !Fingerprint
- mi_orphan :: !WhetherHasOrphans
- mi_finsts :: !WhetherHasFamInst
- mi_exp_hash :: !Fingerprint
- mi_orphan_hash :: !Fingerprint
- mi_warn_fn :: !(OccName -> Maybe (WarningTxt GhcRn))
- mi_fix_fn :: !(OccName -> Maybe Fixity)
- mi_hash_fn :: !(OccName -> Maybe (OccName, Fingerprint))
}
type PartialModIface = ModIface_ 'ModIfaceCore
data HscBackendAction
- = HscUpdate ModIface
- | HscRecomp {
  - hscs_guts :: CgGuts
  - hscs_mod_location :: !ModLocation
  - hscs_partial_iface :: !PartialModIface
  - hscs_old_iface_hash :: !(Maybe Fingerprint)
  }
data HscRecompStatus
- = HscUpToDate ModIface HomeModLinkable
- | HscRecompNeeded (Maybe Fingerprint)
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 FileHeaderPragmaType
- = OptionsPrag
- | IncludePrag
- | LanguagePrag
- | DocOptionsPrag
data TransLayoutReason
- = TransLayout_Where
- | TransLayout_Pipe
data CmmParserError
- = CmmUnknownPrimitive !FastString
- | CmmUnknownMacro !FastString
- | CmmUnknownCConv !String
- | CmmUnrecognisedSafety !String
- | CmmUnrecognisedHint !String
data LexErr
- = LexError
- | LexUnknownPragma
- | LexErrorInPragma
- | LexNumEscapeRange
- | LexStringCharLit
- | LexStringCharLitEOF
- | LexUnterminatedComment
- | LexUnterminatedOptions
- | LexUnterminatedQQ
data LexErrKind
- = LexErrKind_EOF
- | LexErrKind_UTF8
- | LexErrKind_Char !Char
data NumUnderscoreReason
- = NumUnderscore_Integral
- | NumUnderscore_Float
data PsErrInPatDetails
- = PEIP_NegApp
- | PEIP_TypeArgs [HsConPatTyArg GhcPs]
- | PEIP_RecPattern [LPat GhcPs] !PatIsRecursive !ParseContext
- | PEIP_OtherPatDetails !ParseContext
data ParseContext = ParseContext {
- is_infix :: !(Maybe RdrName)
- incomplete_do_block :: !PatIncompleteDoBlock
}
data PatIncompleteDoBlock
- = YesIncompleteDoBlock
- | NoIncompleteDoBlock
data PatIsRecursive
- = YesPatIsRecursive
- | NoPatIsRecursive
data PsErrParseDetails = PsErrParseDetails {
- ped_th_enabled :: !Bool
- ped_do_in_last_100 :: !Bool
- ped_mdo_in_last_100 :: !Bool
- ped_pat_syn_enabled :: !Bool
- ped_pattern_parsed :: !Bool
}
data PsMessage
- = PsUnknownMessage UnknownDiagnostic
- | PsHeaderMessage !PsHeaderMessage
- | PsWarnBidirectionalFormatChars (NonEmpty (PsLoc, Char, String))
- | PsWarnTab !Word
- | PsWarnTransitionalLayout !TransLayoutReason
- | PsWarnUnrecognisedPragma !String ![String]
- | PsWarnMisplacedPragma !FileHeaderPragmaType
- | PsWarnHaddockInvalidPos
- | PsWarnHaddockIgnoreMulti
- | PsWarnStarBinder
- | PsWarnStarIsType
- | PsWarnImportPreQualified
- | PsWarnOperatorWhitespaceExtConflict !OperatorWhitespaceSymbol
- | PsWarnOperatorWhitespace !FastString !OperatorWhitespaceOccurrence
- | PsErrLambdaCase
- | PsErrEmptyLambda
- | PsErrNumUnderscores !NumUnderscoreReason
- | PsErrPrimStringInvalidChar
- | PsErrMissingBlock
- | PsErrLexer !LexErr !LexErrKind
- | PsErrSuffixAT
- | PsErrParse !String !PsErrParseDetails
- | PsErrCmmLexer
- | PsErrUnsupportedBoxedSumExpr !(SumOrTuple (HsExpr GhcPs))
- | PsErrUnsupportedBoxedSumPat !(SumOrTuple (PatBuilder GhcPs))
- | PsErrUnexpectedQualifiedConstructor !RdrName
- | PsErrTupleSectionInPat
- | PsErrIllegalBangPattern !(Pat GhcPs)
- | PsErrOpFewArgs !StarIsType !RdrName
- | PsErrImportQualifiedTwice
- | PsErrImportPostQualified
- | PsErrIllegalExplicitNamespace
- | PsErrVarForTyCon !RdrName
- | PsErrIllegalPatSynExport
- | PsErrMalformedEntityString
- | PsErrDotsInRecordUpdate
- | PsErrPrecedenceOutOfRange !Int
- | PsErrOverloadedRecordDotInvalid
- | PsErrOverloadedRecordUpdateNotEnabled
- | PsErrOverloadedRecordUpdateNoQualifiedFields
- | PsErrInvalidDataCon !(HsType GhcPs)
- | PsErrInvalidInfixDataCon !(HsType GhcPs) !RdrName !(HsType GhcPs)
- | PsErrIllegalPromotionQuoteDataCon !RdrName
- | PsErrUnpackDataCon
- | PsErrUnexpectedKindAppInDataCon !DataConBuilder !(HsType GhcPs)
- | PsErrInvalidRecordCon !(PatBuilder GhcPs)
- | PsErrIllegalUnboxedStringInPat !(HsLit GhcPs)
- | PsErrIllegalUnboxedFloatingLitInPat !(HsLit GhcPs)
- | PsErrDoNotationInPat
- | PsErrIfThenElseInPat
- | PsErrLambdaCaseInPat LamCaseVariant
- | PsErrCaseInPat
- | PsErrLetInPat
- | PsErrLambdaInPat
- | PsErrArrowExprInPat !(HsExpr GhcPs)
- | PsErrArrowCmdInPat !(HsCmd GhcPs)
- | PsErrArrowCmdInExpr !(HsCmd GhcPs)
- | PsErrViewPatInExpr !(LHsExpr GhcPs) !(LHsExpr GhcPs)
- | PsErrTypeAppWithoutSpace !RdrName !(LHsExpr GhcPs)
- | PsErrLazyPatWithoutSpace !(LHsExpr GhcPs)
- | PsErrBangPatWithoutSpace !(LHsExpr GhcPs)
- | PsErrUnallowedPragma !(HsPragE GhcPs)
- | PsErrQualifiedDoInCmd !ModuleName
- | PsErrInvalidInfixHole
- | PsErrSemiColonsInCondExpr !(HsExpr GhcPs) !Bool !(HsExpr GhcPs) !Bool !(HsExpr GhcPs)
- | PsErrSemiColonsInCondCmd !(HsExpr GhcPs) !Bool !(HsCmd GhcPs) !Bool !(HsCmd GhcPs)
- | PsErrAtInPatPos
- | PsErrLambdaCmdInFunAppCmd !(LHsCmd GhcPs)
- | PsErrCaseCmdInFunAppCmd !(LHsCmd GhcPs)
- | PsErrLambdaCaseCmdInFunAppCmd !LamCaseVariant !(LHsCmd GhcPs)
- | PsErrIfCmdInFunAppCmd !(LHsCmd GhcPs)
- | PsErrLetCmdInFunAppCmd !(LHsCmd GhcPs)
- | PsErrDoCmdInFunAppCmd !(LHsCmd GhcPs)
- | PsErrDoInFunAppExpr !(Maybe ModuleName) !(LHsExpr GhcPs)
- | PsErrMDoInFunAppExpr !(Maybe ModuleName) !(LHsExpr GhcPs)
- | PsErrLambdaInFunAppExpr !(LHsExpr GhcPs)
- | PsErrCaseInFunAppExpr !(LHsExpr GhcPs)
- | PsErrLambdaCaseInFunAppExpr !LamCaseVariant !(LHsExpr GhcPs)
- | PsErrLetInFunAppExpr !(LHsExpr GhcPs)
- | PsErrIfInFunAppExpr !(LHsExpr GhcPs)
- | PsErrProcInFunAppExpr !(LHsExpr GhcPs)
- | PsErrMalformedTyOrClDecl !(LHsType GhcPs)
- | PsErrIllegalWhereInDataDecl
- | PsErrIllegalDataTypeContext !(LHsContext GhcPs)
- | PsErrParseErrorOnInput !OccName
- | PsErrMalformedDecl !SDoc !RdrName
- | PsErrUnexpectedTypeAppInDecl !(LHsType GhcPs) !SDoc !RdrName
- | PsErrNotADataCon !RdrName
- | PsErrRecordSyntaxInPatSynDecl !(LPat GhcPs)
- | PsErrEmptyWhereInPatSynDecl !RdrName
- | PsErrInvalidWhereBindInPatSynDecl !RdrName !(HsDecl GhcPs)
- | PsErrNoSingleWhereBindInPatSynDecl !RdrName !(HsDecl GhcPs)
- | PsErrDeclSpliceNotAtTopLevel !(SpliceDecl GhcPs)
- | PsErrInferredTypeVarNotAllowed
- | PsErrMultipleNamesInStandaloneKindSignature [LIdP GhcPs]
- | PsErrIllegalImportBundleForm
- | PsErrIllegalRoleName !FastString [Role]
- | PsErrInvalidTypeSignature !(LHsExpr GhcPs)
- | PsErrUnexpectedTypeInDecl !(LHsType GhcPs) !SDoc !RdrName [LHsTypeArg GhcPs] !SDoc
- | PsErrExpectedHyphen
- | PsErrSpaceInSCC
- | PsErrEmptyDoubleQuotes !Bool
- | PsErrInvalidPackageName !FastString
- | PsErrInvalidRuleActivationMarker
- | PsErrLinearFunction
- | PsErrMultiWayIf
- | PsErrExplicitForall !Bool
- | PsErrIllegalQualifiedDo !SDoc
- | PsErrCmmParser !CmmParserError
- | PsErrIllegalTraditionalRecordSyntax !SDoc
- | PsErrParseErrorInCmd !SDoc
- | PsErrInPat !(PatBuilder GhcPs) !PsErrInPatDetails
- | PsErrParseRightOpSectionInPat !RdrName !(PatBuilder GhcPs)
- | PsErrIllegalGadtRecordMultiplicity !(HsArrow GhcPs)
- | PsErrInvalidCApiImport
- | PsErrMultipleConForNewtype !RdrName !Int
- | PsErrUnicodeCharLooksLike Char Char String
data PsHeaderMessage
- = PsErrParseLanguagePragma
- | PsErrUnsupportedExt !String ![String]
- | PsErrParseOptionsPragma !String
- | PsErrUnknownOptionsPragma !String
type PsError = PsMessage
type PsWarning = PsMessage
data HscEnv = HscEnv {
- hsc_dflags :: DynFlags
- hsc_targets :: [Target]
- hsc_mod_graph :: ModuleGraph
- hsc_IC :: InteractiveContext
- hsc_NC :: !NameCache
- hsc_FC :: !FinderCache
- hsc_type_env_vars :: KnotVars (IORef TypeEnv)
- hsc_interp :: Maybe Interp
- hsc_plugins :: !Plugins
- hsc_unit_env :: UnitEnv
- hsc_logger :: !Logger
- hsc_hooks :: !Hooks
- hsc_tmpfs :: !TmpFs
- hsc_llvm_config :: !LlvmConfigCache
}
data CoreM a
type MetaHook (f :: Type -> Type) = MetaRequest -> LHsExpr GhcTc -> f MetaResult
data MetaResult
data MetaRequest
- = MetaE (LHsExpr GhcPs -> MetaResult)
- | MetaP (LPat GhcPs -> MetaResult)
- | MetaT (LHsType GhcPs -> MetaResult)
- | MetaD ([LHsDecl GhcPs] -> MetaResult)
- | MetaAW (Serialized -> MetaResult)
data CoreToDo
- = CoreDoSimplify !SimplifyOpts
- | CoreDoPluginPass String CorePluginPass
- | CoreDoFloatInwards
- | CoreDoFloatOutwards FloatOutSwitches
- | CoreLiberateCase
- | CoreDoPrintCore
- | CoreDoStaticArgs
- | CoreDoCallArity
- | CoreDoExitify
- | CoreDoDemand Bool
- | CoreDoCpr
- | CoreDoWorkerWrapper
- | CoreDoSpecialising
- | CoreDoSpecConstr
- | CoreCSE
- | CoreDoRuleCheck CompilerPhase String
- | CoreDoNothing
- | CoreDoPasses [CoreToDo]
- | CoreDesugar
- | CoreDesugarOpt
- | CoreTidy
- | CorePrep
- | CoreAddCallerCcs
- | CoreAddLateCcs
type CorePluginPass = ModGuts -> CoreM ModGuts
type DefaultingPlugin = [CommandLineOption] -> Maybe DefaultingPlugin
type TcPlugin = [CommandLineOption] -> Maybe TcPlugin
data HoleFitPluginR = HoleFitPluginR {
- hfPluginInit :: TcM (TcRef s)
- hfPluginRun :: TcRef s -> HoleFitPlugin
- hfPluginStop :: TcRef s -> TcM ()
}
type FitPlugin = TypedHole -> [HoleFit] -> TcM [HoleFit]
type CandPlugin = TypedHole -> [HoleFitCandidate] -> TcM [HoleFitCandidate]
data TypedHole = TypedHole {
- th_relevant_cts :: Bag CtEvidence
- th_implics :: [Implication]
- th_hole :: Maybe Hole
}
type FrontendPluginAction = [String] -> [(String, Maybe Phase)] -> Ghc ()
type CorePlugin = [CommandLineOption] -> [CoreToDo] -> CoreM [CoreToDo]
data PluginRecompile
- = ForceRecompile
- | NoForceRecompile
- | MaybeRecompile Fingerprint
data ExternalPlugin = ExternalPlugin {
- epPlugin :: PluginWithArgs
- epUnit :: String
- epModule :: String
}
data PluginWithArgs = PluginWithArgs {
- paPlugin :: Plugin
- paArguments :: [CommandLineOption]
}
data ParsedResult = ParsedResult {
- parsedResultModule :: HsParsedModule
- parsedResultMessages :: PsMessages
}
data PsMessages = PsMessages {
- psWarnings :: Messages PsWarning
- psErrors :: Messages PsError
}
type CommandLineOption = String
data TcRnExprMode
- = TM_Inst
- | TM_Default
data CgInteractiveGuts
type Messager = HscEnv -> (Int, Int) -> RecompileRequired -> ModuleGraphNode -> IO ()
data Serialized = Serialized TypeRep [Word8]
pattern ManyTy :: Mult
pattern OneTy :: Mult
try :: Exception e => IO a -> IO (Either e a)
count :: (a -> Bool) -> [a] -> Int
rational :: Rational -> SDoc
double :: IsLine doc => Double -> doc
space :: IsLine doc => doc
lengthAtLeast :: [a] -> Int -> Bool
throwTo :: Exception e => ThreadId -> e -> IO ()
liftIO :: MonadIO m => IO a -> m a
srcLocFile :: RealSrcLoc -> FastString
foldl1' :: HasCallStack => (a -> a -> a) -> [a] -> a
appPrec :: PprPrec
infinity :: IntWithInf
applyWhen :: Bool -> (a -> a) -> a -> a
parens :: IsLine doc => doc -> doc
fingerprintString :: String -> Fingerprint
fingerprintFingerprints :: [Fingerprint] -> Fingerprint
funResultTy :: HasDebugCallStack => Type -> Type
mkFunTy :: HasDebugCallStack => FunTyFlag -> Mult -> Type -> Type -> Type
splitTyConApp :: Type -> (TyCon, [Type])
singleton :: a -> [a]
fingerprint0 :: Fingerprint
fingerprintData :: Ptr Word8 -> Int -> IO Fingerprint
getFileHash :: FilePath -> IO Fingerprint
sortWith :: Ord b => (a -> b) -> [a] -> [a]
isAlgType :: Type -> Bool
mkNoRepType :: String -> DataType
spanEnd :: (a -> Bool) -> [a] -> ([a], [a])
readRational :: String -> Rational
isEmpty :: SDocContext -> SDoc -> Bool
split :: Char -> String -> [String]
compareLength :: [a] -> [b] -> Ordering
word :: Integer -> SDoc
unzipWith :: (a -> b -> c) -> [(a, b)] -> [c]
pprWithUnitState :: UnitState -> SDoc -> SDoc
mkTyConTy :: TyCon -> Type
mkCoreApps :: CoreExpr -> [CoreExpr] -> CoreExpr
mkCoreConApps :: DataCon -> [CoreExpr] -> CoreExpr
mkIntExpr :: Platform -> Integer -> CoreExpr
mkWordExpr :: Platform -> Integer -> CoreExpr
mkCharExpr :: Char -> CoreExpr
mkStringExpr :: MonadThings m => String -> m CoreExpr
mkFloatExpr :: Float -> CoreExpr
mkDoubleExpr :: Double -> CoreExpr
mkCoreLams :: [CoreBndr] -> CoreExpr -> CoreExpr
mkCoreLets :: [CoreBind] -> CoreExpr -> CoreExpr
mkCoreLet :: CoreBind -> CoreExpr -> CoreExpr
typeLevity_maybe :: HasDebugCallStack => Type -> Maybe Levity
expandTypeSynonyms :: Type -> Type
dropList :: [b] -> [a] -> [a]
panic :: HasCallStack => String -> a
sorry :: HasCallStack => String -> a
pgmError :: HasCallStack => String -> a
cmdLineError :: String -> a
cmdLineErrorIO :: String -> IO a
assertPanic :: String -> Int -> a
nTimes :: Int -> (a -> a) -> a -> a
const2 :: a -> b -> c -> a
fstOf3 :: (a, b, c) -> a
sndOf3 :: (a, b, c) -> b
thdOf3 :: (a, b, c) -> c
fst3 :: (a -> d) -> (a, b, c) -> (d, b, c)
snd3 :: (b -> d) -> (a, b, c) -> (a, d, c)
third3 :: (c -> d) -> (a, b, c) -> (a, b, d)
uncurry3 :: (a -> b -> c -> d) -> (a, b, c) -> d
filterOut :: (a -> Bool) -> [a] -> [a]
partitionWith :: (a -> Either b c) -> [a] -> ([b], [c])
chkAppend :: [a] -> [a] -> [a]
zipEqual :: HasDebugCallStack => String -> [a] -> [b] -> [(a, b)]
zipWithEqual :: HasDebugCallStack => String -> (a -> b -> c) -> [a] -> [b] -> [c]
zipWith3Equal :: HasDebugCallStack => String -> (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
zipWith4Equal :: HasDebugCallStack => String -> (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
filterByList :: [Bool] -> [a] -> [a]
filterByLists :: [Bool] -> [a] -> [a] -> [a]
partitionByList :: [Bool] -> [a] -> ([a], [a])
stretchZipWith :: (a -> Bool) -> b -> (a -> b -> c) -> [a] -> [b] -> [c]
mapFst :: Functor f => (a -> c) -> f (a, b) -> f (c, b)
mapSnd :: Functor f => (b -> c) -> f (a, b) -> f (a, c)
mapAndUnzip :: (a -> (b, c)) -> [a] -> ([b], [c])
mapAndUnzip3 :: (a -> (b, c, d)) -> [a] -> ([b], [c], [d])
zipWithAndUnzip :: (a -> b -> (c, d)) -> [a] -> [b] -> ([c], [d])
zipAndUnzip :: [a] -> [b] -> ([a], [b])
atLength :: ([a] -> b) -> b -> [a] -> Int -> b
lengthExceeds :: [a] -> Int -> Bool
lengthIs :: [a] -> Int -> Bool
lengthIsNot :: [a] -> Int -> Bool
lengthAtMost :: [a] -> Int -> Bool
lengthLessThan :: [a] -> Int -> Bool
listLengthCmp :: [a] -> Int -> Ordering
equalLength :: [a] -> [b] -> Bool
leLength :: [a] -> [b] -> Bool
ltLength :: [a] -> [b] -> Bool
isSingleton :: [a] -> Bool
notNull :: Foldable f => f a -> Bool
only :: [a] -> a
expectOnly :: HasCallStack => String -> [a] -> a
chunkList :: Int -> [a] -> [[a]]
holes :: [a] -> [(a, [a])]
changeLast :: [a] -> a -> [a]
mapLastM :: Functor f => (a -> f a) -> NonEmpty a -> f (NonEmpty a)
whenNonEmpty :: Applicative m => [a] -> (NonEmpty a -> m ()) -> m ()
mergeListsBy :: (a -> a -> Ordering) -> [[a]] -> [a]
isSortedBy :: (a -> a -> Ordering) -> [a] -> Bool
minWith :: Ord b => (a -> b) -> [a] -> a
nubSort :: Ord a => [a] -> [a]
ordNub :: Ord a => [a] -> [a]
ordNubOn :: Ord b => (a -> b) -> [a] -> [a]
transitiveClosure :: (a -> [a]) -> (a -> a -> Bool) -> [a] -> [a]
foldl2 :: (acc -> a -> b -> acc) -> acc -> [a] -> [b] -> acc
all2 :: (a -> b -> Bool) -> [a] -> [b] -> Bool
countWhile :: (a -> Bool) -> [a] -> Int
takeList :: [b] -> [a] -> [a]
splitAtList :: [b] -> [a] -> ([a], [a])
dropTail :: Int -> [a] -> [a]
dropWhileEndLE :: (a -> Bool) -> [a] -> [a]
last2 :: [a] -> Maybe (a, a)
lastMaybe :: [a] -> Maybe a
onJust :: b -> Maybe a -> (a -> b) -> b
snocView :: [a] -> Maybe ([a], a)
capitalise :: String -> String
isEqual :: Ordering -> Bool
removeSpaces :: String -> String
(<&&>) :: Applicative f => f Bool -> f Bool -> f Bool
(<||>) :: Applicative f => f Bool -> f Bool -> f Bool
fuzzyMatch :: String -> [String] -> [String]
fuzzyLookup :: String -> [(String, a)] -> [a]
seqList :: [a] -> b -> b
strictMap :: (a -> b) -> [a] -> [b]
strictZipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
strictZipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
looksLikeModuleName :: String -> Bool
looksLikePackageName :: String -> Bool
exactLog2 :: Integer -> Maybe Integer
readSignificandExponentPair :: String -> (Integer, Integer)
readHexRational :: String -> Rational
readHexSignificandExponentPair :: String -> (Integer, Integer)
doesDirNameExist :: FilePath -> IO Bool
getModificationUTCTime :: FilePath -> IO UTCTime
modificationTimeIfExists :: FilePath -> IO (Maybe UTCTime)
fileHashIfExists :: FilePath -> IO (Maybe Fingerprint)
withAtomicRename :: MonadIO m => FilePath -> (FilePath -> m a) -> m a
splitLongestPrefix :: String -> (Char -> Bool) -> (String, String)
escapeSpaces :: String -> String
reslash :: Direction -> FilePath -> FilePath
makeRelativeTo :: FilePath -> FilePath -> FilePath
abstractConstr :: String -> Constr
abstractDataType :: String -> DataType
charToC :: Word8 -> String
hashString :: String -> Int32
mapMaybe' :: Foldable f => (a -> Maybe b) -> f a -> [b]
bytesFS :: FastString -> ByteString
fastStringToByteString :: FastString -> ByteString
fastStringToShortByteString :: FastString -> ShortByteString
fastZStringToByteString :: FastZString -> ByteString
unsafeMkByteString :: String -> ByteString
hPutFZS :: Handle -> FastZString -> IO ()
zString :: FastZString -> String
zStringTakeN :: Int -> FastZString -> String
lengthFZS :: FastZString -> Int
lexicalCompareFS :: FastString -> FastString -> Ordering
uniqCompareFS :: FastString -> FastString -> Ordering
mkFastString# :: Addr# -> FastString
mkFastStringBytes :: Ptr Word8 -> Int -> FastString
mkFastStringByteString :: ByteString -> FastString
mkFastStringShortByteString :: ShortByteString -> FastString
mkFastString :: String -> FastString
mkFastStringByteList :: [Word8] -> FastString
lengthFS :: FastString -> Int
nullFS :: FastString -> Bool
unpackFS :: FastString -> String
zEncodeFS :: FastString -> FastZString
appendFS :: FastString -> FastString -> FastString
concatFS :: [FastString] -> FastString
consFS :: Char -> FastString -> FastString
unconsFS :: FastString -> Maybe (Char, FastString)
uniqueOfFS :: FastString -> Int
nilFS :: FastString
getFastStringTable :: IO [[[FastString]]]
getFastStringZEncCounter :: IO Int
hPutFS :: Handle -> FastString -> IO ()
mkPtrString# :: Addr# -> PtrString
unpackPtrString :: PtrString -> String
unpackPtrStringTakeN :: Int -> PtrString -> String
lengthPS :: PtrString -> Int
fsLit :: String -> FastString
ptext :: PtrString -> SDoc
semi :: IsLine doc => doc
comma :: IsLine doc => doc
colon :: IsLine doc => doc
equals :: IsLine doc => doc
lparen :: IsLine doc => doc
rparen :: IsLine doc => doc
lbrack :: IsLine doc => doc
rbrack :: IsLine doc => doc
lbrace :: IsLine doc => doc
rbrace :: IsLine doc => doc
int :: IsLine doc => Int -> doc
integer :: IsLine doc => Integer -> doc
float :: IsLine doc => Float -> doc
quotes :: SDoc -> SDoc
quote :: SDoc -> SDoc
doubleQuotes :: IsLine doc => doc -> doc
brackets :: IsLine doc => doc -> doc
braces :: IsLine doc => doc -> doc
nest :: Int -> SDoc -> SDoc
hang :: SDoc -> Int -> SDoc -> SDoc
hangNotEmpty :: SDoc -> Int -> SDoc -> SDoc
punctuate :: IsLine doc => doc -> [doc] -> [doc]
($+$) :: SDoc -> SDoc -> SDoc
cat :: [SDoc] -> SDoc
fcat :: [SDoc] -> SDoc
isBoxed :: Boxity -> Bool
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
mkVarOccFS :: FastString -> OccName
mkRecFldSelOcc :: FastString -> OccName
isListEmptyOrSingleton :: [a] -> IsEmptyOrSingleton
reallyAlwaysQualifyNames :: QueryQualifyName
alwaysQualifyNames :: QueryQualifyName
neverQualifyNames :: QueryQualifyName
alwaysQualifyModules :: QueryQualifyModule
neverQualifyModules :: QueryQualifyModule
alwaysQualifyPackages :: QueryQualifyPackage
neverQualifyPackages :: QueryQualifyPackage
alwaysPrintPromTick :: QueryPromotionTick
reallyAlwaysQualify :: NamePprCtx
alwaysQualify :: NamePprCtx
neverQualify :: NamePprCtx
defaultUserStyle :: PprStyle
defaultDumpStyle :: PprStyle
mkDumpStyle :: NamePprCtx -> PprStyle
defaultErrStyle :: PprStyle
mkErrStyle :: NamePprCtx -> PprStyle
cmdlineParserStyle :: PprStyle
mkUserStyle :: NamePprCtx -> Depth -> PprStyle
withUserStyle :: NamePprCtx -> Depth -> SDoc -> SDoc
withErrStyle :: NamePprCtx -> SDoc -> SDoc
setStyleColoured :: Bool -> PprStyle -> PprStyle
runSDoc :: SDoc -> SDocContext -> Doc
defaultSDocContext :: SDocContext
traceSDocContext :: SDocContext
withPprStyle :: PprStyle -> SDoc -> SDoc
pprDeeper :: SDoc -> SDoc
pprDeeperList :: ([SDoc] -> SDoc) -> [SDoc] -> SDoc
pprSetDepth :: Depth -> SDoc -> SDoc
getPprStyle :: (PprStyle -> SDoc) -> SDoc
sdocWithContext :: (SDocContext -> SDoc) -> SDoc
sdocOption :: (SDocContext -> a) -> (a -> SDoc) -> SDoc
updSDocContext :: (SDocContext -> SDocContext) -> SDoc -> SDoc
qualName :: PprStyle -> QueryQualifyName
qualModule :: PprStyle -> QueryQualifyModule
qualPackage :: PprStyle -> QueryQualifyPackage
promTick :: PprStyle -> QueryPromotionTick
queryQual :: PprStyle -> NamePprCtx
codeStyle :: PprStyle -> Bool
dumpStyle :: PprStyle -> Bool
userStyle :: PprStyle -> Bool
getPprDebug :: IsOutput doc => (Bool -> doc) -> doc
ifPprDebug :: IsOutput doc => doc -> doc -> doc
whenPprDebug :: IsOutput doc => doc -> doc
printSDoc :: SDocContext -> Mode -> Handle -> SDoc -> IO ()
printSDocLn :: SDocContext -> Mode -> Handle -> SDoc -> IO ()
bufLeftRenderSDoc :: SDocContext -> BufHandle -> SDoc -> IO ()
pprCode :: SDoc -> SDoc
renderWithContext :: SDocContext -> SDoc -> String
showSDocOneLine :: SDocContext -> SDoc -> String
showSDocUnsafe :: SDoc -> String
showPprUnsafe :: Outputable a => a -> String
pprDebugAndThen :: SDocContext -> (String -> a) -> SDoc -> SDoc -> a
docToSDoc :: Doc -> SDoc
doublePrec :: Int -> Double -> SDoc
angleBrackets :: IsLine doc => doc -> doc
cparen :: Bool -> SDoc -> SDoc
blankLine :: SDoc
dcolon :: SDoc
arrow :: SDoc
lollipop :: SDoc
larrow :: SDoc
darrow :: SDoc
arrowt :: SDoc
larrowt :: SDoc
arrowtt :: SDoc
larrowtt :: SDoc
lambda :: SDoc
underscore :: IsLine doc => doc
dot :: IsLine doc => doc
vbar :: IsLine doc => doc
forAllLit :: SDoc
bullet :: SDoc
unicodeSyntax :: SDoc -> SDoc -> SDoc
ppWhen :: IsOutput doc => Bool -> doc -> doc
ppUnless :: IsOutput doc => Bool -> doc -> doc
ppWhenOption :: (SDocContext -> Bool) -> SDoc -> SDoc
ppUnlessOption :: IsLine doc => (SDocContext -> Bool) -> doc -> doc
coloured :: PprColour -> SDoc -> SDoc
keyword :: SDoc -> SDoc
pprModuleName :: IsLine doc => ModuleName -> doc
pprHsChar :: Char -> SDoc
pprHsString :: FastString -> SDoc
pprHsBytes :: ByteString -> SDoc
primCharSuffix :: SDoc
primFloatSuffix :: SDoc
primIntSuffix :: SDoc
primDoubleSuffix :: SDoc
primWordSuffix :: SDoc
primInt8Suffix :: SDoc
primWord8Suffix :: SDoc
primInt16Suffix :: SDoc
primWord16Suffix :: SDoc
primInt32Suffix :: SDoc
primWord32Suffix :: SDoc
primInt64Suffix :: SDoc
primWord64Suffix :: SDoc
pprPrimChar :: Char -> SDoc
pprPrimInt :: Integer -> SDoc
pprPrimWord :: Integer -> SDoc
pprPrimInt8 :: Integer -> SDoc
pprPrimInt16 :: Integer -> SDoc
pprPrimInt32 :: Integer -> SDoc
pprPrimInt64 :: Integer -> SDoc
pprPrimWord8 :: Integer -> SDoc
pprPrimWord16 :: Integer -> SDoc
pprPrimWord32 :: Integer -> SDoc
pprPrimWord64 :: Integer -> SDoc
pprPrefixVar :: Bool -> SDoc -> SDoc
pprInfixVar :: Bool -> SDoc -> SDoc
pprFastFilePath :: FastString -> SDoc
pprFilePathString :: IsLine doc => FilePath -> doc
pprWithCommas :: (a -> SDoc) -> [a] -> SDoc
pprWithBars :: (a -> SDoc) -> [a] -> SDoc
spaceIfSingleQuote :: SDoc -> SDoc
interppSP :: Outputable a => [a] -> SDoc
interpp'SP :: Outputable a => [a] -> SDoc
interpp'SP' :: (a -> SDoc) -> [a] -> SDoc
pprQuotedList :: Outputable a => [a] -> SDoc
quotedListWithOr :: [SDoc] -> SDoc
quotedListWithNor :: [SDoc] -> SDoc
intWithCommas :: Integral a => a -> SDoc
speakNth :: Int -> SDoc
speakN :: Int -> SDoc
speakNOf :: Int -> SDoc -> SDoc
plural :: [a] -> SDoc
singular :: [a] -> SDoc
isOrAre :: [a] -> SDoc
doOrDoes :: [a] -> SDoc
itsOrTheir :: [a] -> SDoc
thisOrThese :: [a] -> SDoc
hasOrHave :: [a] -> SDoc
bPutHDoc :: BufHandle -> SDocContext -> HDoc -> IO ()
showException :: Exception e => e -> String
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 ()
pprIdDetails :: IdDetails -> SDoc
isCoVarDetails :: IdDetails -> Bool
coVarDetails :: IdDetails
vanillaIdInfo :: IdInfo
emptyPlugins :: Plugins
tidyNameOcc :: Name -> OccName -> Name
nameOccName :: Name -> OccName
setNameUnique :: Name -> Unique -> Name
nameUnique :: Name -> Unique
idName :: Id -> Name
mkPrelTyConRepName :: Name -> TyConRepName
tyConRepName_maybe :: TyCon -> Maybe TyConRepName
isUnboxedTupleTyCon :: TyCon -> Bool
isTupleTyCon :: TyCon -> Bool
mkForAllTy :: ForAllTyBinder -> Type -> Type
pprCo :: Coercion -> SDoc
noFreeVarsOfType :: Type -> Bool
emptyUFM :: UniqFM key elt
isNullUFM :: UniqFM key elt -> Bool
unitUFM :: Uniquable key => key -> elt -> UniqFM key elt
unitDirectlyUFM :: Unique -> elt -> UniqFM key elt
zipToUFM :: Uniquable key => [key] -> [elt] -> UniqFM key elt
listToUFM :: Uniquable key => [(key, elt)] -> UniqFM key elt
listToUFM_Directly :: [(Unique, elt)] -> UniqFM key elt
listToIdentityUFM :: Uniquable key => [key] -> UniqFM key key
listToUFM_C :: Uniquable key => (elt -> elt -> elt) -> [(key, elt)] -> UniqFM key elt
addToUFM :: Uniquable key => UniqFM key elt -> key -> elt -> UniqFM key elt
addListToUFM :: Uniquable key => UniqFM key elt -> [(key, elt)] -> UniqFM key elt
addListToUFM_Directly :: UniqFM key elt -> [(Unique, elt)] -> UniqFM key elt
addToUFM_Directly :: UniqFM key elt -> Unique -> elt -> UniqFM key elt
addToUFM_C :: Uniquable key => (elt -> elt -> elt) -> UniqFM key elt -> key -> elt -> UniqFM key elt
addToUFM_Acc :: Uniquable key => (elt -> elts -> elts) -> (elt -> elts) -> UniqFM key elts -> key -> elt -> UniqFM key elts
addToUFM_L :: Uniquable key => (key -> elt -> elt -> elt) -> key -> elt -> UniqFM key elt -> (Maybe elt, UniqFM key elt)
alterUFM :: Uniquable key => (Maybe elt -> Maybe elt) -> UniqFM key elt -> key -> UniqFM key elt
addListToUFM_C :: Uniquable key => (elt -> elt -> elt) -> UniqFM key elt -> [(key, elt)] -> UniqFM key elt
adjustUFM :: Uniquable key => (elt -> elt) -> UniqFM key elt -> key -> UniqFM key elt
adjustUFM_Directly :: (elt -> elt) -> UniqFM key elt -> Unique -> UniqFM key elt
delFromUFM :: Uniquable key => UniqFM key elt -> key -> UniqFM key elt
delListFromUFM :: Uniquable key => UniqFM key elt -> [key] -> UniqFM key elt
delListFromUFM_Directly :: UniqFM key elt -> [Unique] -> UniqFM key elt
delFromUFM_Directly :: UniqFM key elt -> Unique -> UniqFM key elt
plusUFM :: UniqFM key elt -> UniqFM key elt -> UniqFM key elt
plusUFM_C :: (elt -> elt -> elt) -> UniqFM key elt -> UniqFM key elt -> UniqFM key elt
plusUFM_CD :: (elta -> eltb -> eltc) -> UniqFM key elta -> elta -> UniqFM key eltb -> eltb -> UniqFM key eltc
plusUFM_CD2 :: (Maybe elta -> Maybe eltb -> eltc) -> UniqFM key elta -> UniqFM key eltb -> UniqFM key eltc
mergeUFM :: (elta -> eltb -> Maybe eltc) -> (UniqFM key elta -> UniqFM key eltc) -> (UniqFM key eltb -> UniqFM key eltc) -> UniqFM key elta -> UniqFM key eltb -> UniqFM key eltc
plusMaybeUFM_C :: (elt -> elt -> Maybe elt) -> UniqFM key elt -> UniqFM key elt -> UniqFM key elt
plusUFMList :: [UniqFM key elt] -> UniqFM key elt
sequenceUFMList :: [UniqFM key elt] -> UniqFM key [elt]
minusUFM :: UniqFM key elt1 -> UniqFM key elt2 -> UniqFM key elt1
minusUFM_C :: (elt1 -> elt2 -> Maybe elt1) -> UniqFM key elt1 -> UniqFM key elt2 -> UniqFM key elt1
intersectUFM :: UniqFM key elt1 -> UniqFM key elt2 -> UniqFM key elt1
intersectUFM_C :: (elt1 -> elt2 -> elt3) -> UniqFM key elt1 -> UniqFM key elt2 -> UniqFM key elt3
disjointUFM :: UniqFM key elt1 -> UniqFM key elt2 -> Bool
foldUFM :: (elt -> a -> a) -> a -> UniqFM key elt -> a
mapUFM :: (elt1 -> elt2) -> UniqFM key elt1 -> UniqFM key elt2
mapMaybeUFM :: (elt1 -> Maybe elt2) -> UniqFM key elt1 -> UniqFM key elt2
mapUFM_Directly :: (Unique -> elt1 -> elt2) -> UniqFM key elt1 -> UniqFM key elt2
filterUFM :: (elt -> Bool) -> UniqFM key elt -> UniqFM key elt
filterUFM_Directly :: (Unique -> elt -> Bool) -> UniqFM key elt -> UniqFM key elt
partitionUFM :: (elt -> Bool) -> UniqFM key elt -> (UniqFM key elt, UniqFM key elt)
sizeUFM :: UniqFM key elt -> Int
elemUFM :: Uniquable key => key -> UniqFM key elt -> Bool
elemUFM_Directly :: Unique -> UniqFM key elt -> Bool
lookupUFM :: Uniquable key => UniqFM key elt -> key -> Maybe elt
lookupUFM_Directly :: UniqFM key elt -> Unique -> Maybe elt
lookupWithDefaultUFM :: Uniquable key => UniqFM key elt -> elt -> key -> elt
lookupWithDefaultUFM_Directly :: UniqFM key elt -> elt -> Unique -> elt
ufmToSet_Directly :: UniqFM key elt -> IntSet
anyUFM :: (elt -> Bool) -> UniqFM key elt -> Bool
allUFM :: (elt -> Bool) -> UniqFM key elt -> Bool
seqEltsUFM :: (elt -> ()) -> UniqFM key elt -> ()
nonDetEltsUFM :: UniqFM key elt -> [elt]
nonDetKeysUFM :: UniqFM key elt -> [Unique]
nonDetStrictFoldUFM :: (elt -> a -> a) -> a -> UniqFM key elt -> a
nonDetStrictFoldUFM_DirectlyM :: Monad m => (Unique -> b -> elt -> m b) -> b -> UniqFM key elt -> m b
nonDetStrictFoldUFM_Directly :: (Unique -> elt -> a -> a) -> a -> UniqFM key elt -> a
nonDetUFMToList :: UniqFM key elt -> [(Unique, elt)]
ufmToIntMap :: UniqFM key elt -> IntMap elt
unsafeIntMapToUFM :: IntMap elt -> UniqFM key elt
unsafeCastUFMKey :: UniqFM key1 elt -> UniqFM key2 elt
equalKeysUFM :: UniqFM key a -> UniqFM key b -> Bool
pprUniqFM :: (a -> SDoc) -> UniqFM key a -> SDoc
pprUFM :: UniqFM key a -> ([a] -> SDoc) -> SDoc
pprUFMWithKeys :: UniqFM key a -> ([(Unique, a)] -> SDoc) -> SDoc
pluralUFM :: UniqFM key a -> SDoc
insertList :: Ord key => [(key, elt)] -> Map key elt -> Map key elt
insertListWith :: Ord key => (elt -> elt -> elt) -> [(key, elt)] -> Map key elt -> Map key elt
deleteList :: Ord key => [key] -> Map key elt -> Map key elt
foldRight :: (elt -> a -> a) -> a -> Map key elt -> a
foldRightWithKey :: (key -> elt -> a -> a) -> a -> Map key elt -> a
mkSplitUniqSupply :: Char -> IO UniqSupply
initUniqSupply :: Word -> Int -> IO ()
uniqFromMask :: Char -> IO Unique
splitUniqSupply :: UniqSupply -> (UniqSupply, UniqSupply)
listSplitUniqSupply :: UniqSupply -> [UniqSupply]
uniqFromSupply :: UniqSupply -> Unique
uniqsFromSupply :: UniqSupply -> [Unique]
takeUniqFromSupply :: UniqSupply -> (Unique, UniqSupply)
initUs :: UniqSupply -> UniqSM a -> (a, UniqSupply)
initUs_ :: UniqSupply -> UniqSM a -> a
showOpt :: Option -> String
mkSrcLoc :: FastString -> Int -> Int -> SrcLoc
mkRealSrcLoc :: FastString -> Int -> Int -> RealSrcLoc
leftmostColumn :: Int
getBufPos :: SrcLoc -> Maybe BufPos
noSrcLoc :: SrcLoc
generatedSrcLoc :: SrcLoc
interactiveSrcLoc :: SrcLoc
mkGeneralSrcLoc :: FastString -> SrcLoc
srcLocLine :: RealSrcLoc -> Int
srcLocCol :: RealSrcLoc -> Int
advanceSrcLoc :: RealSrcLoc -> Char -> RealSrcLoc
advanceBufPos :: BufPos -> BufPos
sortLocated :: [Located a] -> [Located a]
sortRealLocated :: [RealLocated a] -> [RealLocated a]
lookupSrcLoc :: SrcLoc -> Map RealSrcLoc a -> Maybe a
lookupSrcSpan :: SrcSpan -> Map RealSrcSpan a -> Maybe a
removeBufSpan :: SrcSpan -> SrcSpan
getBufSpan :: SrcSpan -> Maybe BufSpan
noSrcSpan :: SrcSpan
wiredInSrcSpan :: SrcSpan
interactiveSrcSpan :: SrcSpan
generatedSrcSpan :: SrcSpan
isGeneratedSrcSpan :: SrcSpan -> Bool
isNoSrcSpan :: SrcSpan -> Bool
mkGeneralSrcSpan :: FastString -> SrcSpan
srcLocSpan :: SrcLoc -> SrcSpan
realSrcLocSpan :: RealSrcLoc -> RealSrcSpan
mkRealSrcSpan :: RealSrcLoc -> RealSrcLoc -> RealSrcSpan
mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan
combineSrcSpans :: SrcSpan -> SrcSpan -> SrcSpan
combineRealSrcSpans :: RealSrcSpan -> RealSrcSpan -> RealSrcSpan
combineBufSpans :: BufSpan -> BufSpan -> BufSpan
srcSpanFirstCharacter :: SrcSpan -> SrcSpan
isGoodSrcSpan :: SrcSpan -> Bool
isOneLineSpan :: SrcSpan -> Bool
isZeroWidthSpan :: SrcSpan -> Bool
containsSpan :: RealSrcSpan -> RealSrcSpan -> Bool
srcSpanStartLine :: RealSrcSpan -> Int
srcSpanEndLine :: RealSrcSpan -> Int
srcSpanStartCol :: RealSrcSpan -> Int
srcSpanEndCol :: RealSrcSpan -> Int
srcSpanStart :: SrcSpan -> SrcLoc
srcSpanEnd :: SrcSpan -> SrcLoc
realSrcSpanStart :: RealSrcSpan -> RealSrcLoc
realSrcSpanEnd :: RealSrcSpan -> RealSrcLoc
srcSpanFileName_maybe :: SrcSpan -> Maybe FastString
srcSpanToRealSrcSpan :: SrcSpan -> Maybe RealSrcSpan
unhelpfulSpanFS :: UnhelpfulSpanReason -> FastString
pprUnhelpfulSpanReason :: UnhelpfulSpanReason -> SDoc
pprUserSpan :: Bool -> SrcSpan -> SDoc
pprUserRealSpan :: Bool -> RealSrcSpan -> SDoc
unLoc :: GenLocated l e -> e
getLoc :: GenLocated l e -> l
noLoc :: e -> Located e
mkGeneralLocated :: String -> e -> Located e
combineLocs :: Located a -> Located b -> SrcSpan
addCLoc :: Located a -> Located b -> c -> Located c
eqLocated :: Eq a => GenLocated l a -> GenLocated l a -> Bool
cmpLocated :: Ord a => GenLocated l a -> GenLocated l a -> Ordering
cmpBufSpan :: HasDebugCallStack => Located a -> Located a -> Ordering
pprLocated :: (Outputable l, Outputable e) => GenLocated l e -> SDoc
pprLocatedAlways :: (Outputable l, Outputable e) => GenLocated l e -> SDoc
rightmost_smallest :: SrcSpan -> SrcSpan -> Ordering
leftmost_smallest :: SrcSpan -> SrcSpan -> Ordering
leftmost_largest :: SrcSpan -> SrcSpan -> Ordering
spans :: SrcSpan -> (Int, Int) -> Bool
isSubspanOf :: SrcSpan -> SrcSpan -> Bool
isRealSubspanOf :: RealSrcSpan -> RealSrcSpan -> Bool
getRealSrcSpan :: RealLocated a -> RealSrcSpan
unRealSrcSpan :: RealLocated a -> a
psLocatedToLocated :: PsLocated a -> Located a
advancePsLoc :: PsLoc -> Char -> PsLoc
mkPsSpan :: PsLoc -> PsLoc -> PsSpan
psSpanStart :: PsSpan -> PsLoc
psSpanEnd :: PsSpan -> PsLoc
mkSrcSpanPs :: PsSpan -> SrcSpan
emptyFsEnv :: FastStringEnv a
extendFsEnv :: FastStringEnv a -> FastString -> a -> FastStringEnv a
lookupFsEnv :: FastStringEnv a -> FastString -> Maybe a
mkFsEnv :: [(FastString, a)] -> FastStringEnv a
emptyUniqSet :: UniqSet a
unitUniqSet :: Uniquable a => a -> UniqSet a
mkUniqSet :: Uniquable a => [a] -> UniqSet a
addOneToUniqSet :: Uniquable a => UniqSet a -> a -> UniqSet a
addListToUniqSet :: Uniquable a => UniqSet a -> [a] -> UniqSet a
delOneFromUniqSet :: Uniquable a => UniqSet a -> a -> UniqSet a
delOneFromUniqSet_Directly :: UniqSet a -> Unique -> UniqSet a
delListFromUniqSet :: Uniquable a => UniqSet a -> [a] -> UniqSet a
delListFromUniqSet_Directly :: UniqSet a -> [Unique] -> UniqSet a
unionUniqSets :: UniqSet a -> UniqSet a -> UniqSet a
unionManyUniqSets :: [UniqSet a] -> UniqSet a
minusUniqSet :: UniqSet a -> UniqSet a -> UniqSet a
intersectUniqSets :: UniqSet a -> UniqSet a -> UniqSet a
disjointUniqSets :: UniqSet a -> UniqSet a -> Bool
restrictUniqSetToUFM :: UniqSet key -> UniqFM key b -> UniqSet key
uniqSetMinusUFM :: UniqSet key -> UniqFM key b -> UniqSet key
uniqSetMinusUDFM :: UniqSet key -> UniqDFM key b -> UniqSet key
elementOfUniqSet :: Uniquable a => a -> UniqSet a -> Bool
elemUniqSet_Directly :: Unique -> UniqSet a -> Bool
filterUniqSet :: (a -> Bool) -> UniqSet a -> UniqSet a
filterUniqSet_Directly :: (Unique -> elt -> Bool) -> UniqSet elt -> UniqSet elt
partitionUniqSet :: (a -> Bool) -> UniqSet a -> (UniqSet a, UniqSet a)
uniqSetAny :: (a -> Bool) -> UniqSet a -> Bool
uniqSetAll :: (a -> Bool) -> UniqSet a -> Bool
sizeUniqSet :: UniqSet a -> Int
isEmptyUniqSet :: UniqSet a -> Bool
lookupUniqSet :: Uniquable key => UniqSet key -> key -> Maybe key
lookupUniqSet_Directly :: UniqSet a -> Unique -> Maybe a
nonDetEltsUniqSet :: UniqSet elt -> [elt]
nonDetKeysUniqSet :: UniqSet elt -> [Unique]
nonDetStrictFoldUniqSet :: (elt -> a -> a) -> a -> UniqSet elt -> a
mapUniqSet :: Uniquable b => (a -> b) -> UniqSet a -> UniqSet b
getUniqSet :: UniqSet a -> UniqFM a a
unsafeUFMToUniqSet :: UniqFM a a -> UniqSet a
pprUniqSet :: (a -> SDoc) -> UniqSet a -> SDoc
pprWithSourceText :: SourceText -> SDoc -> SDoc
mkIntegralLit :: Integral a => a -> IntegralLit
negateIntegralLit :: IntegralLit -> IntegralLit
mkFractionalLit :: SourceText -> Bool -> Rational -> Integer -> FractionalExponentBase -> FractionalLit
fractionalLitFromRational :: Rational -> FractionalLit
rationalFromFractionalLit :: FractionalLit -> Rational
mkTHFractionalLit :: Rational -> FractionalLit
negateFractionalLit :: FractionalLit -> FractionalLit
integralFractionalLit :: Bool -> Integer -> FractionalLit
mkSourceFractionalLit :: String -> Bool -> Integer -> Integer -> FractionalExponentBase -> FractionalLit
optimisationFlags :: EnumSet GeneralFlag
codeGenFlags :: EnumSet GeneralFlag
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
toUnitId :: Unit -> UnitId
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)
homeUnitId :: GenHomeUnit u -> UnitId
homeUnitInstantiations :: GenHomeUnit u -> GenInstantiations u
homeUnitInstanceOf :: HomeUnit -> UnitId
homeUnitInstanceOfMaybe :: GenHomeUnit u -> Maybe u
homeUnitAsUnit :: HomeUnit -> Unit
homeUnitMap :: IsUnitId v => (u -> v) -> GenHomeUnit u -> GenHomeUnit v
isHomeUnitIndefinite :: GenHomeUnit u -> Bool
isHomeUnitDefinite :: GenHomeUnit u -> Bool
isHomeUnitInstantiating :: GenHomeUnit u -> Bool
isHomeUnit :: HomeUnit -> Unit -> Bool
isHomeUnitId :: GenHomeUnit u -> UnitId -> Bool
notHomeUnitId :: Maybe (GenHomeUnit u) -> UnitId -> Bool
isHomeUnitInstanceOf :: HomeUnit -> UnitId -> Bool
isHomeModule :: HomeUnit -> Module -> Bool
isHomeInstalledModule :: GenHomeUnit u -> InstalledModule -> Bool
notHomeInstalledModule :: GenHomeUnit u -> InstalledModule -> Bool
notHomeInstalledModuleMaybe :: Maybe (GenHomeUnit u) -> InstalledModule -> Bool
notHomeModule :: HomeUnit -> Module -> Bool
notHomeModuleMaybe :: Maybe HomeUnit -> Module -> Bool
mkHomeModule :: HomeUnit -> ModuleName -> Module
mkHomeInstalledModule :: GenHomeUnit u -> ModuleName -> InstalledModule
homeModuleNameInstantiation :: HomeUnit -> ModuleName -> Module
homeModuleInstantiation :: Maybe HomeUnit -> Module -> Module
isPromoted :: PromotionFlag -> Bool
pickLR :: LeftOrRight -> (a, a) -> a
fIRST_TAG :: ConTag
mkAlignment :: Int -> Alignment
alignmentOf :: Int -> Alignment
noOneShotInfo :: OneShotInfo
isOneShotInfo :: OneShotInfo -> Bool
hasNoOneShotInfo :: OneShotInfo -> Bool
worstOneShot :: OneShotInfo -> OneShotInfo -> OneShotInfo
bestOneShot :: OneShotInfo -> OneShotInfo -> OneShotInfo
flipSwap :: SwapFlag -> SwapFlag
isSwapped :: SwapFlag -> Bool
unSwap :: SwapFlag -> (a -> a -> b) -> a -> a -> b
pprRuleName :: RuleName -> SDoc
isNotTopLevel :: TopLevelFlag -> Bool
isTopLevel :: TopLevelFlag -> Bool
isMarkedCbv :: CbvMark -> Bool
isRec :: RecFlag -> Bool
isNonRec :: RecFlag -> Bool
boolToRecFlag :: Bool -> RecFlag
isGenerated :: Origin -> Bool
setOverlapModeMaybe :: OverlapFlag -> Maybe OverlapMode -> OverlapFlag
hasIncoherentFlag :: OverlapMode -> Bool
hasOverlappableFlag :: OverlapMode -> Bool
hasOverlappingFlag :: OverlapMode -> Bool
topPrec :: PprPrec
sigPrec :: PprPrec
funPrec :: PprPrec
opPrec :: PprPrec
starPrec :: PprPrec
maxPrec :: PprPrec
maybeParen :: PprPrec -> PprPrec -> SDoc -> SDoc
tupleSortBoxity :: TupleSort -> Boxity
boxityTupleSort :: Boxity -> TupleSort
tupleParens :: TupleSort -> SDoc -> SDoc
sumParens :: SDoc -> SDoc
pprAlternative :: (a -> SDoc) -> a -> ConTag -> Arity -> SDoc
unboxedTupleOrSumExtension :: UnboxedTupleOrSum -> Extension
oneBranch :: BranchCount
noOccInfo :: OccInfo
isNoOccInfo :: OccInfo -> Bool
isManyOccs :: OccInfo -> Bool
seqOccInfo :: OccInfo -> ()
tailCallInfo :: OccInfo -> TailCallInfo
zapOccTailCallInfo :: OccInfo -> OccInfo
isAlwaysTailCalled :: OccInfo -> Bool
strongLoopBreaker :: OccInfo
weakLoopBreaker :: OccInfo
isWeakLoopBreaker :: OccInfo -> Bool
isStrongLoopBreaker :: OccInfo -> Bool
isDeadOcc :: OccInfo -> Bool
isOneOcc :: OccInfo -> Bool
zapFragileOcc :: OccInfo -> OccInfo
successIf :: Bool -> SuccessFlag
succeeded :: SuccessFlag -> Bool
failed :: SuccessFlag -> Bool
beginPhase :: Activation -> CompilerPhase
activeAfter :: CompilerPhase -> Activation
nextPhase :: CompilerPhase -> CompilerPhase
laterPhase :: CompilerPhase -> CompilerPhase -> CompilerPhase
activateAfterInitial :: Activation
activateDuringFinal :: Activation
isActive :: CompilerPhase -> Activation -> Bool
activeInFinalPhase :: Activation -> Bool
isNeverActive :: Activation -> Bool
isAlwaysActive :: Activation -> Bool
competesWith :: Activation -> Activation -> Bool
isConLike :: RuleMatchInfo -> Bool
isFunLike :: RuleMatchInfo -> Bool
noUserInlineSpec :: InlineSpec -> Bool
defaultInlinePragma :: InlinePragma
alwaysInlinePragma :: InlinePragma
neverInlinePragma :: InlinePragma
alwaysInlineConLikePragma :: InlinePragma
inlinePragmaSpec :: InlinePragma -> InlineSpec
inlinePragmaSource :: InlinePragma -> SourceText
inlineSpecSource :: InlineSpec -> SourceText
dfunInlinePragma :: InlinePragma
isDefaultInlinePragma :: InlinePragma -> Bool
isInlinePragma :: InlinePragma -> Bool
isInlinablePragma :: InlinePragma -> Bool
isNoInlinePragma :: InlinePragma -> Bool
isAnyInlinePragma :: InlinePragma -> Bool
isOpaquePragma :: InlinePragma -> Bool
inlinePragmaSat :: InlinePragma -> Maybe Arity
inlinePragmaActivation :: InlinePragma -> Activation
inlinePragmaRuleMatchInfo :: InlinePragma -> RuleMatchInfo
setInlinePragmaActivation :: InlinePragma -> Activation -> InlinePragma
setInlinePragmaRuleMatchInfo :: InlinePragma -> RuleMatchInfo -> InlinePragma
inlinePragmaName :: InlineSpec -> SDoc
pprInline :: InlinePragma -> SDoc
pprInlineDebug :: InlinePragma -> SDoc
isStableUserSource :: UnfoldingSource -> Bool
isStableSystemSource :: UnfoldingSource -> Bool
isCompulsorySource :: UnfoldingSource -> Bool
isStableSource :: UnfoldingSource -> Bool
intGtLimit :: Int -> IntWithInf -> Bool
subWithInf :: IntWithInf -> Int -> IntWithInf
treatZeroAsInf :: Int -> IntWithInf
mkIntWithInf :: Int -> IntWithInf
isTypeLevel :: TypeOrKind -> Bool
isKindLevel :: TypeOrKind -> Bool
mightBeLifted :: Maybe Levity -> Bool
mightBeUnlifted :: Maybe Levity -> Bool
defaultNonStandardTyVars :: DefaultingStrategy -> Bool
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]
dataConExTyCoVars :: DataCon -> [TyCoVar]
dataConTyCon :: DataCon -> TyCon
dataConWorkId :: DataCon -> Id
dataConName :: DataCon -> Name
sumTyCon :: Arity -> TyCon
sumDataCon :: ConTag -> Arity -> DataCon
cTupleSelIdName :: ConTag -> Arity -> Name
cTupleTyConName :: Arity -> Name
cTupleDataConName :: Arity -> Name
cTupleDataCon :: Arity -> DataCon
tupleTyCon :: Boxity -> Arity -> TyCon
tupleDataCon :: Boxity -> Arity -> DataCon
promotedTupleDataCon :: Boxity -> Arity -> TyCon
integerTy :: Type
naturalTy :: Type
tupleDataConName :: Boxity -> Arity -> Name
tupleTyConName :: TupleSort -> Arity -> Name
multMulTyCon :: TyCon
unrestrictedFunTyCon :: TyCon
manyDataConTyCon :: TyCon
manyDataConTy :: Type
oneDataConTyCon :: TyCon
oneDataConTy :: Type
multiplicityTy :: Type
multiplicityTyCon :: TyCon
unboxedTupleKind :: [Type] -> Kind
anyTypeOfKind :: Kind -> Type
int8ElemRepDataConTy :: Type
int16ElemRepDataConTy :: Type
int32ElemRepDataConTy :: Type
int64ElemRepDataConTy :: Type
word8ElemRepDataConTy :: Type
word16ElemRepDataConTy :: Type
word32ElemRepDataConTy :: Type
word64ElemRepDataConTy :: Type
floatElemRepDataConTy :: Type
doubleElemRepDataConTy :: Type
vec2DataConTy :: Type
vec4DataConTy :: Type
vec8DataConTy :: Type
vec16DataConTy :: Type
vec32DataConTy :: Type
vec64DataConTy :: Type
intRepDataConTy :: RuntimeRepType
int8RepDataConTy :: RuntimeRepType
int16RepDataConTy :: RuntimeRepType
int32RepDataConTy :: RuntimeRepType
int64RepDataConTy :: RuntimeRepType
wordRepDataConTy :: RuntimeRepType
word8RepDataConTy :: RuntimeRepType
word16RepDataConTy :: RuntimeRepType
word32RepDataConTy :: RuntimeRepType
word64RepDataConTy :: RuntimeRepType
addrRepDataConTy :: RuntimeRepType
floatRepDataConTy :: RuntimeRepType
doubleRepDataConTy :: RuntimeRepType
liftedDataConTy :: Type
unliftedDataConTy :: Type
liftedRepTy :: RuntimeRepType
unliftedRepTy :: RuntimeRepType
zeroBitRepTy :: RuntimeRepType
vecRepDataConTyCon :: TyCon
tupleRepDataConTyCon :: TyCon
boxedRepDataConTyCon :: TyCon
liftedDataConTyCon :: TyCon
runtimeRepTy :: Type
levityTy :: Type
runtimeRepTyCon :: TyCon
levityTyCon :: TyCon
vecCountTyCon :: TyCon
vecElemTyCon :: TyCon
constraintKind :: Kind
liftedRepTyCon :: TyCon
unliftedRepTyCon :: TyCon
liftedTypeKindTyCon :: TyCon
unliftedTypeKindTyCon :: TyCon
liftedTypeKind :: Type
unliftedTypeKind :: Type
zeroBitTypeKind :: Type
constraintKindTyConName :: Name
liftedTypeKindTyConName :: Name
unitTy :: Type
coercibleTyCon :: TyCon
heqTyCon :: TyCon
mkBoxedTupleTy :: [Type] -> Type
charTy :: Type
typeSymbolKind :: Kind
listTyCon :: TyCon
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)
wordAlignment :: Platform -> Alignment
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
nonDetCmpVar :: Var -> Var -> Ordering
varUnique :: Var -> Unique
varMultMaybe :: Id -> Maybe Mult
setVarUnique :: Var -> Unique -> Var
setVarName :: Var -> Name -> Var
setVarType :: Var -> Type -> Var
updateVarType :: (Type -> Type) -> Var -> Var
updateVarTypeM :: Monad m => (Type -> m Type) -> Var -> m Var
isVisibleForAllTyFlag :: ForAllTyFlag -> Bool
isInvisibleForAllTyFlag :: ForAllTyFlag -> Bool
isInferredForAllTyFlag :: ForAllTyFlag -> Bool
mkFunTyFlag :: TypeOrConstraint -> TypeOrConstraint -> FunTyFlag
visArg :: TypeOrConstraint -> FunTyFlag
visArgTypeLike :: FunTyFlag
visArgConstraintLike :: FunTyFlag
invisArg :: TypeOrConstraint -> FunTyFlag
invisArgTypeLike :: FunTyFlag
invisArgConstraintLike :: FunTyFlag
isInvisibleFunArg :: FunTyFlag -> Bool
isVisibleFunArg :: FunTyFlag -> Bool
isFUNArg :: FunTyFlag -> Bool
funTyFlagResultTypeOrConstraint :: FunTyFlag -> TypeOrConstraint
tyVarSpecToBinders :: [VarBndr a Specificity] -> [VarBndr a ForAllTyFlag]
tyVarSpecToBinder :: VarBndr a Specificity -> VarBndr a ForAllTyFlag
tyVarReqToBinders :: [VarBndr a ()] -> [VarBndr a ForAllTyFlag]
tyVarReqToBinder :: VarBndr a () -> VarBndr a ForAllTyFlag
binderVar :: VarBndr tv argf -> tv
binderVars :: [VarBndr tv argf] -> [tv]
binderFlag :: VarBndr tv argf -> argf
binderFlags :: [VarBndr tv argf] -> [argf]
binderType :: VarBndr TyCoVar argf -> Type
isTyVarBinder :: VarBndr TyCoVar vis -> Bool
mkForAllTyBinder :: vis -> TyCoVar -> VarBndr TyCoVar vis
mkTyVarBinder :: vis -> TyVar -> VarBndr TyVar vis
mkForAllTyBinders :: vis -> [TyCoVar] -> [VarBndr TyCoVar vis]
mkTyVarBinders :: vis -> [TyVar] -> [VarBndr TyVar vis]
mapVarBndr :: (var -> var') -> VarBndr var flag -> VarBndr var' flag
mapVarBndrs :: (var -> var') -> [VarBndr var flag] -> [VarBndr var' flag]
isInvisiblePiTyBinder :: PiTyBinder -> Bool
isVisiblePiTyBinder :: PiTyBinder -> Bool
isNamedPiTyBinder :: PiTyBinder -> Bool
namedPiTyBinder_maybe :: PiTyBinder -> Maybe TyCoVar
isAnonPiTyBinder :: PiTyBinder -> Bool
anonPiTyBinderType_maybe :: PiTyBinder -> Maybe Type
isTyBinder :: PiTyBinder -> Bool
piTyBinderType :: PiTyBinder -> Type
tyVarName :: TyVar -> Name
tyVarKind :: TyVar -> Kind
setTyVarUnique :: TyVar -> Unique -> TyVar
setTyVarName :: TyVar -> Name -> TyVar
setTyVarKind :: TyVar -> Kind -> TyVar
updateTyVarKind :: (Kind -> Kind) -> TyVar -> TyVar
updateTyVarKindM :: Monad m => (Kind -> m Kind) -> TyVar -> m TyVar
mkTyVar :: Name -> Kind -> TyVar
mkTcTyVar :: Name -> Kind -> TcTyVarDetails -> TyVar
tcTyVarDetails :: TyVar -> TcTyVarDetails
setTcTyVarDetails :: TyVar -> TcTyVarDetails -> TyVar
idInfo :: HasDebugCallStack => Id -> IdInfo
idDetails :: Id -> IdDetails
mkGlobalVar :: IdDetails -> Name -> Type -> IdInfo -> Id
mkLocalVar :: IdDetails -> Name -> Mult -> Type -> IdInfo -> Id
mkCoVar :: Name -> Type -> CoVar
mkExportedLocalVar :: IdDetails -> Name -> Type -> IdInfo -> Id
lazySetIdInfo :: Id -> IdInfo -> Var
setIdDetails :: Id -> IdDetails -> Id
globaliseId :: Id -> Id
setIdExported :: Id -> Id
setIdNotExported :: Id -> Id
updateIdTypeButNotMult :: (Type -> Type) -> Id -> Id
updateIdTypeAndMult :: (Type -> Type) -> Id -> Id
updateIdTypeAndMultM :: Monad m => (Type -> m Type) -> Id -> m Id
setIdMult :: Id -> Mult -> Id
isTyVar :: Var -> Bool
isTcTyVar :: Var -> Bool
isTyCoVar :: Var -> Bool
isId :: Var -> Bool
isCoVar :: Var -> Bool
isNonCoVarId :: Var -> Bool
isLocalId :: Var -> Bool
isLocalVar :: Var -> Bool
isGlobalId :: Var -> Bool
mustHaveLocalBinding :: Var -> Bool
isExportedId :: Var -> Bool
chooseFunTyFlag :: HasDebugCallStack => Type -> Type -> FunTyFlag
partitionInvisibleTypes :: TyCon -> [Type] -> ([Type], [Type])
getLevity :: HasDebugCallStack => Type -> Type
getTyVar_maybe :: Type -> Maybe TyVar
tyConAppTyCon_maybe :: Type -> Maybe TyCon
splitTyConApp_maybe :: HasDebugCallStack => Type -> Maybe (TyCon, [Type])
isLiftedTypeKind :: Kind -> Bool
isMultiplicityTy :: Type -> Bool
isLevityTy :: Type -> Bool
isRuntimeRepTy :: Type -> Bool
coreView :: Type -> Maybe Type
typeTypeOrConstraint :: HasDebugCallStack => Type -> TypeOrConstraint
typeKind :: HasDebugCallStack => Type -> Kind
piResultTy :: HasDebugCallStack => Type -> Type -> Type
mkCoercionTy :: Coercion -> Type
mkTyConApp :: TyCon -> [Type] -> Type
mkCastTy :: Type -> Coercion -> Type
mkAppTy :: Type -> Type -> Type
isCoercionTy :: Type -> Bool
isPredTy :: HasDebugCallStack => Type -> Bool
emptyVarSet :: VarSet
unitVarSet :: Var -> VarSet
extendVarSet :: VarSet -> Var -> VarSet
extendVarSetList :: VarSet -> [Var] -> VarSet
intersectVarSet :: VarSet -> VarSet -> VarSet
unionVarSet :: VarSet -> VarSet -> VarSet
unionVarSets :: [VarSet] -> VarSet
elemVarSet :: Var -> VarSet -> Bool
minusVarSet :: VarSet -> VarSet -> VarSet
delVarSet :: VarSet -> Var -> VarSet
delVarSetList :: VarSet -> [Var] -> VarSet
isEmptyVarSet :: VarSet -> Bool
mkVarSet :: [Var] -> VarSet
lookupVarSet_Directly :: VarSet -> Unique -> Maybe Var
lookupVarSet :: VarSet -> Var -> Maybe Var
lookupVarSetByName :: VarSet -> Name -> Maybe Var
sizeVarSet :: VarSet -> Int
filterVarSet :: (Var -> Bool) -> VarSet -> VarSet
delVarSetByKey :: VarSet -> Unique -> VarSet
elemVarSetByKey :: Unique -> VarSet -> Bool
partitionVarSet :: (Var -> Bool) -> VarSet -> (VarSet, VarSet)
mapUnionVarSet :: (a -> VarSet) -> [a] -> VarSet
intersectsVarSet :: VarSet -> VarSet -> Bool
disjointVarSet :: VarSet -> VarSet -> Bool
subVarSet :: VarSet -> VarSet -> Bool
anyVarSet :: (Var -> Bool) -> VarSet -> Bool
allVarSet :: (Var -> Bool) -> VarSet -> Bool
mapVarSet :: Uniquable b => (a -> b) -> UniqSet a -> UniqSet b
nonDetStrictFoldVarSet :: (Var -> a -> a) -> a -> VarSet -> a
fixVarSet :: (VarSet -> VarSet) -> VarSet -> VarSet
transCloVarSet :: (VarSet -> VarSet) -> VarSet -> VarSet
seqVarSet :: VarSet -> ()
pluralVarSet :: VarSet -> SDoc
pprVarSet :: VarSet -> ([Var] -> SDoc) -> SDoc
emptyDVarSet :: DVarSet
unitDVarSet :: Var -> DVarSet
mkDVarSet :: [Var] -> DVarSet
extendDVarSet :: DVarSet -> Var -> DVarSet
elemDVarSet :: Var -> DVarSet -> Bool
dVarSetElems :: DVarSet -> [Var]
subDVarSet :: DVarSet -> DVarSet -> Bool
unionDVarSet :: DVarSet -> DVarSet -> DVarSet
unionDVarSets :: [DVarSet] -> DVarSet
mapUnionDVarSet :: (a -> DVarSet) -> [a] -> DVarSet
intersectDVarSet :: DVarSet -> DVarSet -> DVarSet
dVarSetIntersectVarSet :: DVarSet -> VarSet -> DVarSet
disjointDVarSet :: DVarSet -> DVarSet -> Bool
intersectsDVarSet :: DVarSet -> DVarSet -> Bool
isEmptyDVarSet :: DVarSet -> Bool
delDVarSet :: DVarSet -> Var -> DVarSet
minusDVarSet :: DVarSet -> DVarSet -> DVarSet
dVarSetMinusVarSet :: DVarSet -> VarSet -> DVarSet
nonDetStrictFoldDVarSet :: (Var -> a -> a) -> a -> DVarSet -> a
anyDVarSet :: (Var -> Bool) -> DVarSet -> Bool
allDVarSet :: (Var -> Bool) -> DVarSet -> Bool
mapDVarSet :: Uniquable b => (a -> b) -> UniqDSet a -> UniqDSet b
filterDVarSet :: (Var -> Bool) -> DVarSet -> DVarSet
sizeDVarSet :: DVarSet -> Int
partitionDVarSet :: (Var -> Bool) -> DVarSet -> (DVarSet, DVarSet)
delDVarSetList :: DVarSet -> [Var] -> DVarSet
seqDVarSet :: DVarSet -> ()
extendDVarSetList :: DVarSet -> [Var] -> DVarSet
dVarSetToVarSet :: DVarSet -> VarSet
transCloDVarSet :: (DVarSet -> DVarSet) -> DVarSet -> DVarSet
unitFV :: Name -> FreeVars
delFV :: Name -> FreeVars -> FreeVars
delFVs :: [Name] -> FreeVars -> FreeVars
mkFVs :: [Name] -> FreeVars
emptyInScopeSet :: InScopeSet
getInScopeVars :: InScopeSet -> VarSet
mkInScopeSet :: VarSet -> InScopeSet
mkInScopeSetList :: [Var] -> InScopeSet
extendInScopeSet :: InScopeSet -> Var -> InScopeSet
extendInScopeSetList :: InScopeSet -> [Var] -> InScopeSet
extendInScopeSetSet :: InScopeSet -> VarSet -> InScopeSet
delInScopeSet :: InScopeSet -> Var -> InScopeSet
elemInScopeSet :: Var -> InScopeSet -> Bool
lookupInScope :: InScopeSet -> Var -> Maybe Var
lookupInScope_Directly :: InScopeSet -> Unique -> Maybe Var
unionInScope :: InScopeSet -> InScopeSet -> InScopeSet
varSetInScope :: VarSet -> InScopeSet -> Bool
uniqAway :: InScopeSet -> Var -> Var
unsafeGetFreshLocalUnique :: InScopeSet -> Unique
mkRnEnv2 :: InScopeSet -> RnEnv2
extendRnInScopeSetList :: RnEnv2 -> [Var] -> RnEnv2
rnInScope :: Var -> RnEnv2 -> Bool
rnInScopeSet :: RnEnv2 -> InScopeSet
rnEnvL :: RnEnv2 -> VarEnv Var
rnEnvR :: RnEnv2 -> VarEnv Var
rnBndrs2 :: RnEnv2 -> [Var] -> [Var] -> RnEnv2
rnBndr2 :: RnEnv2 -> Var -> Var -> RnEnv2
rnBndr2_var :: RnEnv2 -> Var -> Var -> (RnEnv2, Var)
rnBndrL :: RnEnv2 -> Var -> (RnEnv2, Var)
rnBndrR :: RnEnv2 -> Var -> (RnEnv2, Var)
rnEtaL :: RnEnv2 -> Var -> (RnEnv2, Var)
rnEtaR :: RnEnv2 -> Var -> (RnEnv2, Var)
delBndrL :: RnEnv2 -> Var -> RnEnv2
delBndrR :: RnEnv2 -> Var -> RnEnv2
delBndrsL :: RnEnv2 -> [Var] -> RnEnv2
delBndrsR :: RnEnv2 -> [Var] -> RnEnv2
rnOccL :: RnEnv2 -> Var -> Var
rnOccR :: RnEnv2 -> Var -> Var
rnOccL_maybe :: RnEnv2 -> Var -> Maybe Var
rnOccR_maybe :: RnEnv2 -> Var -> Maybe Var
inRnEnvL :: RnEnv2 -> Var -> Bool
inRnEnvR :: RnEnv2 -> Var -> Bool
anyInRnEnvR :: RnEnv2 -> VarSet -> Bool
lookupRnInScope :: RnEnv2 -> Var -> Var
nukeRnEnvL :: RnEnv2 -> RnEnv2
nukeRnEnvR :: RnEnv2 -> RnEnv2
rnSwap :: RnEnv2 -> RnEnv2
emptyTidyEnv :: TidyEnv
mkEmptyTidyEnv :: TidyOccEnv -> TidyEnv
delTidyEnvList :: TidyEnv -> [Var] -> TidyEnv
elemVarEnv :: Var -> VarEnv a -> Bool
elemVarEnvByKey :: Unique -> VarEnv a -> Bool
disjointVarEnv :: VarEnv a -> VarEnv a -> Bool
alterVarEnv :: (Maybe a -> Maybe a) -> VarEnv a -> Var -> VarEnv a
extendVarEnv :: VarEnv a -> Var -> a -> VarEnv a
extendVarEnv_C :: (a -> a -> a) -> VarEnv a -> Var -> a -> VarEnv a
extendVarEnv_Acc :: (a -> b -> b) -> (a -> b) -> VarEnv b -> Var -> a -> VarEnv b
extendVarEnvList :: VarEnv a -> [(Var, a)] -> VarEnv a
plusVarEnv_C :: (a -> a -> a) -> VarEnv a -> VarEnv a -> VarEnv a
plusVarEnv_CD :: (a -> a -> a) -> VarEnv a -> a -> VarEnv a -> a -> VarEnv a
plusMaybeVarEnv_C :: (a -> a -> Maybe a) -> VarEnv a -> VarEnv a -> VarEnv a
delVarEnvList :: VarEnv a -> [Var] -> VarEnv a
delVarEnv :: VarEnv a -> Var -> VarEnv a
minusVarEnv :: VarEnv a -> VarEnv b -> VarEnv a
plusVarEnv :: VarEnv a -> VarEnv a -> VarEnv a
plusVarEnvList :: [VarEnv a] -> VarEnv a
lookupVarEnv :: VarEnv a -> Var -> Maybe a
lookupVarEnv_Directly :: VarEnv a -> Unique -> Maybe a
filterVarEnv :: (a -> Bool) -> VarEnv a -> VarEnv a
anyVarEnv :: (elt -> Bool) -> UniqFM key elt -> Bool
lookupWithDefaultVarEnv :: VarEnv a -> a -> Var -> a
mapVarEnv :: (a -> b) -> VarEnv a -> VarEnv b
mkVarEnv :: [(Var, a)] -> VarEnv a
mkVarEnv_Directly :: [(Unique, a)] -> VarEnv a
emptyVarEnv :: VarEnv a
unitVarEnv :: Var -> a -> VarEnv a
isEmptyVarEnv :: VarEnv a -> Bool
partitionVarEnv :: (a -> Bool) -> VarEnv a -> (VarEnv a, VarEnv a)
varEnvDomain :: VarEnv elt -> UnVarSet
restrictVarEnv :: VarEnv a -> VarSet -> VarEnv a
zipVarEnv :: [Var] -> [a] -> VarEnv a
lookupVarEnv_NF :: VarEnv a -> Var -> a
modifyVarEnv :: (a -> a) -> VarEnv a -> Var -> VarEnv a
modifyVarEnv_Directly :: (a -> a) -> UniqFM key a -> Unique -> UniqFM key a
emptyDVarEnv :: DVarEnv a
dVarEnvElts :: DVarEnv a -> [a]
mkDVarEnv :: [(Var, a)] -> DVarEnv a
extendDVarEnv :: DVarEnv a -> Var -> a -> DVarEnv a
minusDVarEnv :: DVarEnv a -> DVarEnv a' -> DVarEnv a
lookupDVarEnv :: DVarEnv a -> Var -> Maybe a
foldDVarEnv :: (a -> b -> b) -> b -> DVarEnv a -> b
nonDetStrictFoldDVarEnv :: (a -> b -> b) -> b -> DVarEnv a -> b
mapDVarEnv :: (a -> b) -> DVarEnv a -> DVarEnv b
filterDVarEnv :: (a -> Bool) -> DVarEnv a -> DVarEnv a
alterDVarEnv :: (Maybe a -> Maybe a) -> DVarEnv a -> Var -> DVarEnv a
plusDVarEnv :: DVarEnv a -> DVarEnv a -> DVarEnv a
plusDVarEnv_C :: (a -> a -> a) -> DVarEnv a -> DVarEnv a -> DVarEnv a
unitDVarEnv :: Var -> a -> DVarEnv a
delDVarEnv :: DVarEnv a -> Var -> DVarEnv a
delDVarEnvList :: DVarEnv a -> [Var] -> DVarEnv a
isEmptyDVarEnv :: DVarEnv a -> Bool
elemDVarEnv :: Var -> DVarEnv a -> Bool
extendDVarEnv_C :: (a -> a -> a) -> DVarEnv a -> Var -> a -> DVarEnv a
modifyDVarEnv :: (a -> a) -> DVarEnv a -> Var -> DVarEnv a
partitionDVarEnv :: (a -> Bool) -> DVarEnv a -> (DVarEnv a, DVarEnv a)
extendDVarEnvList :: DVarEnv a -> [(Var, a)] -> DVarEnv a
anyDVarEnv :: (a -> Bool) -> DVarEnv a -> Bool
isEmptyNameSet :: NameSet -> Bool
emptyNameSet :: NameSet
unitNameSet :: Name -> NameSet
mkNameSet :: [Name] -> NameSet
extendNameSetList :: NameSet -> [Name] -> NameSet
extendNameSet :: NameSet -> Name -> NameSet
unionNameSet :: NameSet -> NameSet -> NameSet
unionNameSets :: [NameSet] -> NameSet
minusNameSet :: NameSet -> NameSet -> NameSet
elemNameSet :: Name -> NameSet -> Bool
delFromNameSet :: NameSet -> Name -> NameSet
filterNameSet :: (Name -> Bool) -> NameSet -> NameSet
intersectNameSet :: NameSet -> NameSet -> NameSet
disjointNameSet :: NameSet -> NameSet -> Bool
delListFromNameSet :: NameSet -> [Name] -> NameSet
intersectsNameSet :: NameSet -> NameSet -> Bool
nameSetAny :: (Name -> Bool) -> NameSet -> Bool
nameSetAll :: (Name -> Bool) -> NameSet -> Bool
nameSetElemsStable :: NameSet -> [Name]
isEmptyFVs :: NameSet -> Bool
emptyFVs :: FreeVars
plusFVs :: [FreeVars] -> FreeVars
plusFV :: FreeVars -> FreeVars -> FreeVars
addOneFV :: FreeVars -> Name -> FreeVars
intersectFVs :: FreeVars -> FreeVars -> FreeVars
emptyDUs :: DefUses
usesOnly :: Uses -> DefUses
mkDUs :: [(Defs, Uses)] -> DefUses
plusDU :: DefUses -> DefUses -> DefUses
duDefs :: DefUses -> Defs
allUses :: DefUses -> Uses
duUses :: DefUses -> Uses
findUses :: DefUses -> Uses -> Uses
depAnal :: (node -> [Name]) -> (node -> [Name]) -> [node] -> [SCC node]
nonDetNameEnvElts :: NameEnv a -> [a]
emptyNameEnv :: NameEnv a
isEmptyNameEnv :: NameEnv a -> Bool
unitNameEnv :: Name -> a -> NameEnv a
extendNameEnv :: NameEnv a -> Name -> a -> NameEnv a
extendNameEnvList :: NameEnv a -> [(Name, a)] -> NameEnv a
lookupNameEnv :: NameEnv a -> Name -> Maybe a
alterNameEnv :: (Maybe a -> Maybe a) -> NameEnv a -> Name -> NameEnv a
mkNameEnv :: [(Name, a)] -> NameEnv a
mkNameEnvWith :: (a -> Name) -> [a] -> NameEnv a
elemNameEnv :: Name -> NameEnv a -> Bool
plusNameEnv :: NameEnv a -> NameEnv a -> NameEnv a
plusNameEnv_C :: (a -> a -> a) -> NameEnv a -> NameEnv a -> NameEnv a
plusNameEnv_CD :: (a -> a -> a) -> NameEnv a -> a -> NameEnv a -> a -> NameEnv a
plusNameEnv_CD2 :: (Maybe a -> Maybe a -> a) -> NameEnv a -> NameEnv a -> NameEnv a
extendNameEnv_C :: (a -> a -> a) -> NameEnv a -> Name -> a -> NameEnv a
mapNameEnv :: (elt1 -> elt2) -> NameEnv elt1 -> NameEnv elt2
extendNameEnv_Acc :: (a -> b -> b) -> (a -> b) -> NameEnv b -> Name -> a -> NameEnv b
extendNameEnvList_C :: (a -> a -> a) -> NameEnv a -> [(Name, a)] -> NameEnv a
delFromNameEnv :: NameEnv a -> Name -> NameEnv a
delListFromNameEnv :: NameEnv a -> [Name] -> NameEnv a
filterNameEnv :: (elt -> Bool) -> NameEnv elt -> NameEnv elt
mapMaybeNameEnv :: (a -> Maybe b) -> NameEnv a -> NameEnv b
anyNameEnv :: (elt -> Bool) -> NameEnv elt -> Bool
disjointNameEnv :: NameEnv a -> NameEnv a -> Bool
seqEltsNameEnv :: (elt -> ()) -> NameEnv elt -> ()
lookupNameEnv_NF :: NameEnv a -> Name -> a
emptyDNameEnv :: DNameEnv a
isEmptyDNameEnv :: DNameEnv a -> Bool
lookupDNameEnv :: DNameEnv a -> Name -> Maybe a
delFromDNameEnv :: DNameEnv a -> Name -> DNameEnv a
filterDNameEnv :: (a -> Bool) -> DNameEnv a -> DNameEnv a
mapDNameEnv :: (a -> b) -> DNameEnv a -> DNameEnv b
adjustDNameEnv :: (a -> a) -> DNameEnv a -> Name -> DNameEnv a
alterDNameEnv :: (Maybe a -> Maybe a) -> DNameEnv a -> Name -> DNameEnv a
extendDNameEnv :: DNameEnv a -> Name -> a -> DNameEnv a
extendDNameEnv_C :: (a -> a -> a) -> DNameEnv a -> Name -> a -> DNameEnv a
eltsDNameEnv :: DNameEnv a -> [a]
foldDNameEnv :: (a -> b -> b) -> b -> DNameEnv a -> b
plusDNameEnv_C :: (elt -> elt -> elt) -> DNameEnv elt -> DNameEnv elt -> DNameEnv elt
nonDetStrictFoldDNameEnv :: (a -> b -> b) -> b -> DNameEnv a -> b
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
realSrcSpan :: SrcSpan -> RealSrcSpan
noSrcSpanA :: SrcAnn ann
noAnn :: EpAnn a
pprIfPs :: forall (p :: Pass). IsPass p => (p ~ 'Parsed => SDoc) -> SDoc
pprIfRn :: forall (p :: Pass). IsPass p => (p ~ 'Renamed => SDoc) -> SDoc
pprIfTc :: forall (p :: Pass). IsPass p => (p ~ 'Typechecked => SDoc) -> SDoc
noHsTok :: forall (tok :: Symbol). GenLocated TokenLocation (HsToken tok)
noHsUniTok :: forall (tok :: Symbol) (utok :: Symbol). GenLocated TokenLocation (HsUniToken tok utok)
listTyConKey :: Unique
nilDataConKey :: Unique
emptyAnnEnv :: AnnEnv
mkAnnEnv :: [Annotation] -> AnnEnv
extendAnnEnvList :: AnnEnv -> [Annotation] -> AnnEnv
plusAnnEnv :: AnnEnv -> AnnEnv -> AnnEnv
findAnns :: Typeable a => ([Word8] -> a) -> AnnEnv -> CoreAnnTarget -> [a]
findAnnsByTypeRep :: AnnEnv -> CoreAnnTarget -> TypeRep -> [[Word8]]
deserializeAnns :: Typeable a => ([Word8] -> a) -> AnnEnv -> (ModuleEnv [a], NameEnv [a])
sProgramName :: Settings -> String
sProjectVersion :: Settings -> String
sGhcUsagePath :: Settings -> FilePath
sGhciUsagePath :: Settings -> FilePath
sToolDir :: Settings -> Maybe FilePath
sTopDir :: Settings -> FilePath
sGlobalPackageDatabasePath :: Settings -> FilePath
sLdSupportsCompactUnwind :: Settings -> Bool
sLdSupportsFilelist :: Settings -> Bool
sLdIsGnuLd :: Settings -> Bool
sGccSupportsNoPie :: Settings -> Bool
sPgm_L :: Settings -> String
sPgm_P :: Settings -> (String, [Option])
sPgm_F :: Settings -> String
sPgm_c :: Settings -> String
sPgm_cxx :: Settings -> String
sPgm_a :: Settings -> (String, [Option])
sPgm_l :: Settings -> (String, [Option])
sPgm_lm :: Settings -> Maybe (String, [Option])
sPgm_dll :: Settings -> (String, [Option])
sPgm_T :: Settings -> String
sPgm_windres :: Settings -> String
sPgm_ar :: Settings -> String
sPgm_ranlib :: Settings -> String
sPgm_lo :: Settings -> (String, [Option])
sPgm_lc :: Settings -> (String, [Option])
sPgm_lcc :: Settings -> (String, [Option])
sPgm_i :: Settings -> String
sOpt_L :: Settings -> [String]
sOpt_P :: Settings -> [String]
sOpt_P_fingerprint :: Settings -> Fingerprint
sOpt_F :: Settings -> [String]
sOpt_c :: Settings -> [String]
sOpt_cxx :: Settings -> [String]
sOpt_a :: Settings -> [String]
sOpt_l :: Settings -> [String]
sOpt_lm :: Settings -> [String]
sOpt_windres :: Settings -> [String]
sOpt_lo :: Settings -> [String]
sOpt_lc :: Settings -> [String]
sOpt_lcc :: Settings -> [String]
sOpt_i :: Settings -> [String]
sExtraGccViaCFlags :: Settings -> [String]
sTargetPlatformString :: Settings -> String
sGhcWithInterpreter :: Settings -> Bool
sLibFFI :: Settings -> Bool
mkUnitKeyInfo :: DbUnitInfo -> UnitKeyInfo
mapUnitInfo :: IsUnitId v => (u -> v) -> GenUnitInfo u -> GenUnitInfo v
unitPackageIdString :: GenUnitInfo u -> String
unitPackageNameString :: GenUnitInfo u -> String
pprUnitInfo :: UnitInfo -> SDoc
mkUnit :: UnitInfo -> Unit
mkUnitPprInfo :: (u -> FastString) -> GenUnitInfo u -> UnitPprInfo
collectIncludeDirs :: [UnitInfo] -> [FilePath]
collectExtraCcOpts :: [UnitInfo] -> [String]
collectLibraryDirs :: Ways -> [UnitInfo] -> [FilePath]
collectFrameworks :: [UnitInfo] -> [String]
collectFrameworksDirs :: [UnitInfo] -> [String]
unitHsLibs :: GhcNameVersion -> Ways -> UnitInfo -> [String]
topNormaliseNewType_maybe :: Type -> Maybe (Coercion, Type)
coercionType :: Coercion -> Type
coercionRKind :: Coercion -> Type
coercionLKind :: Coercion -> Type
coercionKind :: Coercion -> Pair Type
seqCo :: Coercion -> ()
liftCoSubst :: HasDebugCallStack => Role -> LiftingContext -> Type -> Coercion
mkCoercionType :: Role -> Type -> Type -> Type
coVarRole :: CoVar -> Role
coVarKindsTypesRole :: HasDebugCallStack => CoVar -> (Kind, Kind, Type, Type, Role)
decomposePiCos :: HasDebugCallStack => CoercionN -> Pair Type -> [Type] -> ([CoercionN], CoercionN)
isReflexiveCo :: Coercion -> Bool
isReflCo :: Coercion -> Bool
isGReflCo :: Coercion -> Bool
mkAxiomRuleCo :: CoAxiomRule -> [Coercion] -> Coercion
mkProofIrrelCo :: Role -> CoercionN -> Coercion -> Coercion -> Coercion
mkSubCo :: HasDebugCallStack => Coercion -> Coercion
mkKindCo :: Coercion -> Coercion
mkNomReflCo :: Type -> Coercion
mkGReflCo :: Role -> Type -> MCoercionN -> Coercion
mkInstCo :: Coercion -> CoercionN -> Coercion
mkLRCo :: LeftOrRight -> Coercion -> Coercion
mkSelCo :: HasDebugCallStack => CoSel -> Coercion -> Coercion
mkTransCo :: Coercion -> Coercion -> Coercion
mkSymCo :: Coercion -> Coercion
mkUnivCo :: UnivCoProvenance -> Role -> Type -> Type -> Coercion
mkPhantomCo :: Coercion -> Type -> Type -> Coercion
mkAxiomInstCo :: CoAxiom Branched -> BranchIndex -> [Coercion] -> Coercion
mkCoVarCo :: CoVar -> Coercion
mkFunCo2 :: HasDebugCallStack => Role -> FunTyFlag -> FunTyFlag -> CoercionN -> Coercion -> Coercion -> Coercion
mkNakedFunCo1 :: Role -> FunTyFlag -> CoercionN -> Coercion -> Coercion -> Coercion
mkFunCo1 :: HasDebugCallStack => Role -> FunTyFlag -> CoercionN -> Coercion -> Coercion -> Coercion
mkForAllCo :: TyCoVar -> CoercionN -> Coercion -> Coercion
mkAppCo :: Coercion -> Coercion -> Coercion
mkTyConAppCo :: HasDebugCallStack => Role -> TyCon -> [Coercion] -> Coercion
mkReflCo :: Role -> Type -> Coercion
algTcFields :: TyConDetails -> FieldLabelEnv
mkAnonTyConBinder :: TyVar -> TyConBinder
mkAnonTyConBinders :: [TyVar] -> [TyConBinder]
mkInvisAnonTyConBinder :: TyVar -> TyConBinder
mkNamedTyConBinder :: ForAllTyFlag -> TyVar -> TyConBinder
mkNamedTyConBinders :: ForAllTyFlag -> [TyVar] -> [TyConBinder]
mkRequiredTyConBinder :: TyCoVarSet -> TyVar -> TyConBinder
tyConBinderForAllTyFlag :: TyConBinder -> ForAllTyFlag
tyConBndrVisForAllTyFlag :: TyConBndrVis -> ForAllTyFlag
isNamedTyConBinder :: TyConBinder -> Bool
isVisibleTyConBinder :: VarBndr tv TyConBndrVis -> Bool
isVisibleTcbVis :: TyConBndrVis -> Bool
isInvisibleTyConBinder :: VarBndr tv TyConBndrVis -> Bool
mkTyConKind :: [TyConBinder] -> Kind -> Kind
tyConInvisTVBinders :: [TyConBinder] -> [InvisTVBinder]
tyConVisibleTyVars :: TyCon -> [TyVar]
mkLevPolyDataTyConRhs :: Bool -> Bool -> [DataCon] -> AlgTyConRhs
mkDataTyConRhs :: [DataCon] -> AlgTyConRhs
visibleDataCons :: AlgTyConRhs -> [DataCon]
isNoParent :: AlgTyConFlav -> Bool
tyConRepModOcc :: Module -> OccName -> (Module, OccName)
isVoidRep :: PrimRep -> Bool
isGcPtrRep :: PrimRep -> Bool
primRepCompatible :: Platform -> PrimRep -> PrimRep -> Bool
primRepsCompatible :: Platform -> [PrimRep] -> [PrimRep] -> Bool
primRepSizeB :: Platform -> PrimRep -> Int
primElemRepSizeB :: Platform -> PrimElemRep -> Int
primElemRepToPrimRep :: PrimElemRep -> PrimRep
primRepIsFloat :: PrimRep -> Maybe Bool
primRepIsWord :: PrimRep -> Bool
primRepIsInt :: PrimRep -> Bool
tyConFieldLabels :: TyCon -> [FieldLabel]
lookupTyConFieldLabel :: FieldLabelString -> TyCon -> Maybe FieldLabel
mkAlgTyCon :: Name -> [TyConBinder] -> Kind -> [Role] -> Maybe CType -> [PredType] -> AlgTyConRhs -> AlgTyConFlav -> Bool -> TyCon
mkClassTyCon :: Name -> [TyConBinder] -> [Role] -> AlgTyConRhs -> Class -> Name -> TyCon
mkTupleTyCon :: Name -> [TyConBinder] -> Kind -> DataCon -> TupleSort -> AlgTyConFlav -> TyCon
mkSumTyCon :: Name -> [TyConBinder] -> Kind -> [DataCon] -> AlgTyConFlav -> TyCon
mkTcTyCon :: Name -> [TyConBinder] -> Kind -> [(Name, TcTyVar)] -> Bool -> TyConFlavour -> TyCon
noTcTyConScopedTyVars :: [(Name, TcTyVar)]
mkPrimTyCon :: Name -> [TyConBinder] -> Kind -> [Role] -> TyCon
mkSynonymTyCon :: Name -> [TyConBinder] -> Kind -> [Role] -> Type -> Bool -> Bool -> Bool -> TyCon
mkFamilyTyCon :: Name -> [TyConBinder] -> Kind -> Maybe Name -> FamTyConFlav -> Maybe Class -> Injectivity -> TyCon
mkPromotedDataCon :: DataCon -> Name -> TyConRepName -> [TyConPiTyBinder] -> Kind -> [Role] -> PromDataConInfo -> TyCon
isAbstractTyCon :: TyCon -> Bool
isPrimTyCon :: TyCon -> Bool
isAlgTyCon :: TyCon -> Bool
isVanillaAlgTyCon :: TyCon -> Bool
isDataTyCon :: TyCon -> Bool
isTypeDataTyCon :: TyCon -> Bool
isInjectiveTyCon :: TyCon -> Role -> Bool
isGenerativeTyCon :: TyCon -> Role -> Bool
isGenInjAlgRhs :: AlgTyConRhs -> Bool
isNewTyCon :: TyCon -> Bool
unwrapNewTyCon_maybe :: TyCon -> Maybe ([TyVar], Type, CoAxiom Unbranched)
unwrapNewTyConEtad_maybe :: TyCon -> Maybe ([TyVar], Type, CoAxiom Unbranched)
isTypeSynonymTyCon :: TyCon -> Bool
isTauTyCon :: TyCon -> Bool
isFamFreeTyCon :: TyCon -> Bool
isForgetfulSynTyCon :: TyCon -> Bool
tyConMustBeSaturated :: TyCon -> Bool
isGadtSyntaxTyCon :: TyCon -> Bool
isEnumerationTyCon :: TyCon -> Bool
isFamilyTyCon :: TyCon -> Bool
isOpenFamilyTyCon :: TyCon -> Bool
isTypeFamilyTyCon :: TyCon -> Bool
isDataFamilyTyCon :: TyCon -> Bool
isOpenTypeFamilyTyCon :: TyCon -> Bool
isClosedSynFamilyTyConWithAxiom_maybe :: TyCon -> Maybe (CoAxiom Branched)
isBuiltInSynFamTyCon_maybe :: TyCon -> Maybe BuiltInSynFamily
tyConFamilyResVar_maybe :: TyCon -> Maybe Name
tyConInjectivityInfo :: TyCon -> Injectivity
isTyConAssoc :: TyCon -> Bool
tyConAssoc_maybe :: TyCon -> Maybe TyCon
tyConFlavourAssoc_maybe :: TyConFlavour -> Maybe TyCon
tyConTuple_maybe :: TyCon -> Maybe TupleSort
isBoxedTupleTyCon :: TyCon -> Bool
isUnboxedSumTyCon :: TyCon -> Bool
isLiftedAlgTyCon :: TyCon -> Bool
isPromotedDataCon_maybe :: TyCon -> Maybe DataCon
isPromotedTupleTyCon :: TyCon -> Bool
isPromotedDataCon :: TyCon -> Bool
isDataKindsPromotedDataCon :: TyCon -> Bool
isKindTyCon :: TyCon -> Bool
isLiftedTypeKindTyConName :: Name -> Bool
isImplicitTyCon :: TyCon -> Bool
tyConCType_maybe :: TyCon -> Maybe CType
tcHasFixedRuntimeRep :: TyCon -> Bool
isConcreteTyCon :: TyCon -> Bool
isTcTyCon :: TyCon -> Bool
setTcTyConKind :: TyCon -> Kind -> TyCon
isMonoTcTyCon :: TyCon -> Bool
tcTyConScopedTyVars :: TyCon -> [(Name, TcTyVar)]
expandSynTyCon_maybe :: TyCon -> [tyco] -> ExpandSynResult tyco
isTyConWithSrcDataCons :: TyCon -> Bool
tyConDataCons :: TyCon -> [DataCon]
tyConDataCons_maybe :: TyCon -> Maybe [DataCon]
tyConSingleDataCon_maybe :: TyCon -> Maybe DataCon
tyConSingleDataCon :: TyCon -> DataCon
tyConSingleAlgDataCon_maybe :: TyCon -> Maybe DataCon
tyConAlgDataCons_maybe :: TyCon -> Maybe [DataCon]
tyConFamilySize :: TyCon -> Int
algTyConRhs :: TyCon -> AlgTyConRhs
newTyConRhs :: TyCon -> ([TyVar], Type)
newTyConEtadArity :: TyCon -> Int
newTyConEtadRhs :: TyCon -> ([TyVar], Type)
newTyConCo_maybe :: TyCon -> Maybe (CoAxiom Unbranched)
newTyConCo :: TyCon -> CoAxiom Unbranched
newTyConDataCon_maybe :: TyCon -> Maybe DataCon
tyConStupidTheta :: TyCon -> [PredType]
synTyConDefn_maybe :: TyCon -> Maybe ([TyVar], Type)
synTyConRhs_maybe :: TyCon -> Maybe Type
famTyConFlav_maybe :: TyCon -> Maybe FamTyConFlav
isClassTyCon :: TyCon -> Bool
tyConClass_maybe :: TyCon -> Maybe Class
tyConATs :: TyCon -> [TyCon]
isFamInstTyCon :: TyCon -> Bool
tyConFamInstSig_maybe :: TyCon -> Maybe (TyCon, [Type], CoAxiom Unbranched)
tyConFamInst_maybe :: TyCon -> Maybe (TyCon, [Type])
tyConFamilyCoercion_maybe :: TyCon -> Maybe (CoAxiom Unbranched)
tyConPromDataConInfo :: TyCon -> PromDataConInfo
mkTyConTagMap :: TyCon -> NameEnv ConTag
tyConFlavour :: TyCon -> TyConFlavour
tcFlavourIsOpen :: TyConFlavour -> Bool
pprPromotionQuote :: TyCon -> SDoc
tyConSkolem :: TyCon -> Bool
mkTyVarTy :: TyVar -> Type
mkTyVarTys :: [TyVar] -> [Type]
mkInvisFunTy :: HasDebugCallStack => Type -> Type -> Type
mkInvisFunTys :: HasDebugCallStack => [Type] -> Type -> Type
tcMkVisFunTy :: Mult -> Type -> Type -> Type
tcMkInvisFunTy :: TypeOrConstraint -> Type -> Type -> Type
mkVisFunTy :: HasDebugCallStack => Mult -> Type -> Type -> Type
mkVisFunTyMany :: HasDebugCallStack => Type -> Type -> Type
mkVisFunTysMany :: [Type] -> Type -> Type
mkScaledFunTys :: HasDebugCallStack => [Scaled Type] -> Type -> Type
tcMkScaledFunTys :: [Scaled Type] -> Type -> Type
mkForAllTys :: [ForAllTyBinder] -> Type -> Type
mkInvisForAllTys :: [InvisTVBinder] -> Type -> Type
mkPiTy :: PiTyBinder -> Type -> Type
mkPiTys :: [PiTyBinder] -> Type -> Type
coHoleCoVar :: CoercionHole -> CoVar
setCoHoleCoVar :: CoercionHole -> CoVar -> CoercionHole
foldTyCo :: Monoid a => TyCoFolder env a -> env -> (Type -> a, [Type] -> a, Coercion -> a, [Coercion] -> a)
noView :: Type -> Maybe Type
typeSize :: Type -> Int
coercionSize :: Coercion -> Int
funTyFlagTyCon :: FunTyFlag -> TyCon
tYPETyCon :: TyCon
tYPETyConName :: Name
tYPEKind :: Type
cONSTRAINTTyCon :: TyCon
cONSTRAINTTyConName :: Name
cONSTRAINTKind :: Type
tyCoVarsOfType :: Type -> TyCoVarSet
tyCoVarsOfTypes :: [Type] -> TyCoVarSet
tyCoVarsOfCo :: Coercion -> TyCoVarSet
tyCoVarsOfCos :: [Coercion] -> TyCoVarSet
coVarsOfType :: Type -> CoVarSet
coVarsOfTypes :: [Type] -> CoVarSet
coVarsOfCo :: Coercion -> CoVarSet
closeOverKinds :: TyCoVarSet -> TyCoVarSet
closeOverKindsList :: [TyVar] -> [TyVar]
closeOverKindsDSet :: DTyVarSet -> DTyVarSet
tyCoVarsOfTypeDSet :: Type -> DTyCoVarSet
tyCoFVsOfType :: Type -> FV
tyCoFVsBndr :: ForAllTyBinder -> FV -> FV
tyCoFVsVarBndrs :: [Var] -> FV -> FV
tyCoFVsVarBndr :: Var -> FV -> FV
tyCoVarsOfCoDSet :: Coercion -> DTyCoVarSet
tyCoFVsOfCo :: Coercion -> FV
tyCoFVsOfCos :: [Coercion] -> FV
anyFreeVarsOfType :: (TyCoVar -> Bool) -> Type -> Bool
anyFreeVarsOfTypes :: (TyCoVar -> Bool) -> [Type] -> Bool
anyFreeVarsOfCo :: (TyCoVar -> Bool) -> Coercion -> Bool
scopedSort :: [TyCoVar] -> [TyCoVar]
tyCoVarsOfTypeWellScoped :: Type -> [TyVar]
tyCoVarsOfTypesWellScoped :: [Type] -> [TyVar]
tyConsOfType :: Type -> UniqSet TyCon
occCheckExpand :: [Var] -> Type -> Maybe Type
emptyTvSubstEnv :: TvSubstEnv
emptyCvSubstEnv :: CvSubstEnv
composeTCvSubst :: Subst -> Subst -> Subst
emptySubst :: Subst
mkEmptySubst :: InScopeSet -> Subst
isEmptySubst :: Subst -> Bool
isEmptyTCvSubst :: Subst -> Bool
mkSubst :: InScopeSet -> TvSubstEnv -> CvSubstEnv -> IdSubstEnv -> Subst
getTvSubstEnv :: Subst -> TvSubstEnv
getCvSubstEnv :: Subst -> CvSubstEnv
getSubstInScope :: Subst -> InScopeSet
setInScope :: Subst -> InScopeSet -> Subst
getSubstRangeTyCoFVs :: Subst -> VarSet
isInScope :: Var -> Subst -> Bool
notElemSubst :: Var -> Subst -> Bool
zapSubst :: Subst -> Subst
extendSubstInScope :: Subst -> Var -> Subst
extendSubstInScopeList :: Subst -> [Var] -> Subst
extendSubstInScopeSet :: Subst -> VarSet -> Subst
extendTCvSubst :: Subst -> TyCoVar -> Type -> Subst
extendTCvSubstWithClone :: Subst -> TyCoVar -> TyCoVar -> Subst
extendTvSubst :: Subst -> TyVar -> Type -> Subst
extendTvSubstBinderAndInScope :: Subst -> PiTyBinder -> Type -> Subst
extendTvSubstWithClone :: Subst -> TyVar -> TyVar -> Subst
extendCvSubst :: Subst -> CoVar -> Coercion -> Subst
extendTvSubstAndInScope :: Subst -> TyVar -> Type -> Subst
extendTvSubstList :: Subst -> [(TyVar, Type)] -> Subst
extendTCvSubstList :: Subst -> [Var] -> [Type] -> Subst
unionSubst :: Subst -> Subst -> Subst
zipTvSubst :: HasDebugCallStack => [TyVar] -> [Type] -> Subst
zipTCvSubst :: HasDebugCallStack => [TyCoVar] -> [Type] -> Subst
mkTvSubstPrs :: [(TyVar, Type)] -> Subst
zipTyEnv :: HasDebugCallStack => [TyVar] -> [Type] -> TvSubstEnv
zipCoEnv :: HasDebugCallStack => [CoVar] -> [Coercion] -> CvSubstEnv
substTyWith :: HasDebugCallStack => [TyVar] -> [Type] -> Type -> Type
substTyWithUnchecked :: [TyVar] -> [Type] -> Type -> Type
substCoWith :: HasDebugCallStack => [TyVar] -> [Type] -> Coercion -> Coercion
substCoWithUnchecked :: [TyVar] -> [Type] -> Coercion -> Coercion
substTysWith :: [TyVar] -> [Type] -> [Type] -> [Type]
substTyAddInScope :: Subst -> Type -> Type
substTyUnchecked :: Subst -> Type -> Type
substScaledTy :: HasDebugCallStack => Subst -> Scaled Type -> Scaled Type
substScaledTyUnchecked :: HasDebugCallStack => Subst -> Scaled Type -> Scaled Type
substTys :: HasDebugCallStack => Subst -> [Type] -> [Type]
substScaledTys :: HasDebugCallStack => Subst -> [Scaled Type] -> [Scaled Type]
substTysUnchecked :: Subst -> [Type] -> [Type]
substScaledTysUnchecked :: Subst -> [Scaled Type] -> [Scaled Type]
substTheta :: HasDebugCallStack => Subst -> ThetaType -> ThetaType
substThetaUnchecked :: Subst -> ThetaType -> ThetaType
substTyVar :: Subst -> TyVar -> Type
substTyVarToTyVar :: HasDebugCallStack => Subst -> TyVar -> TyVar
substTyVars :: Subst -> [TyVar] -> [Type]
lookupTyVar :: Subst -> TyVar -> Maybe Type
substCo :: HasDebugCallStack => Subst -> Coercion -> Coercion
substCoUnchecked :: Subst -> Coercion -> Coercion
substCos :: HasDebugCallStack => Subst -> [Coercion] -> [Coercion]
substCoVar :: Subst -> CoVar -> Coercion
substCoVars :: Subst -> [CoVar] -> [Coercion]
lookupCoVar :: Subst -> Var -> Maybe Coercion
substTyVarBndr :: HasDebugCallStack => Subst -> TyVar -> (Subst, TyVar)
substTyVarBndrs :: HasDebugCallStack => Subst -> [TyVar] -> (Subst, [TyVar])
substVarBndr :: HasDebugCallStack => Subst -> TyCoVar -> (Subst, TyCoVar)
substVarBndrs :: HasDebugCallStack => Subst -> [TyCoVar] -> (Subst, [TyCoVar])
substCoVarBndr :: HasDebugCallStack => Subst -> CoVar -> (Subst, CoVar)
cloneTyVarBndr :: Subst -> TyVar -> Unique -> (Subst, TyVar)
cloneTyVarBndrs :: Subst -> [TyVar] -> UniqSupply -> (Subst, [TyVar])
substTyCoBndr :: Subst -> PiTyBinder -> (Subst, PiTyBinder)
tidyVarBndrs :: TidyEnv -> [TyCoVar] -> (TidyEnv, [TyCoVar])
tidyVarBndr :: TidyEnv -> TyCoVar -> (TidyEnv, TyCoVar)
tidyForAllTyBinder :: TidyEnv -> VarBndr TyCoVar vis -> (TidyEnv, VarBndr TyCoVar vis)
tidyForAllTyBinders :: TidyEnv -> [VarBndr TyCoVar vis] -> (TidyEnv, [VarBndr TyCoVar vis])
tidyFreeTyCoVars :: TidyEnv -> [TyCoVar] -> TidyEnv
tidyOpenTyCoVars :: TidyEnv -> [TyCoVar] -> (TidyEnv, [TyCoVar])
tidyOpenTyCoVar :: TidyEnv -> TyCoVar -> (TidyEnv, TyCoVar)
tidyTyCoVarOcc :: TidyEnv -> TyCoVar -> TyCoVar
tidyTypes :: TidyEnv -> [Type] -> [Type]
tidyType :: TidyEnv -> Type -> Type
tidyOpenTypes :: TidyEnv -> [Type] -> (TidyEnv, [Type])
tidyOpenType :: TidyEnv -> Type -> (TidyEnv, Type)
tidyTopType :: Type -> Type
tidyCo :: TidyEnv -> Coercion -> Coercion
tidyCos :: TidyEnv -> [Coercion] -> [Coercion]
kindRep :: HasDebugCallStack => Kind -> RuntimeRepType
kindRep_maybe :: HasDebugCallStack => Kind -> Maybe RuntimeRepType
isUnliftedTypeKind :: Kind -> Bool
pickyIsLiftedTypeKind :: Kind -> Bool
kindBoxedRepLevity_maybe :: Type -> Maybe Levity
isLiftedRuntimeRep :: RuntimeRepType -> Bool
isUnliftedRuntimeRep :: RuntimeRepType -> Bool
isLiftedLevity :: Type -> Bool
isUnliftedLevity :: Type -> Bool
isRuntimeRepVar :: TyVar -> Bool
isLevityVar :: TyVar -> Bool
isMultiplicityVar :: TyVar -> Bool
splitRuntimeRep_maybe :: RuntimeRepType -> Maybe (TyCon, [Type])
isBoxedRuntimeRep :: RuntimeRepType -> Bool
runtimeRepLevity_maybe :: RuntimeRepType -> Maybe Levity
levityType_maybe :: LevityType -> Maybe Levity
mapTyCo :: Monad m => TyCoMapper () m -> (Type -> m Type, [Type] -> m [Type], Coercion -> m Coercion, [Coercion] -> m [Coercion])
mapTyCoX :: Monad m => TyCoMapper env m -> (env -> Type -> m Type, env -> [Type] -> m [Type], env -> Coercion -> m Coercion, env -> [Coercion] -> m [Coercion])
getTyVar :: HasDebugCallStack => Type -> TyVar
repGetTyVar_maybe :: Type -> Maybe TyVar
isTyVarTy :: Type -> Bool
getCastedTyVar_maybe :: Type -> Maybe (TyVar, CoercionN)
mkAppTys :: Type -> [Type] -> Type
splitAppTy_maybe :: Type -> Maybe (Type, Type)
splitAppTy :: Type -> (Type, Type)
splitAppTyNoView_maybe :: HasDebugCallStack => Type -> Maybe (Type, Type)
tcSplitAppTyNoView_maybe :: Type -> Maybe (Type, Type)
splitAppTys :: Type -> (Type, [Type])
splitAppTysNoView :: HasDebugCallStack => Type -> (Type, [Type])
mkNumLitTy :: Integer -> Type
isNumLitTy :: Type -> Maybe Integer
mkStrLitTy :: FastString -> Type
isStrLitTy :: Type -> Maybe FastString
mkCharLitTy :: Char -> Type
isCharLitTy :: Type -> Maybe Char
isLitTy :: Type -> Maybe TyLit
userTypeError_maybe :: Type -> Maybe Type
pprUserTypeErrorTy :: Type -> SDoc
funTyConAppTy_maybe :: FunTyFlag -> Type -> Type -> Type -> Maybe (TyCon, [Type])
tyConAppFunTy_maybe :: HasDebugCallStack => TyCon -> [Type] -> Maybe Type
tyConAppFunCo_maybe :: HasDebugCallStack => Role -> TyCon -> [Coercion] -> Maybe Coercion
mkFunctionType :: HasDebugCallStack => Mult -> Type -> Type -> Type
mkScaledFunctionTys :: [Scaled Type] -> Type -> Type
splitFunTy :: Type -> (Mult, Type, Type)
splitFunTy_maybe :: Type -> Maybe (FunTyFlag, Mult, Type, Type)
splitFunTys :: Type -> ([Scaled Type], Type)
funArgTy :: Type -> Type
piResultTys :: HasDebugCallStack => Type -> [Type] -> Type
applyTysX :: HasDebugCallStack => [TyVar] -> Type -> [Type] -> Type
tyConAppTyConPicky_maybe :: Type -> Maybe TyCon
tyConAppTyCon :: HasDebugCallStack => Type -> TyCon
tyConAppArgs_maybe :: Type -> Maybe [Type]
tyConAppArgs :: HasCallStack => Type -> [Type]
splitTyConAppNoView_maybe :: Type -> Maybe (TyCon, [Type])
tcSplitTyConApp_maybe :: HasCallStack => Type -> Maybe (TyCon, [Type])
tcSplitTyConApp :: Type -> (TyCon, [Type])
newTyConInstRhs :: TyCon -> [Type] -> Type
splitCastTy_maybe :: Type -> Maybe (Type, Coercion)
isCoercionTy_maybe :: Type -> Maybe Coercion
stripCoercionTy :: Type -> Coercion
tyConBindersPiTyBinders :: [TyConBinder] -> [PiTyBinder]
mkTyCoInvForAllTy :: TyCoVar -> Type -> Type
mkInfForAllTy :: TyVar -> Type -> Type
mkTyCoInvForAllTys :: [TyCoVar] -> Type -> Type
mkInfForAllTys :: [TyVar] -> Type -> Type
mkSpecForAllTy :: TyVar -> Type -> Type
mkSpecForAllTys :: [TyVar] -> Type -> Type
mkVisForAllTys :: [TyVar] -> Type -> Type
mkTyConBindersPreferAnon :: [TyVar] -> TyCoVarSet -> [TyConBinder]
splitForAllForAllTyBinders :: Type -> ([ForAllTyBinder], Type)
splitForAllTyCoVars :: Type -> ([TyCoVar], Type)
splitForAllTyVars :: Type -> ([TyVar], Type)
splitForAllReqTyBinders :: Type -> ([ReqTyBinder], Type)
splitForAllInvisTyBinders :: Type -> ([InvisTyBinder], Type)
isForAllTy :: Type -> Bool
isForAllTy_ty :: Type -> Bool
isForAllTy_co :: Type -> Bool
isPiTy :: Type -> Bool
isFunTy :: Type -> Bool
splitForAllTyCoVar :: Type -> (TyCoVar, Type)
dropForAlls :: Type -> Type
splitForAllTyCoVar_maybe :: Type -> Maybe (TyCoVar, Type)
splitForAllTyVar_maybe :: Type -> Maybe (TyVar, Type)
splitForAllCoVar_maybe :: Type -> Maybe (CoVar, Type)
splitPiTy_maybe :: Type -> Maybe (PiTyBinder, Type)
splitPiTy :: Type -> (PiTyBinder, Type)
splitPiTys :: Type -> ([PiTyBinder], Type)
getRuntimeArgTys :: Type -> [(Scaled Type, FunTyFlag)]
invisibleTyBndrCount :: Type -> Int
splitInvisPiTys :: Type -> ([PiTyBinder], Type)
splitInvisPiTysN :: Int -> Type -> ([PiTyBinder], Type)
filterOutInvisibleTypes :: TyCon -> [Type] -> [Type]
filterOutInferredTypes :: TyCon -> [Type] -> [Type]
partitionInvisibles :: [(a, ForAllTyFlag)] -> ([a], [a])
tyConForAllTyFlags :: TyCon -> [Type] -> [ForAllTyFlag]
appTyForAllTyFlags :: Type -> [Type] -> [ForAllTyFlag]
isTauTy :: Type -> Bool
isAtomicTy :: Type -> Bool
mkFamilyTyConApp :: TyCon -> [Type] -> Type
coAxNthLHS :: forall (br :: BranchFlag). CoAxiom br -> Int -> Type
isFamFreeTy :: Type -> Bool
isCoVarType :: Type -> Bool
buildSynTyCon :: Name -> [KnotTied TyConBinder] -> Kind -> [Role] -> KnotTied Type -> TyCon
isUnliftedType :: HasDebugCallStack => Type -> Bool
mightBeLiftedType :: Type -> Bool
mightBeUnliftedType :: Type -> Bool
isBoxedType :: Type -> Bool
isRuntimeRepKindedTy :: Type -> Bool
dropRuntimeRepArgs :: [Type] -> [Type]
getRuntimeRep :: HasDebugCallStack => Type -> RuntimeRepType
isUnboxedTupleType :: Type -> Bool
isUnboxedSumType :: Type -> Bool
isDataFamilyAppType :: Type -> Bool
isStrictType :: HasDebugCallStack => Type -> Bool
isPrimitiveType :: Type -> Bool
isValidJoinPointType :: JoinArity -> Type -> Bool
seqType :: Type -> ()
seqTypes :: [Type] -> ()
sORTKind_maybe :: Kind -> Maybe (TypeOrConstraint, Type)
isTYPEorCONSTRAINT :: Kind -> Bool
tyConIsTYPEorCONSTRAINT :: TyCon -> Bool
isConstraintLikeKind :: Kind -> Bool
isConstraintKind :: Kind -> Bool
tcIsLiftedTypeKind :: Kind -> Bool
tcIsBoxedTypeKind :: Kind -> Bool
isTypeLikeKind :: Kind -> Bool
returnsConstraintKind :: Kind -> Bool
typeHasFixedRuntimeRep :: HasDebugCallStack => Type -> Bool
argsHaveFixedRuntimeRep :: Type -> Bool
isFixedRuntimeRepKind :: HasDebugCallStack => Kind -> Bool
isConcrete :: Type -> Bool
tyConAppNeedsKindSig :: Bool -> TyCon -> Int -> Bool
unrestricted :: a -> Scaled a
linear :: a -> Scaled a
tymult :: a -> Scaled a
irrelevantMult :: Scaled a -> a
mkScaled :: Mult -> a -> Scaled a
scaledSet :: Scaled a -> b -> Scaled b
isManyTy :: Mult -> Bool
isOneTy :: Mult -> Bool
isLinearType :: Type -> Bool
mkTYPEapp :: RuntimeRepType -> Type
mkTYPEapp_maybe :: RuntimeRepType -> Maybe Type
mkCONSTRAINTapp :: RuntimeRepType -> Type
mkCONSTRAINTapp_maybe :: RuntimeRepType -> Maybe Type
mkBoxedRepApp_maybe :: LevityType -> Maybe Type
mkTupleRepApp_maybe :: Type -> Maybe Type
typeOrConstraintKind :: TypeOrConstraint -> RuntimeRepType -> Kind
negateOverLitVal :: OverLitVal -> OverLitVal
litNumIsSigned :: LitNumType -> Bool
litNumBitSize :: Platform -> LitNumType -> Maybe Word
mkLitNumberWrap :: Platform -> LitNumType -> Integer -> Literal
litNumWrap :: Platform -> Literal -> Literal
litNumCoerce :: LitNumType -> Platform -> Literal -> Literal
litNumNarrow :: LitNumType -> Platform -> Literal -> Literal
litNumCheckRange :: Platform -> LitNumType -> Integer -> Bool
litNumRange :: Platform -> LitNumType -> (Maybe Integer, Maybe Integer)
mkLitNumber :: Platform -> LitNumType -> Integer -> Literal
mkLitInt :: Platform -> Integer -> Literal
mkLitIntWrap :: Platform -> Integer -> Literal
mkLitIntUnchecked :: Integer -> Literal
mkLitIntWrapC :: Platform -> Integer -> (Literal, Bool)
mkLitWord :: Platform -> Integer -> Literal
mkLitWordWrap :: Platform -> Integer -> Literal
mkLitWordUnchecked :: Integer -> Literal
mkLitWordWrapC :: Platform -> Integer -> (Literal, Bool)
mkLitInt8 :: Integer -> Literal
mkLitInt8Wrap :: Integer -> Literal
mkLitInt8Unchecked :: Integer -> Literal
mkLitWord8 :: Integer -> Literal
mkLitWord8Wrap :: Integer -> Literal
mkLitWord8Unchecked :: Integer -> Literal
mkLitInt16 :: Integer -> Literal
mkLitInt16Wrap :: Integer -> Literal
mkLitInt16Unchecked :: Integer -> Literal
mkLitWord16 :: Integer -> Literal
mkLitWord16Wrap :: Integer -> Literal
mkLitWord16Unchecked :: Integer -> Literal
mkLitInt32 :: Integer -> Literal
mkLitInt32Wrap :: Integer -> Literal
mkLitInt32Unchecked :: Integer -> Literal
mkLitWord32 :: Integer -> Literal
mkLitWord32Wrap :: Integer -> Literal
mkLitWord32Unchecked :: Integer -> Literal
mkLitInt64 :: Integer -> Literal
mkLitInt64Wrap :: Integer -> Literal
mkLitInt64Unchecked :: Integer -> Literal
mkLitWord64 :: Integer -> Literal
mkLitWord64Wrap :: Integer -> Literal
mkLitWord64Unchecked :: Integer -> Literal
mkLitFloat :: Rational -> Literal
mkLitDouble :: Rational -> Literal
mkLitChar :: Char -> Literal
mkLitString :: String -> Literal
mkLitBigNat :: Integer -> Literal
isLitRubbish :: Literal -> Bool
isMinBound :: Platform -> Literal -> Bool
isMaxBound :: Platform -> Literal -> Bool
inCharRange :: Char -> Bool
isZeroLit :: Literal -> Bool
isOneLit :: Literal -> Bool
litValue :: Literal -> Integer
isLitValue_maybe :: Literal -> Maybe Integer
mapLitValue :: Platform -> (Integer -> Integer) -> Literal -> Literal
narrowInt8Lit :: Literal -> Literal
narrowInt16Lit :: Literal -> Literal
narrowInt32Lit :: Literal -> Literal
narrowInt64Lit :: Literal -> Literal
narrowWord8Lit :: Literal -> Literal
narrowWord16Lit :: Literal -> Literal
narrowWord32Lit :: Literal -> Literal
narrowWord64Lit :: Literal -> Literal
convertToWordLit :: Platform -> Literal -> Literal
convertToIntLit :: Platform -> Literal -> Literal
charToIntLit :: Literal -> Literal
intToCharLit :: Literal -> Literal
floatToIntLit :: Literal -> Literal
intToFloatLit :: Literal -> Literal
doubleToIntLit :: Literal -> Literal
intToDoubleLit :: Literal -> Literal
floatToDoubleLit :: Literal -> Literal
doubleToFloatLit :: Literal -> Literal
nullAddrLit :: Literal
litIsTrivial :: Literal -> Bool
litIsDupable :: Platform -> Literal -> Bool
litFitsInChar :: Literal -> Bool
litIsLifted :: Literal -> Bool
literalType :: Literal -> Type
pprLiteral :: (SDoc -> SDoc) -> Literal -> SDoc
pprParendCo :: Coercion -> SDoc
coVarName :: CoVar -> Name
setCoVarUnique :: CoVar -> Unique -> CoVar
setCoVarName :: CoVar -> Name -> CoVar
etaExpandCoAxBranch :: CoAxBranch -> ([TyVar], [Type], Type)
pprCoAxiom :: forall (br :: BranchFlag). CoAxiom br -> SDoc
pprCoAxBranchUser :: TyCon -> CoAxBranch -> SDoc
pprCoAxBranchLHS :: TyCon -> CoAxBranch -> SDoc
pprCoAxBranch :: TyCon -> CoAxBranch -> SDoc
tidyCoAxBndrsForUser :: TidyEnv -> [Var] -> (TidyEnv, [Var])
coToMCo :: Coercion -> MCoercion
checkReflexiveMCo :: MCoercion -> MCoercion
isGReflMCo :: MCoercion -> Bool
mkTransMCo :: MCoercion -> MCoercion -> MCoercion
mkTransMCoL :: MCoercion -> Coercion -> MCoercion
mkTransMCoR :: Coercion -> MCoercion -> MCoercion
mkSymMCo :: MCoercion -> MCoercion
mkCastTyMCo :: Type -> MCoercion -> Type
mkHomoForAllMCo :: TyCoVar -> MCoercion -> MCoercion
mkPiMCos :: [Var] -> MCoercion -> MCoercion
mkFunResMCo :: Id -> MCoercionR -> MCoercionR
mkGReflLeftMCo :: Role -> Type -> MCoercionN -> Coercion
mkGReflRightMCo :: Role -> Type -> MCoercionN -> Coercion
mkCoherenceRightMCo :: Role -> Type -> MCoercionN -> Coercion -> Coercion
isReflMCo :: MCoercion -> Bool
decomposeCo :: Arity -> Coercion -> Infinite Role -> [Coercion]
decomposeFunCo :: HasDebugCallStack => Coercion -> (CoercionN, Coercion, Coercion)
getCoVar_maybe :: Coercion -> Maybe CoVar
multToCo :: Mult -> Coercion
splitAppCo_maybe :: Coercion -> Maybe (Coercion, Coercion)
splitFunCo_maybe :: Coercion -> Maybe (Coercion, Coercion)
splitForAllCo_maybe :: Coercion -> Maybe (TyCoVar, Coercion, Coercion)
splitForAllCo_ty_maybe :: Coercion -> Maybe (TyVar, Coercion, Coercion)
splitForAllCo_co_maybe :: Coercion -> Maybe (CoVar, Coercion, Coercion)
coVarLType :: HasDebugCallStack => CoVar -> Type
coVarRType :: HasDebugCallStack => CoVar -> Type
coVarTypes :: HasDebugCallStack => CoVar -> Pair Type
coVarKind :: CoVar -> Type
mkRuntimeRepCo :: HasDebugCallStack => Coercion -> Coercion
isReflCoVar_maybe :: Var -> Maybe Coercion
isGReflCo_maybe :: Coercion -> Maybe (Type, Role)
isReflCo_maybe :: Coercion -> Maybe (Type, Role)
isReflexiveCo_maybe :: Coercion -> Maybe (Type, Role)
mkRepReflCo :: Type -> Coercion
mkFunCoNoFTF :: HasDebugCallStack => Role -> CoercionN -> Coercion -> Coercion -> Coercion
mkNakedFunCo2 :: Role -> FunTyFlag -> FunTyFlag -> CoercionN -> Coercion -> Coercion -> Coercion
mkAppCos :: Coercion -> [Coercion] -> Coercion
mkForAllCos :: [(TyCoVar, CoercionN)] -> Coercion -> Coercion
mkHomoForAllCos :: [TyCoVar] -> Coercion -> Coercion
mkCoVarCos :: [CoVar] -> [Coercion]
mkAxInstCo :: forall (br :: BranchFlag). Role -> CoAxiom br -> BranchIndex -> [Type] -> [Coercion] -> Coercion
mkUnbranchedAxInstCo :: Role -> CoAxiom Unbranched -> [Type] -> [Coercion] -> Coercion
mkAxInstRHS :: forall (br :: BranchFlag). CoAxiom br -> BranchIndex -> [Type] -> [Coercion] -> Type
mkUnbranchedAxInstRHS :: CoAxiom Unbranched -> [Type] -> [Coercion] -> Type
mkAxInstLHS :: forall (br :: BranchFlag). CoAxiom br -> BranchIndex -> [Type] -> [Coercion] -> Type
mkUnbranchedAxInstLHS :: CoAxiom Unbranched -> [Type] -> [Coercion] -> Type
mkHoleCo :: CoercionHole -> Coercion
getNthFun :: FunSel -> a -> a -> a -> a
mkGReflRightCo :: Role -> Type -> CoercionN -> Coercion
mkGReflLeftCo :: Role -> Type -> CoercionN -> Coercion
mkCoherenceLeftCo :: Role -> Type -> CoercionN -> Coercion -> Coercion
mkCoherenceRightCo :: Role -> Type -> CoercionN -> Coercion -> Coercion
downgradeRole :: Role -> Role -> Coercion -> Coercion
setNominalRole_maybe :: Role -> Coercion -> Maybe CoercionN
tyConRolesX :: Role -> TyCon -> Infinite Role
tyConRoleListX :: Role -> TyCon -> [Role]
tyConRolesRepresentational :: TyCon -> Infinite Role
tyConRoleListRepresentational :: TyCon -> [Role]
tyConRole :: Role -> TyCon -> Int -> Role
funRole :: Role -> FunSel -> Role
ltRole :: Role -> Role -> Bool
promoteCoercion :: Coercion -> CoercionN
castCoercionKind2 :: Coercion -> Role -> Type -> Type -> CoercionN -> CoercionN -> Coercion
castCoercionKind1 :: Coercion -> Role -> Type -> Type -> CoercionN -> Coercion
castCoercionKind :: Coercion -> CoercionN -> CoercionN -> Coercion
mkPiCos :: Role -> [Var] -> Coercion -> Coercion
mkPiCo :: Role -> Var -> Coercion -> Coercion
mkFunResCo :: Role -> Id -> Coercion -> Coercion
mkCoCast :: Coercion -> CoercionR -> Coercion
instNewTyCon_maybe :: TyCon -> [Type] -> Maybe (Type, Coercion)
composeSteppers :: NormaliseStepper ev -> NormaliseStepper ev -> NormaliseStepper ev
unwrapNewTypeStepper :: NormaliseStepper Coercion
topNormaliseTypeX :: NormaliseStepper ev -> (ev -> ev -> ev) -> Type -> Maybe (ev, Type)
eqCoercion :: Coercion -> Coercion -> Bool
eqCoercionX :: RnEnv2 -> Coercion -> Coercion -> Bool
liftCoSubstWithEx :: Role -> [TyVar] -> [Coercion] -> [TyCoVar] -> [Type] -> (Type -> Coercion, [Type])
liftCoSubstWith :: Role -> [TyCoVar] -> [Coercion] -> Type -> Coercion
emptyLiftingContext :: InScopeSet -> LiftingContext
mkSubstLiftingContext :: Subst -> LiftingContext
extendLiftingContext :: LiftingContext -> TyCoVar -> Coercion -> LiftingContext
extendLiftingContextAndInScope :: LiftingContext -> TyCoVar -> Coercion -> LiftingContext
zapLiftingContext :: LiftingContext -> LiftingContext
substForAllCoBndrUsingLC :: Bool -> (Coercion -> Coercion) -> LiftingContext -> TyCoVar -> Coercion -> (LiftingContext, TyCoVar, Coercion)
liftCoSubstTyVar :: LiftingContext -> Role -> TyVar -> Maybe Coercion
liftCoSubstVarBndrUsing :: (r -> CoercionN) -> (LiftingContext -> Type -> r) -> LiftingContext -> TyCoVar -> (LiftingContext, TyCoVar, r)
isMappedByLC :: TyCoVar -> LiftingContext -> Bool
substLeftCo :: LiftingContext -> Coercion -> Coercion
substRightCo :: LiftingContext -> Coercion -> Coercion
swapLiftCoEnv :: LiftCoEnv -> LiftCoEnv
lcSubstLeft :: LiftingContext -> Subst
lcSubstRight :: LiftingContext -> Subst
liftEnvSubstLeft :: Subst -> LiftCoEnv -> Subst
liftEnvSubstRight :: Subst -> LiftCoEnv -> Subst
lcSubst :: LiftingContext -> Subst
lcInScopeSet :: LiftingContext -> InScopeSet
coercionKinds :: [Coercion] -> Pair [Type]
coercionKindRole :: Coercion -> (Pair Type, Role)
getNthFromType :: HasDebugCallStack => CoSel -> Type -> Type
coercionRole :: Coercion -> Role
mkPrimEqPred :: Type -> Type -> Type
mkPrimEqPredRole :: Role -> Type -> Type -> PredType
mkHeteroPrimEqPred :: Kind -> Kind -> Type -> Type -> Type
mkHeteroReprPrimEqPred :: Kind -> Kind -> Type -> Type -> Type
mkReprPrimEqPred :: Type -> Type -> Type
buildCoercion :: Type -> Type -> CoercionN
hasCoercionHoleTy :: Type -> Bool
hasCoercionHoleCo :: Coercion -> Bool
hasThisCoercionHoleTy :: Type -> CoercionHole -> Bool
setCoHoleType :: CoercionHole -> Type -> CoercionHole
suggestExtension :: Extension -> GhcHint
suggestExtensionWithInfo :: SDoc -> Extension -> GhcHint
suggestExtensions :: [Extension] -> GhcHint
suggestExtensionsWithInfo :: SDoc -> [Extension] -> GhcHint
suggestAnyExtension :: [Extension] -> GhcHint
suggestAnyExtensionWithInfo :: SDoc -> [Extension] -> GhcHint
useExtensionInOrderTo :: SDoc -> Extension -> GhcHint
emptyMessages :: Messages e
mkMessages :: Bag (MsgEnvelope e) -> Messages e
isEmptyMessages :: Messages e -> Bool
singleMessage :: MsgEnvelope e -> Messages e
addMessage :: MsgEnvelope e -> Messages e -> Messages e
unionMessages :: Messages e -> Messages e -> Messages e
unionManyMessages :: Foldable f => f (Messages e) -> Messages e
mkDecorated :: [SDoc] -> DecoratedSDoc
mkSimpleDecorated :: SDoc -> DecoratedSDoc
unionDecoratedSDoc :: DecoratedSDoc -> DecoratedSDoc -> DecoratedSDoc
mapDecoratedSDoc :: (SDoc -> SDoc) -> DecoratedSDoc -> DecoratedSDoc
noHints :: [GhcHint]
mkPlainDiagnostic :: DiagnosticReason -> [GhcHint] -> SDoc -> DiagnosticMessage
mkPlainError :: [GhcHint] -> SDoc -> DiagnosticMessage
mkDecoratedDiagnostic :: DiagnosticReason -> [GhcHint] -> [SDoc] -> DiagnosticMessage
mkDecoratedError :: [GhcHint] -> [SDoc] -> DiagnosticMessage
pprMessageBag :: Bag SDoc -> SDoc
mkLocMessage :: MessageClass -> SrcSpan -> SDoc -> SDoc
mkLocMessageWarningGroups :: Bool -> MessageClass -> SrcSpan -> SDoc -> SDoc
getCaretDiagnostic :: MessageClass -> SrcSpan -> IO SDoc
isIntrinsicErrorMessage :: Diagnostic e => MsgEnvelope e -> Bool
isWarningMessage :: Diagnostic e => MsgEnvelope e -> Bool
errorsFound :: Diagnostic e => Messages e -> Bool
isExtrinsicErrorMessage :: MsgEnvelope e -> Bool
errorsOrFatalWarningsFound :: Messages e -> Bool
getWarningMessages :: Diagnostic e => Messages e -> Bag (MsgEnvelope e)
getErrorMessages :: Diagnostic e => Messages e -> Bag (MsgEnvelope e)
partitionMessages :: Diagnostic e => Messages e -> (Messages e, Messages e)
diag_wopt :: WarningFlag -> DiagOpts -> Bool
diag_fatal_wopt :: WarningFlag -> DiagOpts -> Bool
diagReasonSeverity :: DiagOpts -> DiagnosticReason -> Severity
mkMCDiagnostic :: DiagOpts -> DiagnosticReason -> Maybe DiagnosticCode -> MessageClass
errorDiagnostic :: MessageClass
mkMsgEnvelope :: Diagnostic e => DiagOpts -> SrcSpan -> NamePprCtx -> e -> MsgEnvelope e
mkErrorMsgEnvelope :: Diagnostic e => SrcSpan -> NamePprCtx -> e -> MsgEnvelope e
mkPlainMsgEnvelope :: Diagnostic e => DiagOpts -> SrcSpan -> e -> MsgEnvelope e
mkPlainErrorMsgEnvelope :: Diagnostic e => SrcSpan -> e -> MsgEnvelope e
andValid :: Validity' a -> Validity' a -> Validity' a
allValid :: [Validity' a] -> Validity' a
getInvalids :: [Validity' a] -> [a]
formatBulleted :: SDocContext -> DecoratedSDoc -> SDoc
pprMessages :: Diagnostic e => DiagnosticOpts e -> Messages e -> SDoc
pprMsgEnvelopeBagWithLoc :: Diagnostic e => DiagnosticOpts e -> Bag (MsgEnvelope e) -> [SDoc]
pprMsgEnvelopeBagWithLocDefault :: Diagnostic e => Bag (MsgEnvelope e) -> [SDoc]
pprLocMsgEnvelopeDefault :: Diagnostic e => MsgEnvelope e -> SDoc
pprLocMsgEnvelope :: Diagnostic e => DiagnosticOpts e -> MsgEnvelope e -> SDoc
sortMsgBag :: Maybe DiagOpts -> Bag (MsgEnvelope e) -> [MsgEnvelope e]
ghcExit :: Logger -> Int -> IO ()
errorMsg :: Logger -> SDoc -> IO ()
fatalErrorMsg :: Logger -> SDoc -> IO ()
compilationProgressMsg :: Logger -> SDoc -> IO ()
showPass :: Logger -> String -> IO ()
withTiming :: MonadIO m => Logger -> SDoc -> (a -> ()) -> m a -> m a
withTimingSilent :: MonadIO m => Logger -> SDoc -> (a -> ()) -> m a -> m a
debugTraceMsg :: Logger -> Int -> SDoc -> IO ()
putMsg :: Logger -> SDoc -> IO ()
printInfoForUser :: Logger -> NamePprCtx -> SDoc -> IO ()
printOutputForUser :: Logger -> NamePprCtx -> SDoc -> IO ()
logInfo :: Logger -> SDoc -> IO ()
logOutput :: Logger -> SDoc -> IO ()
prettyPrintGhcErrors :: ExceptionMonad m => Logger -> m a -> m a
traceCmd :: Logger -> String -> String -> IO a -> IO a
traceSystoolCommand :: Logger -> String -> IO a -> IO a
simplCountN :: SimplCount -> Int
zeroSimplCount :: Bool -> SimplCount
isZeroSimplCount :: SimplCount -> Bool
hasDetailedCounts :: SimplCount -> Bool
doFreeSimplTick :: Tick -> SimplCount -> SimplCount
doSimplTick :: Int -> Tick -> SimplCount -> SimplCount
plusSimplCount :: SimplCount -> SimplCount -> SimplCount
pprSimplCount :: SimplCount -> SDoc
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])
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
isOrphan :: IsOrphan -> Bool
notOrphan :: IsOrphan -> Bool
chooseOrphanAnchor :: NameSet -> IsOrphan
isBuiltinRule :: CoreRule -> Bool
isAutoRule :: CoreRule -> Bool
ruleArity :: CoreRule -> Int
ruleName :: CoreRule -> RuleName
ruleModule :: CoreRule -> Maybe Module
ruleActivation :: CoreRule -> Activation
ruleIdName :: CoreRule -> Name
isLocalRule :: CoreRule -> Bool
setRuleIdName :: Name -> CoreRule -> CoreRule
needSaturated :: Bool
unSaturatedOk :: Bool
boringCxtOk :: Bool
boringCxtNotOk :: Bool
noUnfolding :: Unfolding
evaldUnfolding :: Unfolding
bootUnfolding :: Unfolding
mkOtherCon :: [AltCon] -> Unfolding
unfoldingTemplate :: Unfolding -> CoreExpr
maybeUnfoldingTemplate :: Unfolding -> Maybe CoreExpr
otherCons :: Unfolding -> [AltCon]
isValueUnfolding :: Unfolding -> Bool
isEvaldUnfolding :: Unfolding -> Bool
isConLikeUnfolding :: Unfolding -> Bool
isCheapUnfolding :: Unfolding -> Bool
isExpandableUnfolding :: Unfolding -> Bool
expandUnfolding_maybe :: Unfolding -> Maybe CoreExpr
isCompulsoryUnfolding :: Unfolding -> Bool
isStableUnfolding :: Unfolding -> Bool
isStableUserUnfolding :: Unfolding -> Bool
isStableSystemUnfolding :: Unfolding -> Bool
isInlineUnfolding :: Unfolding -> Bool
hasSomeUnfolding :: Unfolding -> Bool
isBootUnfolding :: Unfolding -> Bool
neverUnfoldGuidance :: UnfoldingGuidance -> Bool
hasCoreUnfolding :: Unfolding -> Bool
canUnfold :: Unfolding -> Bool
cmpAlt :: Alt a -> Alt a -> Ordering
ltAlt :: Alt a -> Alt a -> Bool
cmpAltCon :: AltCon -> AltCon -> Ordering
deTagExpr :: TaggedExpr t -> CoreExpr
mkApps :: Expr b -> [Arg b] -> Expr b
mkCoApps :: Expr b -> [Coercion] -> Expr b
mkVarApps :: Expr b -> [Var] -> Expr b
mkConApp :: DataCon -> [Arg b] -> Expr b
mkTyApps :: Expr b -> [Type] -> Expr b
mkConApp2 :: DataCon -> [Type] -> [Var] -> Expr b
mkTyArg :: Type -> Expr b
mkIntLit :: Platform -> Integer -> Expr b
mkIntLitWrap :: Platform -> Integer -> Expr b
mkWordLit :: Platform -> Integer -> Expr b
mkWordLitWrap :: Platform -> Integer -> Expr b
mkWord8Lit :: Integer -> Expr b
mkWord64LitWord64 :: Word64 -> Expr b
mkInt64LitInt64 :: Int64 -> Expr b
mkCharLit :: Char -> Expr b
mkStringLit :: String -> Expr b
mkFloatLit :: Rational -> Expr b
mkFloatLitFloat :: Float -> Expr b
mkDoubleLit :: Rational -> Expr b
mkDoubleLitDouble :: Double -> Expr b
mkLams :: [b] -> Expr b -> Expr b
mkLets :: [Bind b] -> Expr b -> Expr b
mkLet :: Bind b -> Expr b -> Expr b
mkLetNonRec :: b -> Expr b -> Expr b -> Expr b
mkLetRec :: [(b, Expr b)] -> Expr b -> Expr b
mkTyBind :: TyVar -> Type -> CoreBind
mkCoBind :: CoVar -> Coercion -> CoreBind
varToCoreExpr :: CoreBndr -> Expr b
varsToCoreExprs :: [CoreBndr] -> [Expr b]
exprToType :: CoreExpr -> Type
bindersOf :: Bind b -> [b]
bindersOfBinds :: [Bind b] -> [b]
foldBindersOfBindStrict :: (a -> b -> a) -> a -> Bind b -> a
foldBindersOfBindsStrict :: (a -> b -> a) -> a -> [Bind b] -> a
rhssOfBind :: Bind b -> [Expr b]
rhssOfAlts :: [Alt b] -> [Expr b]
flattenBinds :: [Bind b] -> [(b, Expr b)]
collectBinders :: Expr b -> ([b], Expr b)
collectTyBinders :: CoreExpr -> ([TyVar], CoreExpr)
collectTyAndValBinders :: CoreExpr -> ([TyVar], [Id], CoreExpr)
collectNBinders :: JoinArity -> Expr b -> ([b], Expr b)
collectNValBinders_maybe :: Arity -> CoreExpr -> Maybe ([Var], CoreExpr)
collectArgs :: Expr b -> (Expr b, [Arg b])
collectFunSimple :: Expr b -> Expr b
wrapLamBody :: (CoreExpr -> CoreExpr) -> CoreExpr -> CoreExpr
stripNArgs :: Word -> Expr a -> Maybe (Expr a)
collectArgsTicks :: (CoreTickish -> Bool) -> Expr b -> (Expr b, [Arg b], [CoreTickish])
isRuntimeVar :: Var -> Bool
isRuntimeArg :: CoreExpr -> Bool
isValArg :: Expr b -> Bool
isTyCoArg :: Expr b -> Bool
isCoArg :: Expr b -> Bool
isTypeArg :: Expr b -> Bool
valBndrCount :: [CoreBndr] -> Int
valArgCount :: [Arg b] -> Int
collectAnnArgs :: AnnExpr b a -> (AnnExpr b a, [AnnExpr b a])
collectAnnArgsTicks :: (CoreTickish -> Bool) -> AnnExpr b a -> (AnnExpr b a, [AnnExpr b a], [CoreTickish])
deAnnotate :: AnnExpr bndr annot -> Expr bndr
deAnnotate' :: AnnExpr' bndr annot -> Expr bndr
deAnnAlt :: AnnAlt bndr annot -> Alt bndr
deAnnBind :: AnnBind b annot -> Bind b
collectAnnBndrs :: AnnExpr bndr annot -> ([bndr], AnnExpr bndr annot)
collectNAnnBndrs :: Int -> AnnExpr bndr annot -> ([bndr], AnnExpr bndr annot)
isJoinIdDetails_maybe :: IdDetails -> Maybe (JoinArity, Maybe [CbvMark])
oneShotInfo :: IdInfo -> OneShotInfo
arityInfo :: IdInfo -> ArityInfo
cafInfo :: IdInfo -> CafInfo
callArityInfo :: IdInfo -> ArityInfo
tagSigInfo :: IdInfo -> Maybe TagSig
setRuleInfo :: IdInfo -> RuleInfo -> IdInfo
setInlinePragInfo :: IdInfo -> InlinePragma -> IdInfo
setOccInfo :: IdInfo -> OccInfo -> IdInfo
unfoldingInfo :: IdInfo -> Unfolding
setUnfoldingInfo :: IdInfo -> Unfolding -> IdInfo
hasInlineUnfolding :: IdInfo -> Bool
setArityInfo :: IdInfo -> ArityInfo -> IdInfo
setCallArityInfo :: IdInfo -> ArityInfo -> IdInfo
setCafInfo :: IdInfo -> CafInfo -> IdInfo
setLFInfo :: IdInfo -> LambdaFormInfo -> IdInfo
setTagSig :: IdInfo -> TagSig -> IdInfo
setOneShotInfo :: IdInfo -> OneShotInfo -> IdInfo
setDemandInfo :: IdInfo -> Demand -> IdInfo
setDmdSigInfo :: IdInfo -> DmdSig -> IdInfo
setCprSigInfo :: IdInfo -> CprSig -> IdInfo
noCafIdInfo :: IdInfo
unknownArity :: Arity
ppArityInfo :: Int -> SDoc
pprStrictness :: DmdSig -> SDoc
emptyRuleInfo :: RuleInfo
isEmptyRuleInfo :: RuleInfo -> Bool
ruleInfoFreeVars :: RuleInfo -> DVarSet
ruleInfoRules :: RuleInfo -> [CoreRule]
setRuleInfoHead :: Name -> RuleInfo -> RuleInfo
mayHaveCafRefs :: CafInfo -> Bool
ppCafInfo :: CafInfo -> SDoc
zapLamInfo :: IdInfo -> Maybe IdInfo
zapDemandInfo :: IdInfo -> Maybe IdInfo
zapUsageInfo :: IdInfo -> Maybe IdInfo
zapUsageEnvInfo :: IdInfo -> Maybe IdInfo
zapUsedOnceInfo :: IdInfo -> Maybe IdInfo
zapFragileInfo :: IdInfo -> Maybe IdInfo
trimUnfolding :: Unfolding -> Unfolding
zapTailCallInfo :: IdInfo -> Maybe IdInfo
zapCallArityInfo :: IdInfo -> IdInfo
idUnique :: Id -> Unique
idType :: Id -> Kind
idMult :: Id -> Mult
idScaledType :: Id -> Scaled Type
scaleIdBy :: Mult -> Id -> Id
scaleVarBy :: Mult -> Var -> Var
setIdName :: Id -> Name -> Id
setIdUnique :: Id -> Unique -> Id
setIdType :: Id -> Type -> Id
localiseId :: Id -> Id
setIdInfo :: Id -> IdInfo -> Id
modifyIdInfo :: HasDebugCallStack => (IdInfo -> IdInfo) -> Id -> Id
maybeModifyIdInfo :: Maybe IdInfo -> Id -> Id
mkGlobalId :: IdDetails -> Name -> Type -> IdInfo -> Id
mkVanillaGlobal :: Name -> Type -> Id
mkVanillaGlobalWithInfo :: Name -> Type -> IdInfo -> Id
mkLocalId :: HasDebugCallStack => Name -> Mult -> Type -> Id
mkLocalCoVar :: Name -> Type -> CoVar
mkLocalIdOrCoVar :: Name -> Mult -> Type -> Id
mkLocalIdWithInfo :: HasDebugCallStack => Name -> Mult -> Type -> IdInfo -> Id
mkExportedLocalId :: IdDetails -> Name -> Type -> Id
mkExportedVanillaId :: Name -> Type -> Id
mkSysLocal :: FastString -> Unique -> Mult -> Type -> Id
mkSysLocalOrCoVar :: FastString -> Unique -> Mult -> Type -> Id
mkSysLocalM :: MonadUnique m => FastString -> Mult -> Type -> m Id
mkSysLocalOrCoVarM :: MonadUnique m => FastString -> Mult -> Type -> m Id
mkUserLocal :: OccName -> Unique -> Mult -> Type -> SrcSpan -> Id
mkUserLocalOrCoVar :: OccName -> Unique -> Mult -> Type -> SrcSpan -> Id
mkWorkerId :: Unique -> Id -> Type -> Id
mkTemplateLocal :: Int -> Type -> Id
mkScaledTemplateLocal :: Int -> Scaled Type -> Id
mkTemplateLocals :: [Type] -> [Id]
mkTemplateLocalsNum :: Int -> [Type] -> [Id]
recordSelectorTyCon :: Id -> RecSelParent
recordSelectorTyCon_maybe :: Id -> Maybe RecSelParent
isRecordSelector :: Id -> Bool
isDataConRecordSelector :: Id -> Bool
isPatSynRecordSelector :: Id -> Bool
isNaughtyRecordSelector :: Id -> Bool
isClassOpId :: Id -> Bool
isClassOpId_maybe :: Id -> Maybe Class
isPrimOpId :: Id -> Bool
isDFunId :: Id -> Bool
isPrimOpId_maybe :: Id -> Maybe PrimOp
isFCallId :: Id -> Bool
isFCallId_maybe :: Id -> Maybe ForeignCall
isDataConWorkId :: Id -> Bool
isDataConWorkId_maybe :: Id -> Maybe DataCon
isDataConWrapId :: Id -> Bool
isDataConWrapId_maybe :: Id -> Maybe DataCon
isDataConId_maybe :: Id -> Maybe DataCon
isWorkerLikeId :: Id -> Bool
isJoinId :: Var -> Bool
isJoinId_maybe :: Var -> Maybe JoinArity
idDataCon :: Id -> DataCon
hasNoBinding :: Id -> Bool
isImplicitId :: Id -> Bool
idIsFrom :: Module -> Id -> Bool
isDeadBinder :: Id -> Bool
idJoinArity :: JoinId -> JoinArity
asJoinId :: Id -> JoinArity -> JoinId
zapJoinId :: Id -> Id
asJoinId_maybe :: Id -> Maybe JoinArity -> Id
idArity :: Id -> Arity
setIdArity :: Id -> Arity -> Id
idCallArity :: Id -> Arity
setIdCallArity :: Id -> Arity -> Id
idFunRepArity :: Id -> RepArity
isDeadEndId :: Var -> Bool
idDmdSig :: Id -> DmdSig
setIdDmdSig :: Id -> DmdSig -> Id
idCprSig :: Id -> CprSig
setIdCprSig :: Id -> CprSig -> Id
zapIdDmdSig :: Id -> Id
isStrictId :: Id -> Bool
idTagSig_maybe :: Id -> Maybe TagSig
idUnfolding :: IdUnfoldingFun
noUnfoldingFun :: IdUnfoldingFun
alwaysActiveUnfoldingFun :: IdUnfoldingFun
whenActiveUnfoldingFun :: (Activation -> Bool) -> IdUnfoldingFun
realIdUnfolding :: Id -> Unfolding
setIdUnfolding :: Id -> Unfolding -> Id
idDemandInfo :: Id -> Demand
setIdDemandInfo :: Id -> Demand -> Id
setIdTagSig :: Id -> TagSig -> Id
setIdCbvMarks :: Id -> [CbvMark] -> Id
idCbvMarks_maybe :: Id -> Maybe [CbvMark]
idCbvMarkArity :: Id -> Arity
asNonWorkerLikeId :: Id -> Id
asWorkerLikeId :: Id -> Id
setCaseBndrEvald :: StrictnessMark -> Id -> Id
zapIdUnfolding :: Id -> Id
idSpecialisation :: Id -> RuleInfo
idCoreRules :: Id -> [CoreRule]
idHasRules :: Id -> Bool
setIdSpecialisation :: Id -> RuleInfo -> Id
idCafInfo :: Id -> CafInfo
setIdCafInfo :: Id -> CafInfo -> Id
idLFInfo_maybe :: Id -> Maybe LambdaFormInfo
setIdLFInfo :: Id -> LambdaFormInfo -> Id
idOccInfo :: Id -> OccInfo
setIdOccInfo :: Id -> OccInfo -> Id
zapIdOccInfo :: Id -> Id
idInlinePragma :: Id -> InlinePragma
setInlinePragma :: Id -> InlinePragma -> Id
modifyInlinePragma :: Id -> (InlinePragma -> InlinePragma) -> Id
idInlineActivation :: Id -> Activation
setInlineActivation :: Id -> Activation -> Id
idRuleMatchInfo :: Id -> RuleMatchInfo
isConLikeId :: Id -> Bool
idOneShotInfo :: Id -> OneShotInfo
setOneShotLambda :: Id -> Id
clearOneShotLambda :: Id -> Id
setIdOneShotInfo :: Id -> OneShotInfo -> Id
updOneShotInfo :: Id -> OneShotInfo -> Id
zapLamIdInfo :: Id -> Id
zapFragileIdInfo :: Id -> Id
zapIdDemandInfo :: Id -> Id
zapIdUsageInfo :: Id -> Id
zapIdUsageEnvInfo :: Id -> Id
zapIdUsedOnceInfo :: Id -> Id
zapIdTailCallInfo :: Id -> Id
zapStableUnfolding :: Id -> Id
transferPolyIdInfo :: Id -> [Var] -> Id -> Id
wiredInTyCons :: [TyCon]
mkWiredInTyConName :: BuiltInSyntax -> Module -> FastString -> Unique -> TyCon -> Name
mkWiredInIdName :: Module -> FastString -> Unique -> Id -> Name
eqTyConName :: Name
eqTyCon_RDR :: RdrName
heqTyConName :: Name
coercibleTyConName :: Name
charTyConName :: Name
intTyConName :: Name
boolTyConName :: Name
listTyConName :: Name
nilDataConName :: Name
consDataConName :: Name
maybeTyConName :: Name
nothingDataConName :: Name
justDataConName :: Name
wordTyConName :: Name
floatTyConName :: Name
doubleTyConName :: Name
anyTyCon :: TyCon
anyTy :: Type
makeRecoveryTyCon :: TyCon -> TyCon
boolTyCon_RDR :: RdrName
false_RDR :: RdrName
true_RDR :: RdrName
intTyCon_RDR :: RdrName
charTyCon_RDR :: RdrName
stringTyCon_RDR :: RdrName
intDataCon_RDR :: RdrName
listTyCon_RDR :: RdrName
consDataCon_RDR :: RdrName
typeSymbolKindCon :: TyCon
isBuiltInOcc_maybe :: OccName -> Maybe Name
isPunOcc_maybe :: Module -> OccName -> Maybe Name
mkTupleStr :: Boxity -> NameSpace -> Arity -> String
cTupleTyCon :: Arity -> TyCon
cTupleTyConNames :: [Name]
isCTupleTyConName :: Name -> Bool
cTupleTyConNameArity_maybe :: Name -> Maybe Arity
cTupleDataConNames :: [Name]
cTupleSelId :: ConTag -> Arity -> Id
mkPromotedPairTy :: Kind -> Kind -> Type -> Type -> Type
isPromotedPairType :: Type -> Maybe (Type, Type)
unitTyCon :: TyCon
unitTyConKey :: Unique
unitDataCon :: DataCon
unitDataConId :: Id
soloTyCon :: TyCon
pairTyCon :: TyCon
unboxedUnitTy :: Type
unboxedUnitTyCon :: TyCon
unboxedUnitDataCon :: DataCon
unboxedSumKind :: [Type] -> Kind
eqTyCon :: TyCon
eqClass :: Class
eqDataCon :: DataCon
heqClass :: Class
heqDataCon :: DataCon
coercibleClass :: Class
coercibleDataCon :: DataCon
multiplicityTyConName :: Name
oneDataConName :: Name
manyDataConName :: Name
oneDataCon :: DataCon
manyDataCon :: DataCon
unrestrictedFunTyConName :: Name
constraintKindTyCon :: TyCon
typeToTypeKind :: Type
unliftedTypeKindTyConName :: Name
unliftedDataConTyCon :: TyCon
sumRepDataConTyCon :: TyCon
liftedRepTyConName :: Name
unliftedRepTyConName :: Name
charTyCon :: TyCon
charDataCon :: DataCon
stringTy :: Type
intTy :: Type
intTyCon :: TyCon
intDataCon :: DataCon
wordTy :: Type
wordTyCon :: TyCon
wordDataCon :: DataCon
word8Ty :: Type
word8TyCon :: TyCon
word8DataCon :: DataCon
floatTy :: Type
floatTyCon :: TyCon
floatDataCon :: DataCon
doubleTy :: Type
doubleTyCon :: TyCon
doubleDataCon :: DataCon
boxingDataCon :: Type -> BoxingInfo b
boolTy :: Type
boolTyCon :: TyCon
falseDataCon :: DataCon
trueDataCon :: DataCon
falseDataConId :: Id
trueDataConId :: Id
orderingTyCon :: TyCon
ordLTDataCon :: DataCon
ordEQDataCon :: DataCon
ordGTDataCon :: DataCon
ordLTDataConId :: Id
ordEQDataConId :: Id
ordGTDataConId :: Id
mkListTy :: Type -> Type
nilDataCon :: DataCon
consDataCon :: DataCon
maybeTyCon :: TyCon
nothingDataCon :: DataCon
justDataCon :: DataCon
mkPromotedMaybeTy :: Kind -> Maybe Type -> Type
mkMaybeTy :: Type -> Kind
isPromotedMaybeTy :: Type -> Maybe (Maybe Type)
mkTupleTy :: Boxity -> [Type] -> Type
mkTupleTy1 :: Boxity -> [Type] -> Type
mkConstraintTupleTy :: [Type] -> Type
mkSumTy :: [Type] -> Type
promotedTrueDataCon :: TyCon
promotedFalseDataCon :: TyCon
promotedNothingDataCon :: TyCon
promotedJustDataCon :: TyCon
promotedLTDataCon :: TyCon
promotedEQDataCon :: TyCon
promotedGTDataCon :: TyCon
promotedConsDataCon :: TyCon
promotedNilDataCon :: TyCon
mkPromotedListTy :: Kind -> [Type] -> Type
integerTyConName :: Name
integerISDataConName :: Name
integerIPDataConName :: Name
integerINDataConName :: Name
integerTyCon :: TyCon
integerISDataCon :: DataCon
integerIPDataCon :: DataCon
integerINDataCon :: DataCon
naturalTyConName :: Name
naturalNSDataConName :: Name
naturalNBDataConName :: Name
naturalTyCon :: TyCon
naturalNSDataCon :: DataCon
naturalNBDataCon :: DataCon
filterCTuple :: RdrName -> RdrName
lookupOrigNameCache :: OrigNameCache -> Module -> OccName -> Maybe Name
exprFreeVars :: CoreExpr -> VarSet
exprFVs :: CoreExpr -> FV
exprFreeVarsDSet :: CoreExpr -> DVarSet
exprFreeVarsList :: CoreExpr -> [Var]
exprFreeIds :: CoreExpr -> IdSet
exprsFreeIds :: [CoreExpr] -> IdSet
exprFreeIdsDSet :: CoreExpr -> DIdSet
exprFreeIdsList :: CoreExpr -> [Id]
exprsFreeIdsDSet :: [CoreExpr] -> DIdSet
exprsFreeIdsList :: [CoreExpr] -> [Id]
exprsFreeVars :: [CoreExpr] -> VarSet
exprsFreeVarsList :: [CoreExpr] -> [Var]
bindFreeVars :: CoreBind -> VarSet
exprSomeFreeVars :: InterestingVarFun -> CoreExpr -> VarSet
exprSomeFreeVarsList :: InterestingVarFun -> CoreExpr -> [Var]
exprsSomeFreeVars :: InterestingVarFun -> [CoreExpr] -> VarSet
exprsSomeFreeVarsList :: InterestingVarFun -> [CoreExpr] -> [Var]
exprsOrphNames :: [CoreExpr] -> NameSet
orphNamesOfType :: Type -> NameSet
orphNamesOfTypes :: [Type] -> NameSet
orphNamesOfCo :: Coercion -> NameSet
orphNamesOfCoCon :: forall (br :: BranchFlag). CoAxiom br -> NameSet
orphNamesOfAxiomLHS :: forall (br :: BranchFlag). CoAxiom br -> NameSet
ruleRhsFreeVars :: CoreRule -> VarSet
rulesRhsFreeIds :: [CoreRule] -> VarSet
ruleLhsFreeIds :: CoreRule -> VarSet
ruleLhsFreeIdsList :: CoreRule -> [Var]
ruleFreeVars :: CoreRule -> VarSet
rulesFreeVarsDSet :: [CoreRule] -> DVarSet
rulesFreeVars :: [CoreRule] -> VarSet
mkRuleInfo :: [CoreRule] -> RuleInfo
freeVarsOf :: CoreExprWithFVs -> DIdSet
freeVarsOfAnn :: FVAnn -> DIdSet
varTypeTyCoVars :: Var -> TyCoVarSet
varTypeTyCoFVs :: Var -> FV
idFreeVars :: Id -> VarSet
dIdFreeVars :: Id -> DVarSet
idFVs :: Id -> FV
bndrRuleAndUnfoldingVarsDSet :: Id -> DVarSet
bndrRuleAndUnfoldingIds :: Id -> IdSet
idRuleVars :: Id -> VarSet
idUnfoldingVars :: Id -> VarSet
stableUnfoldingVars :: Unfolding -> Maybe VarSet
freeVarsBind :: CoreBind -> DVarSet -> (CoreBindWithFVs, DVarSet)
freeVars :: CoreExpr -> CoreExprWithFVs
exprType :: HasDebugCallStack => CoreExpr -> Type
coreAltType :: CoreAlt -> Type
coreAltsType :: [CoreAlt] -> Type
mkLamType :: HasDebugCallStack => Var -> Type -> Type
mkLamTypes :: [Var] -> Type -> Type
applyTypeToArgs :: HasDebugCallStack => SDoc -> Type -> [CoreExpr] -> Type
mkCastMCo :: CoreExpr -> MCoercionR -> CoreExpr
mkPiMCo :: Var -> MCoercionR -> MCoercionR
mkCast :: HasDebugCallStack => CoreExpr -> CoercionR -> CoreExpr
mkTick :: CoreTickish -> CoreExpr -> CoreExpr
mkTicks :: [CoreTickish] -> CoreExpr -> CoreExpr
isSaturatedConApp :: CoreExpr -> Bool
mkTickNoHNF :: CoreTickish -> CoreExpr -> CoreExpr
tickHNFArgs :: CoreTickish -> CoreExpr -> CoreExpr
stripTicksTop :: (CoreTickish -> Bool) -> Expr b -> ([CoreTickish], Expr b)
stripTicksTopE :: (CoreTickish -> Bool) -> Expr b -> Expr b
stripTicksTopT :: (CoreTickish -> Bool) -> Expr b -> [CoreTickish]
stripTicksE :: (CoreTickish -> Bool) -> Expr b -> Expr b
stripTicksT :: (CoreTickish -> Bool) -> Expr b -> [CoreTickish]
bindNonRec :: HasDebugCallStack => Id -> CoreExpr -> CoreExpr -> CoreExpr
needsCaseBinding :: Type -> CoreExpr -> Bool
mkAltExpr :: AltCon -> [CoreBndr] -> [Type] -> CoreExpr
mkDefaultCase :: CoreExpr -> Id -> CoreExpr -> CoreExpr
mkSingleAltCase :: CoreExpr -> Id -> AltCon -> [Var] -> CoreExpr -> CoreExpr
findDefault :: [Alt b] -> ([Alt b], Maybe (Expr b))
addDefault :: [Alt b] -> Maybe (Expr b) -> [Alt b]
isDefaultAlt :: Alt b -> Bool
findAlt :: AltCon -> [Alt b] -> Maybe (Alt b)
mergeAlts :: [Alt a] -> [Alt a] -> [Alt a]
trimConArgs :: AltCon -> [CoreArg] -> [CoreArg]
filterAlts :: TyCon -> [Type] -> [AltCon] -> [Alt b] -> ([AltCon], [Alt b])
refineDefaultAlt :: [Unique] -> Mult -> TyCon -> [Type] -> [AltCon] -> [CoreAlt] -> (Bool, [CoreAlt])
combineIdenticalAlts :: [AltCon] -> [CoreAlt] -> (Bool, [AltCon], [CoreAlt])
scaleAltsBy :: Mult -> [CoreAlt] -> [CoreAlt]
exprIsTrivial :: CoreExpr -> Bool
getIdFromTrivialExpr :: HasDebugCallStack => CoreExpr -> Id
getIdFromTrivialExpr_maybe :: CoreExpr -> Maybe Id
exprIsDupable :: Platform -> CoreExpr -> Bool
exprIsWorkFree :: CoreExpr -> Bool
exprIsCheap :: CoreExpr -> Bool
exprIsCheapX :: CheapAppFun -> CoreExpr -> Bool
exprIsExpandable :: CoreExpr -> Bool
isCheapApp :: CheapAppFun
isExpandableApp :: CheapAppFun
exprOkForSpeculation :: CoreExpr -> Bool
exprOkForSideEffects :: CoreExpr -> Bool
exprOkForSpecEval :: (Id -> Bool) -> CoreExpr -> Bool
altsAreExhaustive :: [Alt b] -> Bool
etaExpansionTick :: forall (pass :: TickishPass). Id -> GenTickish pass -> Bool
exprIsHNF :: CoreExpr -> Bool
exprIsConLike :: CoreExpr -> Bool
exprIsTopLevelBindable :: CoreExpr -> Type -> Bool
exprIsTickedString :: CoreExpr -> Bool
exprIsTickedString_maybe :: CoreExpr -> Maybe ByteString
dataConRepInstPat :: [Unique] -> Mult -> DataCon -> [Type] -> ([TyCoVar], [Id])
dataConRepFSInstPat :: [FastString] -> [Unique] -> Mult -> DataCon -> [Type] -> ([TyCoVar], [Id])
cheapEqExpr :: Expr b -> Expr b -> Bool
cheapEqExpr' :: (CoreTickish -> Bool) -> Expr b -> Expr b -> Bool
diffBinds :: Bool -> RnEnv2 -> [(Var, CoreExpr)] -> [(Var, CoreExpr)] -> ([SDoc], RnEnv2)
isEmptyTy :: Type -> Bool
normSplitTyConApp_maybe :: FamInstEnvs -> Type -> Maybe (TyCon, [Type], Coercion)
extendInScopeSetBind :: InScopeSet -> CoreBind -> InScopeSet
extendInScopeSetBndrs :: InScopeSet -> [CoreBind] -> InScopeSet
mkInScopeSetBndrs :: [CoreBind] -> InScopeSet
collectMakeStaticArgs :: CoreExpr -> Maybe (CoreExpr, Type, CoreExpr, CoreExpr)
isJoinBind :: CoreBind -> Bool
dumpIdInfoOfProgram :: Bool -> (IdInfo -> SDoc) -> CoreProgram -> SDoc
mkStrictFieldSeqs :: [(Id, StrictnessMark)] -> CoreExpr -> CoreExpr
shouldStrictifyIdForCbv :: Var -> Bool
shouldUseCbvForId :: Var -> Bool
isUnsafeEqualityProof :: CoreExpr -> Bool
extendIdSubst :: Subst -> Id -> CoreExpr -> Subst
extendIdSubstWithClone :: Subst -> Id -> Id -> Subst
extendIdSubstList :: Subst -> [(Id, CoreExpr)] -> Subst
extendSubst :: Subst -> Var -> CoreArg -> Subst
extendSubstWithVar :: Subst -> Var -> Var -> Subst
extendSubstList :: Subst -> [(Var, CoreArg)] -> Subst
lookupIdSubst :: HasDebugCallStack => Subst -> Id -> CoreExpr
lookupIdSubst_maybe :: HasDebugCallStack => Subst -> Id -> Maybe CoreExpr
delBndr :: Subst -> Var -> Subst
delBndrs :: Subst -> [Var] -> Subst
mkOpenSubst :: InScopeSet -> [(Var, CoreArg)] -> Subst
substExprSC :: HasDebugCallStack => Subst -> CoreExpr -> CoreExpr
substExpr :: HasDebugCallStack => Subst -> CoreExpr -> CoreExpr
substBindSC :: HasDebugCallStack => Subst -> CoreBind -> (Subst, CoreBind)
substBind :: HasDebugCallStack => Subst -> CoreBind -> (Subst, CoreBind)
deShadowBinds :: CoreProgram -> CoreProgram
substBndr :: Subst -> Var -> (Subst, Var)
substBndrs :: Traversable f => Subst -> f Var -> (Subst, f Var)
substRecBndrs :: Traversable f => Subst -> f Id -> (Subst, f Id)
cloneIdBndr :: Subst -> UniqSupply -> Id -> (Subst, Id)
cloneIdBndrs :: Subst -> UniqSupply -> [Id] -> (Subst, [Id])
cloneBndrs :: Subst -> UniqSupply -> [Var] -> (Subst, [Var])
cloneBndr :: Subst -> Unique -> Var -> (Subst, Var)
cloneRecIdBndrs :: Subst -> UniqSupply -> [Id] -> (Subst, [Id])
substIdType :: Subst -> Id -> Id
substIdInfo :: Subst -> Id -> IdInfo -> Maybe IdInfo
substUnfoldingSC :: Subst -> Unfolding -> Unfolding
substUnfolding :: Subst -> Unfolding -> Unfolding
substIdOcc :: Subst -> Id -> Id
substRuleInfo :: Subst -> Id -> RuleInfo -> RuleInfo
substRulesForImportedIds :: Subst -> [CoreRule] -> [CoreRule]
substDVarSet :: HasDebugCallStack => Subst -> DVarSet -> DVarSet
substTickish :: Subst -> CoreTickish -> CoreTickish
sortQuantVars :: [Var] -> [Var]
mkCoreApp :: SDoc -> CoreExpr -> CoreExpr -> CoreExpr
mkWildEvBinder :: PredType -> EvVar
mkWildValBinder :: Mult -> Type -> Id
mkWildCase :: CoreExpr -> Scaled Type -> Type -> [CoreAlt] -> CoreExpr
mkIfThenElse :: CoreExpr -> CoreExpr -> CoreExpr -> CoreExpr
castBottomExpr :: CoreExpr -> Type -> CoreExpr
mkLitRubbish :: Type -> Maybe CoreExpr
mkUncheckedIntExpr :: Integer -> CoreExpr
mkIntExprInt :: Platform -> Int -> CoreExpr
mkIntegerExpr :: Platform -> Integer -> CoreExpr
mkNaturalExpr :: Platform -> Integer -> CoreExpr
mkStringExprFS :: MonadThings m => FastString -> m CoreExpr
getMkStringIds :: Applicative m => (Name -> m Id) -> m MkStringIds
mkStringExprFSWith :: MkStringIds -> FastString -> CoreExpr
mkCoreUnboxedTuple :: [CoreExpr] -> CoreExpr
mkCoreTupBoxity :: Boxity -> [CoreExpr] -> CoreExpr
mkCoreVarTupTy :: [Id] -> Type
mkCoreTup :: [CoreExpr] -> CoreExpr
mkCoreUnboxedSum :: Int -> Int -> [Type] -> CoreExpr -> CoreExpr
mkBigCoreVarTupSolo :: [Id] -> CoreExpr
mkBigCoreVarTup :: [Id] -> CoreExpr
mkBigCoreTup :: [CoreExpr] -> CoreExpr
mkBigCoreVarTupTy :: [Id] -> Type
mkBigCoreTupTy :: [Type] -> Type
unitExpr :: CoreExpr
mkChunkified :: ([a] -> a) -> [a] -> a
chunkify :: [a] -> [[a]]
mkBigTupleSelector :: [Id] -> Id -> Id -> CoreExpr -> CoreExpr
mkBigTupleSelectorSolo :: [Id] -> Id -> Id -> CoreExpr -> CoreExpr
mkBigTupleCase :: UniqSupply -> [Id] -> CoreExpr -> CoreExpr -> CoreExpr
wrapFloat :: FloatBind -> CoreExpr -> CoreExpr
wrapFloats :: [FloatBind] -> CoreExpr -> CoreExpr
floatBindings :: FloatBind -> [Var]
mkNilExpr :: Type -> CoreExpr
mkConsExpr :: Type -> CoreExpr -> CoreExpr -> CoreExpr
mkListExpr :: Type -> [CoreExpr] -> CoreExpr
mkFoldrExpr :: MonadThings m => Type -> Type -> CoreExpr -> CoreExpr -> CoreExpr -> m CoreExpr
mkBuildExpr :: (MonadFail m, MonadThings m, MonadUnique m) => Type -> ((Id, Type) -> (Id, Type) -> m CoreExpr) -> m CoreExpr
mkNothingExpr :: Type -> CoreExpr
mkJustExpr :: Type -> CoreExpr -> CoreExpr
mkRuntimeErrorApp :: Id -> Type -> String -> CoreExpr
errorIds :: [Id]
rEC_SEL_ERROR_ID :: Id
rEC_CON_ERROR_ID :: Id
pAT_ERROR_ID :: Id
nO_METHOD_BINDING_ERROR_ID :: Id
nON_EXHAUSTIVE_GUARDS_ERROR_ID :: Id
tYPE_ERROR_ID :: Id
aBSENT_SUM_FIELD_ERROR_ID :: Id
mkImpossibleExpr :: Type -> String -> CoreExpr
mkAbsentErrorApp :: Type -> String -> CoreExpr
addGlobalInclude :: IncludeSpecs -> [String] -> IncludeSpecs
addQuoteInclude :: IncludeSpecs -> [String] -> IncludeSpecs
addImplicitQuoteInclude :: IncludeSpecs -> [String] -> IncludeSpecs
flattenIncludes :: IncludeSpecs -> [String]
settings :: DynFlags -> Settings
programName :: DynFlags -> String
projectVersion :: DynFlags -> String
ghcUsagePath :: DynFlags -> FilePath
ghciUsagePath :: DynFlags -> FilePath
topDir :: DynFlags -> FilePath
extraGccViaCFlags :: DynFlags -> [String]
globalPackageDatabasePath :: DynFlags -> FilePath
pgm_L :: DynFlags -> String
pgm_P :: DynFlags -> (String, [Option])
pgm_F :: DynFlags -> String
pgm_c :: DynFlags -> String
pgm_cxx :: DynFlags -> String
pgm_a :: DynFlags -> (String, [Option])
pgm_l :: DynFlags -> (String, [Option])
pgm_lm :: DynFlags -> Maybe (String, [Option])
pgm_dll :: DynFlags -> (String, [Option])
pgm_T :: DynFlags -> String
pgm_windres :: DynFlags -> String
pgm_lcc :: DynFlags -> (String, [Option])
pgm_ar :: DynFlags -> String
pgm_ranlib :: DynFlags -> String
pgm_lo :: DynFlags -> (String, [Option])
pgm_lc :: DynFlags -> (String, [Option])
pgm_i :: DynFlags -> String
opt_L :: DynFlags -> [String]
opt_P :: DynFlags -> [String]
opt_P_signature :: DynFlags -> ([String], Fingerprint)
opt_F :: DynFlags -> [String]
opt_c :: DynFlags -> [String]
opt_cxx :: DynFlags -> [String]
opt_a :: DynFlags -> [String]
opt_l :: DynFlags -> [String]
opt_lm :: DynFlags -> [String]
opt_windres :: DynFlags -> [String]
opt_lcc :: DynFlags -> [String]
opt_lo :: DynFlags -> [String]
opt_lc :: DynFlags -> [String]
opt_i :: DynFlags -> [String]
versionedAppDir :: String -> ArchOS -> MaybeT IO FilePath
versionedFilePath :: ArchOS -> FilePath
isOneShot :: GhcMode -> Bool
isNoLink :: GhcLink -> Bool
packageFlagsChanged :: DynFlags -> DynFlags -> Bool
positionIndependent :: DynFlags -> Bool
dynamicTooState :: DynFlags -> DynamicTooState
setDynamicNow :: DynFlags -> DynFlags
initDynFlags :: DynFlags -> IO DynFlags
defaultDynFlags :: Settings -> DynFlags
defaultFatalMessager :: FatalMessager
defaultFlushOut :: FlushOut
languageExtensions :: Maybe Language -> [Extension]
hasPprDebug :: DynFlags -> Bool
hasNoDebugOutput :: DynFlags -> Bool
hasNoStateHack :: DynFlags -> Bool
hasNoOptCoercion :: DynFlags -> Bool
dopt :: DumpFlag -> DynFlags -> Bool
dopt_set :: DynFlags -> DumpFlag -> DynFlags
dopt_unset :: DynFlags -> DumpFlag -> DynFlags
gopt :: GeneralFlag -> DynFlags -> Bool
gopt_set :: DynFlags -> GeneralFlag -> DynFlags
gopt_unset :: DynFlags -> GeneralFlag -> DynFlags
wopt :: WarningFlag -> DynFlags -> Bool
wopt_set :: DynFlags -> WarningFlag -> DynFlags
wopt_unset :: DynFlags -> WarningFlag -> DynFlags
wopt_fatal :: WarningFlag -> DynFlags -> Bool
wopt_set_fatal :: DynFlags -> WarningFlag -> DynFlags
wopt_unset_fatal :: DynFlags -> WarningFlag -> DynFlags
xopt :: Extension -> DynFlags -> Bool
xopt_set :: DynFlags -> Extension -> DynFlags
xopt_unset :: DynFlags -> Extension -> DynFlags
xopt_set_unlessExplSpec :: Extension -> (DynFlags -> Extension -> DynFlags) -> DynFlags -> DynFlags
xopt_DuplicateRecordFields :: DynFlags -> DuplicateRecordFields
xopt_FieldSelectors :: DynFlags -> FieldSelectors
lang_set :: DynFlags -> Maybe Language -> DynFlags
packageTrustOn :: DynFlags -> Bool
safeHaskellOn :: DynFlags -> Bool
safeHaskellModeEnabled :: DynFlags -> Bool
safeLanguageOn :: DynFlags -> Bool
safeInferOn :: DynFlags -> Bool
safeImportsOn :: DynFlags -> Bool
safeDirectImpsReq :: DynFlags -> Bool
safeImplicitImpsReq :: DynFlags -> Bool
unsafeFlags :: [(String, DynFlags -> SrcSpan, DynFlags -> Bool, DynFlags -> DynFlags)]
unsafeFlagsForInfer :: [(String, DynFlags -> SrcSpan, DynFlags -> Bool, DynFlags -> DynFlags)]
getOpts :: DynFlags -> (DynFlags -> [a]) -> [a]
getVerbFlags :: DynFlags -> [String]
setOutputFile :: Maybe String -> DynFlags -> DynFlags
setDynOutputFile :: Maybe String -> DynFlags -> DynFlags
setOutputHi :: Maybe String -> DynFlags -> DynFlags
setDynOutputHi :: Maybe String -> DynFlags -> DynFlags
addPluginModuleName :: String -> DynFlags -> DynFlags
updOptLevel :: Int -> DynFlags -> DynFlags
parseDynamicFlagsCmdLine :: MonadIO m => DynFlags -> [Located String] -> m (DynFlags, [Located String], [Warn])
parseDynamicFilePragma :: MonadIO m => DynFlags -> [Located String] -> m (DynFlags, [Located String], [Warn])
getCmdLineState :: CmdLineP s s
putCmdLineState :: s -> CmdLineP s ()
runCmdLineP :: CmdLineP s a -> s -> (a, s)
processCmdLineP :: forall s m. MonadIO m => [Flag (CmdLineP s)] -> s -> [Located String] -> m (([Located String], [Err], [Warn]), s)
parseDynamicFlagsFull :: MonadIO m => [Flag (CmdLineP DynFlags)] -> Bool -> DynFlags -> [Located String] -> m (DynFlags, [Located String], [Warn])
allNonDeprecatedFlags :: [String]
flagsAll :: [Flag (CmdLineP DynFlags)]
flagsDynamic :: [Flag (CmdLineP DynFlags)]
flagsPackage :: [Flag (CmdLineP DynFlags)]
flagsForCompletion :: Bool -> [String]
turnOn :: TurnOnFlag
turnOff :: TurnOnFlag
flagSpecOf :: WarningFlag -> Maybe (FlagSpec WarningFlag)
wWarningFlags :: [FlagSpec WarningFlag]
fFlags :: [FlagSpec GeneralFlag]
fLangFlags :: [FlagSpec Extension]
supportedLanguagesAndExtensions :: ArchOS -> [String]
xFlags :: [FlagSpec Extension]
impliedGFlags :: [(GeneralFlag, TurnOnFlag, GeneralFlag)]
impliedOffGFlags :: [(GeneralFlag, TurnOnFlag, GeneralFlag)]
impliedXFlags :: [(Extension, TurnOnFlag, Extension)]
glasgowExtsFlags :: [Extension]
setGeneralFlag' :: GeneralFlag -> DynFlags -> DynFlags
unSetGeneralFlag' :: GeneralFlag -> DynFlags -> DynFlags
setUnitId :: String -> DynFlags -> DynFlags
augmentByWorkingDirectory :: DynFlags -> FilePath -> FilePath
setFlagsFromEnvFile :: FilePath -> String -> DynP ()
setTmpDir :: FilePath -> DynFlags -> DynFlags
picCCOpts :: DynFlags -> [String]
pieCCLDOpts :: DynFlags -> [String]
picPOpts :: DynFlags -> [String]
compilerInfo :: DynFlags -> [(String, String)]
targetProfile :: DynFlags -> Profile
makeDynFlagsConsistent :: DynFlags -> (DynFlags, [Located String])
setUnsafeGlobalDynFlags :: DynFlags -> IO ()
isSse4_2Enabled :: DynFlags -> Bool
isAvxEnabled :: DynFlags -> Bool
isAvx2Enabled :: DynFlags -> Bool
isAvx512cdEnabled :: DynFlags -> Bool
isAvx512erEnabled :: DynFlags -> Bool
isAvx512fEnabled :: DynFlags -> Bool
isAvx512pfEnabled :: DynFlags -> Bool
isBmiEnabled :: DynFlags -> Bool
isBmi2Enabled :: DynFlags -> Bool
sccProfilingEnabled :: DynFlags -> Bool
needSourceNotes :: DynFlags -> Bool
useXLinkerRPath :: DynFlags -> OS -> Bool
initSDocContext :: DynFlags -> PprStyle -> SDocContext
initDefaultSDocContext :: DynFlags -> SDocContext
initPromotionTickContext :: DynFlags -> PromotionTickContext
outputFile :: DynFlags -> Maybe String
objectSuf :: DynFlags -> String
ways :: DynFlags -> Ways
pprDynFlagsDiff :: DynFlags -> DynFlags -> SDoc
updatePlatformConstants :: DynFlags -> Maybe PlatformConstants -> IO DynFlags
emptyUnitState :: UnitState
lookupUnit :: UnitState -> Unit -> Maybe UnitInfo
lookupUnit' :: Bool -> UnitInfoMap -> PreloadUnitClosure -> Unit -> Maybe UnitInfo
lookupUnitId :: UnitState -> UnitId -> Maybe UnitInfo
lookupUnitId' :: UnitInfoMap -> UnitId -> Maybe UnitInfo
unsafeLookupUnit :: HasDebugCallStack => UnitState -> Unit -> UnitInfo
unsafeLookupUnitId :: HasDebugCallStack => UnitState -> UnitId -> UnitInfo
lookupPackageName :: UnitState -> PackageName -> Maybe UnitId
searchPackageId :: UnitState -> PackageId -> [UnitInfo]
resolvePackageImport :: UnitState -> ModuleName -> PackageName -> Maybe UnitId
listUnitInfo :: UnitState -> [UnitInfo]
initUnits :: Logger -> DynFlags -> Maybe [UnitDatabase UnitId] -> Set UnitId -> IO ([UnitDatabase UnitId], UnitState, HomeUnit, Maybe PlatformConstants)
readUnitDatabases :: Logger -> UnitConfig -> IO [UnitDatabase UnitId]
getUnitDbRefs :: UnitConfig -> IO [PkgDbRef]
resolveUnitDatabase :: UnitConfig -> PkgDbRef -> IO (Maybe FilePath)
readUnitDatabase :: Logger -> UnitConfig -> FilePath -> IO (UnitDatabase UnitId)
pprFlag :: PackageFlag -> SDoc
pprReason :: SDoc -> UnusableUnitReason -> SDoc
unwireUnit :: UnitState -> Unit -> Unit
lookupModuleInAllUnits :: UnitState -> ModuleName -> [(Module, UnitInfo)]
lookupModuleWithSuggestions :: UnitState -> ModuleName -> PkgQual -> LookupResult
lookupModulePackage :: UnitState -> ModuleName -> PkgQual -> Maybe [UnitInfo]
lookupPluginModuleWithSuggestions :: UnitState -> ModuleName -> PkgQual -> LookupResult
listVisibleModuleNames :: UnitState -> [ModuleName]
closeUnitDeps :: UnitInfoMap -> [(UnitId, Maybe UnitId)] -> MaybeErr UnitErr [UnitId]
closeUnitDeps' :: UnitInfoMap -> [UnitId] -> [(UnitId, Maybe UnitId)] -> MaybeErr UnitErr [UnitId]
mayThrowUnitErr :: MaybeErr UnitErr a -> IO a
requirementMerges :: UnitState -> ModuleName -> [InstantiatedModule]
pprUnitIdForUser :: UnitState -> UnitId -> SDoc
pprUnitInfoForUser :: UnitInfo -> SDoc
pprUnits :: UnitState -> SDoc
pprUnitsSimple :: UnitState -> SDoc
pprModuleMap :: ModuleNameProvidersMap -> SDoc
improveUnit :: UnitState -> Unit -> Unit
instUnitToUnit :: UnitState -> InstantiatedUnit -> Unit
renameHoleModule :: UnitState -> ShHoleSubst -> Module -> Module
renameHoleUnit :: UnitState -> ShHoleSubst -> Unit -> Unit
renameHoleModule' :: UnitInfoMap -> PreloadUnitClosure -> ShHoleSubst -> Module -> Module
renameHoleUnit' :: UnitInfoMap -> PreloadUnitClosure -> ShHoleSubst -> Unit -> Unit
instModuleToModule :: UnitState -> InstantiatedModule -> Module
implicitPackageDeps :: DynFlags -> [UnitId]
showSDoc :: DynFlags -> SDoc -> String
showPpr :: Outputable a => DynFlags -> a -> String
showSDocForUser :: DynFlags -> UnitState -> NamePprCtx -> SDoc -> String
printForUser :: DynFlags -> Handle -> NamePprCtx -> Depth -> SDoc -> IO ()
mg_mnwib :: ModGuts -> ModuleNameWithIsBoot
mkRule :: Module -> Bool -> Bool -> RuleName -> Activation -> Name -> [CoreBndr] -> [CoreExpr] -> CoreExpr -> CoreRule
mkSpecRule :: DynFlags -> Module -> Bool -> Activation -> SDoc -> Id -> [CoreBndr] -> [CoreExpr] -> CoreExpr -> CoreRule
roughTopNames :: [CoreExpr] -> [Maybe Name]
pprRulesForUser :: [CoreRule] -> SDoc
extendRuleInfo :: RuleInfo -> [CoreRule] -> RuleInfo
addRuleInfo :: RuleInfo -> RuleInfo -> RuleInfo
addIdSpecialisations :: Id -> [CoreRule] -> Id
addRulesToId :: RuleBase -> Id -> Id
rulesOfBinds :: [CoreBind] -> [CoreRule]
emptyRuleBase :: RuleBase
mkRuleBase :: [CoreRule] -> RuleBase
extendRuleBaseList :: RuleBase -> [CoreRule] -> RuleBase
pprRuleBase :: RuleBase -> SDoc
mkRuleEnv :: ModGuts -> RuleBase -> RuleBase -> RuleEnv
updExternalPackageRules :: RuleEnv -> RuleBase -> RuleEnv
updLocalRules :: RuleEnv -> [CoreRule] -> RuleEnv
addLocalRules :: RuleEnv -> [CoreRule] -> RuleEnv
emptyRuleEnv :: RuleEnv
getRules :: RuleEnv -> Id -> [CoreRule]
lookupRule :: RuleOpts -> InScopeEnv -> (Activation -> Bool) -> Id -> [CoreExpr] -> [CoreRule] -> Maybe (CoreRule, CoreExpr)
ruleCheckProgram :: RuleOpts -> CompilerPhase -> String -> (Id -> [CoreRule]) -> CoreProgram -> SDoc
mi_boot :: ModIface -> IsBootInterface
mi_mnwib :: ModIface -> ModuleNameWithIsBoot
mi_fix :: ModIface -> OccName -> Fixity
mi_semantic_module :: forall (a :: ModIfacePhase). ModIface_ a -> Module
mi_free_holes :: ModIface -> UniqDSet ModuleName
renameFreeHoles :: UniqDSet ModuleName -> [(ModuleName, Module)] -> UniqDSet ModuleName
emptyPartialModIface :: Module -> PartialModIface
emptyFullModIface :: Module -> ModIface
mkIfaceHashCache :: [(Fingerprint, IfaceDecl)] -> OccName -> Maybe (OccName, Fingerprint)
emptyIfaceHashCache :: OccName -> Maybe (OccName, Fingerprint)
forceModIface :: ModIface -> IO ()
ms_unitid :: ModSummary -> UnitId
ms_installed_mod :: ModSummary -> InstalledModule
ms_mod_name :: ModSummary -> ModuleName
ms_imps :: ModSummary -> [(PkgQual, Located ModuleName)]
ms_plugin_imps :: ModSummary -> [(PkgQual, Located ModuleName)]
ms_home_srcimps :: ModSummary -> [Located ModuleName]
ms_home_imps :: ModSummary -> [(PkgQual, Located ModuleName)]
msHsFilePath :: ModSummary -> FilePath
msHiFilePath :: ModSummary -> FilePath
msDynHiFilePath :: ModSummary -> FilePath
msObjFilePath :: ModSummary -> FilePath
msDynObjFilePath :: ModSummary -> FilePath
isBootSummary :: ModSummary -> IsBootInterface
ms_mnwib :: ModSummary -> ModuleNameWithIsBoot
msDeps :: ModSummary -> [(PkgQual, GenWithIsBoot (Located ModuleName))]
findTarget :: ModSummary -> [Target] -> Maybe Target
noParseContext :: ParseContext
incompleteDoBlock :: ParseContext
fromParseContext :: ParseContext -> PsErrInPatDetails
mkSrcErr :: Messages GhcMessage -> SourceError
srcErrorMessages :: SourceError -> Messages GhcMessage
throwErrors :: MonadIO io => Messages GhcMessage -> io a
throwOneError :: MonadIO io => MsgEnvelope GhcMessage -> io a
handleSourceError :: MonadCatch m => (SourceError -> m a) -> m a -> m a
runHsc :: HscEnv -> Hsc a -> IO a
runHsc' :: HscEnv -> Hsc a -> IO (a, Messages GhcMessage)
mkInteractiveHscEnv :: HscEnv -> HscEnv
runInteractiveHsc :: HscEnv -> Hsc a -> IO a
hsc_home_unit :: HscEnv -> HomeUnit
hsc_home_unit_maybe :: HscEnv -> Maybe HomeUnit
hsc_units :: HasDebugCallStack => HscEnv -> UnitState
hsc_HPT :: HscEnv -> HomePackageTable
hsc_HUE :: HscEnv -> HomeUnitEnv
hsc_HUG :: HscEnv -> HomeUnitGraph
hsc_all_home_unit_ids :: HscEnv -> Set UnitId
hscUpdateHPT_lazy :: (HomePackageTable -> HomePackageTable) -> HscEnv -> HscEnv
hscUpdateHPT :: (HomePackageTable -> HomePackageTable) -> HscEnv -> HscEnv
hscUpdateHUG :: (HomeUnitGraph -> HomeUnitGraph) -> HscEnv -> HscEnv
hscEPS :: HscEnv -> IO ExternalPackageState
hptCompleteSigs :: HscEnv -> [CompleteMatch]
hptAllInstances :: HscEnv -> (InstEnv, [FamInst])
hptInstancesBelow :: HscEnv -> UnitId -> ModuleNameWithIsBoot -> (InstEnv, [FamInst])
hptRules :: HscEnv -> UnitId -> ModuleNameWithIsBoot -> [CoreRule]
hptAnns :: HscEnv -> Maybe (UnitId, ModuleNameWithIsBoot) -> [Annotation]
hptAllThings :: (HomeModInfo -> [a]) -> HscEnv -> [a]
hptSomeThingsBelowUs :: (HomeModInfo -> [a]) -> Bool -> HscEnv -> UnitId -> ModuleNameWithIsBoot -> [a]
prepareAnnotations :: HscEnv -> Maybe ModGuts -> IO AnnEnv
lookupType :: HscEnv -> Name -> IO (Maybe TyThing)
lookupIfaceByModule :: HomeUnitGraph -> PackageIfaceTable -> Module -> Maybe ModIface
mainModIs :: HomeUnitEnv -> Module
hscInterp :: HscEnv -> Interp
hscUpdateLoggerFlags :: HscEnv -> HscEnv
hscUpdateFlags :: (DynFlags -> DynFlags) -> HscEnv -> HscEnv
hscSetFlags :: HasDebugCallStack => DynFlags -> HscEnv -> HscEnv
hscSetActiveHomeUnit :: HasDebugCallStack => HomeUnit -> HscEnv -> HscEnv
hscSetActiveUnitId :: HasDebugCallStack => UnitId -> HscEnv -> HscEnv
hscActiveUnitId :: HscEnv -> UnitId
discardIC :: HscEnv -> HscEnv
runCoreM :: HscEnv -> RuleBase -> Char -> Module -> NamePprCtx -> SrcSpan -> CoreM a -> IO (a, SimplCount)
liftIOWithCount :: IO (SimplCount, a) -> CoreM a
getHscEnv :: Hsc HscEnv
initRuleEnv :: ModGuts -> CoreM RuleEnv
getExternalRuleBase :: CoreM RuleBase
getNamePprCtx :: CoreM NamePprCtx
getSrcSpanM :: CoreM SrcSpan
addSimplCount :: SimplCount -> CoreM ()
getUniqMask :: CoreM Char
mapDynFlagsCoreM :: (DynFlags -> DynFlags) -> CoreM a -> CoreM a
dropSimplCount :: CoreM a -> CoreM a
getInteractiveContext :: CoreM InteractiveContext
getPackageFamInstEnv :: CoreM PackageFamInstEnv
getAnnotations :: Typeable a => ([Word8] -> a) -> ModGuts -> CoreM (ModuleEnv [a], NameEnv [a])
getFirstAnnotations :: Typeable a => ([Word8] -> a) -> ModGuts -> CoreM (ModuleEnv a, NameEnv a)
msg :: MessageClass -> SDoc -> CoreM ()
putMsgS :: String -> CoreM ()
fatalErrorMsgS :: String -> CoreM ()
debugTraceMsgS :: String -> CoreM ()
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
bindsOnlyPass :: (CoreProgram -> CoreM CoreProgram) -> ModGuts -> CoreM ModGuts
pprPassDetails :: CoreToDo -> SDoc
pprHoleFitCand :: HoleFitCandidate -> SDoc
hfIsLcl :: HoleFit -> Bool
lpModuleName :: LoadedPlugin -> ModuleName
pluginRecompile' :: PluginWithArgs -> IO PluginRecompile
purePlugin :: [CommandLineOption] -> IO PluginRecompile
impurePlugin :: [CommandLineOption] -> IO PluginRecompile
flagRecompile :: [CommandLineOption] -> IO PluginRecompile
defaultPlugin :: Plugin
keepRenamedSource :: [CommandLineOption] -> TcGblEnv -> HsGroup GhcRn -> TcM (TcGblEnv, HsGroup GhcRn)
pluginsWithArgs :: Plugins -> [PluginWithArgs]
withPlugins :: Monad m => Plugins -> PluginOperation m a -> a -> m a
mapPlugins :: Plugins -> (Plugin -> [CommandLineOption] -> a) -> [a]
withPlugins_ :: Monad m => Plugins -> ConstPluginOperation m a -> a -> m ()
defaultFrontendPlugin :: FrontendPlugin
loadExternalPlugins :: [ExternalPluginSpec] -> IO [ExternalPlugin]
initFinderCache :: IO FinderCache
flushFinderCaches :: FinderCache -> UnitEnv -> IO ()
lookupFileCache :: FinderCache -> FilePath -> IO Fingerprint
findImportedModule :: HscEnv -> ModuleName -> PkgQual -> IO FindResult
findPluginModule :: FinderCache -> FinderOpts -> UnitState -> Maybe HomeUnit -> ModuleName -> IO FindResult
findExactModule :: FinderCache -> FinderOpts -> UnitEnvGraph FinderOpts -> UnitState -> Maybe HomeUnit -> InstalledModule -> IO InstalledFindResult
findExposedPackageModule :: FinderCache -> FinderOpts -> UnitState -> ModuleName -> PkgQual -> IO FindResult
addModuleToFinder :: FinderCache -> Module -> ModLocation -> IO ()
addHomeModuleToFinder :: FinderCache -> HomeUnit -> ModuleName -> ModLocation -> IO Module
uncacheModule :: FinderCache -> HomeUnit -> ModuleName -> IO ()
findHomeModule :: FinderCache -> FinderOpts -> HomeUnit -> ModuleName -> IO FindResult
mkHomeModLocation :: FinderOpts -> ModuleName -> FilePath -> ModLocation
mkHomeModLocation2 :: FinderOpts -> ModuleName -> FilePath -> String -> ModLocation
mkHiOnlyModLocation :: FinderOpts -> Suffix -> Suffix -> FilePath -> String -> ModLocation
mkObjPath :: FinderOpts -> FilePath -> String -> FilePath
mkHiPath :: FinderOpts -> FilePath -> String -> FilePath
mkStubPaths :: FinderOpts -> ModuleName -> ModLocation -> FilePath
findObjectLinkableMaybe :: Module -> ModLocation -> IO (Maybe Linkable)
findObjectLinkable :: Module -> FilePath -> UTCTime -> IO Linkable
newGlobalBinder :: Module -> OccName -> SrcSpan -> TcRnIf a b Name
newInteractiveBinder :: HscEnv -> OccName -> SrcSpan -> IO Name
allocateGlobalBinder :: NameCache -> Module -> OccName -> SrcSpan -> IO Name
ifaceExportNames :: [IfaceExport] -> TcRnIf gbl lcl [AvailInfo]
lookupOrig :: Module -> OccName -> TcRnIf a b Name
lookupNameCache :: NameCache -> Module -> OccName -> IO Name
externaliseName :: Module -> Name -> TcRnIf m n Name
setNameModule :: Maybe Module -> Name -> TcRnIf m n Name
tcIfaceLclId :: FastString -> IfL Id
extendIfaceIdEnv :: [Id] -> IfL a -> IfL a
tcIfaceTyVar :: FastString -> IfL TyVar
lookupIfaceTyVar :: IfaceTvBndr -> IfL (Maybe TyVar)
lookupIfaceVar :: IfaceBndr -> IfL (Maybe TyCoVar)
extendIfaceTyVarEnv :: [TyVar] -> IfL a -> IfL a
extendIfaceEnvs :: [TyCoVar] -> IfL a -> IfL a
lookupIfaceTop :: OccName -> IfL Name
newIfaceName :: OccName -> IfL Name
newIfaceNames :: [OccName] -> IfL [Name]
trace_if :: Logger -> SDoc -> IO ()
trace_hi_diffs :: Logger -> SDoc -> IO ()
thNameToGhcName :: Name -> CoreM (Maybe Name)
thNameToGhcNameIO :: NameCache -> Name -> IO (Maybe Name)
newHscEnv :: FilePath -> DynFlags -> IO HscEnv
newHscEnvWithHUG :: FilePath -> DynFlags -> UnitId -> HomeUnitGraph -> IO HscEnv
initHscEnv :: Maybe FilePath -> IO HscEnv
ioMsgMaybe :: IO (Messages GhcMessage, Maybe a) -> Hsc a
hscTcRnLookupRdrName :: HscEnv -> LocatedN RdrName -> IO (NonEmpty Name)
hscTcRcLookupName :: HscEnv -> Name -> IO (Maybe TyThing)
hscTcRnGetInfo :: HscEnv -> Name -> IO (Maybe (TyThing, Fixity, [ClsInst], [FamInst], SDoc))
hscIsGHCiMonad :: HscEnv -> String -> IO Name
hscGetModuleInterface :: HscEnv -> Module -> IO ModIface
hscRnImportDecls :: HscEnv -> [LImportDecl GhcPs] -> IO GlobalRdrEnv
hscParse :: HscEnv -> ModSummary -> IO HsParsedModule
hscParse' :: ModSummary -> Hsc HsParsedModule
hscTypecheckRename :: HscEnv -> ModSummary -> HsParsedModule -> IO (TcGblEnv, RenamedStuff)
hscTypecheckAndGetWarnings :: HscEnv -> ModSummary -> IO (FrontendResult, WarningMessages)
tcRnModule' :: ModSummary -> Bool -> HsParsedModule -> Hsc TcGblEnv
hscDesugar :: HscEnv -> ModSummary -> TcGblEnv -> IO ModGuts
hscDesugar' :: ModLocation -> TcGblEnv -> Hsc ModGuts
makeSimpleDetails :: Logger -> TcGblEnv -> IO ModDetails
hscRecompStatus :: Maybe Messager -> HscEnv -> ModSummary -> Maybe ModIface -> HomeModLinkable -> (Int, Int) -> IO HscRecompStatus
initModDetails :: HscEnv -> ModIface -> IO ModDetails
initWholeCoreBindings :: HscEnv -> ModIface -> ModDetails -> Linkable -> IO Linkable
hscDesugarAndSimplify :: ModSummary -> FrontendResult -> Messages GhcMessage -> Maybe Fingerprint -> Hsc HscBackendAction
hscMaybeWriteIface :: Logger -> DynFlags -> Bool -> ModIface -> Maybe Fingerprint -> ModLocation -> IO ()
oneShotMsg :: Logger -> RecompileRequired -> IO ()
batchMsg :: Messager
batchMultiMsg :: Messager
hscCheckSafe :: HscEnv -> Module -> SrcSpan -> IO Bool
hscGetSafe :: HscEnv -> Module -> SrcSpan -> IO (Bool, Set UnitId)
hscSimplify :: HscEnv -> [String] -> ModGuts -> IO ModGuts
hscSimplify' :: [String] -> ModGuts -> Hsc ModGuts
hscSimpleIface' :: Maybe CoreProgram -> TcGblEnv -> ModSummary -> Hsc (ModIface, ModDetails)
hscGenHardCode :: HscEnv -> CgGuts -> ModLocation -> FilePath -> IO (FilePath, Maybe FilePath, [(ForeignSrcLang, FilePath)], Maybe StgCgInfos, Maybe CmmCgInfos)
mkCgInteractiveGuts :: CgGuts -> CgInteractiveGuts
hscInteractive :: HscEnv -> CgInteractiveGuts -> ModLocation -> IO (Maybe FilePath, CompiledByteCode, [SptEntry])
generateByteCode :: HscEnv -> CgInteractiveGuts -> ModLocation -> IO [Unlinked]
generateFreshByteCode :: HscEnv -> ModuleName -> CgInteractiveGuts -> ModLocation -> IO Linkable
hscCompileCmmFile :: HscEnv -> FilePath -> FilePath -> FilePath -> IO (Maybe FilePath)
doCodeGen :: HscEnv -> Module -> InfoTableProvMap -> [TyCon] -> CollectedCCs -> [CgStgTopBinding] -> HpcInfo -> IO (Stream IO CmmGroupSRTs CmmCgInfos)
hscStmt :: HscEnv -> String -> IO (Maybe ([Id], ForeignHValue, FixityEnv))
hscStmtWithLocation :: HscEnv -> String -> String -> Int -> IO (Maybe ([Id], ForeignHValue, FixityEnv))
hscParsedStmt :: HscEnv -> GhciLStmt GhcPs -> IO (Maybe ([Id], ForeignHValue, FixityEnv))
hscDecls :: HscEnv -> String -> IO ([TyThing], InteractiveContext)
hscParseModuleWithLocation :: HscEnv -> String -> Int -> String -> IO (HsModule GhcPs)
hscParseDeclsWithLocation :: HscEnv -> String -> Int -> String -> IO [LHsDecl GhcPs]
hscDeclsWithLocation :: HscEnv -> String -> String -> Int -> IO ([TyThing], InteractiveContext)
hscParsedDecls :: HscEnv -> [LHsDecl GhcPs] -> IO ([TyThing], InteractiveContext)
hscAddSptEntries :: HscEnv -> [SptEntry] -> IO ()
hscImport :: HscEnv -> String -> IO (ImportDecl GhcPs)
hscTcExpr :: HscEnv -> TcRnExprMode -> String -> IO Type
hscKcType :: HscEnv -> Bool -> String -> IO (Type, Kind)
hscParseExpr :: String -> Hsc (LHsExpr GhcPs)
hscParseStmtWithLocation :: String -> Int -> String -> Hsc (Maybe (GhciLStmt GhcPs))
hscParseType :: String -> Hsc (LHsType GhcPs)
hscParseIdentifier :: HscEnv -> String -> IO (LocatedN RdrName)
hscTidy :: HscEnv -> ModGuts -> IO (CgGuts, ModDetails)
hscCompileCoreExpr :: HscEnv -> SrcSpan -> CoreExpr -> IO (ForeignHValue, [Linkable], PkgsLoaded)
hscCompileCoreExpr' :: HscEnv -> SrcSpan -> CoreExpr -> IO (ForeignHValue, [Linkable], PkgsLoaded)
dumpIfaceStats :: HscEnv -> IO ()
showModuleIndex :: (Int, Int) -> SDoc
writeInterfaceOnlyMode :: DynFlags -> Bool
toSerialized :: Typeable a => (a -> [Word8]) -> a -> Serialized
fromSerialized :: Typeable a => ([Word8] -> a) -> Serialized -> Maybe a
serializeWithData :: Data a => a -> [Word8]
deserializeWithData :: Data a => [Word8] -> a
mkParseError :: String -> MsgEnvelope PsMessage

Documentation

data Levity #

Constructors

Lifted
Unlifted

Instances

Instances details

Outputable Levity
Instance details Defined in GHC.Types.Basic Methods ppr :: Levity -> SDoc #
Eq Levity
Instance details Defined in GHC.Types.Basic Methods (==) :: Levity -> Levity -> Bool # (/=) :: Levity -> Levity -> Bool #

data TyCon #

TyCons represent type constructors. Type constructors are introduced by things such as:

1) Data declarations: data Foo = ... creates the Foo type constructor of kind *

2) Type synonyms: type Foo = ... creates the Foo type constructor

3) Newtypes: newtype Foo a = MkFoo ... creates the Foo type constructor of kind * -> *

4) Class declarations: class Foo where creates the Foo type constructor of kind *

This data type also encodes a number of primitive, built in type constructors such as those for function and tuple types.

If you edit this type, you may need to update the GHC formalism See Note [GHC Formalism] in GHC.Core.Lint

Instances

Instances details

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

type Module = GenModule Unit #

A Module is a pair of a Unit and a ModuleName.

data Type #

Instances

Instances details

Data Type
Instance details 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 # toConstr :: Type -> Constr # dataTypeOf :: Type -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Type) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type) # gmapT :: (forall b. Data b => b -> b) -> Type -> Type # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r # gmapQr :: 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 #
Outputable Type
Instance details Defined in GHC.Core.TyCo.Rep Methods ppr :: Type -> SDoc #
Eq (DeBruijn Type)
Instance details Defined in GHC.Core.Map.Type Methods (==) :: DeBruijn Type -> DeBruijn Type -> Bool # (/=) :: DeBruijn Type -> DeBruijn Type -> Bool #

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 MyException

The 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 = frontendExceptionFromException

We 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

Instances details

Exception AsyncCancelled
Instance details Defined in Control.Concurrent.Async.Internal Methods toException :: AsyncCancelled -> SomeException # fromException :: SomeException -> Maybe AsyncCancelled # displayException :: AsyncCancelled -> String #
Exception ExceptionInLinkedThread
Instance details Defined in Control.Concurrent.Async.Internal Methods toException :: ExceptionInLinkedThread -> SomeException # fromException :: SomeException -> Maybe ExceptionInLinkedThread # displayException :: ExceptionInLinkedThread -> String #
Exception NestedAtomically	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: NestedAtomically -> SomeException # fromException :: SomeException -> Maybe NestedAtomically # displayException :: NestedAtomically -> String #
Exception NoMatchingContinuationPrompt	Since: base-4.18
Instance details Defined in Control.Exception.Base Methods toException :: NoMatchingContinuationPrompt -> SomeException # fromException :: SomeException -> Maybe NoMatchingContinuationPrompt # displayException :: NoMatchingContinuationPrompt -> String #
Exception NoMethodError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: NoMethodError -> SomeException # fromException :: SomeException -> Maybe NoMethodError # displayException :: NoMethodError -> String #
Exception NonTermination	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: NonTermination -> SomeException # fromException :: SomeException -> Maybe NonTermination # displayException :: NonTermination -> String #
Exception PatternMatchFail	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: PatternMatchFail -> SomeException # fromException :: SomeException -> Maybe PatternMatchFail # displayException :: PatternMatchFail -> String #
Exception RecConError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: RecConError -> SomeException # fromException :: SomeException -> Maybe RecConError # displayException :: RecConError -> String #
Exception RecSelError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: RecSelError -> SomeException # fromException :: SomeException -> Maybe RecSelError # displayException :: RecSelError -> String #
Exception RecUpdError	Since: base-4.0
Instance details Defined in Control.Exception.Base Methods toException :: RecUpdError -> SomeException # fromException :: SomeException -> Maybe RecUpdError # displayException :: RecUpdError -> String #
Exception TypeError	Since: base-4.9.0.0
Instance details Defined in Control.Exception.Base Methods toException :: TypeError -> SomeException # fromException :: SomeException -> Maybe TypeError # displayException :: TypeError -> String #
Exception Void	Since: base-4.8.0.0
Instance details Defined in GHC.Exception.Type Methods toException :: Void -> SomeException # fromException :: SomeException -> Maybe Void # displayException :: Void -> String #
Exception ArithException	Since: base-4.0.0.0
Instance details Defined in GHC.Exception.Type Methods toException :: ArithException -> SomeException # fromException :: SomeException -> Maybe ArithException # displayException :: ArithException -> String #
Exception SomeException	Since: base-3.0
Instance details Defined in GHC.Exception.Type Methods toException :: SomeException -> SomeException # fromException :: SomeException -> Maybe SomeException # displayException :: SomeException -> String #
Exception AllocationLimitExceeded	Since: base-4.8.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: AllocationLimitExceeded -> SomeException # fromException :: SomeException -> Maybe AllocationLimitExceeded # displayException :: AllocationLimitExceeded -> String #
Exception ArrayException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: ArrayException -> SomeException # fromException :: SomeException -> Maybe ArrayException # displayException :: ArrayException -> String #
Exception AssertionFailed	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: AssertionFailed -> SomeException # fromException :: SomeException -> Maybe AssertionFailed # displayException :: AssertionFailed -> String #
Exception AsyncException	Since: base-4.7.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: AsyncException -> SomeException # fromException :: SomeException -> Maybe AsyncException # displayException :: AsyncException -> String #
Exception BlockedIndefinitelyOnMVar	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: BlockedIndefinitelyOnMVar -> SomeException # fromException :: SomeException -> Maybe BlockedIndefinitelyOnMVar # displayException :: BlockedIndefinitelyOnMVar -> String #
Exception BlockedIndefinitelyOnSTM	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: BlockedIndefinitelyOnSTM -> SomeException # fromException :: SomeException -> Maybe BlockedIndefinitelyOnSTM # displayException :: BlockedIndefinitelyOnSTM -> String #
Exception CompactionFailed	Since: base-4.10.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: CompactionFailed -> SomeException # fromException :: SomeException -> Maybe CompactionFailed # displayException :: CompactionFailed -> String #
Exception Deadlock	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: Deadlock -> SomeException # fromException :: SomeException -> Maybe Deadlock # displayException :: Deadlock -> String #
Exception ExitCode	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: ExitCode -> SomeException # fromException :: SomeException -> Maybe ExitCode # displayException :: ExitCode -> String #
Exception FixIOException	Since: base-4.11.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: FixIOException -> SomeException # fromException :: SomeException -> Maybe FixIOException # displayException :: FixIOException -> String #
Exception IOException	Since: base-4.1.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: IOException -> SomeException # fromException :: SomeException -> Maybe IOException # displayException :: IOException -> String #
Exception SomeAsyncException	Since: base-4.7.0.0
Instance details Defined in GHC.IO.Exception Methods toException :: SomeAsyncException -> SomeException # fromException :: SomeException -> Maybe SomeAsyncException # displayException :: SomeAsyncException -> String #
Exception ASCII7_Invalid
Instance details Defined in Basement.String.Encoding.ASCII7 Methods toException :: ASCII7_Invalid -> SomeException # fromException :: SomeException -> Maybe ASCII7_Invalid # displayException :: ASCII7_Invalid -> String #
Exception ISO_8859_1_Invalid
Instance details Defined in Basement.String.Encoding.ISO_8859_1 Methods toException :: ISO_8859_1_Invalid -> SomeException # fromException :: SomeException -> Maybe ISO_8859_1_Invalid # displayException :: ISO_8859_1_Invalid -> String #
Exception UTF16_Invalid
Instance details Defined in Basement.String.Encoding.UTF16 Methods toException :: UTF16_Invalid -> SomeException # fromException :: SomeException -> Maybe UTF16_Invalid # displayException :: UTF16_Invalid -> String #
Exception UTF32_Invalid
Instance details Defined in Basement.String.Encoding.UTF32 Methods toException :: UTF32_Invalid -> SomeException # fromException :: SomeException -> Maybe UTF32_Invalid # displayException :: UTF32_Invalid -> String #
Exception IOEnvFailure
Instance details Defined in GHC.Data.IOEnv Methods toException :: IOEnvFailure -> SomeException # fromException :: SomeException -> Maybe IOEnvFailure # displayException :: IOEnvFailure -> String #
Exception SourceError
Instance details Defined in GHC.Types.SourceError Methods toException :: SourceError -> SomeException # fromException :: SomeException -> Maybe SourceError # displayException :: SourceError -> String #
Exception GhcException
Instance details Defined in GHC.Utils.Panic Methods toException :: GhcException -> SomeException # fromException :: SomeException -> Maybe GhcException # displayException :: GhcException -> String #
Exception PlainGhcException
Instance details Defined in GHC.Utils.Panic.Plain Methods toException :: PlainGhcException -> SomeException # fromException :: SomeException -> Maybe PlainGhcException # displayException :: PlainGhcException -> String #
Exception AsyncExceptionWrapper
Instance details Defined in Control.Exception.Safe Methods toException :: AsyncExceptionWrapper -> SomeException # fromException :: SomeException -> Maybe AsyncExceptionWrapper # displayException :: AsyncExceptionWrapper -> String #
Exception StringException
Instance details Defined in Control.Exception.Safe Methods toException :: StringException -> SomeException # fromException :: SomeException -> Maybe StringException # displayException :: StringException -> String #
Exception SyncExceptionWrapper
Instance details Defined in Control.Exception.Safe Methods toException :: SyncExceptionWrapper -> SomeException # fromException :: SomeException -> Maybe SyncExceptionWrapper # displayException :: SyncExceptionWrapper -> String #
Exception StringException	Since: unliftio-0.1.0.0
Instance details Defined in UnliftIO.Exception Methods toException :: StringException -> SomeException # fromException :: SomeException -> Maybe StringException # displayException :: StringException -> String #
Exception ConcException
Instance details Defined in UnliftIO.Internals.Async Methods toException :: ConcException -> SomeException # fromException :: SomeException -> Maybe ConcException # displayException :: ConcException -> String #

data Fingerprint #

Constructors

Fingerprint !Word64 !Word64

Instances

Instances details

Generic Fingerprint
Instance details Defined in GHC.Generics Associated Types type Rep Fingerprint :: Type -> Type # Methods from :: Fingerprint -> Rep Fingerprint x # to :: Rep Fingerprint x -> Fingerprint #
Show Fingerprint	Since: base-4.7.0.0
Instance details Defined in GHC.Fingerprint.Type Methods showsPrec :: Int -> Fingerprint -> ShowS # show :: Fingerprint -> String # showList :: [Fingerprint] -> ShowS #
Outputable Fingerprint
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Fingerprint -> SDoc #
Eq Fingerprint	Since: base-4.4.0.0
Instance details Defined in GHC.Fingerprint.Type Methods (==) :: Fingerprint -> Fingerprint -> Bool # (/=) :: Fingerprint -> Fingerprint -> Bool #
Ord Fingerprint	Since: base-4.4.0.0
Instance details Defined in GHC.Fingerprint.Type Methods compare :: Fingerprint -> Fingerprint -> Ordering # (<) :: Fingerprint -> Fingerprint -> Bool # (<=) :: Fingerprint -> Fingerprint -> Bool # (>) :: Fingerprint -> Fingerprint -> Bool # (>=) :: Fingerprint -> Fingerprint -> Bool # max :: Fingerprint -> Fingerprint -> Fingerprint # min :: Fingerprint -> Fingerprint -> Fingerprint #
Hashable Fingerprint	Since: hashable-1.3.0.0
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Fingerprint -> Int # hash :: Fingerprint -> Int #
type Rep Fingerprint	Since: base-4.15.0.0
Instance details Defined in GHC.Generics type Rep Fingerprint = D1 ('MetaData "Fingerprint" "GHC.Fingerprint.Type" "base" 'False) (C1 ('MetaCons "Fingerprint" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'SourceUnpack 'SourceStrict 'DecidedUnpack) (Rec0 Word64) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'SourceUnpack 'SourceStrict 'DecidedUnpack) (Rec0 Word64)))

data SrcLoc #

Source Location

Constructors

RealSrcLoc !RealSrcLoc !(Maybe BufPos)
UnhelpfulLoc !FastString

Instances

Instances details

Show SrcLoc
Instance details Defined in GHC.Types.SrcLoc Methods showsPrec :: Int -> SrcLoc -> ShowS # show :: SrcLoc -> String # showList :: [SrcLoc] -> ShowS #
Outputable SrcLoc
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: SrcLoc -> SDoc #
Eq SrcLoc
Instance details Defined in GHC.Types.SrcLoc Methods (==) :: SrcLoc -> SrcLoc -> Bool # (/=) :: SrcLoc -> SrcLoc -> Bool #

type HasCallStack = ?callStack :: CallStack #

Request a CallStack.

NOTE: The implicit parameter ?callStack :: CallStack is an implementation detail and should not be considered part of the CallStack API, we may decide to change the implementation in the future.

Since: base-4.9.0.0

data Version #

A Version represents the version of a software entity.

An instance of Eq is provided, which implements exact equality modulo reordering of the tags in the versionTags field.

An instance of Ord is also provided, which gives lexicographic ordering on the versionBranch fields (i.e. 2.1 > 2.0, 1.2.3 > 1.2.2, etc.). This is expected to be sufficient for many uses, but note that you may need to use a more specific ordering for your versioning scheme. For example, some versioning schemes may include pre-releases which have tags "pre1", "pre2", and so on, and these would need to be taken into account when determining ordering. In some cases, date ordering may be more appropriate, so the application would have to look for date tags in the versionTags field and compare those. The bottom line is, don't always assume that compare and other Ord operations are the right thing for every Version.

Similarly, concrete representations of versions may differ. One possible concrete representation is provided (see showVersion and parseVersion), but depending on the application a different concrete representation may be more appropriate.

Constructors

Version

Fields

versionBranch :: [Int]
The numeric branch for this version. This reflects the fact that most software versions are tree-structured; there is a main trunk which is tagged with versions at various points (1,2,3...), and the first branch off the trunk after version 3 is 3.1, the second branch off the trunk after version 3 is 3.2, and so on. The tree can be branched arbitrarily, just by adding more digits.
We represent the branch as a list of Int, so version 3.2.1 becomes [3,2,1]. Lexicographic ordering (i.e. the default instance of Ord for [Int]) gives the natural ordering of branches.
versionTags :: [String]
A version can be tagged with an arbitrary list of strings. The interpretation of the list of tags is entirely dependent on the entity that this version applies to.

Instances

Instances details

Data Version	Since: base-4.7.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Version -> c Version # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Version # toConstr :: Version -> Constr # dataTypeOf :: Version -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Version) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Version) # gmapT :: (forall b. Data b => b -> b) -> Version -> Version # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Version -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Version -> r # gmapQ :: (forall d. Data d => d -> u) -> Version -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Version -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Version -> m Version # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Version -> m Version # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Version -> m Version #
Generic Version
Instance details Defined in Data.Version Associated Types type Rep Version :: Type -> Type # Methods from :: Version -> Rep Version x # to :: Rep Version x -> Version #
IsList Version	Since: base-4.8.0.0
Instance details Defined in GHC.IsList Associated Types type Item Version # Methods fromList :: [Item Version] -> Version # fromListN :: Int -> [Item Version] -> Version # toList :: Version -> [Item Version] #
Read Version	Since: base-2.1
Instance details Defined in Data.Version Methods readsPrec :: Int -> ReadS Version # readList :: ReadS [Version] # readPrec :: ReadPrec Version # readListPrec :: ReadPrec [Version] #
Show Version	Since: base-2.1
Instance details Defined in Data.Version Methods showsPrec :: Int -> Version -> ShowS # show :: Version -> String # showList :: [Version] -> ShowS #
Eq Version	Since: base-2.1
Instance details Defined in Data.Version Methods (==) :: Version -> Version -> Bool # (/=) :: Version -> Version -> Bool #
Ord Version	Since: base-2.1
Instance details Defined in Data.Version Methods compare :: Version -> Version -> Ordering # (<) :: Version -> Version -> Bool # (<=) :: Version -> Version -> Bool # (>) :: Version -> Version -> Bool # (>=) :: Version -> Version -> Bool # max :: Version -> Version -> Version # min :: Version -> Version -> Version #
Hashable Version
Instance details Defined in Data.Hashable.Class Methods hashWithSalt :: Int -> Version -> Int # hash :: Version -> Int #
type Rep Version	Since: base-4.9.0.0
Instance details Defined in Data.Version type Rep Version = D1 ('MetaData "Version" "Data.Version" "base" 'False) (C1 ('MetaCons "Version" 'PrefixI 'True) (S1 ('MetaSel ('Just "versionBranch") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Int]) :*: S1 ('MetaSel ('Just "versionTags") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [String])))
type Item Version
Instance details Defined in GHC.IsList type Item Version = Int

data FractionalExponentBase #

Constructors

Base2
Base10

Instances

Instances details

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

data Coercion #

A Coercion is concrete evidence of the equality/convertibility of two types.

Instances

Instances details

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

data Alt b #

A case split alternative. Consists of the constructor leading to the alternative, the variables bound from the constructor, and the expression to be executed given that binding. The default alternative is (DEFAULT, [], rhs)

Constructors

Alt AltCon [b] (Expr b)

Instances

Instances details

Data b => Data (Alt b)

Instance details

Defined in GHC.Core

Methods

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

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

toConstr :: Alt b -> Constr #

dataTypeOf :: Alt b -> DataType #

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

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

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

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

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

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

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

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

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

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

data Option #

When invoking external tools as part of the compilation pipeline, we pass these a sequence of options on the command-line. Rather than just using a list of Strings, we use a type that allows us to distinguish between filepaths and 'other stuff'. The reason for this is that this type gives us a handle on transforming filenames, and filenames only, to whatever format they're expected to be on a particular platform.

Constructors

FileOption String String
Option String

Instances

Instances details

Eq Option
Instance details Defined in GHC.Utils.CliOption Methods (==) :: Option -> Option -> Bool # (/=) :: Option -> Option -> Bool #

data Unique #

Unique identifier.

The type of unique identifiers that are used in many places in GHC for fast ordering and equality tests. You should generate these with the functions from the UniqSupply module

These are sometimes also referred to as "keys" in comments in GHC.

Instances

Instances details

Show Unique
Instance details Defined in GHC.Types.Unique Methods showsPrec :: Int -> Unique -> ShowS # show :: Unique -> String # showList :: [Unique] -> ShowS #
Uniquable Unique
Instance details Defined in GHC.Types.Unique Methods getUnique :: Unique -> Unique #
Outputable Unique
Instance details Defined in GHC.Types.Unique Methods ppr :: Unique -> SDoc #
Eq Unique
Instance details Defined in GHC.Types.Unique Methods (==) :: Unique -> Unique -> Bool # (/=) :: Unique -> Unique -> Bool #

type Arg b = Expr b #

Type synonym for expressions that occur in function argument positions. Only Arg should contain a Type at top level, general Expr should not

type Unit = GenUnit UnitId #

data GhcException #

GHC's own exception type error messages all take the form:

     <location>: <error>

If the location is on the command line, or in GHC itself, then <location>="ghc". All of the error types below correspond to a <location> of "ghc", except for ProgramError (where the string is assumed to contain a location already, so we don't print one).

Constructors

Signal Int	Some other fatal signal (SIGHUP,SIGTERM)
UsageError String	Prints the short usage msg after the error
CmdLineError String	A problem with the command line arguments, but don't print usage.
Panic String	The `impossible` happened.
PprPanic String SDoc
Sorry String	The user tickled something that's known not to work yet, but we're not counting it as a bug.
PprSorry String SDoc
InstallationError String	An installation problem.
ProgramError String	An error in the user's code, probably.
PprProgramError String SDoc

Instances

Instances details

Exception GhcException
Instance details Defined in GHC.Utils.Panic Methods toException :: GhcException -> SomeException # fromException :: SomeException -> Maybe GhcException # displayException :: GhcException -> String #
Show GhcException
Instance details Defined in GHC.Utils.Panic Methods showsPrec :: Int -> GhcException -> ShowS # show :: GhcException -> String # showList :: [GhcException] -> ShowS #

data SDoc #

Represents a pretty-printable document.

To display an SDoc, use printSDoc, printSDocLn, bufLeftRenderSDoc, or renderWithContext. Avoid calling runSDoc directly as it breaks the abstraction layer.

Instances

Instances details

IsString SDoc
Instance details Defined in GHC.Utils.Outputable Methods fromString :: String -> SDoc #
IsDoc SDoc
Instance details Defined in GHC.Utils.Outputable Associated Types type Line SDoc = (r :: Type) # Methods line :: Line SDoc -> SDoc # ($$) :: SDoc -> SDoc -> SDoc # lines_ :: [Line SDoc] -> SDoc # vcat :: [SDoc] -> SDoc # dualDoc :: SDoc -> HDoc -> SDoc #
IsLine SDoc
Instance details Defined in GHC.Utils.Outputable Methods char :: Char -> SDoc # text :: String -> SDoc # ftext :: FastString -> SDoc # ztext :: FastZString -> SDoc # (<>) :: SDoc -> SDoc -> SDoc # (<+>) :: SDoc -> SDoc -> SDoc # sep :: [SDoc] -> SDoc # fsep :: [SDoc] -> SDoc # hcat :: [SDoc] -> SDoc # hsep :: [SDoc] -> SDoc # dualLine :: SDoc -> HLine -> SDoc #
IsOutput SDoc
Instance details Defined in GHC.Utils.Outputable Methods empty :: SDoc # docWithContext :: (SDocContext -> SDoc) -> SDoc #
Outputable SDoc
Instance details Defined in GHC.Utils.Outputable Methods ppr :: SDoc -> SDoc #
OutputableP env SDoc
Instance details Defined in GHC.Utils.Outputable Methods pdoc :: env -> SDoc -> SDoc #
type Line SDoc
Instance details Defined in GHC.Utils.Outputable type Line SDoc = SDoc

data AnnDecl pass #

Annotation Declaration

Constructors

HsAnnotation (XHsAnnotation pass) (AnnProvenance pass) (XRec pass (HsExpr pass))	`AnnKeywordId` : `AnnOpen`, `AnnType` `AnnModule` `AnnClose`
XAnnDecl !(XXAnnDecl pass)

Instances

Instances details

type Anno (AnnDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (AnnDecl (GhcPass p)) = SrcSpanAnnA

data IE 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) - `AnnKeywordId`s : `AnnPattern`, `AnnType`,`AnnVal`
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 `AnnKeywordId`s : `AnnOpen`, `AnnDotdot`,`AnnClose`, `AnnType`
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] - `AnnKeywordId`s : `AnnOpen`, `AnnClose`, `AnnComma`, `AnnType`
IEModuleContents (XIEModuleContents pass) (XRec pass ModuleName)	Imported or exported module contents (Export Only) `AnnKeywordId`s : `AnnModule`
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)

Instances

Instances details

type Anno (LocatedA (IE (GhcPass p)))
Instance details Defined in GHC.Hs.ImpExp type Anno (LocatedA (IE (GhcPass p))) = SrcSpanAnnA
type Anno (IE (GhcPass p))
Instance details Defined in GHC.Hs.ImpExp type Anno (IE (GhcPass p)) = SrcSpanAnnA
type Anno [LocatedA (IE (GhcPass p))]
Instance details Defined in GHC.Hs.ImpExp type Anno [LocatedA (IE (GhcPass p))] = SrcSpanAnnL

data Annotation #

Represents an annotation after it has been sufficiently desugared from it's initial form of AnnDecl

Constructors

Annotation
Fields ann_target :: CoreAnnTarget The target of the annotation ann_value :: AnnPayload

Instances

Instances details

Outputable Annotation
Instance details Defined in GHC.Types.Annotations Methods ppr :: Annotation -> SDoc #

type Kind = Type #

The key type representing kinds in the compiler.

data HsExpr p #

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 `AnnKeywordId` : `AnnLam`, `AnnRarrow`,
HsLamCase (XLamCase p) LamCaseVariant (MatchGroup p (LHsExpr p))	Lambda-case `AnnKeywordId` : `AnnLam`, `AnnCase`,`AnnOpen`, `AnnClose` `AnnKeywordId` : `AnnLam`, `AnnCases`,`AnnOpen`, `AnnClose`
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 `AnnKeywordId` : `AnnAt`,
OpApp (XOpApp p) (LHsExpr p) (LHsExpr p) (LHsExpr p)	Operator applications: NB Bracketed ops such as (+) come out as Vars.
NegApp (XNegApp p) (LHsExpr p) (SyntaxExpr p)	Negation operator. Contains the negated expression and the name of `negate` `AnnKeywordId` : `AnnMinus`
HsPar	`AnnKeywordId` : `AnnOpen` `'('`, `AnnClose` `')'`
Fields (XPar p) !(LHsToken "(" p) (LHsExpr p) Parenthesised expr; see Note [Parens in HsSyn] !(LHsToken ")" p)
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 `AnnKeywordId` : `AnnOpen`, `AnnClose`
ExplicitSum (XExplicitSum p) ConTag SumWidth (LHsExpr p)	Used for unboxed sum types `AnnKeywordId` : `AnnOpen` `'(#'`, `AnnVbar`, `AnnClose` `'#)'`, There will be multiple `AnnVbar`, (1 - alternative) before the expression, (arity - alternative) after it
HsCase (XCase p) (LHsExpr p) (MatchGroup p (LHsExpr p))	`AnnKeywordId` : `AnnCase`, `AnnOf`,`AnnOpen` `'{'`, `AnnClose` `'}'`
HsIf (XIf p) (LHsExpr p) (LHsExpr p) (LHsExpr p)	`AnnKeywordId` : `AnnIf`, `AnnSemi`, `AnnThen`,`AnnSemi`, `AnnElse`,
HsMultiIf (XMultiIf p) [LGRHS p (LHsExpr p)]	Multi-way if `AnnKeywordId` : `AnnIf` `AnnOpen`,`AnnClose`,
HsLet (XLet p) !(LHsToken "let" p) (HsLocalBinds p) !(LHsToken "in" p) (LHsExpr p)	let(rec) `AnnKeywordId` : `AnnLet`, `AnnOpen` `'{'`, `AnnClose` `'}'`,`AnnIn`
HsDo (XDo p) HsDoFlavour (XRec p [ExprLStmt p])	`AnnKeywordId` : `AnnDo`, `AnnOpen`, `AnnSemi`, `AnnVbar`, `AnnClose`
ExplicitList (XExplicitList p) [LHsExpr p]	Syntactic list: [a,b,c,...] `AnnKeywordId` : `AnnOpen` `'['`, `AnnClose` `']'`
RecordCon	Record construction `AnnKeywordId` : `AnnOpen` `'{'`, `AnnDotdot`,`AnnClose` `'}'`
Fields rcon_ext :: XRecordCon p rcon_con :: XRec p (ConLikeP p) rcon_flds :: HsRecordBinds p
RecordUpd	Record update `AnnKeywordId` : `AnnOpen` `'{'`, `AnnDotdot`,`AnnClose` `'}'` 'GHC.Parser.Annotation.AnnComma, `AnnDot`, `AnnClose` `'}'`
Fields rupd_ext :: XRecordUpd p rupd_expr :: LHsExpr p rupd_flds :: Either [LHsRecUpdField p] [LHsRecUpdProj p]
HsGetField	Record field selection e.g `z.x`. `AnnKeywordId` : `AnnDot`
Fields gf_ext :: XGetField p gf_expr :: LHsExpr p gf_field :: XRec p (DotFieldOcc p)
HsProjection	Record field selector. e.g. `(.x)` or `(.x.y)` This case only arises when the OverloadedRecordDot langauge extensions is enabled. See Note [Record selectors in the AST].
Fields proj_ext :: XProjection p proj_flds :: NonEmpty (XRec p (DotFieldOcc p))
ExprWithTySig (XExprWithTySig p) (LHsExpr p) (LHsSigWcType (NoGhcTc p))	Expression with an explicit type signature. `e :: type` `AnnKeywordId` : `AnnDcolon`
ArithSeq (XArithSeq p) (Maybe (SyntaxExpr p)) (ArithSeqInfo p)	Arithmetic sequence `AnnKeywordId` : `AnnOpen` `'['`, `AnnComma`,`AnnDotdot`, `AnnClose` `']'`
HsTypedBracket (XTypedBracket p) (LHsExpr p)	`AnnKeywordId` : `AnnOpen`, `AnnOpenE`,`AnnOpenEQ`, `AnnClose`,`AnnCloseQ`
HsUntypedBracket (XUntypedBracket p) (HsQuote p)
HsTypedSplice (XTypedSplice p) (LHsExpr p)	`AnnKeywordId` : `AnnOpen`, `AnnClose`
HsUntypedSplice (XUntypedSplice p) (HsUntypedSplice p)
HsProc (XProc p) (LPat p) (LHsCmdTop p)	`proc` notation for Arrows `AnnKeywordId` : `AnnProc`, `AnnRarrow`
HsStatic (XStatic p) (LHsExpr p)	`AnnKeywordId` : `AnnStatic`,
HsPragE (XPragE p) (HsPragE p) (LHsExpr p)
XExpr !(XXExpr p)

Instances

Instances details

DisambECP (HsExpr GhcPs)
Instance details Defined in GHC.Parser.PostProcess Associated Types type Body (HsExpr GhcPs) :: Type -> Type # type InfixOp (HsExpr GhcPs) # type FunArg (HsExpr GhcPs) # Methods ecpFromCmd' :: LHsCmd GhcPs -> PV (LocatedA (HsExpr GhcPs)) # ecpFromExp' :: LHsExpr GhcPs -> PV (LocatedA (HsExpr GhcPs)) # mkHsProjUpdatePV :: SrcSpan -> Located [LocatedAn NoEpAnns (DotFieldOcc GhcPs)] -> LocatedA (HsExpr GhcPs) -> Bool -> [AddEpAnn] -> PV (LHsRecProj GhcPs (LocatedA (HsExpr GhcPs))) # mkHsLamPV :: SrcSpan -> (EpAnnComments -> MatchGroup GhcPs (LocatedA (HsExpr GhcPs))) -> PV (LocatedA (HsExpr GhcPs)) # mkHsLetPV :: SrcSpan -> LHsToken "let" GhcPs -> HsLocalBinds GhcPs -> LHsToken "in" GhcPs -> LocatedA (HsExpr GhcPs) -> PV (LocatedA (HsExpr GhcPs)) # superInfixOp :: (DisambInfixOp (InfixOp (HsExpr GhcPs)) => PV (LocatedA (HsExpr GhcPs))) -> PV (LocatedA (HsExpr GhcPs)) # mkHsOpAppPV :: SrcSpan -> LocatedA (HsExpr GhcPs) -> LocatedN (InfixOp (HsExpr GhcPs)) -> LocatedA (HsExpr GhcPs) -> PV (LocatedA (HsExpr GhcPs)) # mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> LocatedL [LMatch GhcPs (LocatedA (HsExpr GhcPs))] -> EpAnnHsCase -> PV (LocatedA (HsExpr GhcPs)) # mkHsLamCasePV :: SrcSpan -> LamCaseVariant -> LocatedL [LMatch GhcPs (LocatedA (HsExpr GhcPs))] -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) # superFunArg :: (DisambECP (FunArg (HsExpr GhcPs)) => PV (LocatedA (HsExpr GhcPs))) -> PV (LocatedA (HsExpr GhcPs)) # mkHsAppPV :: SrcSpanAnnA -> LocatedA (HsExpr GhcPs) -> LocatedA (FunArg (HsExpr GhcPs)) -> PV (LocatedA (HsExpr GhcPs)) # mkHsAppTypePV :: SrcSpanAnnA -> LocatedA (HsExpr GhcPs) -> LHsToken "@" GhcPs -> LHsType GhcPs -> PV (LocatedA (HsExpr GhcPs)) # mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> LocatedA (HsExpr GhcPs) -> Bool -> LocatedA (HsExpr GhcPs) -> AnnsIf -> PV (LocatedA (HsExpr GhcPs)) # mkHsDoPV :: SrcSpan -> Maybe ModuleName -> LocatedL [LStmt GhcPs (LocatedA (HsExpr GhcPs))] -> AnnList -> PV (LocatedA (HsExpr GhcPs)) # mkHsParPV :: SrcSpan -> LHsToken "(" GhcPs -> LocatedA (HsExpr GhcPs) -> LHsToken ")" GhcPs -> PV (LocatedA (HsExpr GhcPs)) # mkHsVarPV :: LocatedN RdrName -> PV (LocatedA (HsExpr GhcPs)) # mkHsLitPV :: Located (HsLit GhcPs) -> PV (Located (HsExpr GhcPs)) # mkHsOverLitPV :: LocatedAn a (HsOverLit GhcPs) -> PV (LocatedAn a (HsExpr GhcPs)) # mkHsWildCardPV :: SrcSpan -> PV (Located (HsExpr GhcPs)) # mkHsTySigPV :: SrcSpanAnnA -> LocatedA (HsExpr GhcPs) -> LHsType GhcPs -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) # mkHsExplicitListPV :: SrcSpan -> [LocatedA (HsExpr GhcPs)] -> AnnList -> PV (LocatedA (HsExpr GhcPs)) # mkHsSplicePV :: Located (HsUntypedSplice GhcPs) -> PV (Located (HsExpr GhcPs)) # mkHsRecordPV :: Bool -> SrcSpan -> SrcSpan -> LocatedA (HsExpr GhcPs) -> ([Fbind (HsExpr GhcPs)], Maybe SrcSpan) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) # mkHsNegAppPV :: SrcSpan -> LocatedA (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) # mkHsSectionR_PV :: SrcSpan -> LocatedA (InfixOp (HsExpr GhcPs)) -> LocatedA (HsExpr GhcPs) -> PV (Located (HsExpr GhcPs)) # mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> LocatedA (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) # mkHsAsPatPV :: SrcSpan -> LocatedN RdrName -> LHsToken "@" GhcPs -> LocatedA (HsExpr GhcPs) -> PV (LocatedA (HsExpr GhcPs)) # mkHsLazyPatPV :: SrcSpan -> LocatedA (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) # mkHsBangPatPV :: SrcSpan -> LocatedA (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) # mkSumOrTuplePV :: SrcSpanAnnA -> Boxity -> SumOrTuple (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) # rejectPragmaPV :: LocatedA (HsExpr GhcPs) -> PV () #
DisambInfixOp (HsExpr GhcPs)
Instance details Defined in GHC.Parser.PostProcess Methods mkHsVarOpPV :: LocatedN RdrName -> PV (LocatedN (HsExpr GhcPs)) # mkHsConOpPV :: LocatedN RdrName -> PV (LocatedN (HsExpr GhcPs)) # mkHsInfixHolePV :: SrcSpan -> (EpAnnComments -> EpAnn EpAnnUnboundVar) -> PV (Located (HsExpr GhcPs)) #
type Body (HsExpr GhcPs)
Instance details Defined in GHC.Parser.PostProcess type Body (HsExpr GhcPs) = HsExpr
type FunArg (HsExpr GhcPs)
Instance details Defined in GHC.Parser.PostProcess type FunArg (HsExpr GhcPs) = HsExpr GhcPs
type InfixOp (HsExpr GhcPs)
Instance details Defined in GHC.Parser.PostProcess type InfixOp (HsExpr GhcPs) = HsExpr GhcPs
type Anno (HsExpr (GhcPass p))
Instance details Defined in GHC.Hs.Expr type Anno (HsExpr (GhcPass p)) = SrcSpanAnnA
type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))] = SrcSpanAnnL
type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p))))
Instance details Defined in GHC.Hs.Expr type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcAnn NoEpAnns
type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))
Instance details Defined in GHC.Hs.Expr type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpanAnnA

data RdrName #

Reader Name

Do not use the data constructors of RdrName directly: prefer the family of functions that creates them, such as mkRdrUnqual

Note: A Located RdrName will only have API Annotations if it is a compound one, e.g.

`bar`
( ~ )

AnnKeywordId : AnnType, AnnOpen '(' or '[' or '[:', AnnClose ')' or ']' or ':]',, AnnBackquote '`', AnnVal AnnTilde,

Constructors

Unqual OccName	Unqualified name Used for ordinary, unqualified occurrences, e.g. `x`, `y` or `Foo`. Create such a `RdrName` with `mkRdrUnqual`
Qual ModuleName OccName	Qualified name A qualified name written by the user in source code. The module isn't necessarily the module where the thing is defined; just the one from which it is imported. Examples are `Bar.x`, `Bar.y` or `Bar.Foo`. Create such a `RdrName` with `mkRdrQual`
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 `mkOrig`
Exact Name	Exact name We know exactly the `Name`. This is used: When the parser parses built-in syntax like `[]` and `(,)`, but wants a `RdrName` from it By Template Haskell, when TH has generated a unique name Such a `RdrName` can be created by using `getRdrName` on a `Name`

Instances

Instances details

Data RdrName
Instance details Defined in GHC.Types.Name.Reader Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RdrName -> c RdrName # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RdrName # toConstr :: RdrName -> Constr # dataTypeOf :: RdrName -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RdrName) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RdrName) # gmapT :: (forall b. Data b => b -> b) -> RdrName -> RdrName # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RdrName -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RdrName -> r # gmapQ :: (forall d. Data d => d -> u) -> RdrName -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RdrName -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RdrName -> m RdrName # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RdrName -> m RdrName # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RdrName -> m RdrName #
DisambInfixOp RdrName
Instance details Defined in GHC.Parser.PostProcess Methods mkHsVarOpPV :: LocatedN RdrName -> PV (LocatedN RdrName) # mkHsConOpPV :: LocatedN RdrName -> PV (LocatedN RdrName) # mkHsInfixHolePV :: SrcSpan -> (EpAnnComments -> EpAnn EpAnnUnboundVar) -> PV (Located RdrName) #
HasOccName RdrName
Instance details Defined in GHC.Types.Name.Reader Methods occName :: RdrName -> OccName #
Outputable RdrName
Instance details Defined in GHC.Types.Name.Reader Methods ppr :: RdrName -> SDoc #
OutputableBndr RdrName
Instance details Defined in GHC.Types.Name.Reader Methods pprBndr :: BindingSite -> RdrName -> SDoc # pprPrefixOcc :: RdrName -> SDoc # pprInfixOcc :: RdrName -> SDoc # bndrIsJoin_maybe :: RdrName -> Maybe Int #
Eq RdrName
Instance details Defined in GHC.Types.Name.Reader Methods (==) :: RdrName -> RdrName -> Bool # (/=) :: RdrName -> RdrName -> Bool #
Ord RdrName
Instance details Defined in GHC.Types.Name.Reader Methods compare :: RdrName -> RdrName -> Ordering # (<) :: RdrName -> RdrName -> Bool # (<=) :: RdrName -> RdrName -> Bool # (>) :: RdrName -> RdrName -> Bool # (>=) :: RdrName -> RdrName -> Bool # max :: RdrName -> RdrName -> RdrName # min :: RdrName -> RdrName -> RdrName #
type Anno RdrName
Instance details Defined in GHC.Hs.Extension type Anno RdrName = SrcSpanAnnN
type Anno (LocatedN RdrName)
Instance details Defined in GHC.Hs.Binds type Anno (LocatedN RdrName) = SrcSpan
type Anno [LocatedN RdrName]
Instance details Defined in GHC.Hs.Binds type Anno [LocatedN RdrName] = SrcSpan

type Id = Var #

Identifier

data Subst #

Type & coercion & id substitution

The Subst data type defined in this module contains substitution for tyvar, covar and id. However, operations on IdSubstEnv (mapping from Id to CoreExpr) that require the definition of the Expr data type are defined in GHC.Core.Subst to avoid circular module dependency.

Constructors

Subst InScopeSet IdSubstEnv TvSubstEnv CvSubstEnv

Instances

Instances details

Outputable Subst
Instance details Defined in GHC.Core.TyCo.Subst Methods ppr :: Subst -> SDoc #

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

Instances details

Data NoExtField
Instance details 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
Instance details Defined in Language.Haskell.Syntax.Extension Methods (==) :: NoExtField -> NoExtField -> Bool # (/=) :: NoExtField -> NoExtField -> Bool #
Ord NoExtField
Instance details 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 #

data FloatOutSwitches #

Constructors

FloatOutSwitches

Fields

floatOutLambdas :: Maybe Int
Just n = float lambdas to top level, if doing so will abstract over n or fewer value variables Nothing = float all lambdas to top level, regardless of how many free variables Just 0 is the vanilla case: float a lambda iff it has no free vars
floatOutConstants :: Bool
True = float constants to top level, even if they do not escape a lambda
floatOutOverSatApps :: Bool
True = float out over-saturated applications based on arity information. See Note [Floating over-saturated applications] in GHC.Core.Opt.SetLevels
floatToTopLevelOnly :: Bool
Allow floating to the top level only.

Instances

Instances details

Outputable FloatOutSwitches
Instance details Defined in GHC.Core.Opt.Monad Methods ppr :: FloatOutSwitches -> SDoc #

data DynFlags #

Contains not only a collection of GeneralFlags but also a plethora of information relating to the compilation of a single file or GHC session

Constructors

DynFlags

Fields

ghcMode :: GhcMode
ghcLink :: GhcLink
backend :: !Backend
The backend to use (if any).
Whenever you change the backend, also make sure to set ghcLink to something sensible.
NoBackend can be used to avoid generating any output, however, note that:
- If a program uses Template Haskell the typechecker may need to run code from an imported module. To facilitate this, code generation is enabled for modules imported by modules that use template haskell, using the default backend for the platform. See Note [-fno-code mode].
ghcNameVersion :: !GhcNameVersion
fileSettings :: !FileSettings
targetPlatform :: Platform
toolSettings :: !ToolSettings
platformMisc :: !PlatformMisc
rawSettings :: [(String, String)]
tmpDir :: TempDir
llvmOptLevel :: Int
LLVM optimisation level
verbosity :: Int
Verbosity level: see Note [Verbosity levels]
debugLevel :: Int
How much debug information to produce
simplPhases :: Int
Number of simplifier phases
maxSimplIterations :: Int
Max simplifier iterations
ruleCheck :: Maybe String
strictnessBefore :: [Int]
Additional demand analysis
parMakeCount :: Maybe Int
The number of modules to compile in parallel in --make mode, where Nothing ==> compile as many in parallel as there are CPUs.
enableTimeStats :: Bool
Enable RTS timing statistics?
ghcHeapSize :: Maybe Int
The heap size to set.
maxRelevantBinds :: Maybe Int
Maximum number of bindings from the type envt to show in type error messages
maxValidHoleFits :: Maybe Int
Maximum number of hole fits to show in typed hole error messages
maxRefHoleFits :: Maybe Int
Maximum number of refinement hole fits to show in typed hole error messages
refLevelHoleFits :: Maybe Int
Maximum level of refinement for refinement hole fits in typed hole error messages
maxUncoveredPatterns :: Int
Maximum number of unmatched patterns to show in non-exhaustiveness warnings
maxPmCheckModels :: Int
Soft limit on the number of models the pattern match checker checks a pattern against. A safe guard against exponential blow-up.
simplTickFactor :: Int
Multiplier for simplifier ticks
dmdUnboxWidth :: !Int
Whether DmdAnal should optimistically put an Unboxed demand on returned products with at most this number of fields
specConstrThreshold :: Maybe Int
Threshold for SpecConstr
specConstrCount :: Maybe Int
Max number of specialisations for any one function
specConstrRecursive :: Int
Max number of specialisations for recursive types Not optional; otherwise ForceSpecConstr can diverge.
binBlobThreshold :: Maybe Word
Binary literals (e.g. strings) whose size is above this threshold will be dumped in a binary file by the assembler code generator. 0 and Nothing disables this feature. See Config.
liberateCaseThreshold :: Maybe Int
Threshold for LiberateCase
floatLamArgs :: Maybe Int
Arg count for lambda floating See FloatOutSwitches
liftLamsRecArgs :: Maybe Int
Maximum number of arguments after lambda lifting a recursive function.
liftLamsNonRecArgs :: Maybe Int
Maximum number of arguments after lambda lifting a non-recursive function.
liftLamsKnown :: Bool
Lambda lift even when this turns a known call into an unknown call.
cmmProcAlignment :: Maybe Int
Align Cmm functions at this boundary or use default.
historySize :: Int
Simplification history size
importPaths :: [FilePath]
mainModuleNameIs :: ModuleName
mainFunIs :: Maybe String
reductionDepth :: IntWithInf
Typechecker maximum stack depth
solverIterations :: IntWithInf
Number of iterations in the constraints solver Typically only 1 is needed
homeUnitId_ :: UnitId
Target home unit-id
homeUnitInstanceOf_ :: Maybe UnitId
Id of the unit to instantiate
homeUnitInstantiations_ :: [(ModuleName, Module)]
Module instantiations
workingDirectory :: Maybe FilePath
thisPackageName :: Maybe String
What the package is called, use with multiple home units
hiddenModules :: Set ModuleName
reexportedModules :: Set ModuleName
targetWays_ :: Ways
Target way flags from the command line
splitInfo :: Maybe (String, Int)
objectDir :: Maybe String
dylibInstallName :: Maybe String
hiDir :: Maybe String
hieDir :: Maybe String
stubDir :: Maybe String
dumpDir :: Maybe String
objectSuf_ :: String
hcSuf :: String
hiSuf_ :: String
hieSuf :: String
dynObjectSuf_ :: String
dynHiSuf_ :: String
outputFile_ :: Maybe String
dynOutputFile_ :: Maybe String
outputHi :: Maybe String
dynOutputHi :: Maybe String
dynLibLoader :: DynLibLoader
dynamicNow :: !Bool
Indicate if we are now generating dynamic output because of -dynamic-too. This predicate is used to query the appropriate fields (outputFile/dynOutputFile, ways, etc.)
dumpPrefix :: FilePath
This defaults to 'non-module'. It can be set by setDumpPrefix or 'ghc.GHCi.UI.runStmt' based on where its output is going.
dumpPrefixForce :: Maybe FilePath
Override the dumpPrefix set by setDumpPrefix or 'ghc.GHCi.UI.runStmt'. Set by -ddump-file-prefix
ldInputs :: [Option]
includePaths :: IncludeSpecs
libraryPaths :: [String]
frameworkPaths :: [String]
cmdlineFrameworks :: [String]
rtsOpts :: Maybe String
rtsOptsEnabled :: RtsOptsEnabled
rtsOptsSuggestions :: Bool
hpcDir :: String
Path to store the .mix files
pluginModNames :: [ModuleName]
the -fplugin flags given on the command line, in *reverse* order that they're specified on the command line.
pluginModNameOpts :: [(ModuleName, String)]
frontendPluginOpts :: [String]
the -ffrontend-opt flags given on the command line, in *reverse* order that they're specified on the command line.
externalPluginSpecs :: [ExternalPluginSpec]
External plugins loaded from shared libraries
depMakefile :: FilePath
depIncludePkgDeps :: Bool
depIncludeCppDeps :: Bool
depExcludeMods :: [ModuleName]
depSuffixes :: [String]
packageDBFlags :: [PackageDBFlag]
The -package-db flags given on the command line, In *reverse* order that they're specified on the command line. This is intended to be applied with the list of "initial" package databases derived from GHC_PACKAGE_PATH; see getUnitDbRefs.
ignorePackageFlags :: [IgnorePackageFlag]
The -ignore-package flags from the command line. In *reverse* order that they're specified on the command line.
packageFlags :: [PackageFlag]
The -package and -hide-package flags from the command-line. In *reverse* order that they're specified on the command line.
pluginPackageFlags :: [PackageFlag]
The -plugin-package-id flags from command line. In *reverse* order that they're specified on the command line.
trustFlags :: [TrustFlag]
The -trust and -distrust flags. In *reverse* order that they're specified on the command line.
packageEnv :: Maybe FilePath
Filepath to the package environment file (if overriding default)
dumpFlags :: EnumSet DumpFlag
generalFlags :: EnumSet GeneralFlag
warningFlags :: EnumSet WarningFlag
fatalWarningFlags :: EnumSet WarningFlag
language :: Maybe Language
safeHaskell :: SafeHaskellMode
Safe Haskell mode
safeInfer :: Bool
safeInferred :: Bool
thOnLoc :: SrcSpan
newDerivOnLoc :: SrcSpan
deriveViaOnLoc :: SrcSpan
overlapInstLoc :: SrcSpan
incoherentOnLoc :: SrcSpan
pkgTrustOnLoc :: SrcSpan
warnSafeOnLoc :: SrcSpan
warnUnsafeOnLoc :: SrcSpan
trustworthyOnLoc :: SrcSpan
extensions :: [OnOff Extension]
extensionFlags :: EnumSet Extension
unfoldingOpts :: !UnfoldingOpts
Unfolding control See Note [Discounts and thresholds] in GHC.Core.Unfold
maxWorkerArgs :: Int
ghciHistSize :: Int
flushOut :: FlushOut
ghcVersionFile :: Maybe FilePath
haddockOptions :: Maybe String
ghciScripts :: [String]
GHCi scripts specified by -ghci-script, in reverse order
pprUserLength :: Int
pprCols :: Int
useUnicode :: Bool
useColor :: OverridingBool
canUseColor :: Bool
colScheme :: Scheme
profAuto :: ProfAuto
what kind of {-# SCC #-} to add automatically
callerCcFilters :: [CallerCcFilter]
interactivePrint :: Maybe String
sseVersion :: Maybe SseVersion
Machine dependent flags (-m<blah> stuff)
bmiVersion :: Maybe BmiVersion
avx :: Bool
avx2 :: Bool
avx512cd :: Bool
avx512er :: Bool
avx512f :: Bool
avx512pf :: Bool
rtldInfo :: IORef (Maybe LinkerInfo)
Run-time linker information (what options we need, etc.)
rtccInfo :: IORef (Maybe CompilerInfo)
Run-time C compiler information
rtasmInfo :: IORef (Maybe CompilerInfo)
Run-time assembler information
maxInlineAllocSize :: Int
Max size, in bytes, of inline array allocations.
maxInlineMemcpyInsns :: Int
Only inline memcpy if it generates no more than this many pseudo (roughly: Cmm) instructions.
maxInlineMemsetInsns :: Int
Only inline memset if it generates no more than this many pseudo (roughly: Cmm) instructions.
reverseErrors :: Bool
Reverse the order of error messages in GHC/GHCi
maxErrors :: Maybe Int
Limit the maximum number of errors to show
initialUnique :: Word
Unique supply configuration for testing build determinism
uniqueIncrement :: Int
cfgWeights :: Weights
Temporary: CFG Edge weights for fast iterations

newtype SourceError #

A source error is an error that is caused by one or more errors in the source code. A SourceError is thrown by many functions in the compilation pipeline. Inside GHC these errors are merely printed via log_action, but API clients may treat them differently, for example, insert them into a list box. If you want the default behaviour, use the idiom:

handleSourceError printExceptionAndWarnings $ do
  ... api calls that may fail ...

The SourceErrors error messages can be accessed via srcErrorMessages. This list may be empty if the compiler failed due to -Werror (Opt_WarnIsError).

See printExceptionAndWarnings for more information on what to take care of when writing a custom error handler.

Constructors

SourceError (Messages GhcMessage)

Instances

Instances details

Exception SourceError
Instance details Defined in GHC.Types.SourceError Methods toException :: SourceError -> SomeException # fromException :: SomeException -> Maybe SourceError # displayException :: SourceError -> String #
Show SourceError
Instance details Defined in GHC.Types.SourceError Methods showsPrec :: Int -> SourceError -> ShowS # show :: SourceError -> String # showList :: [SourceError] -> ShowS #

data Plugin #

Plugin is the compiler plugin data type. Try to avoid constructing one of these directly, and just modify some fields of defaultPlugin instead: this is to try and preserve source-code compatibility when we add fields to this.

Nonetheless, this API is preliminary and highly likely to change in the future.

Constructors

Plugin

Fields

installCoreToDos :: CorePlugin
Modify the Core pipeline that will be used for compilation. This is called as the Core pipeline is built for every module being compiled, and plugins get the opportunity to modify the pipeline in a nondeterministic order.
tcPlugin :: TcPlugin
An optional typechecker plugin, which may modify the behaviour of the constraint solver.
defaultingPlugin :: DefaultingPlugin
An optional defaulting plugin, which may specify the additional type-defaulting rules.
holeFitPlugin :: HoleFitPlugin
An optional plugin to handle hole fits, which may re-order or change the list of valid hole fits and refinement hole fits.
driverPlugin :: [CommandLineOption] -> HscEnv -> IO HscEnv
An optional plugin to update HscEnv, right after plugin loading. This can be used to register hooks or tweak any field of DynFlags before doing actual work on a module.
Since: ghc-8.10.1
pluginRecompile :: [CommandLineOption] -> IO PluginRecompile
Specify how the plugin should affect recompilation.
parsedResultAction :: [CommandLineOption] -> ModSummary -> ParsedResult -> Hsc ParsedResult
Modify the module when it is parsed. This is called by GHC.Driver.Main when the parser has produced no or only non-fatal errors. Compilation will fail if the messages produced by this function contain any errors.
renamedResultAction :: [CommandLineOption] -> TcGblEnv -> HsGroup GhcRn -> TcM (TcGblEnv, HsGroup GhcRn)
Modify each group after it is renamed. This is called after each HsGroup has been renamed.
typeCheckResultAction :: [CommandLineOption] -> ModSummary -> TcGblEnv -> TcM TcGblEnv
Modify the module when it is type checked. This is called at the very end of typechecking.
spliceRunAction :: [CommandLineOption] -> LHsExpr GhcTc -> TcM (LHsExpr GhcTc)
Modify the TH splice or quasiqoute before it is run.
interfaceLoadAction :: forall lcl. [CommandLineOption] -> ModIface -> IfM lcl ModIface
Modify an interface that have been loaded. This is called by GHC.Iface.Load when an interface is successfully loaded. Not applied to the loading of the plugin interface. Tools that rely on information from modules other than the currently compiled one should implement this function.

data FrontendPlugin #

Constructors

FrontendPlugin
Fields frontend :: FrontendPluginAction

data GenericUnitInfo srcpkgid srcpkgname uid modulename mod #

Information about an unit (a unit is an installed module library).

This is a subset of Cabal's InstalledPackageInfo, with just the bits that GHC is interested in.

Some types are left as parameters to be instantiated differently in ghc-pkg and in ghc itself.

Constructors

GenericUnitInfo

Fields

unitId :: uid
Unique unit identifier that is used during compilation (e.g. to generate symbols).
unitInstanceOf :: uid
Identifier of an indefinite unit (i.e. with module holes) that this unit is an instance of.
For non instantiated units, unitInstanceOf=unitId
unitInstantiations :: [(modulename, mod)]
How this unit instantiates some of its module holes. Map hole module names to actual module
unitPackageId :: srcpkgid
Source package identifier.
Cabal instantiates this with Distribution.Types.PackageId.PackageId type which only contains the source package name and version. Notice that it doesn't contain the Hackage revision, nor any kind of hash.
unitPackageName :: srcpkgname
Source package name
unitPackageVersion :: Version
Source package version
unitComponentName :: Maybe srcpkgname
Name of the component.
Cabal supports more than one components (libraries, executables, testsuites) in the same package. Each component has a name except the default one (that can only be a library component) for which we use Nothing.
GHC only deals with "library" components as they are the only kind of components that can be registered in a database and used by other modules.
unitAbiHash :: ShortText
ABI hash used to avoid mixing up units compiled with different dependencies, compiler, options, etc.
unitDepends :: [uid]
Identifiers of the units this one depends on
unitAbiDepends :: [(uid, ShortText)]
Like unitDepends, but each dependency is annotated with the ABI hash we expect the dependency to respect.
unitImportDirs :: [FilePathST]
Directories containing module interfaces
unitLibraries :: [ShortText]
Names of the Haskell libraries provided by this unit
unitExtDepLibsSys :: [ShortText]
Names of the external system libraries that this unit depends on. See also unitExtDepLibsGhc field.
unitExtDepLibsGhc :: [ShortText]
Because of slight differences between the GHC dynamic linker (in GHC.Runtime.Linker) and the native system linker, some packages have to link with a different list of libraries when using GHC's. Examples include: libs that are actually gnu ld scripts, and the possibility that the .a libs do not exactly match the .so/.dll equivalents.
If this field is set, then we use that instead of the unitExtDepLibsSys field.
unitLibraryDirs :: [FilePathST]
Directories containing libraries provided by this unit. See also unitLibraryDynDirs.
It seems to be used to store paths to external library dependencies too.
unitLibraryDynDirs :: [FilePathST]
Directories containing the dynamic libraries provided by this unit. See also unitLibraryDirs.
It seems to be used to store paths to external dynamic library dependencies too.
unitExtDepFrameworks :: [ShortText]
Names of the external MacOS frameworks that this unit depends on.
unitExtDepFrameworkDirs :: [FilePathST]
Directories containing MacOS frameworks that this unit depends on.
unitLinkerOptions :: [ShortText]
Linker (e.g. ld) command line options
unitCcOptions :: [ShortText]
C compiler options that needs to be passed to the C compiler when we compile some C code against this unit.
unitIncludes :: [ShortText]
C header files that are required by this unit (provided by this unit or external)
unitIncludeDirs :: [FilePathST]
Directories containing C header files that this unit depends on.
unitHaddockInterfaces :: [FilePathST]
Paths to Haddock interface files for this unit
unitHaddockHTMLs :: [FilePathST]
Paths to Haddock directories containing HTML files
unitExposedModules :: [(modulename, Maybe mod)]
Modules exposed by the unit.
A module can be re-exported from another package. In this case, we indicate the module origin in the second parameter.
unitHiddenModules :: [modulename]
Hidden modules.
These are useful for error reporting (e.g. if a hidden module is imported)
unitIsIndefinite :: Bool
True if this unit has some module holes that need to be instantiated with real modules to make the unit usable (a.k.a. Backpack).
unitIsExposed :: Bool
True if the unit is exposed. A unit could be installed in a database by "disabled" by not being exposed.
unitIsTrusted :: Bool
True if the unit is trusted (cf Safe Haskell)

Instances

Instances details

Binary DbUnitInfo
Instance details Defined in GHC.Unit.Database Methods put :: DbUnitInfo -> Put # get :: Get DbUnitInfo # putList :: [DbUnitInfo] -> Put #
(Show uid, Show modulename, Show mod, Show srcpkgid, Show srcpkgname) => Show (GenericUnitInfo srcpkgid srcpkgname uid modulename mod)
Instance details Defined in GHC.Unit.Database Methods showsPrec :: Int -> GenericUnitInfo srcpkgid srcpkgname uid modulename mod -> ShowS # show :: GenericUnitInfo srcpkgid srcpkgname uid modulename mod -> String # showList :: [GenericUnitInfo srcpkgid srcpkgname uid modulename mod] -> ShowS #
(Eq uid, Eq modulename, Eq mod, Eq srcpkgid, Eq srcpkgname) => Eq (GenericUnitInfo srcpkgid srcpkgname uid modulename mod)
Instance details Defined in GHC.Unit.Database Methods (==) :: GenericUnitInfo srcpkgid srcpkgname uid modulename mod -> GenericUnitInfo srcpkgid srcpkgname uid modulename mod -> Bool # (/=) :: GenericUnitInfo srcpkgid srcpkgname uid modulename mod -> GenericUnitInfo srcpkgid srcpkgname uid modulename mod -> Bool #

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

Instances details

Generic ForeignSrcLang
Instance details Defined in GHC.ForeignSrcLang.Type Associated Types type Rep ForeignSrcLang :: Type -> Type # Methods from :: ForeignSrcLang -> Rep ForeignSrcLang x # to :: Rep ForeignSrcLang x -> ForeignSrcLang #
Show ForeignSrcLang
Instance details Defined in GHC.ForeignSrcLang.Type Methods showsPrec :: Int -> ForeignSrcLang -> ShowS # show :: ForeignSrcLang -> String # showList :: [ForeignSrcLang] -> ShowS #
Eq ForeignSrcLang
Instance details Defined in GHC.ForeignSrcLang.Type Methods (==) :: ForeignSrcLang -> ForeignSrcLang -> Bool # (/=) :: ForeignSrcLang -> ForeignSrcLang -> Bool #
type Rep ForeignSrcLang
Instance details Defined in GHC.ForeignSrcLang.Type type Rep ForeignSrcLang = D1 ('MetaData "ForeignSrcLang" "GHC.ForeignSrcLang.Type" "ghc-boot-th-9.6.3" 'False) ((C1 ('MetaCons "LangC" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "LangCxx" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "LangObjc" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "LangObjcxx" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "LangAsm" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "LangJs" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "RawObject" 'PrefixI 'False) (U1 :: Type -> Type))))

type HasDebugCallStack = () #

A call stack constraint, but only when isDebugOn.

data Direction #

Constructors

Forwards
Backwards

type Suffix = String #

data PtrString #

A PtrString is a pointer to some array of Latin-1 encoded chars.

Constructors

PtrString !(Ptr Word8) !Int

newtype LexicalFastString #

Lexical FastString

This is a simple FastString wrapper with an Ord instance using lexicalCompareFS (i.e. which compares FastStrings on their String representation). Hence it is deterministic from one run to the other.

Constructors

LexicalFastString FastString

Instances

Instances details

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

newtype NonDetFastString #

Non-deterministic FastString

This is a simple FastString wrapper with an Ord instance using uniqCompareFS (i.e. which compares FastStrings on their Uniques). Hence it is not deterministic from one run to the other.

Constructors

NonDetFastString FastString

Instances

Instances details

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

data FastString #

A FastString is a UTF-8 encoded string together with a unique ID. All FastStrings are stored in a global hashtable to support fast O(1) comparison.

It is also associated with a lazy reference to the Z-encoding of this string which is used by the compiler internally.

Constructors

FastString
Fields uniq :: !Int n_chars :: !Int fs_sbs :: !ShortByteString fs_zenc :: FastZString Lazily computed Z-encoding of this string. See Note [Z-Encoding] in GHC.Utils.Encoding. Since `FastString`s are globally memoized this is computed at most once for any given string.

Instances

Instances details

Data FastString
Instance details Defined in GHC.Data.FastString Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FastString -> c FastString # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FastString # toConstr :: FastString -> Constr # dataTypeOf :: FastString -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FastString) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FastString) # gmapT :: (forall b. Data b => b -> b) -> FastString -> FastString # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FastString -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FastString -> r # gmapQ :: (forall d. Data d => d -> u) -> FastString -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FastString -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FastString -> m FastString # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FastString -> m FastString # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FastString -> m FastString #
IsString FastString
Instance details Defined in GHC.Data.FastString Methods fromString :: String -> FastString #
Monoid FastString
Instance details Defined in GHC.Data.FastString Methods mempty :: FastString # mappend :: FastString -> FastString -> FastString # mconcat :: [FastString] -> FastString #
Semigroup FastString
Instance details Defined in GHC.Data.FastString Methods (<>) :: FastString -> FastString -> FastString # sconcat :: NonEmpty FastString -> FastString # stimes :: Integral b => b -> FastString -> FastString #
Show FastString
Instance details Defined in GHC.Data.FastString Methods showsPrec :: Int -> FastString -> ShowS # show :: FastString -> String # showList :: [FastString] -> ShowS #
NFData FastString
Instance details Defined in GHC.Data.FastString Methods rnf :: FastString -> () #
ToJExpr FastString
Instance details Defined in GHC.JS.Make Methods toJExpr :: FastString -> JExpr # toJExprFromList :: [FastString] -> JExpr #
Uniquable FastString
Instance details Defined in GHC.Types.Unique Methods getUnique :: FastString -> Unique #
Outputable FastString
Instance details Defined in GHC.Utils.Outputable Methods ppr :: FastString -> SDoc #
Eq FastString
Instance details Defined in GHC.Data.FastString Methods (==) :: FastString -> FastString -> Bool # (/=) :: FastString -> FastString -> Bool #
ToJExpr a => ToJExpr (UniqMap FastString a)
Instance details Defined in GHC.JS.Make Methods toJExpr :: UniqMap FastString a -> JExpr # toJExprFromList :: [UniqMap FastString a] -> JExpr #
type Anno FastString
Instance details Defined in GHC.Hs.Expr type Anno FastString = SrcAnn NoEpAnns
type Anno (SourceText, RuleName)
Instance details Defined in GHC.Hs.Decls type Anno (SourceText, RuleName) = SrcAnn NoEpAnns

data FastZString #

Instances

Instances details

NFData FastZString
Instance details Defined in GHC.Data.FastString Methods rnf :: FastZString -> () #

data SrcUnpackedness #

Source Unpackedness

What unpackedness the user requested

Constructors

SrcUnpack	{-# UNPACK #-} specified
SrcNoUnpack	{-# NOUNPACK #-} specified
NoSrcUnpack	no unpack pragma

Instances

Instances details

Data SrcUnpackedness
Instance details 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
Instance details 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

Instances details

Data SrcStrictness
Instance details 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
Instance details Defined in Language.Haskell.Syntax.Basic Methods (==) :: SrcStrictness -> SrcStrictness -> Bool # (/=) :: SrcStrictness -> SrcStrictness -> Bool #

data 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

Instances details

Data Role
Instance details 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 # toConstr :: Role -> Constr # 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
Instance details Defined in Language.Haskell.Syntax.Basic Methods (==) :: Role -> Role -> Bool # (/=) :: Role -> Role -> Bool #
Ord Role
Instance details Defined in Language.Haskell.Syntax.Basic Methods compare :: Role -> Role -> Ordering # (<) :: Role -> Role -> Bool # (<=) :: Role -> Role -> Bool # (>) :: Role -> Role -> Bool # (>=) :: Role -> Role -> Bool # max :: Role -> Role -> Role # min :: Role -> Role -> Role #
type Anno (Maybe Role)
Instance details Defined in GHC.Hs.Decls type Anno (Maybe Role) = SrcAnn NoEpAnns
type Anno (Maybe Role)
Instance details Defined in GHC.Hs.Decls type Anno (Maybe Role) = SrcAnn NoEpAnns

data FieldLabelString #

Field labels are just represented as strings; they are not necessarily unique (even within a module)

Instances

Instances details

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

type ConTag = Int #

A *one-index* constructor tag

Type of the tags associated with each constructor possibility or superclass selector

data Boxity #

Constructors

Boxed
Unboxed

Instances

Instances details

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

type family NoGhcTc p #

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

Instances details

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]
Instance details Defined in GHC.Hs.Extension type NoGhcTc (GhcPass pass) = GhcPass (NoGhcTcPass pass)

type family XXIEWrappedName p #

Instances

Instances details

type XXIEWrappedName (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XXIEWrappedName (GhcPass _1) = DataConCantHappen

type family XIEType p #

Instances

Instances details

type XIEType (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEType (GhcPass _1) = EpaLocation

type family XIEPattern p #

Instances

Instances details

type XIEPattern (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEPattern (GhcPass _1) = EpaLocation

type family XIEName p #

Instances

Instances details

type XIEName (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEName (GhcPass _1) = NoExtField

type family XXIE x #

Instances

Instances details

type XXIE (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XXIE (GhcPass _1) = DataConCantHappen

type family XIEDocNamed x #

Instances

Instances details

type XIEDocNamed (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEDocNamed (GhcPass _1) = NoExtField

type family XIEDoc x #

Instances

Instances details

type XIEDoc (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEDoc (GhcPass _1) = NoExtField

type family XIEGroup x #

Instances

Instances details

type XIEGroup (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEGroup (GhcPass _1) = NoExtField

type family XIEModuleContents x #

Instances

Instances details

type XIEModuleContents GhcPs
Instance details Defined in GHC.Hs.ImpExp type XIEModuleContents GhcPs = EpAnn [AddEpAnn]
type XIEModuleContents GhcRn
Instance details Defined in GHC.Hs.ImpExp type XIEModuleContents GhcRn = NoExtField
type XIEModuleContents GhcTc
Instance details Defined in GHC.Hs.ImpExp type XIEModuleContents GhcTc = NoExtField

type family XIEThingWith x #

Instances

Instances details

type XIEThingWith (GhcPass 'Parsed)
Instance details Defined in GHC.Hs.ImpExp type XIEThingWith (GhcPass 'Parsed) = EpAnn [AddEpAnn]
type XIEThingWith (GhcPass 'Renamed)
Instance details Defined in GHC.Hs.ImpExp type XIEThingWith (GhcPass 'Renamed) = [Located FieldLabel]
type XIEThingWith (GhcPass 'Typechecked)
Instance details Defined in GHC.Hs.ImpExp type XIEThingWith (GhcPass 'Typechecked) = NoExtField

type family XIEThingAll x #

Instances

Instances details

type XIEThingAll (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEThingAll (GhcPass _1) = EpAnn [AddEpAnn]

type family XIEThingAbs x #

Instances

Instances details

type XIEThingAbs (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEThingAbs (GhcPass _1) = EpAnn [AddEpAnn]

type family XIEVar x #

Instances

Instances details

type XIEVar GhcPs
Instance details Defined in GHC.Hs.ImpExp type XIEVar GhcPs = NoExtField
type XIEVar GhcRn
Instance details Defined in GHC.Hs.ImpExp type XIEVar GhcRn = NoExtField
type XIEVar GhcTc
Instance details Defined in GHC.Hs.ImpExp type XIEVar GhcTc = NoExtField

type family ImportDeclPkgQual x #

Instances

Instances details

type ImportDeclPkgQual GhcPs
Instance details Defined in GHC.Hs.ImpExp type ImportDeclPkgQual GhcPs = RawPkgQual
type ImportDeclPkgQual GhcRn
Instance details Defined in GHC.Hs.ImpExp type ImportDeclPkgQual GhcRn = PkgQual
type ImportDeclPkgQual GhcTc
Instance details Defined in GHC.Hs.ImpExp type ImportDeclPkgQual GhcTc = PkgQual

type family XXImportDecl x #

Instances

Instances details

type XXImportDecl (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XXImportDecl (GhcPass _1) = DataConCantHappen

type family XCImportDecl x #

Instances

Instances details

type XCImportDecl GhcPs
Instance details Defined in GHC.Hs.ImpExp type XCImportDecl GhcPs = XImportDeclPass
type XCImportDecl GhcRn
Instance details Defined in GHC.Hs.ImpExp type XCImportDecl GhcRn = XImportDeclPass
type XCImportDecl GhcTc
Instance details Defined in GHC.Hs.ImpExp type XCImportDecl GhcTc = DataConCantHappen

type family XXFieldOcc x #

Instances

Instances details

type XXFieldOcc (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XXFieldOcc (GhcPass _1) = DataConCantHappen

type family XCFieldOcc x #

Instances

Instances details

type XCFieldOcc GhcPs
Instance details Defined in GHC.Hs.Type type XCFieldOcc GhcPs = NoExtField
type XCFieldOcc GhcRn
Instance details Defined in GHC.Hs.Type type XCFieldOcc GhcRn = Name
type XCFieldOcc GhcTc
Instance details Defined in GHC.Hs.Type type XCFieldOcc GhcTc = Id

type family XXConDeclField x #

Instances

Instances details

type XXConDeclField (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XXConDeclField (GhcPass _1) = DataConCantHappen

type family XConDeclField x #

Instances

Instances details

type XConDeclField (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XConDeclField (GhcPass _1) = EpAnn [AddEpAnn]

type family XXTyVarBndr x #

Instances

Instances details

type XXTyVarBndr (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XXTyVarBndr (GhcPass _1) = DataConCantHappen

type family XKindedTyVar x #

Instances

Instances details

type XKindedTyVar (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XKindedTyVar (GhcPass _1) = EpAnn [AddEpAnn]

type family XUserTyVar x #

Instances

Instances details

type XUserTyVar (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XUserTyVar (GhcPass _1) = EpAnn [AddEpAnn]

type family XXHsForAllTelescope x #

Instances

Instances details

type XXHsForAllTelescope (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XXHsForAllTelescope (GhcPass _1) = DataConCantHappen

type family XHsForAllInvis x #

Instances

Instances details

type XHsForAllInvis (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XHsForAllInvis (GhcPass _1) = EpAnnForallTy

type family XHsForAllVis x #

Instances

Instances details

type XHsForAllVis (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XHsForAllVis (GhcPass _1) = EpAnnForallTy

type family XXTyLit x #

Instances

Instances details

type XXTyLit (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XXTyLit (GhcPass _1) = DataConCantHappen

type family XCharTy x #

Instances

Instances details

type XCharTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XCharTy (GhcPass _1) = SourceText

type family XStrTy x #

Instances

Instances details

type XStrTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XStrTy (GhcPass _1) = SourceText

type family XNumTy x #

Instances

Instances details

type XNumTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XNumTy (GhcPass _1) = SourceText

type family XXType x #

Instances

Instances details

type XXType (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XXType (GhcPass _1) = HsCoreTy

type family XWildCardTy x #

Instances

Instances details

type XWildCardTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XWildCardTy (GhcPass _1) = NoExtField

type family XTyLit x #

Instances

Instances details

type XTyLit (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XTyLit (GhcPass _1) = NoExtField

type family XExplicitTupleTy x #

Instances

Instances details

type XExplicitTupleTy GhcPs
Instance details Defined in GHC.Hs.Type type XExplicitTupleTy GhcPs = EpAnn [AddEpAnn]
type XExplicitTupleTy GhcRn
Instance details Defined in GHC.Hs.Type type XExplicitTupleTy GhcRn = NoExtField
type XExplicitTupleTy GhcTc
Instance details Defined in GHC.Hs.Type type XExplicitTupleTy GhcTc = [Kind]

type family XExplicitListTy x #

Instances

Instances details

type XExplicitListTy GhcPs
Instance details Defined in GHC.Hs.Type type XExplicitListTy GhcPs = EpAnn [AddEpAnn]
type XExplicitListTy GhcRn
Instance details Defined in GHC.Hs.Type type XExplicitListTy GhcRn = NoExtField
type XExplicitListTy GhcTc
Instance details Defined in GHC.Hs.Type type XExplicitListTy GhcTc = Kind

type family XRecTy x #

Instances

Instances details

type XRecTy GhcPs
Instance details Defined in GHC.Hs.Type type XRecTy GhcPs = EpAnn AnnList
type XRecTy GhcRn
Instance details Defined in GHC.Hs.Type type XRecTy GhcRn = NoExtField
type XRecTy GhcTc
Instance details Defined in GHC.Hs.Type type XRecTy GhcTc = NoExtField

type family XBangTy x #

Instances

Instances details

type XBangTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XBangTy (GhcPass _1) = EpAnn [AddEpAnn]

type family XDocTy x #

Instances

Instances details

type XDocTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XDocTy (GhcPass _1) = EpAnn [AddEpAnn]

type family XSpliceTy x #

Instances

Instances details

type XSpliceTy GhcPs
Instance details Defined in GHC.Hs.Type type XSpliceTy GhcPs = NoExtField
type XSpliceTy GhcRn
Instance details Defined in GHC.Hs.Type type XSpliceTy GhcRn = HsUntypedSpliceResult (LHsType GhcRn)
type XSpliceTy GhcTc
Instance details Defined in GHC.Hs.Type type XSpliceTy GhcTc = Kind

type family XKindSig x #

Instances

Instances details

type XKindSig (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XKindSig (GhcPass _1) = EpAnn [AddEpAnn]

type family XStarTy x #

Instances

Instances details

type XStarTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XStarTy (GhcPass _1) = NoExtField

type family XIParamTy x #

Instances

Instances details

type XIParamTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XIParamTy (GhcPass _1) = EpAnn [AddEpAnn]

type family XParTy x #

Instances

Instances details

type XParTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XParTy (GhcPass _1) = EpAnn AnnParen

type family XOpTy x #

Instances

Instances details

type XOpTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XOpTy (GhcPass _1) = EpAnn [AddEpAnn]

type family XSumTy x #

Instances

Instances details

type XSumTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XSumTy (GhcPass _1) = EpAnn AnnParen

type family XTupleTy x #

Instances

Instances details

type XTupleTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XTupleTy (GhcPass _1) = EpAnn AnnParen

type family XListTy x #

Instances

Instances details

type XListTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XListTy (GhcPass _1) = EpAnn AnnParen

type family XFunTy x #

Instances

Instances details

type XFunTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XFunTy (GhcPass _1) = EpAnnCO

type family XAppKindTy x #

Instances

Instances details

type XAppKindTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XAppKindTy (GhcPass _1) = SrcSpan

type family XAppTy x #

Instances

Instances details

type XAppTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XAppTy (GhcPass _1) = NoExtField

type family XTyVar x #

Instances

Instances details

type XTyVar (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XTyVar (GhcPass _1) = EpAnn [AddEpAnn]

type family XQualTy x #

Instances

Instances details

type XQualTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XQualTy (GhcPass _1) = NoExtField

type family XForAllTy x #

Instances

Instances details

type XForAllTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XForAllTy (GhcPass _1) = NoExtField

type family XXHsPatSigType x #

Instances

Instances details

type XXHsPatSigType (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XXHsPatSigType (GhcPass _1) = DataConCantHappen

type family XHsPS x #

Instances

Instances details

type XHsPS GhcPs
Instance details Defined in GHC.Hs.Type type XHsPS GhcPs = EpAnnCO
type XHsPS GhcRn
Instance details Defined in GHC.Hs.Type type XHsPS GhcRn = HsPSRn
type XHsPS GhcTc
Instance details Defined in GHC.Hs.Type type XHsPS GhcTc = HsPSRn

type family XXHsWildCardBndrs x b #

Instances

Instances details

type XXHsWildCardBndrs (GhcPass _1) _2
Instance details Defined in GHC.Hs.Type type XXHsWildCardBndrs (GhcPass _1) _2 = DataConCantHappen

type family XHsWC x b #

Instances

Instances details

type XHsWC GhcPs b
Instance details Defined in GHC.Hs.Type type XHsWC GhcPs b = NoExtField
type XHsWC GhcRn b
Instance details Defined in GHC.Hs.Type type XHsWC GhcRn b = [Name]
type XHsWC GhcTc b
Instance details Defined in GHC.Hs.Type type XHsWC GhcTc b = [Name]

type family XXHsSigType x #

Instances

Instances details

type XXHsSigType (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XXHsSigType (GhcPass _1) = DataConCantHappen

type family XHsSig x #

Instances

Instances details

type XHsSig (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XHsSig (GhcPass _1) = NoExtField

type family XXHsOuterTyVarBndrs x #

Instances

Instances details

type XXHsOuterTyVarBndrs (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XXHsOuterTyVarBndrs (GhcPass _1) = DataConCantHappen

type family XHsOuterExplicit x flag #

Instances

Instances details

type XHsOuterExplicit GhcPs _1
Instance details Defined in GHC.Hs.Type type XHsOuterExplicit GhcPs _1 = EpAnnForallTy
type XHsOuterExplicit GhcRn _1
Instance details Defined in GHC.Hs.Type type XHsOuterExplicit GhcRn _1 = NoExtField
type XHsOuterExplicit GhcTc flag
Instance details Defined in GHC.Hs.Type type XHsOuterExplicit GhcTc flag = [VarBndr TyVar flag]

type family XHsOuterImplicit x #

Instances

Instances details

type XHsOuterImplicit GhcPs
Instance details Defined in GHC.Hs.Type type XHsOuterImplicit GhcPs = NoExtField
type XHsOuterImplicit GhcRn
Instance details Defined in GHC.Hs.Type type XHsOuterImplicit GhcRn = [Name]
type XHsOuterImplicit GhcTc
Instance details Defined in GHC.Hs.Type type XHsOuterImplicit GhcTc = [TyVar]

type family XXLHsQTyVars x #

Instances

Instances details

type XXLHsQTyVars (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XXLHsQTyVars (GhcPass _1) = DataConCantHappen

type family XHsQTvs x #

Instances

Instances details

type XHsQTvs GhcPs
Instance details Defined in GHC.Hs.Type type XHsQTvs GhcPs = NoExtField
type XHsQTvs GhcRn
Instance details Defined in GHC.Hs.Type type XHsQTvs GhcRn = HsQTvsRn
type XHsQTvs GhcTc
Instance details Defined in GHC.Hs.Type type XHsQTvs GhcTc = HsQTvsRn

type family XHsFieldBind x #

Instances

Instances details

type XHsFieldBind _1
Instance details Defined in GHC.Hs.Pat type XHsFieldBind _1 = EpAnn [AddEpAnn]

type family XXPat x #

Instances

Instances details

type XXPat GhcPs
Instance details Defined in GHC.Hs.Pat type XXPat GhcPs = DataConCantHappen
type XXPat GhcRn
Instance details Defined in GHC.Hs.Pat type XXPat GhcRn = HsPatExpansion (Pat GhcRn) (Pat GhcRn)
type XXPat GhcTc
Instance details Defined in GHC.Hs.Pat type XXPat GhcTc = XXPatGhcTc

type family XCoPat x #

type family XSigPat x #

Instances

Instances details

type XSigPat GhcPs
Instance details Defined in GHC.Hs.Pat type XSigPat GhcPs = EpAnn [AddEpAnn]
type XSigPat GhcRn
Instance details Defined in GHC.Hs.Pat type XSigPat GhcRn = NoExtField
type XSigPat GhcTc
Instance details Defined in GHC.Hs.Pat type XSigPat GhcTc = Type

type family XNPlusKPat x #

Instances

Instances details

type XNPlusKPat GhcPs
Instance details Defined in GHC.Hs.Pat type XNPlusKPat GhcPs = EpAnn EpaLocation
type XNPlusKPat GhcRn
Instance details Defined in GHC.Hs.Pat type XNPlusKPat GhcRn = NoExtField
type XNPlusKPat GhcTc
Instance details Defined in GHC.Hs.Pat type XNPlusKPat GhcTc = Type

type family XNPat x #

Instances

Instances details

type XNPat GhcPs
Instance details Defined in GHC.Hs.Pat type XNPat GhcPs = EpAnn [AddEpAnn]
type XNPat GhcRn
Instance details Defined in GHC.Hs.Pat type XNPat GhcRn = EpAnn [AddEpAnn]
type XNPat GhcTc
Instance details Defined in GHC.Hs.Pat type XNPat GhcTc = Type

type family XLitPat x #

Instances

Instances details

type XLitPat (GhcPass _1)
Instance details Defined in GHC.Hs.Pat type XLitPat (GhcPass _1) = NoExtField

type family XSplicePat x #

Instances

Instances details

type XSplicePat GhcPs
Instance details Defined in GHC.Hs.Pat type XSplicePat GhcPs = NoExtField
type XSplicePat GhcRn
Instance details Defined in GHC.Hs.Pat type XSplicePat GhcRn = HsUntypedSpliceResult (Pat GhcRn)
type XSplicePat GhcTc
Instance details Defined in GHC.Hs.Pat type XSplicePat GhcTc = DataConCantHappen

type family XViewPat x #

Instances

Instances details

type XViewPat GhcPs
Instance details Defined in GHC.Hs.Pat type XViewPat GhcPs = EpAnn [AddEpAnn]
type XViewPat GhcRn
Instance details Defined in GHC.Hs.Pat type XViewPat GhcRn = Maybe (HsExpr GhcRn)
type XViewPat GhcTc
Instance details Defined in GHC.Hs.Pat type XViewPat GhcTc = Type

type family XConPat x #

Instances

Instances details

type XConPat GhcPs
Instance details Defined in GHC.Hs.Pat type XConPat GhcPs = EpAnn [AddEpAnn]
type XConPat GhcRn
Instance details Defined in GHC.Hs.Pat type XConPat GhcRn = NoExtField
type XConPat GhcTc
Instance details Defined in GHC.Hs.Pat type XConPat GhcTc = ConPatTc

type family XSumPat x #

Instances

Instances details

type XSumPat GhcPs
Instance details Defined in GHC.Hs.Pat type XSumPat GhcPs = EpAnn EpAnnSumPat
type XSumPat GhcRn
Instance details Defined in GHC.Hs.Pat type XSumPat GhcRn = NoExtField
type XSumPat GhcTc
Instance details Defined in GHC.Hs.Pat type XSumPat GhcTc = [Type]

type family XTuplePat x #

Instances

Instances details

type XTuplePat GhcPs
Instance details Defined in GHC.Hs.Pat type XTuplePat GhcPs = EpAnn [AddEpAnn]
type XTuplePat GhcRn
Instance details Defined in GHC.Hs.Pat type XTuplePat GhcRn = NoExtField
type XTuplePat GhcTc
Instance details Defined in GHC.Hs.Pat type XTuplePat GhcTc = [Type]

type family XListPat x #

Instances

Instances details

type XListPat GhcPs
Instance details Defined in GHC.Hs.Pat type XListPat GhcPs = EpAnn AnnList
type XListPat GhcRn
Instance details Defined in GHC.Hs.Pat type XListPat GhcRn = NoExtField
type XListPat GhcTc
Instance details Defined in GHC.Hs.Pat type XListPat GhcTc = Type

type family XBangPat x #

Instances

Instances details

type XBangPat GhcPs
Instance details Defined in GHC.Hs.Pat type XBangPat GhcPs = EpAnn [AddEpAnn]
type XBangPat GhcRn
Instance details Defined in GHC.Hs.Pat type XBangPat GhcRn = NoExtField
type XBangPat GhcTc
Instance details Defined in GHC.Hs.Pat type XBangPat GhcTc = NoExtField

type family XParPat x #

Instances

Instances details

type XParPat (GhcPass _1)
Instance details Defined in GHC.Hs.Pat type XParPat (GhcPass _1) = EpAnnCO

type family XAsPat x #

Instances

Instances details

type XAsPat GhcPs
Instance details Defined in GHC.Hs.Pat type XAsPat GhcPs = EpAnnCO
type XAsPat GhcRn
Instance details Defined in GHC.Hs.Pat type XAsPat GhcRn = NoExtField
type XAsPat GhcTc
Instance details Defined in GHC.Hs.Pat type XAsPat GhcTc = NoExtField

type family XLazyPat x #

Instances

Instances details

type XLazyPat GhcPs
Instance details Defined in GHC.Hs.Pat type XLazyPat GhcPs = EpAnn [AddEpAnn]
type XLazyPat GhcRn
Instance details Defined in GHC.Hs.Pat type XLazyPat GhcRn = NoExtField
type XLazyPat GhcTc
Instance details Defined in GHC.Hs.Pat type XLazyPat GhcTc = NoExtField

type family XVarPat x #

Instances

Instances details

type XVarPat (GhcPass _1)
Instance details Defined in GHC.Hs.Pat type XVarPat (GhcPass _1) = NoExtField

type family XWildPat x #

Instances

Instances details

type XWildPat GhcPs
Instance details Defined in GHC.Hs.Pat type XWildPat GhcPs = NoExtField
type XWildPat GhcRn
Instance details Defined in GHC.Hs.Pat type XWildPat GhcRn = NoExtField
type XWildPat GhcTc
Instance details Defined in GHC.Hs.Pat type XWildPat GhcTc = Type

type family XXOverLit x #

Instances

Instances details

type XXOverLit (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XXOverLit (GhcPass _1) = DataConCantHappen

type family XOverLit x #

Instances

Instances details

type XOverLit GhcPs
Instance details Defined in GHC.Hs.Lit type XOverLit GhcPs = NoExtField
type XOverLit GhcRn
Instance details Defined in GHC.Hs.Lit type XOverLit GhcRn = OverLitRn
type XOverLit GhcTc
Instance details Defined in GHC.Hs.Lit type XOverLit GhcTc = OverLitTc

type family XXLit x #

Instances

Instances details

type XXLit (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XXLit (GhcPass _1) = DataConCantHappen

type family XHsDoublePrim x #

Instances

Instances details

type XHsDoublePrim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsDoublePrim (GhcPass _1) = NoExtField

type family XHsFloatPrim x #

Instances

Instances details

type XHsFloatPrim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsFloatPrim (GhcPass _1) = NoExtField

type family XHsRat x #

Instances

Instances details

type XHsRat (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsRat (GhcPass _1) = NoExtField

type family XHsInteger x #

Instances

Instances details

type XHsInteger (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsInteger (GhcPass _1) = SourceText

type family XHsWord64Prim x #

Instances

Instances details

type XHsWord64Prim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsWord64Prim (GhcPass _1) = SourceText

type family XHsInt64Prim x #

Instances

Instances details

type XHsInt64Prim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsInt64Prim (GhcPass _1) = SourceText

type family XHsWordPrim x #

Instances

Instances details

type XHsWordPrim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsWordPrim (GhcPass _1) = SourceText

type family XHsIntPrim x #

Instances

Instances details

type XHsIntPrim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsIntPrim (GhcPass _1) = SourceText

type family XHsInt x #

Instances

Instances details

type XHsInt (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsInt (GhcPass _1) = NoExtField

type family XHsStringPrim x #

Instances

Instances details

type XHsStringPrim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsStringPrim (GhcPass _1) = SourceText

type family XHsString x #

Instances

Instances details

type XHsString (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsString (GhcPass _1) = SourceText

type family XHsCharPrim x #

Instances

Instances details

type XHsCharPrim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsCharPrim (GhcPass _1) = SourceText

type family XHsChar x #

Instances

Instances details

type XHsChar (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsChar (GhcPass _1) = SourceText

type family XXApplicativeArg x #

Instances

Instances details

type XXApplicativeArg (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XXApplicativeArg (GhcPass _1) = DataConCantHappen

type family XApplicativeArgMany x #

Instances

Instances details

type XApplicativeArgMany (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XApplicativeArgMany (GhcPass _1) = NoExtField

type family XApplicativeArgOne x #

Instances

Instances details

type XApplicativeArgOne GhcPs
Instance details Defined in GHC.Hs.Expr type XApplicativeArgOne GhcPs = NoExtField
type XApplicativeArgOne GhcRn
Instance details Defined in GHC.Hs.Expr type XApplicativeArgOne GhcRn = FailOperator GhcRn
type XApplicativeArgOne GhcTc
Instance details Defined in GHC.Hs.Expr type XApplicativeArgOne GhcTc = FailOperator GhcTc

type family XXParStmtBlock x x' #

Instances

Instances details

type XXParStmtBlock (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Expr type XXParStmtBlock (GhcPass pL) (GhcPass pR) = DataConCantHappen

type family XParStmtBlock x x' #

Instances

Instances details

type XParStmtBlock (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Expr type XParStmtBlock (GhcPass pL) (GhcPass pR) = NoExtField

type family XXCmd x #

Instances

Instances details

type XXCmd GhcPs
Instance details Defined in GHC.Hs.Expr type XXCmd GhcPs = DataConCantHappen
type XXCmd GhcRn
Instance details Defined in GHC.Hs.Expr type XXCmd GhcRn = DataConCantHappen
type XXCmd GhcTc
Instance details Defined in GHC.Hs.Expr type XXCmd GhcTc = HsWrap HsCmd

type family XCmdWrap x #

Instances

Instances details

type XCmdWrap (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCmdWrap (GhcPass _1) = NoExtField

type family XCmdDo x #

Instances

Instances details

type XCmdDo GhcPs
Instance details Defined in GHC.Hs.Expr type XCmdDo GhcPs = EpAnn AnnList
type XCmdDo GhcRn
Instance details Defined in GHC.Hs.Expr type XCmdDo GhcRn = NoExtField
type XCmdDo GhcTc
Instance details Defined in GHC.Hs.Expr type XCmdDo GhcTc = Type

type family XCmdLet x #

Instances

Instances details

type XCmdLet GhcPs
Instance details Defined in GHC.Hs.Expr type XCmdLet GhcPs = EpAnnCO
type XCmdLet GhcRn
Instance details Defined in GHC.Hs.Expr type XCmdLet GhcRn = NoExtField
type XCmdLet GhcTc
Instance details Defined in GHC.Hs.Expr type XCmdLet GhcTc = NoExtField

type family XCmdIf x #

Instances

Instances details

type XCmdIf GhcPs
Instance details Defined in GHC.Hs.Expr type XCmdIf GhcPs = EpAnn AnnsIf
type XCmdIf GhcRn
Instance details Defined in GHC.Hs.Expr type XCmdIf GhcRn = NoExtField
type XCmdIf GhcTc
Instance details Defined in GHC.Hs.Expr type XCmdIf GhcTc = NoExtField

type family XCmdLamCase x #

Instances

Instances details

type XCmdLamCase (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCmdLamCase (GhcPass _1) = EpAnn [AddEpAnn]

type family XCmdCase x #

Instances

Instances details

type XCmdCase GhcPs
Instance details Defined in GHC.Hs.Expr type XCmdCase GhcPs = EpAnn EpAnnHsCase
type XCmdCase GhcRn
Instance details Defined in GHC.Hs.Expr type XCmdCase GhcRn = NoExtField
type XCmdCase GhcTc
Instance details Defined in GHC.Hs.Expr type XCmdCase GhcTc = NoExtField

type family XCmdPar x #

Instances

Instances details

type XCmdPar (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCmdPar (GhcPass _1) = EpAnnCO

type family XCmdLam x #

Instances

Instances details

type XCmdLam (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCmdLam (GhcPass _1) = NoExtField

type family XCmdApp x #

Instances

Instances details

type XCmdApp (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCmdApp (GhcPass _1) = EpAnnCO

type family XCmdArrForm x #

Instances

Instances details

type XCmdArrForm GhcPs
Instance details Defined in GHC.Hs.Expr type XCmdArrForm GhcPs = EpAnn AnnList
type XCmdArrForm GhcRn
Instance details Defined in GHC.Hs.Expr type XCmdArrForm GhcRn = NoExtField
type XCmdArrForm GhcTc
Instance details Defined in GHC.Hs.Expr type XCmdArrForm GhcTc = NoExtField

type family XCmdArrApp x #

Instances

Instances details

type XCmdArrApp GhcPs
Instance details Defined in GHC.Hs.Expr type XCmdArrApp GhcPs = EpAnn AddEpAnn
type XCmdArrApp GhcRn
Instance details Defined in GHC.Hs.Expr type XCmdArrApp GhcRn = NoExtField
type XCmdArrApp GhcTc
Instance details Defined in GHC.Hs.Expr type XCmdArrApp GhcTc = Type

type family XXStmtLR x x' b #

Instances

Instances details

type XXStmtLR (GhcPass _1) (GhcPass _2) b
Instance details Defined in GHC.Hs.Expr type XXStmtLR (GhcPass _1) (GhcPass _2) b = DataConCantHappen

type family XRecStmt x x' b #

Instances

Instances details

type XRecStmt (GhcPass _1) GhcPs b
Instance details Defined in GHC.Hs.Expr type XRecStmt (GhcPass _1) GhcPs b = EpAnn AnnList
type XRecStmt (GhcPass _1) GhcRn b
Instance details Defined in GHC.Hs.Expr type XRecStmt (GhcPass _1) GhcRn b = NoExtField
type XRecStmt (GhcPass _1) GhcTc b
Instance details Defined in GHC.Hs.Expr type XRecStmt (GhcPass _1) GhcTc b = RecStmtTc

type family XTransStmt x x' b #

Instances

Instances details

type XTransStmt (GhcPass _1) GhcPs b
Instance details Defined in GHC.Hs.Expr type XTransStmt (GhcPass _1) GhcPs b = EpAnn [AddEpAnn]
type XTransStmt (GhcPass _1) GhcRn b
Instance details Defined in GHC.Hs.Expr type XTransStmt (GhcPass _1) GhcRn b = NoExtField
type XTransStmt (GhcPass _1) GhcTc b
Instance details Defined in GHC.Hs.Expr type XTransStmt (GhcPass _1) GhcTc b = Type

type family XParStmt x x' b #

Instances

Instances details

type XParStmt (GhcPass _1) GhcPs b
Instance details Defined in GHC.Hs.Expr type XParStmt (GhcPass _1) GhcPs b = NoExtField
type XParStmt (GhcPass _1) GhcRn b
Instance details Defined in GHC.Hs.Expr type XParStmt (GhcPass _1) GhcRn b = NoExtField
type XParStmt (GhcPass _1) GhcTc b
Instance details Defined in GHC.Hs.Expr type XParStmt (GhcPass _1) GhcTc b = Type

type family XLetStmt x x' b #

Instances

Instances details

type XLetStmt (GhcPass _1) (GhcPass _2) b
Instance details Defined in GHC.Hs.Expr type XLetStmt (GhcPass _1) (GhcPass _2) b = EpAnn [AddEpAnn]

type family XBodyStmt x x' b #

Instances

Instances details

type XBodyStmt (GhcPass _1) GhcPs b
Instance details Defined in GHC.Hs.Expr type XBodyStmt (GhcPass _1) GhcPs b = NoExtField
type XBodyStmt (GhcPass _1) GhcRn b
Instance details Defined in GHC.Hs.Expr type XBodyStmt (GhcPass _1) GhcRn b = NoExtField
type XBodyStmt (GhcPass _1) GhcTc b
Instance details Defined in GHC.Hs.Expr type XBodyStmt (GhcPass _1) GhcTc b = Type

type family XApplicativeStmt x x' b #

Instances

Instances details

type XApplicativeStmt (GhcPass _1) GhcPs b
Instance details Defined in GHC.Hs.Expr type XApplicativeStmt (GhcPass _1) GhcPs b = NoExtField
type XApplicativeStmt (GhcPass _1) GhcRn b
Instance details Defined in GHC.Hs.Expr type XApplicativeStmt (GhcPass _1) GhcRn b = NoExtField
type XApplicativeStmt (GhcPass _1) GhcTc b
Instance details Defined in GHC.Hs.Expr type XApplicativeStmt (GhcPass _1) GhcTc b = Type

type family XBindStmt x x' b #

Instances

Instances details

type XBindStmt (GhcPass _1) GhcPs b
Instance details Defined in GHC.Hs.Expr type XBindStmt (GhcPass _1) GhcPs b = EpAnn [AddEpAnn]
type XBindStmt (GhcPass _1) GhcRn b
Instance details Defined in GHC.Hs.Expr type XBindStmt (GhcPass _1) GhcRn b = XBindStmtRn
type XBindStmt (GhcPass _1) GhcTc b
Instance details Defined in GHC.Hs.Expr type XBindStmt (GhcPass _1) GhcTc b = XBindStmtTc

type family XLastStmt x x' b #

Instances

Instances details

type XLastStmt (GhcPass _1) (GhcPass _2) b
Instance details Defined in GHC.Hs.Expr type XLastStmt (GhcPass _1) (GhcPass _2) b = NoExtField

type family XXGRHS x b #

Instances

Instances details

type XXGRHS (GhcPass _1) b
Instance details Defined in GHC.Hs.Expr type XXGRHS (GhcPass _1) b = DataConCantHappen

type family XCGRHS x b #

Instances

Instances details

type XCGRHS (GhcPass _1) _2
Instance details Defined in GHC.Hs.Expr type XCGRHS (GhcPass _1) _2 = EpAnn GrhsAnn

type family XXGRHSs x b #

Instances

Instances details

type XXGRHSs (GhcPass _1) _2
Instance details Defined in GHC.Hs.Expr type XXGRHSs (GhcPass _1) _2 = DataConCantHappen

type family XCGRHSs x b #

Instances

Instances details

type XCGRHSs (GhcPass _1) _2
Instance details Defined in GHC.Hs.Expr type XCGRHSs (GhcPass _1) _2 = EpAnnComments

type family XXMatch x b #

Instances

Instances details

type XXMatch (GhcPass _1) b
Instance details Defined in GHC.Hs.Expr type XXMatch (GhcPass _1) b = DataConCantHappen

type family XCMatch x b #

Instances

Instances details

type XCMatch (GhcPass _1) b
Instance details Defined in GHC.Hs.Expr type XCMatch (GhcPass _1) b = EpAnn [AddEpAnn]

type family XXMatchGroup x b #

Instances

Instances details

type XXMatchGroup (GhcPass _1) b
Instance details Defined in GHC.Hs.Expr type XXMatchGroup (GhcPass _1) b = DataConCantHappen

type family XMG x b #

Instances

Instances details

type XMG GhcPs b
Instance details Defined in GHC.Hs.Expr type XMG GhcPs b = Origin
type XMG GhcRn b
Instance details Defined in GHC.Hs.Expr type XMG GhcRn b = Origin
type XMG GhcTc b
Instance details Defined in GHC.Hs.Expr type XMG GhcTc b = MatchGroupTc

type family XXCmdTop x #

Instances

Instances details

type XXCmdTop (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XXCmdTop (GhcPass _1) = DataConCantHappen

type family XCmdTop x #

Instances

Instances details

type XCmdTop GhcPs
Instance details Defined in GHC.Hs.Expr type XCmdTop GhcPs = NoExtField
type XCmdTop GhcRn
Instance details Defined in GHC.Hs.Expr type XCmdTop GhcRn = CmdSyntaxTable GhcRn
type XCmdTop GhcTc
Instance details Defined in GHC.Hs.Expr type XCmdTop GhcTc = CmdTopTc

type family XXQuote x #

Instances

Instances details

type XXQuote GhcPs
Instance details Defined in GHC.Hs.Expr type XXQuote GhcPs = DataConCantHappen
type XXQuote GhcRn
Instance details Defined in GHC.Hs.Expr type XXQuote GhcRn = DataConCantHappen
type XXQuote GhcTc
Instance details Defined in GHC.Hs.Expr type XXQuote GhcTc = NoExtField

type family XVarBr x #

Instances

Instances details

type XVarBr GhcPs
Instance details Defined in GHC.Hs.Expr type XVarBr GhcPs = NoExtField
type XVarBr GhcRn
Instance details Defined in GHC.Hs.Expr type XVarBr GhcRn = NoExtField
type XVarBr GhcTc
Instance details Defined in GHC.Hs.Expr type XVarBr GhcTc = DataConCantHappen

type family XTypBr x #

Instances

Instances details

type XTypBr GhcPs
Instance details Defined in GHC.Hs.Expr type XTypBr GhcPs = NoExtField
type XTypBr GhcRn
Instance details Defined in GHC.Hs.Expr type XTypBr GhcRn = NoExtField
type XTypBr GhcTc
Instance details Defined in GHC.Hs.Expr type XTypBr GhcTc = DataConCantHappen

type family XDecBrG x #

Instances

Instances details

type XDecBrG GhcPs
Instance details Defined in GHC.Hs.Expr type XDecBrG GhcPs = NoExtField
type XDecBrG GhcRn
Instance details Defined in GHC.Hs.Expr type XDecBrG GhcRn = NoExtField
type XDecBrG GhcTc
Instance details Defined in GHC.Hs.Expr type XDecBrG GhcTc = DataConCantHappen

type family XDecBrL x #

Instances

Instances details

type XDecBrL GhcPs
Instance details Defined in GHC.Hs.Expr type XDecBrL GhcPs = NoExtField
type XDecBrL GhcRn
Instance details Defined in GHC.Hs.Expr type XDecBrL GhcRn = NoExtField
type XDecBrL GhcTc
Instance details Defined in GHC.Hs.Expr type XDecBrL GhcTc = DataConCantHappen

type family XPatBr x #

Instances

Instances details

type XPatBr GhcPs
Instance details Defined in GHC.Hs.Expr type XPatBr GhcPs = NoExtField
type XPatBr GhcRn
Instance details Defined in GHC.Hs.Expr type XPatBr GhcRn = NoExtField
type XPatBr GhcTc
Instance details Defined in GHC.Hs.Expr type XPatBr GhcTc = DataConCantHappen

type family XExpBr x #

Instances

Instances details

type XExpBr GhcPs
Instance details Defined in GHC.Hs.Expr type XExpBr GhcPs = NoExtField
type XExpBr GhcRn
Instance details Defined in GHC.Hs.Expr type XExpBr GhcRn = NoExtField
type XExpBr GhcTc
Instance details Defined in GHC.Hs.Expr type XExpBr GhcTc = DataConCantHappen

type family XXUntypedSplice x #

Instances

Instances details

type XXUntypedSplice p
Instance details Defined in GHC.Hs.Expr type XXUntypedSplice p = DataConCantHappen

type family XQuasiQuote x #

Instances

Instances details

type XQuasiQuote p
Instance details Defined in GHC.Hs.Expr type XQuasiQuote p = NoExtField

type family XUntypedSpliceExpr x #

Instances

Instances details

type XUntypedSpliceExpr GhcPs
Instance details Defined in GHC.Hs.Expr type XUntypedSpliceExpr GhcPs = EpAnn [AddEpAnn]
type XUntypedSpliceExpr GhcRn
Instance details Defined in GHC.Hs.Expr type XUntypedSpliceExpr GhcRn = EpAnn [AddEpAnn]
type XUntypedSpliceExpr GhcTc
Instance details Defined in GHC.Hs.Expr type XUntypedSpliceExpr GhcTc = DataConCantHappen

type family XXTupArg x #

Instances

Instances details

type XXTupArg (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XXTupArg (GhcPass _1) = DataConCantHappen

type family XMissing x #

Instances

Instances details

type XMissing GhcPs
Instance details Defined in GHC.Hs.Expr type XMissing GhcPs = EpAnn EpaLocation
type XMissing GhcRn
Instance details Defined in GHC.Hs.Expr type XMissing GhcRn = NoExtField
type XMissing GhcTc
Instance details Defined in GHC.Hs.Expr type XMissing GhcTc = Scaled Type

type family XPresent x #

Instances

Instances details

type XPresent (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XPresent (GhcPass _1) = EpAnn [AddEpAnn]

type family XXAmbiguousFieldOcc x #

Instances

Instances details

type XXAmbiguousFieldOcc (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XXAmbiguousFieldOcc (GhcPass _1) = DataConCantHappen

type family XAmbiguous x #

Instances

Instances details

type XAmbiguous GhcPs
Instance details Defined in GHC.Hs.Type type XAmbiguous GhcPs = NoExtField
type XAmbiguous GhcRn
Instance details Defined in GHC.Hs.Type type XAmbiguous GhcRn = NoExtField
type XAmbiguous GhcTc
Instance details Defined in GHC.Hs.Type type XAmbiguous GhcTc = Id

type family XUnambiguous x #

Instances

Instances details

type XUnambiguous GhcPs
Instance details Defined in GHC.Hs.Type type XUnambiguous GhcPs = NoExtField
type XUnambiguous GhcRn
Instance details Defined in GHC.Hs.Type type XUnambiguous GhcRn = Name
type XUnambiguous GhcTc
Instance details Defined in GHC.Hs.Type type XUnambiguous GhcTc = Id

type family XXPragE x #

Instances

Instances details

type XXPragE (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XXPragE (GhcPass _1) = DataConCantHappen

type family XSCC x #

Instances

Instances details

type XSCC (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XSCC (GhcPass _1) = (EpAnn AnnPragma, SourceText)

type family XXDotFieldOcc x #

Instances

Instances details

type XXDotFieldOcc (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XXDotFieldOcc (GhcPass _1) = DataConCantHappen

type family XCDotFieldOcc x #

Instances

Instances details

type XCDotFieldOcc (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCDotFieldOcc (GhcPass _1) = EpAnn AnnFieldLabel

type family XXExpr x #

Instances

Instances details

type XXExpr GhcPs
Instance details Defined in GHC.Hs.Expr type XXExpr GhcPs = DataConCantHappen
type XXExpr GhcRn
Instance details Defined in GHC.Hs.Expr type XXExpr GhcRn = HsExpansion (HsExpr GhcRn) (HsExpr GhcRn)
type XXExpr GhcTc
Instance details Defined in GHC.Hs.Expr type XXExpr GhcTc = XXExprGhcTc

type family XPragE x #

Instances

Instances details

type XPragE (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XPragE (GhcPass _1) = NoExtField

type family XBinTick x #

type family XTick x #

type family XStatic x #

Instances

Instances details

type XStatic GhcPs
Instance details Defined in GHC.Hs.Expr type XStatic GhcPs = EpAnn [AddEpAnn]
type XStatic GhcRn
Instance details Defined in GHC.Hs.Expr type XStatic GhcRn = NameSet
type XStatic GhcTc
Instance details Defined in GHC.Hs.Expr type XStatic GhcTc = (NameSet, Type)

type family XProc x #

Instances

Instances details

type XProc (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XProc (GhcPass _1) = EpAnn [AddEpAnn]

type family XUntypedSplice x #

Instances

Instances details

type XUntypedSplice GhcPs
Instance details Defined in GHC.Hs.Expr type XUntypedSplice GhcPs = EpAnnCO
type XUntypedSplice GhcRn
Instance details Defined in GHC.Hs.Expr type XUntypedSplice GhcRn = HsUntypedSpliceResult (HsExpr GhcRn)
type XUntypedSplice GhcTc
Instance details Defined in GHC.Hs.Expr type XUntypedSplice GhcTc = DataConCantHappen

type family XTypedSplice x #

Instances

Instances details

type XTypedSplice GhcPs
Instance details Defined in GHC.Hs.Expr type XTypedSplice GhcPs = (EpAnnCO, EpAnn [AddEpAnn])
type XTypedSplice GhcRn
Instance details Defined in GHC.Hs.Expr type XTypedSplice GhcRn = SplicePointName
type XTypedSplice GhcTc
Instance details Defined in GHC.Hs.Expr type XTypedSplice GhcTc = DelayedSplice

type family XUntypedBracket x #

Instances

Instances details

type XUntypedBracket GhcPs
Instance details Defined in GHC.Hs.Expr type XUntypedBracket GhcPs = EpAnn [AddEpAnn]
type XUntypedBracket GhcRn
Instance details Defined in GHC.Hs.Expr type XUntypedBracket GhcRn = [PendingRnSplice]
type XUntypedBracket GhcTc
Instance details Defined in GHC.Hs.Expr type XUntypedBracket GhcTc = HsBracketTc

type family XTypedBracket x #

Instances

Instances details

type XTypedBracket GhcPs
Instance details Defined in GHC.Hs.Expr type XTypedBracket GhcPs = EpAnn [AddEpAnn]
type XTypedBracket GhcRn
Instance details Defined in GHC.Hs.Expr type XTypedBracket GhcRn = NoExtField
type XTypedBracket GhcTc
Instance details Defined in GHC.Hs.Expr type XTypedBracket GhcTc = HsBracketTc

type family XArithSeq x #

Instances

Instances details

type XArithSeq GhcPs
Instance details Defined in GHC.Hs.Expr type XArithSeq GhcPs = EpAnn [AddEpAnn]
type XArithSeq GhcRn
Instance details Defined in GHC.Hs.Expr type XArithSeq GhcRn = NoExtField
type XArithSeq GhcTc
Instance details Defined in GHC.Hs.Expr type XArithSeq GhcTc = PostTcExpr

type family XExprWithTySig x #

Instances

Instances details

type XExprWithTySig GhcPs
Instance details Defined in GHC.Hs.Expr type XExprWithTySig GhcPs = EpAnn [AddEpAnn]
type XExprWithTySig GhcRn
Instance details Defined in GHC.Hs.Expr type XExprWithTySig GhcRn = NoExtField
type XExprWithTySig GhcTc
Instance details Defined in GHC.Hs.Expr type XExprWithTySig GhcTc = NoExtField

type family XProjection x #

Instances

Instances details

type XProjection GhcPs
Instance details Defined in GHC.Hs.Expr type XProjection GhcPs = EpAnn AnnProjection
type XProjection GhcRn
Instance details Defined in GHC.Hs.Expr type XProjection GhcRn = NoExtField
type XProjection GhcTc
Instance details Defined in GHC.Hs.Expr type XProjection GhcTc = DataConCantHappen

type family XGetField x #

Instances

Instances details

type XGetField GhcPs
Instance details Defined in GHC.Hs.Expr type XGetField GhcPs = EpAnnCO
type XGetField GhcRn
Instance details Defined in GHC.Hs.Expr type XGetField GhcRn = NoExtField
type XGetField GhcTc
Instance details Defined in GHC.Hs.Expr type XGetField GhcTc = DataConCantHappen

type family XRecordUpd x #

Instances

Instances details

type XRecordUpd GhcPs
Instance details Defined in GHC.Hs.Expr type XRecordUpd GhcPs = EpAnn [AddEpAnn]
type XRecordUpd GhcRn
Instance details Defined in GHC.Hs.Expr type XRecordUpd GhcRn = NoExtField
type XRecordUpd GhcTc
Instance details Defined in GHC.Hs.Expr type XRecordUpd GhcTc = DataConCantHappen

type family XRecordCon x #

Instances

Instances details

type XRecordCon GhcPs
Instance details Defined in GHC.Hs.Expr type XRecordCon GhcPs = EpAnn [AddEpAnn]
type XRecordCon GhcRn
Instance details Defined in GHC.Hs.Expr type XRecordCon GhcRn = NoExtField
type XRecordCon GhcTc
Instance details Defined in GHC.Hs.Expr type XRecordCon GhcTc = PostTcExpr

type family XExplicitList x #

Instances

Instances details

type XExplicitList GhcPs
Instance details Defined in GHC.Hs.Expr type XExplicitList GhcPs = EpAnn AnnList
type XExplicitList GhcRn
Instance details Defined in GHC.Hs.Expr type XExplicitList GhcRn = NoExtField
type XExplicitList GhcTc
Instance details Defined in GHC.Hs.Expr type XExplicitList GhcTc = Type

type family XDo x #

Instances

Instances details

type XDo GhcPs
Instance details Defined in GHC.Hs.Expr type XDo GhcPs = EpAnn AnnList
type XDo GhcRn
Instance details Defined in GHC.Hs.Expr type XDo GhcRn = NoExtField
type XDo GhcTc
Instance details Defined in GHC.Hs.Expr type XDo GhcTc = Type

type family XLet x #

Instances

Instances details

type XLet GhcPs
Instance details Defined in GHC.Hs.Expr type XLet GhcPs = EpAnnCO
type XLet GhcRn
Instance details Defined in GHC.Hs.Expr type XLet GhcRn = NoExtField
type XLet GhcTc
Instance details Defined in GHC.Hs.Expr type XLet GhcTc = NoExtField

type family XMultiIf x #

Instances

Instances details

type XMultiIf GhcPs
Instance details Defined in GHC.Hs.Expr type XMultiIf GhcPs = EpAnn [AddEpAnn]
type XMultiIf GhcRn
Instance details Defined in GHC.Hs.Expr type XMultiIf GhcRn = NoExtField
type XMultiIf GhcTc
Instance details Defined in GHC.Hs.Expr type XMultiIf GhcTc = Type

type family XIf x #

Instances

Instances details

type XIf GhcPs
Instance details Defined in GHC.Hs.Expr type XIf GhcPs = EpAnn AnnsIf
type XIf GhcRn
Instance details Defined in GHC.Hs.Expr type XIf GhcRn = NoExtField
type XIf GhcTc
Instance details Defined in GHC.Hs.Expr type XIf GhcTc = NoExtField

type family XCase x #

Instances

Instances details

type XCase GhcPs
Instance details Defined in GHC.Hs.Expr type XCase GhcPs = EpAnn EpAnnHsCase
type XCase GhcRn
Instance details Defined in GHC.Hs.Expr type XCase GhcRn = NoExtField
type XCase GhcTc
Instance details Defined in GHC.Hs.Expr type XCase GhcTc = NoExtField

type family XExplicitSum x #

Instances

Instances details

type XExplicitSum GhcPs
Instance details Defined in GHC.Hs.Expr type XExplicitSum GhcPs = EpAnn AnnExplicitSum
type XExplicitSum GhcRn
Instance details Defined in GHC.Hs.Expr type XExplicitSum GhcRn = NoExtField
type XExplicitSum GhcTc
Instance details Defined in GHC.Hs.Expr type XExplicitSum GhcTc = [Type]

type family XExplicitTuple x #

Instances

Instances details

type XExplicitTuple GhcPs
Instance details Defined in GHC.Hs.Expr type XExplicitTuple GhcPs = EpAnn [AddEpAnn]
type XExplicitTuple GhcRn
Instance details Defined in GHC.Hs.Expr type XExplicitTuple GhcRn = NoExtField
type XExplicitTuple GhcTc
Instance details Defined in GHC.Hs.Expr type XExplicitTuple GhcTc = NoExtField

type family XSectionR x #

Instances

Instances details

type XSectionR GhcPs
Instance details Defined in GHC.Hs.Expr type XSectionR GhcPs = EpAnnCO
type XSectionR GhcRn
Instance details Defined in GHC.Hs.Expr type XSectionR GhcRn = EpAnnCO
type XSectionR GhcTc
Instance details Defined in GHC.Hs.Expr type XSectionR GhcTc = DataConCantHappen

type family XSectionL x #

Instances

Instances details

type XSectionL GhcPs
Instance details Defined in GHC.Hs.Expr type XSectionL GhcPs = EpAnnCO
type XSectionL GhcRn
Instance details Defined in GHC.Hs.Expr type XSectionL GhcRn = EpAnnCO
type XSectionL GhcTc
Instance details Defined in GHC.Hs.Expr type XSectionL GhcTc = DataConCantHappen

type family XPar x #

Instances

Instances details

type XPar (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XPar (GhcPass _1) = EpAnnCO

type family XNegApp x #

Instances

Instances details

type XNegApp GhcPs
Instance details Defined in GHC.Hs.Expr type XNegApp GhcPs = EpAnn [AddEpAnn]
type XNegApp GhcRn
Instance details Defined in GHC.Hs.Expr type XNegApp GhcRn = NoExtField
type XNegApp GhcTc
Instance details Defined in GHC.Hs.Expr type XNegApp GhcTc = NoExtField

type family XOpApp x #

Instances

Instances details

type XOpApp GhcPs
Instance details Defined in GHC.Hs.Expr type XOpApp GhcPs = EpAnn [AddEpAnn]
type XOpApp GhcRn
Instance details Defined in GHC.Hs.Expr type XOpApp GhcRn = Fixity
type XOpApp GhcTc
Instance details Defined in GHC.Hs.Expr type XOpApp GhcTc = DataConCantHappen

type family XAppTypeE x #

Instances

Instances details

type XAppTypeE GhcPs
Instance details Defined in GHC.Hs.Expr type XAppTypeE GhcPs = NoExtField
type XAppTypeE GhcRn
Instance details Defined in GHC.Hs.Expr type XAppTypeE GhcRn = NoExtField
type XAppTypeE GhcTc
Instance details Defined in GHC.Hs.Expr type XAppTypeE GhcTc = Type

type family XApp x #

Instances

Instances details

type XApp (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XApp (GhcPass _1) = EpAnnCO

type family XLamCase x #

Instances

Instances details

type XLamCase (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XLamCase (GhcPass _1) = EpAnn [AddEpAnn]

type family XLam x #

Instances

Instances details

type XLam (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XLam (GhcPass _1) = NoExtField
type XLam (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XLam (GhcPass _1) = NoExtField

type family XLitE x #

Instances

Instances details

type XLitE (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XLitE (GhcPass _1) = EpAnnCO

type family XOverLitE x #

Instances

Instances details

type XOverLitE (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XOverLitE (GhcPass _1) = EpAnnCO

type family XIPVar x #

Instances

Instances details

type XIPVar GhcPs
Instance details Defined in GHC.Hs.Expr type XIPVar GhcPs = EpAnnCO
type XIPVar GhcRn
Instance details Defined in GHC.Hs.Expr type XIPVar GhcRn = EpAnnCO
type XIPVar GhcTc
Instance details Defined in GHC.Hs.Expr type XIPVar GhcTc = DataConCantHappen

type family XOverLabel x #

Instances

Instances details

type XOverLabel GhcPs
Instance details Defined in GHC.Hs.Expr type XOverLabel GhcPs = EpAnnCO
type XOverLabel GhcRn
Instance details Defined in GHC.Hs.Expr type XOverLabel GhcRn = EpAnnCO
type XOverLabel GhcTc
Instance details Defined in GHC.Hs.Expr type XOverLabel GhcTc = DataConCantHappen

type family XRecSel x #

Instances

Instances details

type XRecSel GhcPs
Instance details Defined in GHC.Hs.Expr type XRecSel GhcPs = DataConCantHappen
type XRecSel GhcRn
Instance details Defined in GHC.Hs.Expr type XRecSel GhcRn = NoExtField
type XRecSel GhcTc
Instance details Defined in GHC.Hs.Expr type XRecSel GhcTc = NoExtField

type family XUnboundVar x #

Instances

Instances details

type XUnboundVar GhcPs
Instance details Defined in GHC.Hs.Expr type XUnboundVar GhcPs = EpAnn EpAnnUnboundVar
type XUnboundVar GhcRn
Instance details Defined in GHC.Hs.Expr type XUnboundVar GhcRn = NoExtField
type XUnboundVar GhcTc
Instance details Defined in GHC.Hs.Expr type XUnboundVar GhcTc = HoleExprRef

type family XVar x #

Instances

Instances details

type XVar (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XVar (GhcPass _1) = NoExtField
type XVar (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XVar (GhcPass _1) = NoExtField

type family XXModule x #

Instances

Instances details

type XXModule p
Instance details Defined in GHC.Hs type XXModule p = DataConCantHappen

type family XCModule x #

Instances

Instances details

type XCModule GhcPs
Instance details Defined in GHC.Hs type XCModule GhcPs = XModulePs
type XCModule GhcRn
Instance details Defined in GHC.Hs type XCModule GhcRn = DataConCantHappen
type XCModule GhcTc
Instance details Defined in GHC.Hs type XCModule GhcTc = DataConCantHappen

type family XXInjectivityAnn x #

Instances

Instances details

type XXInjectivityAnn (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXInjectivityAnn (GhcPass _1) = DataConCantHappen

type family XCInjectivityAnn x #

Instances

Instances details

type XCInjectivityAnn (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCInjectivityAnn (GhcPass _1) = EpAnn [AddEpAnn]

type family XXRoleAnnotDecl x #

Instances

Instances details

type XXRoleAnnotDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXRoleAnnotDecl (GhcPass _1) = DataConCantHappen

type family XCRoleAnnotDecl x #

Instances

Instances details

type XCRoleAnnotDecl GhcPs
Instance details Defined in GHC.Hs.Decls type XCRoleAnnotDecl GhcPs = EpAnn [AddEpAnn]
type XCRoleAnnotDecl GhcRn
Instance details Defined in GHC.Hs.Decls type XCRoleAnnotDecl GhcRn = NoExtField
type XCRoleAnnotDecl GhcTc
Instance details Defined in GHC.Hs.Decls type XCRoleAnnotDecl GhcTc = NoExtField

type family XXAnnDecl x #

Instances

Instances details

type XXAnnDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXAnnDecl (GhcPass _1) = DataConCantHappen

type family XHsAnnotation x #

Instances

Instances details

type XHsAnnotation (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XHsAnnotation (GhcPass _1) = (EpAnn AnnPragma, SourceText)

type family XXWarnDecl x #

Instances

Instances details

type XXWarnDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXWarnDecl (GhcPass _1) = DataConCantHappen

type family XWarning x #

Instances

Instances details

type XWarning (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XWarning (GhcPass _1) = EpAnn [AddEpAnn]

type family XXWarnDecls x #

Instances

Instances details

type XXWarnDecls (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXWarnDecls (GhcPass _1) = DataConCantHappen

type family XWarnings x #

Instances

Instances details

type XWarnings GhcPs
Instance details Defined in GHC.Hs.Decls type XWarnings GhcPs = (EpAnn [AddEpAnn], SourceText)
type XWarnings GhcRn
Instance details Defined in GHC.Hs.Decls type XWarnings GhcRn = SourceText
type XWarnings GhcTc
Instance details Defined in GHC.Hs.Decls type XWarnings GhcTc = SourceText

type family XXRuleBndr x #

Instances

Instances details

type XXRuleBndr (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXRuleBndr (GhcPass _1) = DataConCantHappen

type family XRuleBndrSig x #

Instances

Instances details

type XRuleBndrSig (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XRuleBndrSig (GhcPass _1) = EpAnn [AddEpAnn]

type family XCRuleBndr x #

Instances

Instances details

type XCRuleBndr (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCRuleBndr (GhcPass _1) = EpAnn [AddEpAnn]

type family XXRuleDecl x #

Instances

Instances details

type XXRuleDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXRuleDecl (GhcPass _1) = DataConCantHappen

type family XHsRule x #

Instances

Instances details

type XHsRule GhcPs
Instance details Defined in GHC.Hs.Decls type XHsRule GhcPs = (EpAnn HsRuleAnn, SourceText)
type XHsRule GhcRn
Instance details Defined in GHC.Hs.Decls type XHsRule GhcRn = (HsRuleRn, SourceText)
type XHsRule GhcTc
Instance details Defined in GHC.Hs.Decls type XHsRule GhcTc = (HsRuleRn, SourceText)

type family XXRuleDecls x #

Instances

Instances details

type XXRuleDecls (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXRuleDecls (GhcPass _1) = DataConCantHappen

type family XCRuleDecls x #

Instances

Instances details

type XCRuleDecls GhcPs
Instance details Defined in GHC.Hs.Decls type XCRuleDecls GhcPs = (EpAnn [AddEpAnn], SourceText)
type XCRuleDecls GhcRn
Instance details Defined in GHC.Hs.Decls type XCRuleDecls GhcRn = SourceText
type XCRuleDecls GhcTc
Instance details Defined in GHC.Hs.Decls type XCRuleDecls GhcTc = SourceText

type family XXForeignExport x #

Instances

Instances details

type XXForeignExport (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXForeignExport (GhcPass _1) = DataConCantHappen

type family XCExport x #

Instances

Instances details

type XCExport (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCExport (GhcPass _1) = Located SourceText

type family XXForeignImport x #

Instances

Instances details

type XXForeignImport (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXForeignImport (GhcPass _1) = DataConCantHappen

type family XCImport x #

Instances

Instances details

type XCImport (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCImport (GhcPass _1) = Located SourceText

type family XXForeignDecl x #

Instances

Instances details

type XXForeignDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXForeignDecl (GhcPass _1) = DataConCantHappen

type family XForeignExport x #

Instances

Instances details

type XForeignExport GhcPs
Instance details Defined in GHC.Hs.Decls type XForeignExport GhcPs = EpAnn [AddEpAnn]
type XForeignExport GhcRn
Instance details Defined in GHC.Hs.Decls type XForeignExport GhcRn = NoExtField
type XForeignExport GhcTc
Instance details Defined in GHC.Hs.Decls type XForeignExport GhcTc = Coercion

type family XForeignImport x #

Instances

Instances details

type XForeignImport GhcPs
Instance details Defined in GHC.Hs.Decls type XForeignImport GhcPs = EpAnn [AddEpAnn]
type XForeignImport GhcRn
Instance details Defined in GHC.Hs.Decls type XForeignImport GhcRn = NoExtField
type XForeignImport GhcTc
Instance details Defined in GHC.Hs.Decls type XForeignImport GhcTc = Coercion

type family XXDefaultDecl x #

Instances

Instances details

type XXDefaultDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXDefaultDecl (GhcPass _1) = DataConCantHappen

type family XCDefaultDecl x #

Instances

Instances details

type XCDefaultDecl GhcPs
Instance details Defined in GHC.Hs.Decls type XCDefaultDecl GhcPs = EpAnn [AddEpAnn]
type XCDefaultDecl GhcRn
Instance details Defined in GHC.Hs.Decls type XCDefaultDecl GhcRn = NoExtField
type XCDefaultDecl GhcTc
Instance details Defined in GHC.Hs.Decls type XCDefaultDecl GhcTc = NoExtField

type family XViaStrategy x #

Instances

Instances details

type XViaStrategy GhcPs
Instance details Defined in GHC.Hs.Decls type XViaStrategy GhcPs = XViaStrategyPs
type XViaStrategy GhcRn
Instance details Defined in GHC.Hs.Decls type XViaStrategy GhcRn = LHsSigType GhcRn
type XViaStrategy GhcTc
Instance details Defined in GHC.Hs.Decls type XViaStrategy GhcTc = Type

type family XNewtypeStrategy x #

Instances

Instances details

type XNewtypeStrategy GhcPs
Instance details Defined in GHC.Hs.Decls type XNewtypeStrategy GhcPs = EpAnn [AddEpAnn]
type XNewtypeStrategy GhcRn
Instance details Defined in GHC.Hs.Decls type XNewtypeStrategy GhcRn = NoExtField
type XNewtypeStrategy GhcTc
Instance details Defined in GHC.Hs.Decls type XNewtypeStrategy GhcTc = NoExtField

type family XAnyClassStrategy x #

Instances

Instances details

type XAnyClassStrategy GhcPs
Instance details Defined in GHC.Hs.Decls type XAnyClassStrategy GhcPs = EpAnn [AddEpAnn]
type XAnyClassStrategy GhcRn
Instance details Defined in GHC.Hs.Decls type XAnyClassStrategy GhcRn = NoExtField
type XAnyClassStrategy GhcTc
Instance details Defined in GHC.Hs.Decls type XAnyClassStrategy GhcTc = NoExtField

type family XStockStrategy x #

Instances

Instances details

type XStockStrategy GhcPs
Instance details Defined in GHC.Hs.Decls type XStockStrategy GhcPs = EpAnn [AddEpAnn]
type XStockStrategy GhcRn
Instance details Defined in GHC.Hs.Decls type XStockStrategy GhcRn = NoExtField
type XStockStrategy GhcTc
Instance details Defined in GHC.Hs.Decls type XStockStrategy GhcTc = NoExtField

type family XXDerivDecl x #

Instances

Instances details

type XXDerivDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXDerivDecl (GhcPass _1) = DataConCantHappen

type family XCDerivDecl x #

Instances

Instances details

type XCDerivDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCDerivDecl (GhcPass _1) = EpAnn [AddEpAnn]

type family XXInstDecl x #

Instances

Instances details

type XXInstDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXInstDecl (GhcPass _1) = DataConCantHappen

type family XTyFamInstD x #

Instances

Instances details

type XTyFamInstD GhcPs
Instance details Defined in GHC.Hs.Decls type XTyFamInstD GhcPs = NoExtField
type XTyFamInstD GhcRn
Instance details Defined in GHC.Hs.Decls type XTyFamInstD GhcRn = NoExtField
type XTyFamInstD GhcTc
Instance details Defined in GHC.Hs.Decls type XTyFamInstD GhcTc = NoExtField

type family XDataFamInstD x #

Instances

Instances details

type XDataFamInstD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XDataFamInstD (GhcPass _1) = NoExtField

type family XClsInstD x #

Instances

Instances details

type XClsInstD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XClsInstD (GhcPass _1) = NoExtField

type family XXClsInstDecl x #

Instances

Instances details

type XXClsInstDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXClsInstDecl (GhcPass _1) = DataConCantHappen

type family XCClsInstDecl x #

Instances

Instances details

type XCClsInstDecl GhcPs
Instance details Defined in GHC.Hs.Decls type XCClsInstDecl GhcPs = (EpAnn [AddEpAnn], AnnSortKey)
type XCClsInstDecl GhcRn
Instance details Defined in GHC.Hs.Decls type XCClsInstDecl GhcRn = NoExtField
type XCClsInstDecl GhcTc
Instance details Defined in GHC.Hs.Decls type XCClsInstDecl GhcTc = NoExtField

type family XXTyFamInstDecl x #

Instances

Instances details

type XXTyFamInstDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXTyFamInstDecl (GhcPass _1) = DataConCantHappen

type family XCTyFamInstDecl x #

Instances

Instances details

type XCTyFamInstDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCTyFamInstDecl (GhcPass _1) = EpAnn [AddEpAnn]

type family XXFamEqn x r #

Instances

Instances details

type XXFamEqn (GhcPass _1) r
Instance details Defined in GHC.Hs.Decls type XXFamEqn (GhcPass _1) r = DataConCantHappen

type family XCFamEqn x r #

Instances

Instances details

type XCFamEqn (GhcPass _1) r
Instance details Defined in GHC.Hs.Decls type XCFamEqn (GhcPass _1) r = EpAnn [AddEpAnn]

type family XXConDecl x #

Instances

Instances details

type XXConDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXConDecl (GhcPass _1) = DataConCantHappen

type family XConDeclH98 x #

Instances

Instances details

type XConDeclH98 (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XConDeclH98 (GhcPass _1) = EpAnn [AddEpAnn]

type family XConDeclGADT x #

Instances

Instances details

type XConDeclGADT (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XConDeclGADT (GhcPass _1) = EpAnn [AddEpAnn]

type family XXDerivClauseTys x #

Instances

Instances details

type XXDerivClauseTys (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXDerivClauseTys (GhcPass _1) = DataConCantHappen

type family XDctMulti x #

Instances

Instances details

type XDctMulti (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XDctMulti (GhcPass _1) = NoExtField

type family XDctSingle x #

Instances

Instances details

type XDctSingle (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XDctSingle (GhcPass _1) = NoExtField

type family XXHsDerivingClause x #

Instances

Instances details

type XXHsDerivingClause (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXHsDerivingClause (GhcPass _1) = DataConCantHappen

type family XCHsDerivingClause x #

Instances

Instances details

type XCHsDerivingClause (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCHsDerivingClause (GhcPass _1) = EpAnn [AddEpAnn]

type family XXHsDataDefn x #

Instances

Instances details

type XXHsDataDefn (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXHsDataDefn (GhcPass _1) = DataConCantHappen

type family XCHsDataDefn x #

Instances

Instances details

type XCHsDataDefn (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCHsDataDefn (GhcPass _1) = NoExtField

type family XXFamilyDecl x #

Instances

Instances details

type XXFamilyDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXFamilyDecl (GhcPass _1) = DataConCantHappen

type family XCFamilyDecl x #

Instances

Instances details

type XCFamilyDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCFamilyDecl (GhcPass _1) = EpAnn [AddEpAnn]

type family XXFamilyResultSig x #

Instances

Instances details

type XXFamilyResultSig (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXFamilyResultSig (GhcPass _1) = DataConCantHappen

type family XTyVarSig x #

Instances

Instances details

type XTyVarSig (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XTyVarSig (GhcPass _1) = NoExtField

type family XCKindSig x #

Instances

Instances details

type XCKindSig (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCKindSig (GhcPass _1) = NoExtField

type family XNoSig x #

Instances

Instances details

type XNoSig (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XNoSig (GhcPass _1) = NoExtField

type family XXTyClGroup x #

Instances

Instances details

type XXTyClGroup (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXTyClGroup (GhcPass _1) = DataConCantHappen

type family XCTyClGroup x #

Instances

Instances details

type XCTyClGroup (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCTyClGroup (GhcPass _1) = NoExtField

type family XXFunDep x #

Instances

Instances details

type XXFunDep (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXFunDep (GhcPass _1) = DataConCantHappen

type family XCFunDep x #

Instances

Instances details

type XCFunDep (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCFunDep (GhcPass _1) = EpAnn [AddEpAnn]

type family XXTyClDecl x #

Instances

Instances details

type XXTyClDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXTyClDecl (GhcPass _1) = DataConCantHappen

type family XClassDecl x #

Instances

Instances details

type XClassDecl GhcPs
Instance details Defined in GHC.Hs.Decls type XClassDecl GhcPs = (EpAnn [AddEpAnn], AnnSortKey)
type XClassDecl GhcRn
Instance details Defined in GHC.Hs.Decls type XClassDecl GhcRn = NameSet
type XClassDecl GhcTc
Instance details Defined in GHC.Hs.Decls type XClassDecl GhcTc = NameSet

type family XDataDecl x #

Instances

Instances details

type XDataDecl GhcPs
Instance details Defined in GHC.Hs.Decls type XDataDecl GhcPs = EpAnn [AddEpAnn]
type XDataDecl GhcRn
Instance details Defined in GHC.Hs.Decls type XDataDecl GhcRn = DataDeclRn
type XDataDecl GhcTc
Instance details Defined in GHC.Hs.Decls type XDataDecl GhcTc = DataDeclRn

type family XSynDecl x #

Instances

Instances details

type XSynDecl GhcPs
Instance details Defined in GHC.Hs.Decls type XSynDecl GhcPs = EpAnn [AddEpAnn]
type XSynDecl GhcRn
Instance details Defined in GHC.Hs.Decls type XSynDecl GhcRn = NameSet
type XSynDecl GhcTc
Instance details Defined in GHC.Hs.Decls type XSynDecl GhcTc = NameSet

type family XFamDecl x #

Instances

Instances details

type XFamDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XFamDecl (GhcPass _1) = NoExtField

type family XXSpliceDecl x #

Instances

Instances details

type XXSpliceDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXSpliceDecl (GhcPass _1) = DataConCantHappen

type family XSpliceDecl x #

Instances

Instances details

type XSpliceDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XSpliceDecl (GhcPass _1) = NoExtField

type family XXHsGroup x #

Instances

Instances details

type XXHsGroup (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXHsGroup (GhcPass _1) = DataConCantHappen

type family XCHsGroup x #

Instances

Instances details

type XCHsGroup (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCHsGroup (GhcPass _1) = NoExtField

type family XXHsDecl x #

Instances

Instances details

type XXHsDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXHsDecl (GhcPass _1) = DataConCantHappen

type family XRoleAnnotD x #

Instances

Instances details

type XRoleAnnotD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XRoleAnnotD (GhcPass _1) = NoExtField

type family XDocD x #

Instances

Instances details

type XDocD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XDocD (GhcPass _1) = NoExtField

type family XSpliceD x #

Instances

Instances details

type XSpliceD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XSpliceD (GhcPass _1) = NoExtField

type family XRuleD x #

Instances

Instances details

type XRuleD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XRuleD (GhcPass _1) = NoExtField

type family XAnnD x #

Instances

Instances details

type XAnnD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XAnnD (GhcPass _1) = NoExtField

type family XWarningD x #

Instances

Instances details

type XWarningD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XWarningD (GhcPass _1) = NoExtField

type family XForD x #

Instances

Instances details

type XForD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XForD (GhcPass _1) = NoExtField

type family XDefD x #

Instances

Instances details

type XDefD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XDefD (GhcPass _1) = NoExtField

type family XKindSigD x #

Instances

Instances details

type XKindSigD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XKindSigD (GhcPass _1) = NoExtField

type family XSigD x #

Instances

Instances details

type XSigD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XSigD (GhcPass _1) = NoExtField

type family XValD x #

Instances

Instances details

type XValD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XValD (GhcPass _1) = NoExtField

type family XDerivD x #

Instances

Instances details

type XDerivD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XDerivD (GhcPass _1) = NoExtField

type family XInstD x #

Instances

Instances details

type XInstD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XInstD (GhcPass _1) = NoExtField

type family XTyClD x #

Instances

Instances details

type XTyClD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XTyClD (GhcPass _1) = NoExtField

type family XXStandaloneKindSig x #

Instances

Instances details

type XXStandaloneKindSig (GhcPass p)
Instance details Defined in GHC.Hs.Decls type XXStandaloneKindSig (GhcPass p) = DataConCantHappen

type family XStandaloneKindSig x #

Instances

Instances details

type XStandaloneKindSig GhcPs
Instance details Defined in GHC.Hs.Decls type XStandaloneKindSig GhcPs = EpAnn [AddEpAnn]
type XStandaloneKindSig GhcRn
Instance details Defined in GHC.Hs.Decls type XStandaloneKindSig GhcRn = NoExtField
type XStandaloneKindSig GhcTc
Instance details Defined in GHC.Hs.Decls type XStandaloneKindSig GhcTc = NoExtField

type family XXFixitySig x #

Instances

Instances details

type XXFixitySig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XXFixitySig (GhcPass p) = DataConCantHappen

type family XFixitySig x #

Instances

Instances details

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

type family XXSig x #

Instances

Instances details

type XXSig GhcPs
Instance details Defined in GHC.Hs.Binds type XXSig GhcPs = DataConCantHappen
type XXSig GhcRn
Instance details Defined in GHC.Hs.Binds type XXSig GhcRn = IdSig
type XXSig GhcTc
Instance details Defined in GHC.Hs.Binds type XXSig GhcTc = IdSig

type family XCompleteMatchSig x #

Instances

Instances details

type XCompleteMatchSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XCompleteMatchSig (GhcPass p) = (EpAnn [AddEpAnn], SourceText)

type family XSCCFunSig x #

Instances

Instances details

type XSCCFunSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XSCCFunSig (GhcPass p) = (EpAnn [AddEpAnn], SourceText)

type family XMinimalSig x #

Instances

Instances details

type XMinimalSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XMinimalSig (GhcPass p) = (EpAnn [AddEpAnn], SourceText)

type family XSpecInstSig x #

Instances

Instances details

type XSpecInstSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XSpecInstSig (GhcPass p) = (EpAnn [AddEpAnn], SourceText)

type family XSpecSig x #

Instances

Instances details

type XSpecSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XSpecSig (GhcPass p) = EpAnn [AddEpAnn]

type family XInlineSig x #

Instances

Instances details

type XInlineSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XInlineSig (GhcPass p) = EpAnn [AddEpAnn]

type family XFixSig x #

Instances

Instances details

type XFixSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XFixSig (GhcPass p) = EpAnn [AddEpAnn]

type family XIdSig x #

type family XClassOpSig x #

Instances

Instances details

type XClassOpSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XClassOpSig (GhcPass p) = EpAnn AnnSig

type family XPatSynSig x #

Instances

Instances details

type XPatSynSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XPatSynSig (GhcPass p) = EpAnn AnnSig

type family XTypeSig x #

Instances

Instances details

type XTypeSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XTypeSig (GhcPass p) = EpAnn AnnSig

type family XXIPBind x #

Instances

Instances details

type XXIPBind (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XXIPBind (GhcPass p) = DataConCantHappen

type family XCIPBind x #

Instances

Instances details

type XCIPBind GhcPs
Instance details Defined in GHC.Hs.Binds type XCIPBind GhcPs = EpAnn [AddEpAnn]
type XCIPBind GhcRn
Instance details Defined in GHC.Hs.Binds type XCIPBind GhcRn = NoExtField
type XCIPBind GhcTc
Instance details Defined in GHC.Hs.Binds type XCIPBind GhcTc = Id

type family XXHsIPBinds x #

Instances

Instances details

type XXHsIPBinds (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XXHsIPBinds (GhcPass p) = DataConCantHappen

type family XIPBinds x #

Instances

Instances details

type XIPBinds GhcPs
Instance details Defined in GHC.Hs.Binds type XIPBinds GhcPs = NoExtField
type XIPBinds GhcRn
Instance details Defined in GHC.Hs.Binds type XIPBinds GhcRn = NoExtField
type XIPBinds GhcTc
Instance details Defined in GHC.Hs.Binds type XIPBinds GhcTc = TcEvBinds

type family XXPatSynBind x x' #

Instances

Instances details

type XXPatSynBind (GhcPass idL) (GhcPass idR)
Instance details Defined in GHC.Hs.Binds type XXPatSynBind (GhcPass idL) (GhcPass idR) = DataConCantHappen

type family XPSB x x' #

Instances

Instances details

type XPSB (GhcPass idL) GhcPs
Instance details Defined in GHC.Hs.Binds type XPSB (GhcPass idL) GhcPs = EpAnn [AddEpAnn]
type XPSB (GhcPass idL) GhcRn
Instance details Defined in GHC.Hs.Binds type XPSB (GhcPass idL) GhcRn = NameSet
type XPSB (GhcPass idL) GhcTc
Instance details Defined in GHC.Hs.Binds type XPSB (GhcPass idL) GhcTc = NameSet

type family XXHsBindsLR x x' #

Instances

Instances details

type XXHsBindsLR GhcPs pR
Instance details Defined in GHC.Hs.Binds type XXHsBindsLR GhcPs pR = DataConCantHappen
type XXHsBindsLR GhcRn pR
Instance details Defined in GHC.Hs.Binds type XXHsBindsLR GhcRn pR = DataConCantHappen
type XXHsBindsLR GhcTc pR
Instance details Defined in GHC.Hs.Binds type XXHsBindsLR GhcTc pR = AbsBinds

type family XPatSynBind x x' #

Instances

Instances details

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

type family XVarBind x x' #

Instances

Instances details

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

type family XPatBind x x' #

Instances

Instances details

type XPatBind GhcPs (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XPatBind GhcPs (GhcPass pR) = EpAnn [AddEpAnn]
type XPatBind GhcRn (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XPatBind GhcRn (GhcPass pR) = NameSet
type XPatBind GhcTc (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XPatBind GhcTc (GhcPass pR) = (Type, ([CoreTickish], [[CoreTickish]]))

type family XFunBind x x' #

Instances

Instances details

type XFunBind (GhcPass pL) GhcPs
Instance details Defined in GHC.Hs.Binds type XFunBind (GhcPass pL) GhcPs = NoExtField
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]
Instance details Defined in GHC.Hs.Binds type XFunBind (GhcPass pL) GhcRn = NameSet
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'.
Instance details Defined in GHC.Hs.Binds type XFunBind (GhcPass pL) GhcTc = (HsWrapper, [CoreTickish])

type family XXValBindsLR x x' #

Instances

Instances details

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

type family XValBinds x x' #

Instances

Instances details

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

type family XXHsLocalBindsLR x x' #

Instances

Instances details

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

type family XEmptyLocalBinds x x' #

Instances

Instances details

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

type family XHsIPBinds x x' #

Instances

Instances details

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

type family XHsValBinds x x' #

Instances

Instances details

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

type LIdP p = XRec p (IdP p) #

type family IdP p #

Maps the "normal" id type for a given pass

Instances

Instances details

type IdP (GhcPass p)
Instance details Defined in GHC.Hs.Extension type IdP (GhcPass p) = IdGhcP p

class WrapXRec p a where #

The trivial wrapper that carries no additional information See Note [XRec and SrcSpans in the AST]

Methods

wrapXRec :: a -> XRec p a #

class MapXRec p where #

We can map over the underlying type contained in an XRec while preserving the annotation as is.

Methods

mapXRec :: Anno a ~ Anno b => (a -> b) -> XRec p a -> XRec p b #

Instances

Instances details

MapXRec (GhcPass p)
Instance details Defined in GHC.Hs.Extension Methods mapXRec :: Anno a ~ Anno b => (a -> b) -> XRec (GhcPass p) a -> XRec (GhcPass p) b #

class UnXRec p where #

We can strip off the XRec to access the underlying data. See Note [XRec and SrcSpans in the AST]

Methods

unXRec :: XRec p a -> a #

Instances

Instances details

UnXRec (GhcPass p)
Instance details Defined in GHC.Hs.Extension Methods unXRec :: XRec (GhcPass p) a -> a #

type family Anno a = (b :: Type) #

Instances

Instances details

type Anno ConLike
Instance details Defined in GHC.Hs.Pat type Anno ConLike = SrcSpanAnnN
type Anno FastString
Instance details Defined in GHC.Hs.Expr type Anno FastString = SrcAnn NoEpAnns
type Anno OverlapMode
Instance details Defined in GHC.Hs.Decls type Anno OverlapMode = SrcSpanAnnP
type Anno OverlapMode
Instance details Defined in GHC.Hs.Decls type Anno OverlapMode = SrcSpanAnnP
type Anno CCallConv
Instance details Defined in GHC.Hs.Decls type Anno CCallConv = SrcSpan
type Anno CExportSpec
Instance details Defined in GHC.Hs.Decls type Anno CExportSpec = SrcSpan
type Anno CType
Instance details Defined in GHC.Hs.Decls type Anno CType = SrcSpanAnnP
type Anno Safety
Instance details Defined in GHC.Hs.Decls type Anno Safety = SrcSpan
type Anno Name
Instance details Defined in GHC.Hs.Extension type Anno Name = SrcSpanAnnN
type Anno RdrName
Instance details Defined in GHC.Hs.Extension type Anno RdrName = SrcSpanAnnN
type Anno StringLiteral
Instance details Defined in GHC.Hs.Binds type Anno StringLiteral = SrcAnn NoEpAnns
type Anno Id
Instance details Defined in GHC.Hs.Extension type Anno Id = SrcSpanAnnN
type Anno FieldLabelString
Instance details Defined in GHC.Hs.Expr type Anno FieldLabelString = SrcSpanAnnN
type Anno ModuleName
Instance details Defined in GHC.Hs type Anno ModuleName = SrcSpanAnnA
type Anno ModuleName
Instance details Defined in GHC.Hs.ImpExp type Anno ModuleName = SrcSpanAnnA
type Anno RecFieldsDotDot
Instance details Defined in GHC.Hs.Pat type Anno RecFieldsDotDot = SrcSpan
type Anno HsIPName
Instance details Defined in GHC.Hs.Type type Anno HsIPName = SrcAnn NoEpAnns
type Anno Bool
Instance details Defined in GHC.Hs.Decls type Anno Bool = SrcAnn NoEpAnns
type Anno (LocatedA (IE (GhcPass p)))
Instance details Defined in GHC.Hs.ImpExp type Anno (LocatedA (IE (GhcPass p))) = SrcSpanAnnA
type Anno (LocatedN Name)
Instance details Defined in GHC.Hs.Binds type Anno (LocatedN Name) = SrcSpan
type Anno (LocatedN RdrName)
Instance details Defined in GHC.Hs.Binds type Anno (LocatedN RdrName) = SrcSpan
type Anno (LocatedN Id)
Instance details Defined in GHC.Hs.Binds type Anno (LocatedN Id) = SrcSpan
type Anno (FixitySig (GhcPass p))
Instance details Defined in GHC.Hs.Binds type Anno (FixitySig (GhcPass p)) = SrcSpanAnnA
type Anno (IPBind (GhcPass p))
Instance details Defined in GHC.Hs.Binds type Anno (IPBind (GhcPass p)) = SrcSpanAnnA
type Anno (Sig (GhcPass p))
Instance details Defined in GHC.Hs.Binds type Anno (Sig (GhcPass p)) = SrcSpanAnnA
type Anno (HsToken tok)
Instance details Defined in GHC.Hs.Extension type Anno (HsToken tok) = TokenLocation
type Anno (AnnDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (AnnDecl (GhcPass p)) = SrcSpanAnnA
type Anno (ClsInstDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (ClsInstDecl (GhcPass p)) = SrcSpanAnnA
type Anno (ConDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (ConDecl (GhcPass p)) = SrcSpanAnnA
type Anno (DataFamInstDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (DataFamInstDecl (GhcPass p)) = SrcSpanAnnA
type Anno (DefaultDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (DefaultDecl (GhcPass p)) = SrcSpanAnnA
type Anno (DerivClauseTys (GhcPass _1))
Instance details Defined in GHC.Hs.Decls type Anno (DerivClauseTys (GhcPass _1)) = SrcSpanAnnC
type Anno (DerivDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (DerivDecl (GhcPass p)) = SrcSpanAnnA
type Anno (DerivStrategy (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (DerivStrategy (GhcPass p)) = SrcAnn NoEpAnns
type Anno (DocDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (DocDecl (GhcPass p)) = SrcSpanAnnA
type Anno (FamilyDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (FamilyDecl (GhcPass p)) = SrcSpanAnnA
type Anno (FamilyResultSig (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (FamilyResultSig (GhcPass p)) = SrcAnn NoEpAnns
type Anno (ForeignDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (ForeignDecl (GhcPass p)) = SrcSpanAnnA
type Anno (FunDep (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (FunDep (GhcPass p)) = SrcSpanAnnA
type Anno (HsDecl (GhcPass _1))
Instance details Defined in GHC.Hs.Decls type Anno (HsDecl (GhcPass _1)) = SrcSpanAnnA
type Anno (HsDerivingClause (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (HsDerivingClause (GhcPass p)) = SrcAnn NoEpAnns
type Anno (InjectivityAnn (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (InjectivityAnn (GhcPass p)) = SrcAnn NoEpAnns
type Anno (InstDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (InstDecl (GhcPass p)) = SrcSpanAnnA
type Anno (RoleAnnotDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (RoleAnnotDecl (GhcPass p)) = SrcSpanAnnA
type Anno (RuleBndr (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (RuleBndr (GhcPass p)) = SrcAnn NoEpAnns
type Anno (RuleDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (RuleDecl (GhcPass p)) = SrcSpanAnnA
type Anno (RuleDecls (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (RuleDecls (GhcPass p)) = SrcSpanAnnA
type Anno (SpliceDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (SpliceDecl (GhcPass p)) = SrcSpanAnnA
type Anno (StandaloneKindSig (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (StandaloneKindSig (GhcPass p)) = SrcSpanAnnA
type Anno (TyClDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (TyClDecl (GhcPass p)) = SrcSpanAnnA
type Anno (TyFamInstDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (TyFamInstDecl (GhcPass p)) = SrcSpanAnnA
type Anno (WarnDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (WarnDecl (GhcPass p)) = SrcSpanAnnA
type Anno (WarnDecls (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (WarnDecls (GhcPass p)) = SrcSpanAnnA
type Anno (DotFieldOcc (GhcPass p))
Instance details Defined in GHC.Hs.Expr type Anno (DotFieldOcc (GhcPass p)) = SrcAnn NoEpAnns
type Anno (FieldLabelStrings (GhcPass p))
Instance details Defined in GHC.Hs.Expr type Anno (FieldLabelStrings (GhcPass p)) = SrcAnn NoEpAnns
type Anno (HsCmd (GhcPass p))
Instance details Defined in GHC.Hs.Expr type Anno (HsCmd (GhcPass p)) = SrcSpanAnnA
type Anno (HsCmdTop (GhcPass p))
Instance details Defined in GHC.Hs.Expr type Anno (HsCmdTop (GhcPass p)) = SrcAnn NoEpAnns
type Anno (HsExpr (GhcPass p))
Instance details Defined in GHC.Hs.Expr type Anno (HsExpr (GhcPass p)) = SrcSpanAnnA
type Anno (HsUntypedSplice (GhcPass p))
Instance details Defined in GHC.Hs.Expr type Anno (HsUntypedSplice (GhcPass p)) = SrcSpanAnnA
type Anno (IE (GhcPass p))
Instance details Defined in GHC.Hs.ImpExp type Anno (IE (GhcPass p)) = SrcSpanAnnA
type Anno (IEWrappedName (GhcPass _1))
Instance details Defined in GHC.Hs.ImpExp type Anno (IEWrappedName (GhcPass _1)) = SrcSpanAnnA
type Anno (ImportDecl (GhcPass p))
Instance details Defined in GHC.Hs.ImpExp type Anno (ImportDecl (GhcPass p)) = SrcSpanAnnA
type Anno (HsOverLit (GhcPass p))
Instance details Defined in GHC.Hs.Pat type Anno (HsOverLit (GhcPass p)) = SrcAnn NoEpAnns
type Anno (Pat (GhcPass p))
Instance details Defined in GHC.Hs.Pat type Anno (Pat (GhcPass p)) = SrcSpanAnnA
type Anno (AmbiguousFieldOcc (GhcPass p))
Instance details Defined in GHC.Hs.Type type Anno (AmbiguousFieldOcc (GhcPass p)) = SrcAnn NoEpAnns
type Anno (BangType (GhcPass p))
Instance details Defined in GHC.Hs.Type type Anno (BangType (GhcPass p)) = SrcSpanAnnA
type Anno (ConDeclField (GhcPass p))
Instance details Defined in GHC.Hs.Type type Anno (ConDeclField (GhcPass p)) = SrcSpanAnnA
type Anno (FieldOcc (GhcPass p))
Instance details Defined in GHC.Hs.Type type Anno (FieldOcc (GhcPass p)) = SrcAnn NoEpAnns
type Anno (HsKind (GhcPass p))
Instance details Defined in GHC.Hs.Type type Anno (HsKind (GhcPass p)) = SrcSpanAnnA
type Anno (HsSigType (GhcPass p))
Instance details Defined in GHC.Hs.Type type Anno (HsSigType (GhcPass p)) = SrcSpanAnnA
type Anno (HsType (GhcPass p))
Instance details Defined in GHC.Hs.Type type Anno (HsType (GhcPass p)) = SrcSpanAnnA
type Anno (Maybe Role)
Instance details Defined in GHC.Hs.Decls type Anno (Maybe Role) = SrcAnn NoEpAnns
type Anno (Maybe Role)
Instance details Defined in GHC.Hs.Decls type Anno (Maybe Role) = SrcAnn NoEpAnns
type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))] = SrcSpanAnnL
type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))] = SrcSpanAnnL
type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))]
Instance details Defined in GHC.Parser.PostProcess type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))]
Instance details Defined in GHC.Parser.Types type Anno [LocatedA (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL
type Anno [LocatedA (IE (GhcPass p))]
Instance details Defined in GHC.Hs.ImpExp type Anno [LocatedA (IE (GhcPass p))] = SrcSpanAnnL
type Anno [LocatedA (ConDeclField (GhcPass _1))]
Instance details Defined in GHC.Hs.Decls type Anno [LocatedA (ConDeclField (GhcPass _1))] = SrcSpanAnnL
type Anno [LocatedA (HsType (GhcPass p))]
Instance details Defined in GHC.Hs.Type type Anno [LocatedA (HsType (GhcPass p))] = SrcSpanAnnC
type Anno [LocatedN Name]
Instance details Defined in GHC.Hs.Binds type Anno [LocatedN Name] = SrcSpan
type Anno [LocatedN RdrName]
Instance details Defined in GHC.Hs.Binds type Anno [LocatedN RdrName] = SrcSpan
type Anno [LocatedN Id]
Instance details Defined in GHC.Hs.Binds type Anno [LocatedN Id] = SrcSpan
type Anno (HsBindLR (GhcPass idL) (GhcPass idR))
Instance details Defined in GHC.Hs.Binds type Anno (HsBindLR (GhcPass idL) (GhcPass idR)) = SrcSpanAnnA
type Anno (HsUniToken tok utok)
Instance details Defined in GHC.Hs.Extension type Anno (HsUniToken tok utok) = TokenLocation
type Anno (FamEqn (GhcPass p) _1)
Instance details Defined in GHC.Hs.Decls type Anno (FamEqn (GhcPass p) _1) = SrcSpanAnnA
type Anno (FamEqn (GhcPass p) _1)
Instance details Defined in GHC.Hs.Decls type Anno (FamEqn (GhcPass p) _1) = SrcSpanAnnA
type Anno (FamEqn p (LocatedA (HsType p)))
Instance details Defined in GHC.Hs.Decls type Anno (FamEqn p (LocatedA (HsType p))) = SrcSpanAnnA
type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p))))
Instance details Defined in GHC.Hs.Expr type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcAnn NoEpAnns
type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p))))
Instance details Defined in GHC.Hs.Expr type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcAnn NoEpAnns
type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs)))
Instance details Defined in GHC.Parser.PostProcess type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs))) = SrcAnn NoEpAnns
type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))
Instance details Defined in GHC.Hs.Expr type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcSpanAnnA
type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))
Instance details Defined in GHC.Hs.Expr type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpanAnnA
type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs)))
Instance details Defined in GHC.Parser.PostProcess type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA
type Anno (HsFieldBind lhs rhs)
Instance details Defined in GHC.Hs.Pat type Anno (HsFieldBind lhs rhs) = SrcSpanAnnA
type Anno (HsOuterTyVarBndrs _1 (GhcPass _2))
Instance details Defined in GHC.Hs.Type type Anno (HsOuterTyVarBndrs _1 (GhcPass _2)) = SrcSpanAnnA
type Anno (HsTyVarBndr _flag (GhcPass _1))
Instance details Defined in GHC.Hs.Type type Anno (HsTyVarBndr _flag (GhcPass _1)) = SrcSpanAnnA
type Anno (HsTyVarBndr _flag GhcPs)
Instance details Defined in GHC.Hs.Type type Anno (HsTyVarBndr _flag GhcPs) = SrcSpanAnnA
type Anno (HsTyVarBndr _flag GhcRn)
Instance details Defined in GHC.Hs.Type type Anno (HsTyVarBndr _flag GhcRn) = SrcSpanAnnA
type Anno (HsTyVarBndr _flag GhcTc)
Instance details Defined in GHC.Hs.Type type Anno (HsTyVarBndr _flag GhcTc) = SrcSpanAnnA
type Anno (SourceText, RuleName)
Instance details Defined in GHC.Hs.Decls type Anno (SourceText, RuleName) = SrcAnn NoEpAnns
type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))
Instance details Defined in GHC.Hs.Expr type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr)))) = SrcSpanAnnA
type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))
Instance details Defined in GHC.Parser.PostProcess type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA
type Anno (StmtLR GhcRn GhcRn (LocatedA (body GhcRn)))
Instance details Defined in GHC.Hs.Expr type Anno (StmtLR GhcRn GhcRn (LocatedA (body GhcRn))) = SrcSpanAnnA

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

Instances details

type XRec (GhcPass p) a
Instance details Defined in GHC.Hs.Extension type XRec (GhcPass p) a = GenLocated (Anno a) a

data DataConCantHappen #

Instances

Instances details

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

newtype ModuleName #

A ModuleName is essentially a simple string, e.g. Data.List.

Constructors

ModuleName FastString

Instances

Instances details

Data ModuleName
Instance details Defined in Language.Haskell.Syntax.Module.Name Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModuleName -> c ModuleName # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ModuleName # toConstr :: ModuleName -> Constr # dataTypeOf :: ModuleName -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ModuleName) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleName) # gmapT :: (forall b. Data b => b -> b) -> ModuleName -> ModuleName # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModuleName -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModuleName -> r # gmapQ :: (forall d. Data d => d -> u) -> ModuleName -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ModuleName -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModuleName -> m ModuleName # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleName -> m ModuleName # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleName -> m ModuleName #
Show ModuleName
Instance details Defined in Language.Haskell.Syntax.Module.Name Methods showsPrec :: Int -> ModuleName -> ShowS # show :: ModuleName -> String # showList :: [ModuleName] -> ShowS #
NFData ModuleName
Instance details Defined in Language.Haskell.Syntax.Module.Name Methods rnf :: ModuleName -> () #
Uniquable ModuleName
Instance details Defined in GHC.Types.Unique Methods getUnique :: ModuleName -> Unique #
Outputable ModuleName
Instance details Defined in GHC.Utils.Outputable Methods ppr :: ModuleName -> SDoc #
Eq ModuleName
Instance details Defined in Language.Haskell.Syntax.Module.Name Methods (==) :: ModuleName -> ModuleName -> Bool # (/=) :: ModuleName -> ModuleName -> Bool #
Ord ModuleName
Instance details Defined in Language.Haskell.Syntax.Module.Name Methods compare :: ModuleName -> ModuleName -> Ordering # (<) :: ModuleName -> ModuleName -> Bool # (<=) :: ModuleName -> ModuleName -> Bool # (>) :: ModuleName -> ModuleName -> Bool # (>=) :: ModuleName -> ModuleName -> Bool # max :: ModuleName -> ModuleName -> ModuleName # min :: ModuleName -> ModuleName -> ModuleName #
type Anno ModuleName
Instance details Defined in GHC.Hs type Anno ModuleName = SrcSpanAnnA
type Anno ModuleName
Instance details Defined in GHC.Hs.ImpExp type Anno ModuleName = SrcSpanAnnA

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.

Methods

occName :: name -> OccName #

Instances

Instances details

HasOccName IfaceClassOp
Instance details Defined in GHC.Iface.Syntax Methods occName :: IfaceClassOp -> OccName #
HasOccName IfaceConDecl
Instance details Defined in GHC.Iface.Syntax Methods occName :: IfaceConDecl -> OccName #
HasOccName IfaceDecl
Instance details Defined in GHC.Iface.Syntax Methods occName :: IfaceDecl -> OccName #
HasOccName HoleFitCandidate
Instance details Defined in GHC.Tc.Errors.Hole.FitTypes Methods occName :: HoleFitCandidate -> OccName #
HasOccName TcBinder
Instance details Defined in GHC.Tc.Types Methods occName :: TcBinder -> OccName #
HasOccName GreName
Instance details Defined in GHC.Types.Avail Methods occName :: GreName -> OccName #
HasOccName FieldLabel
Instance details Defined in GHC.Types.FieldLabel Methods occName :: FieldLabel -> OccName #
HasOccName Name
Instance details Defined in GHC.Types.Name Methods occName :: Name -> OccName #
HasOccName OccName
Instance details Defined in GHC.Types.Name.Occurrence Methods occName :: OccName -> OccName #
HasOccName GlobalRdrElt
Instance details Defined in GHC.Types.Name.Reader Methods occName :: GlobalRdrElt -> OccName #
HasOccName RdrName
Instance details Defined in GHC.Types.Name.Reader Methods occName :: RdrName -> OccName #
HasOccName Var
Instance details Defined in GHC.Types.Var Methods occName :: Var -> OccName #

data OccName #

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

Instances details

Data OccName
Instance details 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 #
NFData OccName
Instance details Defined in GHC.Types.Name.Occurrence Methods rnf :: OccName -> () #
HasOccName OccName
Instance details Defined in GHC.Types.Name.Occurrence Methods occName :: OccName -> OccName #
Uniquable OccName
Instance details Defined in GHC.Types.Name.Occurrence Methods getUnique :: OccName -> Unique #
Binary OccName
Instance details Defined in GHC.Types.Name.Occurrence Methods put_ :: BinHandle -> OccName -> IO () # put :: BinHandle -> OccName -> IO (Bin OccName) # get :: BinHandle -> IO OccName #
Outputable OccName
Instance details Defined in GHC.Types.Name.Occurrence Methods ppr :: OccName -> SDoc #
OutputableBndr OccName
Instance details Defined in GHC.Types.Name.Occurrence Methods pprBndr :: BindingSite -> OccName -> SDoc # pprPrefixOcc :: OccName -> SDoc # pprInfixOcc :: OccName -> SDoc # bndrIsJoin_maybe :: OccName -> Maybe Int #
Eq OccName
Instance details Defined in GHC.Types.Name.Occurrence Methods (==) :: OccName -> OccName -> Bool # (/=) :: OccName -> OccName -> Bool #
Ord OccName
Instance details Defined in GHC.Types.Name.Occurrence Methods compare :: OccName -> OccName -> Ordering # (<) :: OccName -> OccName -> Bool # (<=) :: OccName -> OccName -> Bool # (>) :: OccName -> OccName -> Bool # (>=) :: OccName -> OccName -> Bool # max :: OccName -> OccName -> OccName # min :: OccName -> OccName -> OccName #

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.

Constructors

NotBoot
IsBoot

Instances

Instances details

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

data GenUnit uid #

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

Instances details

Data Unit
Instance details 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 # toConstr :: Unit -> Constr # 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 Unit
Instance details Defined in GHC.Unit.Types Methods showsPrec :: Int -> Unit -> ShowS # show :: Unit -> String # showList :: [Unit] -> ShowS #
NFData Unit
Instance details Defined in GHC.Unit.Types Methods rnf :: Unit -> () #
Uniquable Module
Instance details Defined in GHC.Unit.Types Methods getUnique :: Module -> Unique #
Binary Unit
Instance details Defined in GHC.Unit.Types Methods put_ :: BinHandle -> Unit -> IO () # put :: BinHandle -> Unit -> IO (Bin Unit) # get :: BinHandle -> IO Unit #
Outputable Module
Instance details Defined in GHC.Unit.Types Methods ppr :: Module -> SDoc #
Outputable Unit
Instance details Defined in GHC.Unit.Types Methods ppr :: Unit -> SDoc #
Ord Unit
Instance details Defined in GHC.Unit.Types Methods compare :: Unit -> Unit -> Ordering # (<) :: Unit -> Unit -> Bool # (<=) :: Unit -> Unit -> Bool # (>) :: Unit -> Unit -> Bool # (>=) :: Unit -> Unit -> Bool # max :: Unit -> Unit -> Unit # min :: Unit -> Unit -> Unit #
IsUnitId u => Uniquable (GenUnit u)
Instance details Defined in GHC.Unit.Types Methods getUnique :: GenUnit u -> Unique #
IsUnitId u => IsUnitId (GenUnit u)
Instance details Defined in GHC.Unit.Types Methods unitFS :: GenUnit u -> FastString #
IsUnitId u => Eq (GenUnit u)
Instance details Defined in GHC.Unit.Types Methods (==) :: GenUnit u -> GenUnit u -> Bool # (/=) :: GenUnit u -> GenUnit u -> Bool #

data GenModule unit #

A generic module is a pair of a unit identifier and a ModuleName.

Constructors

Module
Fields moduleUnit :: !unit Unit the module belongs to moduleName :: !ModuleName Module name (e.g. A.B.C)

Instances

Instances details

Functor GenModule
Instance details Defined in GHC.Unit.Types Methods fmap :: (a -> b) -> GenModule a -> GenModule b # (<$) :: a -> GenModule b -> GenModule a #
Uniquable Module
Instance details Defined in GHC.Unit.Types Methods getUnique :: Module -> Unique #
Outputable InstalledModule
Instance details Defined in GHC.Unit.Types Methods ppr :: InstalledModule -> SDoc #
Outputable InstantiatedModule
Instance details Defined in GHC.Unit.Types Methods ppr :: InstantiatedModule -> SDoc #
Outputable Module
Instance details Defined in GHC.Unit.Types Methods ppr :: Module -> SDoc #
Data unit => Data (GenModule unit)
Instance details 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)
Instance details Defined in GHC.Unit.Types Methods rnf :: GenModule a -> () #
Binary a => Binary (GenModule a)
Instance details Defined in GHC.Unit.Types Methods put_ :: BinHandle -> GenModule a -> IO () # put :: BinHandle -> GenModule a -> IO (Bin (GenModule a)) # get :: BinHandle -> IO (GenModule a) #
Eq unit => Eq (GenModule unit)
Instance details Defined in GHC.Unit.Types Methods (==) :: GenModule unit -> GenModule unit -> Bool # (/=) :: GenModule unit -> GenModule unit -> Bool #
Ord unit => Ord (GenModule unit)
Instance details 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 # max :: GenModule unit -> GenModule unit -> GenModule unit # min :: GenModule unit -> GenModule unit -> GenModule unit #

newtype UnitId #

A UnitId identifies a built library in a database and is used to generate unique symbols, etc. It's usually of the form:

pkgname-1.2:libname+hash

These UnitId are provided to us via the -this-unit-id flag.

The library in question may be definite or indefinite; if it is indefinite, none of the holes have been filled (we never install partially instantiated libraries as we can cheaply instantiate them on-the-fly, cf VirtUnit). Put another way, an installed unit id is either fully instantiated, or not instantiated at all.

Constructors

UnitId
Fields unitIdFS :: FastString The full hashed unit identifier, including the component id and the hash.

Instances

Instances details

Data Unit
Instance details 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 # toConstr :: Unit -> Constr # 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 #
Data UnitId
Instance details Defined in GHC.Unit.Types Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UnitId -> c UnitId # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UnitId # toConstr :: UnitId -> Constr # dataTypeOf :: UnitId -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UnitId) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnitId) # gmapT :: (forall b. Data b => b -> b) -> UnitId -> UnitId # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UnitId -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UnitId -> r # gmapQ :: (forall d. Data d => d -> u) -> UnitId -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> UnitId -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> UnitId -> m UnitId # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UnitId -> m UnitId # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UnitId -> m UnitId #
Show Unit
Instance details Defined in GHC.Unit.Types Methods showsPrec :: Int -> Unit -> ShowS # show :: Unit -> String # showList :: [Unit] -> ShowS #
NFData Unit
Instance details Defined in GHC.Unit.Types Methods rnf :: Unit -> () #
Uniquable Module
Instance details Defined in GHC.Unit.Types Methods getUnique :: Module -> Unique #
Uniquable UnitId
Instance details Defined in GHC.Unit.Types Methods getUnique :: UnitId -> Unique #
IsUnitId UnitId
Instance details Defined in GHC.Unit.Types Methods unitFS :: UnitId -> FastString #
Binary InstantiatedUnit
Instance details Defined in GHC.Unit.Types Methods put_ :: BinHandle -> InstantiatedUnit -> IO () # put :: BinHandle -> InstantiatedUnit -> IO (Bin InstantiatedUnit) # get :: BinHandle -> IO InstantiatedUnit #
Binary Unit
Instance details Defined in GHC.Unit.Types Methods put_ :: BinHandle -> Unit -> IO () # put :: BinHandle -> Unit -> IO (Bin Unit) # get :: BinHandle -> IO Unit #
Binary UnitId
Instance details Defined in GHC.Unit.Types Methods put_ :: BinHandle -> UnitId -> IO () # put :: BinHandle -> UnitId -> IO (Bin UnitId) # get :: BinHandle -> IO UnitId #
Outputable InstalledModule
Instance details Defined in GHC.Unit.Types Methods ppr :: InstalledModule -> SDoc #
Outputable InstantiatedModule
Instance details Defined in GHC.Unit.Types Methods ppr :: InstantiatedModule -> SDoc #
Outputable InstantiatedUnit
Instance details Defined in GHC.Unit.Types Methods ppr :: InstantiatedUnit -> SDoc #
Outputable Module
Instance details Defined in GHC.Unit.Types Methods ppr :: Module -> SDoc #
Outputable Unit
Instance details Defined in GHC.Unit.Types Methods ppr :: Unit -> SDoc #
Outputable UnitId
Instance details Defined in GHC.Unit.Types Methods ppr :: UnitId -> SDoc #
Eq UnitId
Instance details Defined in GHC.Unit.Types Methods (==) :: UnitId -> UnitId -> Bool # (/=) :: UnitId -> UnitId -> Bool #
Ord Unit
Instance details Defined in GHC.Unit.Types Methods compare :: Unit -> Unit -> Ordering # (<) :: Unit -> Unit -> Bool # (<=) :: Unit -> Unit -> Bool # (>) :: Unit -> Unit -> Bool # (>=) :: Unit -> Unit -> Bool # max :: Unit -> Unit -> Unit # min :: Unit -> Unit -> Unit #
Ord UnitId
Instance details Defined in GHC.Unit.Types Methods compare :: UnitId -> UnitId -> Ordering # (<) :: UnitId -> UnitId -> Bool # (<=) :: UnitId -> UnitId -> Bool # (>) :: UnitId -> UnitId -> Bool # (>=) :: UnitId -> UnitId -> Bool # max :: UnitId -> UnitId -> UnitId # min :: UnitId -> UnitId -> UnitId #

class (IsOutput doc, IsLine (Line doc)) => IsDoc doc where #

A class of types that represent a multiline document, with support for vertical composition.

See Note [HLine versus HDoc] and Note [The outputable class hierarchy] for more details.

Minimal complete definition

line, ($$), dualDoc

Associated Types

type Line doc = (r :: Type) | r -> doc #

Methods

line :: Line doc -> doc #

($$) :: doc -> doc -> doc #

Join two docs together vertically. If there is no vertical overlap it "dovetails" the two onto one line.

lines_ :: [Line doc] -> doc #

vcat :: [doc] -> doc #

Concatenate docs vertically with dovetailing.

dualDoc :: SDoc -> HDoc -> doc #

Prints as either the given SDoc or the given HDoc, depending on which type the result is instantiated to. This should generally be avoided; see Note [dualLine and dualDoc] for details.

Instances

Instances details

IsDoc HDoc
Instance details Defined in GHC.Utils.Outputable Associated Types type Line HDoc = (r :: Type) # Methods line :: Line HDoc -> HDoc # ($$) :: HDoc -> HDoc -> HDoc # lines_ :: [Line HDoc] -> HDoc # vcat :: [HDoc] -> HDoc # dualDoc :: SDoc -> HDoc -> HDoc #
IsDoc SDoc
Instance details Defined in GHC.Utils.Outputable Associated Types type Line SDoc = (r :: Type) # Methods line :: Line SDoc -> SDoc # ($$) :: SDoc -> SDoc -> SDoc # lines_ :: [Line SDoc] -> SDoc # vcat :: [SDoc] -> SDoc # dualDoc :: SDoc -> HDoc -> SDoc #

type family Line doc = (r :: Type) | r -> doc #

Instances

Instances details

type Line HDoc
Instance details Defined in GHC.Utils.Outputable type Line HDoc = HLine
type Line SDoc
Instance details Defined in GHC.Utils.Outputable type Line SDoc = SDoc

class IsOutput doc => IsLine doc where #

A class of types that represent a single logical line of text, with support for horizontal composition.

See Note [HLine versus HDoc] and Note [The outputable class hierarchy] for more details.

Minimal complete definition

char, text, ftext, ztext, (<>), (<+>), sep, fsep, dualLine

Methods

char :: Char -> doc #

text :: String -> doc #

ftext :: FastString -> doc #

ztext :: FastZString -> doc #

(<>) :: doc -> doc -> doc #

Join two docs together horizontally without a gap.

(<+>) :: doc -> doc -> doc #

Join two docs together horizontally with a gap between them.

sep :: [doc] -> doc #

Separate: is either like hsep or like vcat, depending on what fits.

fsep :: [doc] -> doc #

A paragraph-fill combinator. It's much like sep, only it keeps fitting things on one line until it can't fit any more.

hcat :: [doc] -> doc #

Concatenate docs horizontally without gaps.

hsep :: [doc] -> doc #

Concatenate docs horizontally with a space between each one.

dualLine :: SDoc -> HLine -> doc #

Prints as either the given SDoc or the given HLine, depending on which type the result is instantiated to. This should generally be avoided; see Note [dualLine and dualDoc] for details.

Instances

Instances details

IsLine HLine
Instance details Defined in GHC.Utils.Outputable Methods char :: Char -> HLine # text :: String -> HLine # ftext :: FastString -> HLine # ztext :: FastZString -> HLine # (<>) :: HLine -> HLine -> HLine # (<+>) :: HLine -> HLine -> HLine # sep :: [HLine] -> HLine # fsep :: [HLine] -> HLine # hcat :: [HLine] -> HLine # hsep :: [HLine] -> HLine # dualLine :: SDoc -> HLine -> HLine #
IsLine SDoc
Instance details Defined in GHC.Utils.Outputable Methods char :: Char -> SDoc # text :: String -> SDoc # ftext :: FastString -> SDoc # ztext :: FastZString -> SDoc # (<>) :: SDoc -> SDoc -> SDoc # (<+>) :: SDoc -> SDoc -> SDoc # sep :: [SDoc] -> SDoc # fsep :: [SDoc] -> SDoc # hcat :: [SDoc] -> SDoc # hsep :: [SDoc] -> SDoc # dualLine :: SDoc -> HLine -> SDoc #

class IsOutput doc where #

A superclass for IsLine and IsDoc that provides an identity, empty, as well as access to the shared SDocContext.

See Note [The outputable class hierarchy] for more details.

Methods

empty :: doc #

docWithContext :: (SDocContext -> doc) -> doc #

Instances

Instances details

IsOutput HDoc
Instance details Defined in GHC.Utils.Outputable Methods empty :: HDoc # docWithContext :: (SDocContext -> HDoc) -> HDoc #
IsOutput HLine
Instance details Defined in GHC.Utils.Outputable Methods empty :: HLine # docWithContext :: (SDocContext -> HLine) -> HLine #
IsOutput SDoc
Instance details Defined in GHC.Utils.Outputable Methods empty :: SDoc # docWithContext :: (SDocContext -> SDoc) -> SDoc #

data HDoc #

Represents a (possibly empty) sequence of lines that can be efficiently printed directly to a Handle (actually a BufHandle). See Note [SDoc versus HDoc] and Note [HLine versus HDoc] for more details.

Instances

Instances details

IsDoc HDoc
Instance details Defined in GHC.Utils.Outputable Associated Types type Line HDoc = (r :: Type) # Methods line :: Line HDoc -> HDoc # ($$) :: HDoc -> HDoc -> HDoc # lines_ :: [Line HDoc] -> HDoc # vcat :: [HDoc] -> HDoc # dualDoc :: SDoc -> HDoc -> HDoc #
IsOutput HDoc
Instance details Defined in GHC.Utils.Outputable Methods empty :: HDoc # docWithContext :: (SDocContext -> HDoc) -> HDoc #
type Line HDoc
Instance details Defined in GHC.Utils.Outputable type Line HDoc = HLine

data HLine #

Represents a single line of output that can be efficiently printed directly to a Handle (actually a BufHandle). See Note [SDoc versus HDoc] and Note [HLine versus HDoc] for more details.

Instances

Instances details

IsLine HLine
Instance details Defined in GHC.Utils.Outputable Methods char :: Char -> HLine # text :: String -> HLine # ftext :: FastString -> HLine # ztext :: FastZString -> HLine # (<>) :: HLine -> HLine -> HLine # (<+>) :: HLine -> HLine -> HLine # sep :: [HLine] -> HLine # fsep :: [HLine] -> HLine # hcat :: [HLine] -> HLine # hsep :: [HLine] -> HLine # dualLine :: SDoc -> HLine -> HLine #
IsOutput HLine
Instance details Defined in GHC.Utils.Outputable Methods empty :: HLine # docWithContext :: (SDocContext -> HLine) -> HLine #

class Outputable a => OutputableBndr a where #

When we print a binder, we often want to print its type too. The OutputableBndr class encapsulates this idea.

Minimal complete definition

pprPrefixOcc, pprInfixOcc

Methods

pprBndr :: BindingSite -> a -> SDoc #

pprPrefixOcc :: a -> SDoc #

pprInfixOcc :: a -> SDoc #

bndrIsJoin_maybe :: a -> Maybe Int #

Instances

Instances details

OutputableBndr DataCon
Instance details Defined in GHC.Core.DataCon Methods pprBndr :: BindingSite -> DataCon -> SDoc # pprPrefixOcc :: DataCon -> SDoc # pprInfixOcc :: DataCon -> SDoc # bndrIsJoin_maybe :: DataCon -> Maybe Int #
OutputableBndr PatSyn
Instance details Defined in GHC.Core.PatSyn Methods pprBndr :: BindingSite -> PatSyn -> SDoc # pprPrefixOcc :: PatSyn -> SDoc # pprInfixOcc :: PatSyn -> SDoc # bndrIsJoin_maybe :: PatSyn -> Maybe Int #
OutputableBndr BinderInfo
Instance details Defined in GHC.Stg.Lift.Analysis Methods pprBndr :: BindingSite -> BinderInfo -> SDoc # pprPrefixOcc :: BinderInfo -> SDoc # pprInfixOcc :: BinderInfo -> SDoc # bndrIsJoin_maybe :: BinderInfo -> Maybe Int #
OutputableBndr Name
Instance details Defined in GHC.Types.Name Methods pprBndr :: BindingSite -> Name -> SDoc # pprPrefixOcc :: Name -> SDoc # pprInfixOcc :: Name -> SDoc # bndrIsJoin_maybe :: Name -> Maybe Int #
OutputableBndr OccName
Instance details Defined in GHC.Types.Name.Occurrence Methods pprBndr :: BindingSite -> OccName -> SDoc # pprPrefixOcc :: OccName -> SDoc # pprInfixOcc :: OccName -> SDoc # bndrIsJoin_maybe :: OccName -> Maybe Int #
OutputableBndr RdrName
Instance details Defined in GHC.Types.Name.Reader Methods pprBndr :: BindingSite -> RdrName -> SDoc # pprPrefixOcc :: RdrName -> SDoc # pprInfixOcc :: RdrName -> SDoc # bndrIsJoin_maybe :: RdrName -> Maybe Int #
(Outputable a, OutputableBndr e) => OutputableBndr (GenLocated (SrcSpanAnn' a) e)
Instance details Defined in GHC.Parser.Annotation Methods pprBndr :: BindingSite -> GenLocated (SrcSpanAnn' a) e -> SDoc # pprPrefixOcc :: GenLocated (SrcSpanAnn' a) e -> SDoc # pprInfixOcc :: GenLocated (SrcSpanAnn' a) e -> SDoc # bndrIsJoin_maybe :: GenLocated (SrcSpanAnn' a) e -> Maybe Int #
OutputableBndr (Id, TagSig)
Instance details Defined in GHC.Stg.InferTags.TagSig Methods pprBndr :: BindingSite -> (Id, TagSig) -> SDoc # pprPrefixOcc :: (Id, TagSig) -> SDoc # pprInfixOcc :: (Id, TagSig) -> SDoc # bndrIsJoin_maybe :: (Id, TagSig) -> Maybe Int #

data BindingSite #

BindingSite is used to tell the thing that prints binder what language construct is binding the identifier. This can be used to decide how much info to print. Also see Note [Binding-site specific printing] in GHC.Core.Ppr

Constructors

LambdaBind	The x in (x. e)
CaseBind	The x in case scrut of x { (y,z) -> ... }
CasePatBind	The y,z in case scrut of x { (y,z) -> ... }
LetBind	The x in (let x = rhs in e)

Instances

Instances details

Eq BindingSite
Instance details Defined in GHC.Utils.Outputable Methods (==) :: BindingSite -> BindingSite -> Bool # (/=) :: BindingSite -> BindingSite -> Bool #

newtype PDoc a #

Wrapper for types having a Outputable instance when an OutputableP instance is required.

Constructors

PDoc a

Instances

Instances details

Outputable a => OutputableP env (PDoc a)
Instance details Defined in GHC.Utils.Outputable Methods pdoc :: env -> PDoc a -> SDoc #

class OutputableP env a where #

Outputable class with an additional environment value

See Note [The OutputableP class]

Methods

pdoc :: env -> a -> SDoc #

Instances

Instances details

OutputableP Platform CmmGraph
Instance details Defined in GHC.Cmm Methods pdoc :: Platform -> CmmGraph -> SDoc #
OutputableP Platform CmmInfoTable
Instance details Defined in GHC.Cmm Methods pdoc :: Platform -> CmmInfoTable -> SDoc #
OutputableP Platform CmmStatic
Instance details Defined in GHC.Cmm Methods pdoc :: Platform -> CmmStatic -> SDoc #
OutputableP Platform CmmTopInfo
Instance details Defined in GHC.Cmm Methods pdoc :: Platform -> CmmTopInfo -> SDoc #
OutputableP env Void
Instance details Defined in GHC.Utils.Outputable Methods pdoc :: env -> Void -> SDoc #
OutputableP env Label
Instance details Defined in GHC.Cmm.Dataflow.Label Methods pdoc :: env -> Label -> SDoc #
OutputableP env Alignment
Instance details Defined in GHC.Types.Basic Methods pdoc :: env -> Alignment -> SDoc #
OutputableP env SDoc
Instance details Defined in GHC.Utils.Outputable Methods pdoc :: env -> SDoc -> SDoc #
OutputableP Platform (GenCmmStatics a)
Instance details Defined in GHC.Cmm Methods pdoc :: Platform -> GenCmmStatics a -> SDoc #
OutputableP env a => OutputableP env (SCC a)
Instance details Defined in GHC.Utils.Outputable Methods pdoc :: env -> SCC a -> SDoc #
OutputableP env a => OutputableP env (Set a)
Instance details Defined in GHC.Utils.Outputable Methods pdoc :: env -> Set a -> SDoc #
OutputableP env instr => OutputableP env (GenBasicBlock instr)
Instance details Defined in GHC.Cmm Methods pdoc :: env -> GenBasicBlock instr -> SDoc #
OutputableP env instr => OutputableP env (ListGraph instr)
Instance details Defined in GHC.Cmm Methods pdoc :: env -> ListGraph instr -> SDoc #
OutputableP env a => OutputableP env (LabelMap a)
Instance details Defined in GHC.Cmm.Dataflow.Label Methods pdoc :: env -> LabelMap a -> SDoc #
Outputable a => OutputableP env (PDoc a)
Instance details Defined in GHC.Utils.Outputable Methods pdoc :: env -> PDoc a -> SDoc #
OutputableP env a => OutputableP env (Maybe a)
Instance details Defined in GHC.Utils.Outputable Methods pdoc :: env -> Maybe a -> SDoc #
OutputableP env a => OutputableP env [a]
Instance details Defined in GHC.Utils.Outputable Methods pdoc :: env -> [a] -> SDoc #
(OutputableP env key, OutputableP env elt) => OutputableP env (Map key elt)
Instance details Defined in GHC.Utils.Outputable Methods pdoc :: env -> Map key elt -> SDoc #
(OutputableP env a, OutputableP env b) => OutputableP env (a, b)
Instance details Defined in GHC.Utils.Outputable Methods pdoc :: env -> (a, b) -> SDoc #
(OutputableP Platform d, OutputableP Platform info, OutputableP Platform i) => OutputableP Platform (GenCmmDecl d info i)
Instance details Defined in GHC.Cmm Methods pdoc :: Platform -> GenCmmDecl d info i -> SDoc #
(OutputableP env a, OutputableP env b, OutputableP env c) => OutputableP env (a, b, c)
Instance details Defined in GHC.Utils.Outputable Methods pdoc :: env -> (a, b, c) -> SDoc #

class Outputable a where #

Class designating that some type has an SDoc representation

Methods

ppr :: a -> SDoc #

Instances

Instances details

Outputable Fingerprint
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Fingerprint -> SDoc #
Outputable Int16
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Int16 -> SDoc #
Outputable Int32
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Int32 -> SDoc #
Outputable Int64
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Int64 -> SDoc #
Outputable Int8
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Int8 -> SDoc #
Outputable Word16
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Word16 -> SDoc #
Outputable Word32
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Word32 -> SDoc #
Outputable Word64
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Word64 -> SDoc #
Outputable Word8
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Word8 -> SDoc #
Outputable IntSet
Instance details Defined in GHC.Utils.Outputable Methods ppr :: IntSet -> SDoc #
Outputable PrimCall
Instance details Defined in GHC.Builtin.PrimOps Methods ppr :: PrimCall -> SDoc #
Outputable PrimOp
Instance details Defined in GHC.Builtin.PrimOps Methods ppr :: PrimOp -> SDoc #
Outputable ByteOff
Instance details Defined in GHC.ByteCode.Types Methods ppr :: ByteOff -> SDoc #
Outputable CgBreakInfo
Instance details Defined in GHC.ByteCode.Types Methods ppr :: CgBreakInfo -> SDoc #
Outputable CompiledByteCode
Instance details Defined in GHC.ByteCode.Types Methods ppr :: CompiledByteCode -> SDoc #
Outputable NativeCallInfo
Instance details Defined in GHC.ByteCode.Types Methods ppr :: NativeCallInfo -> SDoc #
Outputable RegBitmap
Instance details Defined in GHC.ByteCode.Types Methods ppr :: RegBitmap -> SDoc #
Outputable UnlinkedBCO
Instance details Defined in GHC.ByteCode.Types Methods ppr :: UnlinkedBCO -> SDoc #
Outputable WordOff
Instance details Defined in GHC.ByteCode.Types Methods ppr :: WordOff -> SDoc #
Outputable CmmStackInfo
Instance details Defined in GHC.Cmm Methods ppr :: CmmStackInfo -> SDoc #
Outputable CmmStatic
Instance details Defined in GHC.Cmm Methods ppr :: CmmStatic -> SDoc #
Outputable Label
Instance details Defined in GHC.Cmm.Dataflow.Label Methods ppr :: Label -> SDoc #
Outputable LabelSet
Instance details Defined in GHC.Cmm.Dataflow.Label Methods ppr :: LabelSet -> SDoc #
Outputable AltCon
Instance details Defined in GHC.Core Methods ppr :: AltCon -> SDoc #
Outputable Class
Instance details Defined in GHC.Core.Class Methods ppr :: Class -> SDoc #
Outputable LiftingContext
Instance details Defined in GHC.Core.Coercion Methods ppr :: LiftingContext -> SDoc #
Outputable CoAxBranch
Instance details Defined in GHC.Core.Coercion.Axiom Methods ppr :: CoAxBranch -> SDoc #
Outputable CoAxiomRule
Instance details Defined in GHC.Core.Coercion.Axiom Methods ppr :: CoAxiomRule -> SDoc #
Outputable DataCon
Instance details Defined in GHC.Core.DataCon Methods ppr :: DataCon -> SDoc #
Outputable EqSpec
Instance details Defined in GHC.Core.DataCon Methods ppr :: EqSpec -> SDoc #
Outputable HsImplBang
Instance details Defined in GHC.Core.DataCon Methods ppr :: HsImplBang -> SDoc #
Outputable HsSrcBang
Instance details Defined in GHC.Core.DataCon Methods ppr :: HsSrcBang -> SDoc #
Outputable StrictnessMark
Instance details Defined in GHC.Core.DataCon Methods ppr :: StrictnessMark -> SDoc #
Outputable FamInst
Instance details Defined in GHC.Core.FamInstEnv Methods ppr :: FamInst -> SDoc #
Outputable FamInstEnv
Instance details Defined in GHC.Core.FamInstEnv Methods ppr :: FamInstEnv -> SDoc #
Outputable FamInstMatch
Instance details Defined in GHC.Core.FamInstEnv Methods ppr :: FamInstMatch -> SDoc #
Outputable ClsInst
Instance details Defined in GHC.Core.InstEnv Methods ppr :: ClsInst -> SDoc #
Outputable InstEnv
Instance details Defined in GHC.Core.InstEnv Methods ppr :: InstEnv -> SDoc #
Outputable InstMatches
Instance details Defined in GHC.Core.InstEnv Methods ppr :: InstMatches -> SDoc #
Outputable PotentialUnifiers
Instance details Defined in GHC.Core.InstEnv Methods ppr :: PotentialUnifiers -> SDoc #
Outputable FloatBind
Instance details Defined in GHC.Core.Make Methods ppr :: FloatBind -> SDoc #
Outputable CallerCcFilter
Instance details Defined in GHC.Core.Opt.CallerCC Methods ppr :: CallerCcFilter -> SDoc #
Outputable NamePattern
Instance details Defined in GHC.Core.Opt.CallerCC Methods ppr :: NamePattern -> SDoc #
Outputable FloatOutSwitches
Instance details Defined in GHC.Core.Opt.Monad Methods ppr :: FloatOutSwitches -> SDoc #
Outputable CoreToDo
Instance details Defined in GHC.Core.Opt.Pipeline.Types Methods ppr :: CoreToDo -> SDoc #
Outputable Tick
Instance details Defined in GHC.Core.Opt.Stats Methods ppr :: Tick -> SDoc #
Outputable PatSyn
Instance details Defined in GHC.Core.PatSyn Methods ppr :: PatSyn -> SDoc #
Outputable CoSel
Instance details Defined in GHC.Core.TyCo.Rep Methods ppr :: CoSel -> SDoc #
Outputable Coercion
Instance details Defined in GHC.Core.TyCo.Rep Methods ppr :: Coercion -> SDoc #
Outputable CoercionHole
Instance details Defined in GHC.Core.TyCo.Rep Methods ppr :: CoercionHole -> SDoc #
Outputable FunSel
Instance details Defined in GHC.Core.TyCo.Rep Methods ppr :: FunSel -> SDoc #
Outputable MCoercion
Instance details Defined in GHC.Core.TyCo.Rep Methods ppr :: MCoercion -> SDoc #
Outputable TyLit
Instance details Defined in GHC.Core.TyCo.Rep Methods ppr :: TyLit -> SDoc #
Outputable Type
Instance details Defined in GHC.Core.TyCo.Rep Methods ppr :: Type -> SDoc #
Outputable UnivCoProvenance
Instance details Defined in GHC.Core.TyCo.Rep Methods ppr :: UnivCoProvenance -> SDoc #
Outputable Subst
Instance details Defined in GHC.Core.TyCo.Subst Methods ppr :: Subst -> SDoc #
Outputable AlgTyConFlav
Instance details Defined in GHC.Core.TyCon Methods ppr :: AlgTyConFlav -> SDoc #
Outputable FamTyConFlav
Instance details Defined in GHC.Core.TyCon Methods ppr :: FamTyConFlav -> SDoc #
Outputable PrimElemRep
Instance details Defined in GHC.Core.TyCon Methods ppr :: PrimElemRep -> SDoc #
Outputable PrimRep
Instance details Defined in GHC.Core.TyCon Methods ppr :: PrimRep -> SDoc #
Outputable TyCon
Instance details Defined in GHC.Core.TyCon Methods ppr :: TyCon -> SDoc #
Outputable TyConBndrVis
Instance details Defined in GHC.Core.TyCon Methods ppr :: TyConBndrVis -> SDoc #
Outputable TyConFlavour
Instance details Defined in GHC.Core.TyCon Methods ppr :: TyConFlavour -> SDoc #
Outputable ArgSummary
Instance details Defined in GHC.Core.Unfold Methods ppr :: ArgSummary -> SDoc #
Outputable CallCtxt
Instance details Defined in GHC.Core.Unfold Methods ppr :: CallCtxt -> SDoc #
Outputable ExprSize
Instance details Defined in GHC.Core.Unfold Methods ppr :: ExprSize -> SDoc #
Outputable FastString
Instance details Defined in GHC.Utils.Outputable Methods ppr :: FastString -> SDoc #
Outputable LexicalFastString
Instance details Defined in GHC.Utils.Outputable Methods ppr :: LexicalFastString -> SDoc #
Outputable NonDetFastString
Instance details Defined in GHC.Utils.Outputable Methods ppr :: NonDetFastString -> SDoc #
Outputable UnVarGraph
Instance details Defined in GHC.Data.Graph.UnVar Methods ppr :: UnVarGraph -> SDoc #
Outputable UnVarSet
Instance details Defined in GHC.Data.Graph.UnVar Methods ppr :: UnVarSet -> SDoc #
Outputable WarnReason
Instance details Defined in GHC.Driver.CmdLine Methods ppr :: WarnReason -> SDoc #
Outputable Language
Instance details Defined in GHC.Driver.Flags Methods ppr :: Language -> SDoc #
Outputable PluginRecompile
Instance details Defined in GHC.Driver.Plugins Methods ppr :: PluginRecompile -> SDoc #
Outputable GhcMode
Instance details Defined in GHC.Driver.Session Methods ppr :: GhcMode -> SDoc #
Outputable ModRenaming
Instance details Defined in GHC.Driver.Session Methods ppr :: ModRenaming -> SDoc #
Outputable PackageArg
Instance details Defined in GHC.Driver.Session Methods ppr :: PackageArg -> SDoc #
Outputable PackageFlag
Instance details Defined in GHC.Driver.Session Methods ppr :: PackageFlag -> SDoc #
Outputable ABExport
Instance details Defined in GHC.Hs.Binds Methods ppr :: ABExport -> SDoc #
Outputable TcSpecPrag
Instance details Defined in GHC.Hs.Binds Methods ppr :: TcSpecPrag -> SDoc #
Outputable XViaStrategyPs
Instance details Defined in GHC.Hs.Decls Methods ppr :: XViaStrategyPs -> SDoc #
Outputable DocStructureItem
Instance details Defined in GHC.Hs.Doc Methods ppr :: DocStructureItem -> SDoc #
Outputable Docs
Instance details Defined in GHC.Hs.Doc Methods ppr :: Docs -> SDoc #
Outputable HsDocString
Instance details Defined in GHC.Hs.DocString Methods ppr :: HsDocString -> SDoc #
Outputable HsDocStringChunk
Instance details Defined in GHC.Hs.DocString Methods ppr :: HsDocStringChunk -> SDoc #
Outputable HsDocStringDecorator
Instance details Defined in GHC.Hs.DocString Methods ppr :: HsDocStringDecorator -> SDoc #
Outputable GrhsAnn
Instance details Defined in GHC.Hs.Expr Methods ppr :: GrhsAnn -> SDoc #
Outputable PendingRnSplice
Instance details Defined in GHC.Hs.Expr Methods ppr :: PendingRnSplice -> SDoc #
Outputable PendingTcSplice
Instance details Defined in GHC.Hs.Expr Methods ppr :: PendingTcSplice -> SDoc #
Outputable SyntaxExprRn
Instance details Defined in GHC.Hs.Expr Methods ppr :: SyntaxExprRn -> SDoc #
Outputable SyntaxExprTc
Instance details Defined in GHC.Hs.Expr Methods ppr :: SyntaxExprTc -> SDoc #
Outputable XXExprGhcTc
Instance details Defined in GHC.Hs.Expr Methods ppr :: XXExprGhcTc -> SDoc #
Outputable DsMatchContext
Instance details Defined in GHC.HsToCore.Monad Methods ppr :: DsMatchContext -> SDoc #
Outputable EquationInfo
Instance details Defined in GHC.HsToCore.Monad Methods ppr :: EquationInfo -> SDoc #
Outputable BotInfo
Instance details Defined in GHC.HsToCore.Pmc.Solver.Types Methods ppr :: BotInfo -> SDoc #
Outputable Nabla
Instance details Defined in GHC.HsToCore.Pmc.Solver.Types Methods ppr :: Nabla -> SDoc #
Outputable Nablas
Instance details Defined in GHC.HsToCore.Pmc.Solver.Types Methods ppr :: Nablas -> SDoc #
Outputable PmAltCon
Instance details Defined in GHC.HsToCore.Pmc.Solver.Types Methods ppr :: PmAltCon -> SDoc #
Outputable PmAltConApp
Instance details Defined in GHC.HsToCore.Pmc.Solver.Types Methods ppr :: PmAltConApp -> SDoc #
Outputable PmAltConSet
Instance details Defined in GHC.HsToCore.Pmc.Solver.Types Methods ppr :: PmAltConSet -> SDoc #
Outputable PmEquality
Instance details Defined in GHC.HsToCore.Pmc.Solver.Types Methods ppr :: PmEquality -> SDoc #
Outputable PmLit
Instance details Defined in GHC.HsToCore.Pmc.Solver.Types Methods ppr :: PmLit -> SDoc #
Outputable PmLitValue
Instance details Defined in GHC.HsToCore.Pmc.Solver.Types Methods ppr :: PmLitValue -> SDoc #
Outputable ResidualCompleteMatches
Instance details Defined in GHC.HsToCore.Pmc.Solver.Types Methods ppr :: ResidualCompleteMatches -> SDoc #
Outputable TmState	Not user-facing.
Instance details Defined in GHC.HsToCore.Pmc.Solver.Types Methods ppr :: TmState -> SDoc #
Outputable TyState	Not user-facing.
Instance details Defined in GHC.HsToCore.Pmc.Solver.Types Methods ppr :: TyState -> SDoc #
Outputable VarInfo	Not user-facing.
Instance details Defined in GHC.HsToCore.Pmc.Solver.Types Methods ppr :: VarInfo -> SDoc #
Outputable CompileReason
Instance details Defined in GHC.Iface.Recomp Methods ppr :: CompileReason -> SDoc #
Outputable IfaceDeclExtras
Instance details Defined in GHC.Iface.Recomp Methods ppr :: IfaceDeclExtras -> SDoc #
Outputable RecompReason
Instance details Defined in GHC.Iface.Recomp Methods ppr :: RecompReason -> SDoc #
Outputable RecompileRequired
Instance details Defined in GHC.Iface.Recomp Methods ppr :: RecompileRequired -> SDoc #
Outputable IfGuidance
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfGuidance -> SDoc #
Outputable IfaceAT
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceAT -> SDoc #
Outputable IfaceAnnotation
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceAnnotation -> SDoc #
Outputable IfaceClassOp
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceClassOp -> SDoc #
Outputable IfaceClsInst
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceClsInst -> SDoc #
Outputable IfaceCompleteMatch
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceCompleteMatch -> SDoc #
Outputable IfaceConAlt
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceConAlt -> SDoc #
Outputable IfaceDecl
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceDecl -> SDoc #
Outputable IfaceExpr
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceExpr -> SDoc #
Outputable IfaceFamInst
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceFamInst -> SDoc #
Outputable IfaceIdDetails
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceIdDetails -> SDoc #
Outputable IfaceInfoItem
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceInfoItem -> SDoc #
Outputable IfaceJoinInfo
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceJoinInfo -> SDoc #
Outputable IfaceLFInfo
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceLFInfo -> SDoc #
Outputable IfaceMaybeRhs
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceMaybeRhs -> SDoc #
Outputable IfaceRule
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceRule -> SDoc #
Outputable IfaceTopBndrInfo
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceTopBndrInfo -> SDoc #
Outputable IfaceTyConParent
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceTyConParent -> SDoc #
Outputable IfaceUnfolding
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceUnfolding -> SDoc #
Outputable ShowHowMuch
Instance details Defined in GHC.Iface.Syntax Methods ppr :: ShowHowMuch -> SDoc #
Outputable IfaceAppArgs
Instance details Defined in GHC.Iface.Type Methods ppr :: IfaceAppArgs -> SDoc #
Outputable IfaceBndr
Instance details Defined in GHC.Iface.Type Methods ppr :: IfaceBndr -> SDoc #
Outputable IfaceCoercion
Instance details Defined in GHC.Iface.Type Methods ppr :: IfaceCoercion -> SDoc #
Outputable IfaceOneShot
Instance details Defined in GHC.Iface.Type Methods ppr :: IfaceOneShot -> SDoc #
Outputable IfaceTyCon
Instance details Defined in GHC.Iface.Type Methods ppr :: IfaceTyCon -> SDoc #
Outputable IfaceTyConInfo
Instance details Defined in GHC.Iface.Type Methods ppr :: IfaceTyConInfo -> SDoc #
Outputable IfaceTyConSort
Instance details Defined in GHC.Iface.Type Methods ppr :: IfaceTyConSort -> SDoc #
Outputable IfaceTyLit
Instance details Defined in GHC.Iface.Type Methods ppr :: IfaceTyLit -> SDoc #
Outputable IfaceType
Instance details Defined in GHC.Iface.Type Methods ppr :: IfaceType -> SDoc #
Outputable LibrarySpec
Instance details Defined in GHC.Linker.Types Methods ppr :: LibrarySpec -> SDoc #
Outputable Linkable
Instance details Defined in GHC.Linker.Types Methods ppr :: Linkable -> SDoc #
Outputable LoadedPkgInfo
Instance details Defined in GHC.Linker.Types Methods ppr :: LoadedPkgInfo -> SDoc #
Outputable SptEntry
Instance details Defined in GHC.Linker.Types Methods ppr :: SptEntry -> SDoc #
Outputable Unlinked
Instance details Defined in GHC.Linker.Types Methods ppr :: Unlinked -> SDoc #
Outputable AddEpAnn
Instance details Defined in GHC.Parser.Annotation Methods ppr :: AddEpAnn -> SDoc #
Outputable Anchor
Instance details Defined in GHC.Parser.Annotation Methods ppr :: Anchor -> SDoc #
Outputable AnchorOperation
Instance details Defined in GHC.Parser.Annotation Methods ppr :: AnchorOperation -> SDoc #
Outputable AnnContext
Instance details Defined in GHC.Parser.Annotation Methods ppr :: AnnContext -> SDoc #
Outputable AnnKeywordId
Instance details Defined in GHC.Parser.Annotation Methods ppr :: AnnKeywordId -> SDoc #
Outputable AnnList
Instance details Defined in GHC.Parser.Annotation Methods ppr :: AnnList -> SDoc #
Outputable AnnListItem
Instance details Defined in GHC.Parser.Annotation Methods ppr :: AnnListItem -> SDoc #
Outputable AnnPragma
Instance details Defined in GHC.Parser.Annotation Methods ppr :: AnnPragma -> SDoc #
Outputable AnnSortKey
Instance details Defined in GHC.Parser.Annotation Methods ppr :: AnnSortKey -> SDoc #
Outputable DeltaPos
Instance details Defined in GHC.Parser.Annotation Methods ppr :: DeltaPos -> SDoc #
Outputable EpAnnComments
Instance details Defined in GHC.Parser.Annotation Methods ppr :: EpAnnComments -> SDoc #
Outputable EpaComment
Instance details Defined in GHC.Parser.Annotation Methods ppr :: EpaComment -> SDoc #
Outputable EpaLocation
Instance details Defined in GHC.Parser.Annotation Methods ppr :: EpaLocation -> SDoc #
Outputable IsUnicodeSyntax
Instance details Defined in GHC.Parser.Annotation Methods ppr :: IsUnicodeSyntax -> SDoc #
Outputable NameAdornment
Instance details Defined in GHC.Parser.Annotation Methods ppr :: NameAdornment -> SDoc #
Outputable NameAnn
Instance details Defined in GHC.Parser.Annotation Methods ppr :: NameAnn -> SDoc #
Outputable NoEpAnns
Instance details Defined in GHC.Parser.Annotation Methods ppr :: NoEpAnns -> SDoc #
Outputable TrailingAnn
Instance details Defined in GHC.Parser.Annotation Methods ppr :: TrailingAnn -> SDoc #
Outputable DataConBuilder
Instance details Defined in GHC.Parser.Types Methods ppr :: DataConBuilder -> SDoc #
Outputable InteractiveImport
Instance details Defined in GHC.Runtime.Context Methods ppr :: InteractiveImport -> SDoc #
Outputable TagInfo
Instance details Defined in GHC.Stg.InferTags.TagSig Methods ppr :: TagInfo -> SDoc #
Outputable TagSig
Instance details Defined in GHC.Stg.InferTags.TagSig Methods ppr :: TagSig -> SDoc #
Outputable BinderInfo
Instance details Defined in GHC.Stg.Lift.Analysis Methods ppr :: BinderInfo -> SDoc #
Outputable Skeleton
Instance details Defined in GHC.Stg.Lift.Analysis Methods ppr :: Skeleton -> SDoc #
Outputable AltType
Instance details Defined in GHC.Stg.Syntax Methods ppr :: AltType -> SDoc #
Outputable ConstructorNumber
Instance details Defined in GHC.Stg.Syntax Methods ppr :: ConstructorNumber -> SDoc #
Outputable NoExtFieldSilent
Instance details Defined in GHC.Stg.Syntax Methods ppr :: NoExtFieldSilent -> SDoc #
Outputable StgArg
Instance details Defined in GHC.Stg.Syntax Methods ppr :: StgArg -> SDoc #
Outputable StgOp
Instance details Defined in GHC.Stg.Syntax Methods ppr :: StgOp -> SDoc #
Outputable UpdateFlag
Instance details Defined in GHC.Stg.Syntax Methods ppr :: UpdateFlag -> SDoc #
Outputable LambdaFormInfo
Instance details Defined in GHC.StgToCmm.Types Methods ppr :: LambdaFormInfo -> SDoc #
Outputable StandardFormInfo
Instance details Defined in GHC.StgToCmm.Types Methods ppr :: StandardFormInfo -> SDoc #
Outputable Deps
Instance details Defined in GHC.StgToJS.Object Methods ppr :: Deps -> SDoc #
Outputable DepsLocation
Instance details Defined in GHC.StgToJS.Object Methods ppr :: DepsLocation -> SDoc #
Outputable ExportedFun
Instance details Defined in GHC.StgToJS.Object Methods ppr :: ExportedFun -> SDoc #
Outputable StaticArg
Instance details Defined in GHC.StgToJS.Types Methods ppr :: StaticArg -> SDoc #
Outputable StaticLit
Instance details Defined in GHC.StgToJS.Types Methods ppr :: StaticLit -> SDoc #
Outputable TypedExpr
Instance details Defined in GHC.StgToJS.Types Methods ppr :: TypedExpr -> SDoc #
Outputable HoleFit
Instance details Defined in GHC.Tc.Errors.Hole.FitTypes Methods ppr :: HoleFit -> SDoc #
Outputable HoleFitCandidate
Instance details Defined in GHC.Tc.Errors.Hole.FitTypes Methods ppr :: HoleFitCandidate -> SDoc #
Outputable TypedHole
Instance details Defined in GHC.Tc.Errors.Hole.FitTypes Methods ppr :: TypedHole -> SDoc #
Outputable ErrorItem
Instance details Defined in GHC.Tc.Errors.Types Methods ppr :: ErrorItem -> SDoc #
Outputable Exported
Instance details Defined in GHC.Tc.Errors.Types Methods ppr :: Exported -> SDoc #
Outputable PromotionErr
Instance details Defined in GHC.Tc.Errors.Types Methods ppr :: PromotionErr -> SDoc #
Outputable TypeDataForbids
Instance details Defined in GHC.Tc.Errors.Types Methods ppr :: TypeDataForbids -> SDoc #
Outputable TouchabilityTestResult
Instance details Defined in GHC.Tc.Solver.Monad Methods ppr :: TouchabilityTestResult -> SDoc #
Outputable DefaultingProposal
Instance details Defined in GHC.Tc.Types Methods ppr :: DefaultingProposal -> SDoc #
Outputable IdBindingInfo
Instance details Defined in GHC.Tc.Types Methods ppr :: IdBindingInfo -> SDoc #
Outputable TcBinder
Instance details Defined in GHC.Tc.Types Methods ppr :: TcBinder -> SDoc #
Outputable TcIdSigInfo
Instance details Defined in GHC.Tc.Types Methods ppr :: TcIdSigInfo -> SDoc #
Outputable TcIdSigInst
Instance details Defined in GHC.Tc.Types Methods ppr :: TcIdSigInst -> SDoc #
Outputable TcPatSynInfo
Instance details Defined in GHC.Tc.Types Methods ppr :: TcPatSynInfo -> SDoc #
Outputable TcSigInfo
Instance details Defined in GHC.Tc.Types Methods ppr :: TcSigInfo -> SDoc #
Outputable TcTyThing
Instance details Defined in GHC.Tc.Types Methods ppr :: TcTyThing -> SDoc #
Outputable ThStage
Instance details Defined in GHC.Tc.Types Methods ppr :: ThStage -> SDoc #
Outputable WhereFrom
Instance details Defined in GHC.Tc.Types Methods ppr :: WhereFrom -> SDoc #
Outputable CanEqLHS
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: CanEqLHS -> SDoc #
Outputable CheckTyEqResult
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: CheckTyEqResult -> SDoc #
Outputable Ct
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: Ct -> SDoc #
Outputable CtEvidence
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: CtEvidence -> SDoc #
Outputable CtFlavour
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: CtFlavour -> SDoc #
Outputable CtIrredReason
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: CtIrredReason -> SDoc #
Outputable DelayedError
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: DelayedError -> SDoc #
Outputable HasGivenEqs
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: HasGivenEqs -> SDoc #
Outputable Hole
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: Hole -> SDoc #
Outputable HoleSort
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: HoleSort -> SDoc #
Outputable ImplicStatus
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: ImplicStatus -> SDoc #
Outputable Implication
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: Implication -> SDoc #
Outputable NotConcreteError
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: NotConcreteError -> SDoc #
Outputable QCInst
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: QCInst -> SDoc #
Outputable RewriterSet
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: RewriterSet -> SDoc #
Outputable SubGoalDepth
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: SubGoalDepth -> SDoc #
Outputable TcEvDest
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: TcEvDest -> SDoc #
Outputable WantedConstraints
Instance details Defined in GHC.Tc.Types.Constraint Methods ppr :: WantedConstraints -> SDoc #
Outputable IsExtraConstraint
Instance details Defined in GHC.Tc.Utils.Monad Methods ppr :: IsExtraConstraint -> SDoc #
Outputable ExpType
Instance details Defined in GHC.Tc.Utils.TcType Methods ppr :: ExpType -> SDoc #
Outputable InferResult
Instance details Defined in GHC.Tc.Utils.TcType Methods ppr :: InferResult -> SDoc #
Outputable MetaDetails
Instance details Defined in GHC.Tc.Utils.TcType Methods ppr :: MetaDetails -> SDoc #
Outputable MetaInfo
Instance details Defined in GHC.Tc.Utils.TcType Methods ppr :: MetaInfo -> SDoc #
Outputable PatersonSize
Instance details Defined in GHC.Tc.Utils.TcType Methods ppr :: PatersonSize -> SDoc #
Outputable TcLevel
Instance details Defined in GHC.Tc.Utils.TcType Methods ppr :: TcLevel -> SDoc #
Outputable TcTyVarDetails
Instance details Defined in GHC.Tc.Utils.TcType Methods ppr :: TcTyVarDetails -> SDoc #
Outputable Annotation
Instance details Defined in GHC.Types.Annotations Methods ppr :: Annotation -> SDoc #
Outputable AvailInfo
Instance details Defined in GHC.Types.Avail Methods ppr :: AvailInfo -> SDoc #
Outputable GreName
Instance details Defined in GHC.Types.Avail Methods ppr :: GreName -> SDoc #
Outputable Activation
Instance details Defined in GHC.Types.Basic Methods ppr :: Activation -> SDoc #
Outputable Alignment
Instance details Defined in GHC.Types.Basic Methods ppr :: Alignment -> SDoc #
Outputable CbvMark
Instance details Defined in GHC.Types.Basic Methods ppr :: CbvMark -> SDoc #
Outputable CompilerPhase
Instance details Defined in GHC.Types.Basic Methods ppr :: CompilerPhase -> SDoc #
Outputable DefaultingStrategy
Instance details Defined in GHC.Types.Basic Methods ppr :: DefaultingStrategy -> SDoc #
Outputable FunctionOrData
Instance details Defined in GHC.Types.Basic Methods ppr :: FunctionOrData -> SDoc #
Outputable InlinePragma
Instance details Defined in GHC.Types.Basic Methods ppr :: InlinePragma -> SDoc #
Outputable InlineSpec
Instance details Defined in GHC.Types.Basic Methods ppr :: InlineSpec -> SDoc #
Outputable IntWithInf
Instance details Defined in GHC.Types.Basic Methods ppr :: IntWithInf -> SDoc #
Outputable LeftOrRight
Instance details Defined in GHC.Types.Basic Methods ppr :: LeftOrRight -> SDoc #
Outputable Levity
Instance details Defined in GHC.Types.Basic Methods ppr :: Levity -> SDoc #
Outputable NonStandardDefaultingStrategy
Instance details Defined in GHC.Types.Basic Methods ppr :: NonStandardDefaultingStrategy -> SDoc #
Outputable OccInfo
Instance details Defined in GHC.Types.Basic Methods ppr :: OccInfo -> SDoc #
Outputable OneShotInfo
Instance details Defined in GHC.Types.Basic Methods ppr :: OneShotInfo -> SDoc #
Outputable Origin
Instance details Defined in GHC.Types.Basic Methods ppr :: Origin -> SDoc #
Outputable OverlapFlag
Instance details Defined in GHC.Types.Basic Methods ppr :: OverlapFlag -> SDoc #
Outputable OverlapMode
Instance details Defined in GHC.Types.Basic Methods ppr :: OverlapMode -> SDoc #
Outputable RecFlag
Instance details Defined in GHC.Types.Basic Methods ppr :: RecFlag -> SDoc #
Outputable RuleMatchInfo
Instance details Defined in GHC.Types.Basic Methods ppr :: RuleMatchInfo -> SDoc #
Outputable SuccessFlag
Instance details Defined in GHC.Types.Basic Methods ppr :: SuccessFlag -> SDoc #
Outputable SwapFlag
Instance details Defined in GHC.Types.Basic Methods ppr :: SwapFlag -> SDoc #
Outputable TailCallInfo
Instance details Defined in GHC.Types.Basic Methods ppr :: TailCallInfo -> SDoc #
Outputable TopLevelFlag
Instance details Defined in GHC.Types.Basic Methods ppr :: TopLevelFlag -> SDoc #
Outputable TupleSort
Instance details Defined in GHC.Types.Basic Methods ppr :: TupleSort -> SDoc #
Outputable TypeOrKind
Instance details Defined in GHC.Types.Basic Methods ppr :: TypeOrKind -> SDoc #
Outputable UnboxedTupleOrSum
Instance details Defined in GHC.Types.Basic Methods ppr :: UnboxedTupleOrSum -> SDoc #
Outputable UnfoldingSource
Instance details Defined in GHC.Types.Basic Methods ppr :: UnfoldingSource -> SDoc #
Outputable CompleteMatch
Instance details Defined in GHC.Types.CompleteMatch Methods ppr :: CompleteMatch -> SDoc #
Outputable CostCentre
Instance details Defined in GHC.Types.CostCentre Methods ppr :: CostCentre -> SDoc #
Outputable CostCentreStack
Instance details Defined in GHC.Types.CostCentre Methods ppr :: CostCentreStack -> SDoc #
Outputable Cpr	BNF: cpr ::= '' -- TopCpr \| n -- FlatConCpr n \| n '(' cpr1 ',' cpr2 ',' ... ')' -- ConCpr n [cpr1,cpr2,...] \| 'b' -- BotCpr Examples: * `f x = f x` has result CPR `b` * `1(1,)` is a valid (nested) `Cpr` denotation for `(I# 42#, f 42)`.
Instance details Defined in GHC.Types.Cpr Methods ppr :: Cpr -> SDoc #
Outputable CprSig	Only print the CPR result
Instance details Defined in GHC.Types.Cpr Methods ppr :: CprSig -> SDoc #
Outputable CprType	BNF: cpr_ty ::= cpr -- short form if arty == 0 \| '\' arty '.' cpr -- if arty > 0 Examples: * `f x y z = f x y z` has denotation `3.b` * `g !x = (x+1, x+2)` has denotation `1.1(1,1)`.
Instance details Defined in GHC.Types.Cpr Methods ppr :: CprType -> SDoc #
Outputable Card	See Note [Demand notation] Current syntax was discussed in #19016.
Instance details Defined in GHC.Types.Demand Methods ppr :: Card -> SDoc #
Outputable Demand	See Note [Demand notation]
Instance details Defined in GHC.Types.Demand Methods ppr :: Demand -> SDoc #
Outputable Divergence
Instance details Defined in GHC.Types.Demand Methods ppr :: Divergence -> SDoc #
Outputable DmdEnv
Instance details Defined in GHC.Types.Demand Methods ppr :: DmdEnv -> SDoc #
Outputable DmdSig
Instance details Defined in GHC.Types.Demand Methods ppr :: DmdSig -> SDoc #
Outputable DmdType
Instance details Defined in GHC.Types.Demand Methods ppr :: DmdType -> SDoc #
Outputable SubDemand	See Note [Demand notation]
Instance details Defined in GHC.Types.Demand Methods ppr :: SubDemand -> SDoc #
Outputable TypeShape
Instance details Defined in GHC.Types.Demand Methods ppr :: TypeShape -> SDoc #
Outputable DiagnosticCode
Instance details Defined in GHC.Types.Error Methods ppr :: DiagnosticCode -> SDoc #
Outputable DiagnosticHint
Instance details Defined in GHC.Types.Error Methods ppr :: DiagnosticHint -> SDoc #
Outputable DiagnosticReason
Instance details Defined in GHC.Types.Error Methods ppr :: DiagnosticReason -> SDoc #
Outputable Severity
Instance details Defined in GHC.Types.Error Methods ppr :: Severity -> SDoc #
Outputable DuplicateRecordFields
Instance details Defined in GHC.Types.FieldLabel Methods ppr :: DuplicateRecordFields -> SDoc #
Outputable FieldLabel
Instance details Defined in GHC.Types.FieldLabel Methods ppr :: FieldLabel -> SDoc #
Outputable FieldSelectors
Instance details Defined in GHC.Types.FieldLabel Methods ppr :: FieldSelectors -> SDoc #
Outputable Fixity
Instance details Defined in GHC.Types.Fixity Methods ppr :: Fixity -> SDoc #
Outputable FixityDirection
Instance details Defined in GHC.Types.Fixity Methods ppr :: FixityDirection -> SDoc #
Outputable LexicalFixity
Instance details Defined in GHC.Types.Fixity Methods ppr :: LexicalFixity -> SDoc #
Outputable FixItem
Instance details Defined in GHC.Types.Fixity.Env Methods ppr :: FixItem -> SDoc #
Outputable CCallConv
Instance details Defined in GHC.Types.ForeignCall Methods ppr :: CCallConv -> SDoc #
Outputable CCallSpec
Instance details Defined in GHC.Types.ForeignCall Methods ppr :: CCallSpec -> SDoc #
Outputable CExportSpec
Instance details Defined in GHC.Types.ForeignCall Methods ppr :: CExportSpec -> SDoc #
Outputable CType
Instance details Defined in GHC.Types.ForeignCall Methods ppr :: CType -> SDoc #
Outputable ForeignCall
Instance details Defined in GHC.Types.ForeignCall Methods ppr :: ForeignCall -> SDoc #
Outputable Header
Instance details Defined in GHC.Types.ForeignCall Methods ppr :: Header -> SDoc #
Outputable Safety
Instance details Defined in GHC.Types.ForeignCall Methods ppr :: Safety -> SDoc #
Outputable CafInfo
Instance details Defined in GHC.Types.Id.Info Methods ppr :: CafInfo -> SDoc #
Outputable IdDetails
Instance details Defined in GHC.Types.Id.Info Methods ppr :: IdDetails -> SDoc #
Outputable RecSelParent
Instance details Defined in GHC.Types.Id.Info Methods ppr :: RecSelParent -> SDoc #
Outputable TickBoxOp
Instance details Defined in GHC.Types.Id.Info Methods ppr :: TickBoxOp -> SDoc #
Outputable Literal
Instance details Defined in GHC.Types.Literal Methods ppr :: Literal -> SDoc #
Outputable Name
Instance details Defined in GHC.Types.Name Methods ppr :: Name -> SDoc #
Outputable NameSort
Instance details Defined in GHC.Types.Name Methods ppr :: NameSort -> SDoc #
Outputable OccName
Instance details Defined in GHC.Types.Name.Occurrence Methods ppr :: OccName -> SDoc #
Outputable GlobalRdrElt
Instance details Defined in GHC.Types.Name.Reader Methods ppr :: GlobalRdrElt -> SDoc #
Outputable ImportSpec
Instance details Defined in GHC.Types.Name.Reader Methods ppr :: ImportSpec -> SDoc #
Outputable LocalRdrEnv
Instance details Defined in GHC.Types.Name.Reader Methods ppr :: LocalRdrEnv -> SDoc #
Outputable Parent
Instance details Defined in GHC.Types.Name.Reader Methods ppr :: Parent -> SDoc #
Outputable RdrName
Instance details Defined in GHC.Types.Name.Reader Methods ppr :: RdrName -> SDoc #
Outputable PkgQual
Instance details Defined in GHC.Types.PkgQual Methods ppr :: PkgQual -> SDoc #
Outputable RawPkgQual
Instance details Defined in GHC.Types.PkgQual Methods ppr :: RawPkgQual -> SDoc #
Outputable IfaceTrustInfo
Instance details Defined in GHC.Types.SafeHaskell Methods ppr :: IfaceTrustInfo -> SDoc #
Outputable SafeHaskellMode
Instance details Defined in GHC.Types.SafeHaskell Methods ppr :: SafeHaskellMode -> SDoc #
Outputable FractionalLit
Instance details Defined in GHC.Types.SourceText Methods ppr :: FractionalLit -> SDoc #
Outputable IntegralLit
Instance details Defined in GHC.Types.SourceText Methods ppr :: IntegralLit -> SDoc #
Outputable SourceText
Instance details Defined in GHC.Types.SourceText Methods ppr :: SourceText -> SDoc #
Outputable StringLiteral
Instance details Defined in GHC.Types.SourceText Methods ppr :: StringLiteral -> SDoc #
Outputable RealSrcLoc
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: RealSrcLoc -> SDoc #
Outputable RealSrcSpan
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: RealSrcSpan -> SDoc #
Outputable SrcLoc
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: SrcLoc -> SDoc #
Outputable SrcSpan
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: SrcSpan -> SDoc #
Outputable UnhelpfulSpanReason
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: UnhelpfulSpanReason -> SDoc #
Outputable Target
Instance details Defined in GHC.Types.Target Methods ppr :: Target -> SDoc #
Outputable TargetId
Instance details Defined in GHC.Types.Target Methods ppr :: TargetId -> SDoc #
Outputable TickishPlacement
Instance details Defined in GHC.Types.Tickish Methods ppr :: TickishPlacement -> SDoc #
Outputable TyThing
Instance details Defined in GHC.Types.TyThing Methods ppr :: TyThing -> SDoc #
Outputable Unique
Instance details Defined in GHC.Types.Unique Methods ppr :: Unique -> SDoc #
Outputable ForAllTyFlag
Instance details Defined in GHC.Types.Var Methods ppr :: ForAllTyFlag -> SDoc #
Outputable FunTyFlag
Instance details Defined in GHC.Types.Var Methods ppr :: FunTyFlag -> SDoc #
Outputable PiTyBinder
Instance details Defined in GHC.Types.Var Methods ppr :: PiTyBinder -> SDoc #
Outputable Var
Instance details Defined in GHC.Types.Var Methods ppr :: Var -> SDoc #
Outputable InScopeSet
Instance details Defined in GHC.Types.Var.Env Methods ppr :: InScopeSet -> SDoc #
Outputable HomeUnitEnv
Instance details Defined in GHC.Unit.Env Methods ppr :: HomeUnitEnv -> SDoc #
Outputable HomeModLinkable
Instance details Defined in GHC.Unit.Home.ModInfo Methods ppr :: HomeModLinkable -> SDoc #
Outputable PackageId
Instance details Defined in GHC.Unit.Info Methods ppr :: PackageId -> SDoc #
Outputable PackageName
Instance details Defined in GHC.Unit.Info Methods ppr :: PackageName -> SDoc #
Outputable NDModule
Instance details Defined in GHC.Unit.Module.Env Methods ppr :: NDModule -> SDoc #
Outputable ModNodeKeyWithUid
Instance details Defined in GHC.Unit.Module.Graph Methods ppr :: ModNodeKeyWithUid -> SDoc #
Outputable ModuleGraphNode
Instance details Defined in GHC.Unit.Module.Graph Methods ppr :: ModuleGraphNode -> SDoc #
Outputable NodeKey
Instance details Defined in GHC.Unit.Module.Graph Methods ppr :: NodeKey -> SDoc #
Outputable ModLocation
Instance details Defined in GHC.Unit.Module.Location Methods ppr :: ModLocation -> SDoc #
Outputable ModSummary
Instance details Defined in GHC.Unit.Module.ModSummary Methods ppr :: ModSummary -> SDoc #
Outputable HscBackendAction
Instance details Defined in GHC.Unit.Module.Status Methods ppr :: HscBackendAction -> SDoc #
Outputable UnitPprInfo
Instance details Defined in GHC.Unit.Ppr Methods ppr :: UnitPprInfo -> SDoc #
Outputable ModuleOrigin
Instance details Defined in GHC.Unit.State Methods ppr :: ModuleOrigin -> SDoc #
Outputable UnitErr
Instance details Defined in GHC.Unit.State Methods ppr :: UnitErr -> SDoc #
Outputable UnitVisibility
Instance details Defined in GHC.Unit.State Methods ppr :: UnitVisibility -> SDoc #
Outputable UnusableUnitReason
Instance details Defined in GHC.Unit.State Methods ppr :: UnusableUnitReason -> SDoc #
Outputable InstalledModule
Instance details Defined in GHC.Unit.Types Methods ppr :: InstalledModule -> SDoc #
Outputable InstantiatedModule
Instance details Defined in GHC.Unit.Types Methods ppr :: InstantiatedModule -> SDoc #
Outputable InstantiatedUnit
Instance details Defined in GHC.Unit.Types Methods ppr :: InstantiatedUnit -> SDoc #
Outputable Module
Instance details Defined in GHC.Unit.Types Methods ppr :: Module -> SDoc #
Outputable Unit
Instance details Defined in GHC.Unit.Types Methods ppr :: Unit -> SDoc #
Outputable UnitId
Instance details Defined in GHC.Unit.Types Methods ppr :: UnitId -> SDoc #
Outputable PprStyle
Instance details Defined in GHC.Utils.Outputable Methods ppr :: PprStyle -> SDoc #
Outputable QualifyName
Instance details Defined in GHC.Utils.Outputable Methods ppr :: QualifyName -> SDoc #
Outputable SDoc
Instance details Defined in GHC.Utils.Outputable Methods ppr :: SDoc -> SDoc #
Outputable ModuleName
Instance details Defined in GHC.Utils.Outputable Methods ppr :: ModuleName -> SDoc #
Outputable Serialized
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Serialized -> SDoc #
Outputable Extension
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Extension -> SDoc #
Outputable Ordering
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Ordering -> SDoc #
Outputable UTCTime
Instance details Defined in GHC.Utils.Outputable Methods ppr :: UTCTime -> SDoc #
Outputable Integer
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Integer -> SDoc #
Outputable ()
Instance details Defined in GHC.Utils.Outputable Methods ppr :: () -> SDoc #
Outputable Bool
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Bool -> SDoc #
Outputable Double
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Double -> SDoc #
Outputable Float
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Float -> SDoc #
Outputable Int
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Int -> SDoc #
Outputable Word
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Word -> SDoc #
Outputable a => Outputable (NonEmpty a)
Instance details Defined in GHC.Utils.Outputable Methods ppr :: NonEmpty a -> SDoc #
Outputable a => Outputable (SCC a)
Instance details Defined in GHC.Utils.Outputable Methods ppr :: SCC a -> SDoc #
Outputable elt => Outputable (IntMap elt)
Instance details Defined in GHC.Utils.Outputable Methods ppr :: IntMap elt -> SDoc #
Outputable a => Outputable (Set a)
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Set a -> SDoc #
Outputable instr => Outputable (GenBasicBlock instr)
Instance details Defined in GHC.Cmm Methods ppr :: GenBasicBlock instr -> SDoc #
Outputable instr => Outputable (ListGraph instr)
Instance details Defined in GHC.Cmm Methods ppr :: ListGraph instr -> SDoc #
Outputable a => Outputable (LabelMap a)
Instance details Defined in GHC.Cmm.Dataflow.Label Methods ppr :: LabelMap a -> SDoc #
Outputable b => Outputable (TaggedBndr b)
Instance details Defined in GHC.Core Methods ppr :: TaggedBndr b -> SDoc #
Outputable ev => Outputable (NormaliseStepResult ev)
Instance details Defined in GHC.Core.Coercion Methods ppr :: NormaliseStepResult ev -> SDoc #
Outputable (CoAxiom br)
Instance details Defined in GHC.Core.Coercion.Axiom Methods ppr :: CoAxiom br -> SDoc #
Outputable a => Outputable (CoreMap a)
Instance details Defined in GHC.Core.Map.Expr Methods ppr :: CoreMap a -> SDoc #
Outputable a => Outputable (TypeMapG a)
Instance details Defined in GHC.Core.Map.Type Methods ppr :: TypeMapG a -> SDoc #
Outputable a => Outputable (Scaled a)
Instance details Defined in GHC.Core.TyCo.Rep Methods ppr :: Scaled a -> SDoc #
Outputable a => Outputable (Bag a)
Instance details Defined in GHC.Data.Bag Methods ppr :: Bag a -> SDoc #
Outputable a => Outputable (Pair a)
Instance details Defined in GHC.Data.Pair Methods ppr :: Pair a -> SDoc #
Outputable (KnotVars a)
Instance details Defined in GHC.Driver.Env.KnotVars Methods ppr :: KnotVars a -> SDoc #
Outputable a => Outputable (OnOff a)
Instance details Defined in GHC.Driver.Session Methods ppr :: OnOff a -> SDoc #
Outputable a => Outputable (MaybeValidated a)
Instance details Defined in GHC.Iface.Recomp Methods ppr :: MaybeValidated a -> SDoc #
Outputable a => Outputable (EpAnn a)
Instance details Defined in GHC.Parser.Annotation Methods ppr :: EpAnn a -> SDoc #
Outputable a => Outputable (SrcSpanAnn' a)
Instance details Defined in GHC.Parser.Annotation Methods ppr :: SrcSpanAnn' a -> SDoc #
Outputable (PatBuilder GhcPs)
Instance details Defined in GHC.Parser.Types Methods ppr :: PatBuilder GhcPs -> SDoc #
Outputable (TagEnv p)
Instance details Defined in GHC.Stg.InferTags.Types Methods ppr :: TagEnv p -> SDoc #
OutputablePass pass => Outputable (GenStgBinding pass)
Instance details Defined in GHC.Stg.Syntax Methods ppr :: GenStgBinding pass -> SDoc #
OutputablePass pass => Outputable (GenStgExpr pass)
Instance details Defined in GHC.Stg.Syntax Methods ppr :: GenStgExpr pass -> SDoc #
OutputablePass pass => Outputable (GenStgRhs pass)
Instance details Defined in GHC.Stg.Syntax Methods ppr :: GenStgRhs pass -> SDoc #
OutputableBndrId a => Outputable (InstInfo (GhcPass a))
Instance details Defined in GHC.Tc.Utils.Env Methods ppr :: InstInfo (GhcPass a) -> SDoc #
Outputable name => Outputable (AnnTarget name)
Instance details Defined in GHC.Types.Annotations Methods ppr :: AnnTarget name -> SDoc #
Outputable (DefMethSpec ty)
Instance details Defined in GHC.Types.Basic Methods ppr :: DefMethSpec ty -> SDoc #
Diagnostic e => Outputable (Messages e)
Instance details Defined in GHC.Types.Error Methods ppr :: Messages e -> SDoc #
Outputable a => Outputable (OccEnv a)
Instance details Defined in GHC.Types.Name.Occurrence Methods ppr :: OccEnv a -> SDoc #
Outputable e => Outputable (Located e)
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: Located e -> SDoc #
Outputable a => Outputable (UniqDSet a)
Instance details Defined in GHC.Types.Unique.DSet Methods ppr :: UniqDSet a -> SDoc #
Outputable a => Outputable (UniqSet a)
Instance details Defined in GHC.Types.Unique.Set Methods ppr :: UniqSet a -> SDoc #
Outputable (UnitEnvGraph HomeUnitEnv)
Instance details Defined in GHC.Unit.Env Methods ppr :: UnitEnvGraph HomeUnitEnv -> SDoc #
Outputable elt => Outputable (InstalledModuleEnv elt)
Instance details Defined in GHC.Unit.Module.Env Methods ppr :: InstalledModuleEnv elt -> SDoc #
Outputable a => Outputable (ModuleEnv a)
Instance details Defined in GHC.Unit.Module.Env Methods ppr :: ModuleEnv a -> SDoc #
Outputable (WarningTxt pass)
Instance details Defined in GHC.Unit.Module.Warnings Methods ppr :: WarningTxt pass -> SDoc #
Outputable u => Outputable (UnitDatabase u)
Instance details Defined in GHC.Unit.State Methods ppr :: UnitDatabase u -> SDoc #
Outputable unit => Outputable (Definite unit)
Instance details Defined in GHC.Unit.Types Methods ppr :: Definite unit -> SDoc #
Outputable a => Outputable (GenWithIsBoot a)
Instance details Defined in GHC.Unit.Types Methods ppr :: GenWithIsBoot a -> SDoc #
Outputable a => Outputable (Maybe a)
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Maybe a -> SDoc #
Outputable a => Outputable [a]
Instance details Defined in GHC.Utils.Outputable Methods ppr :: [a] -> SDoc #
(Outputable a, Outputable b) => Outputable (Either a b)
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Either a b -> SDoc #
(Outputable key, Outputable elt) => Outputable (Map key elt)
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Map key elt -> SDoc #
(Outputable a, Outputable (m a)) => Outputable (GenMap m a)
Instance details Defined in GHC.Data.TrieMap Methods ppr :: GenMap m a -> SDoc #
(TrieMap m, Outputable a) => Outputable (ListMap m a)
Instance details Defined in GHC.Data.TrieMap Methods ppr :: ListMap m a -> SDoc #
Outputable a => Outputable (WithHsDocIdentifiers a pass)	For compatibility with the existing @-ddump-parsed' output, we only show the docstring. Use `pprHsDoc` to show `HsDoc`'s internals.
Instance details Defined in GHC.Hs.Doc Methods ppr :: WithHsDocIdentifiers a pass -> SDoc #
(Outputable a, Outputable b) => Outputable (HsExpansion a b)	Just print the original expression (the `a`).
Instance details Defined in GHC.Hs.Expr Methods ppr :: HsExpansion a b -> SDoc #
(Outputable a, Outputable b) => Outputable (HsPatExpansion a b)
Instance details Defined in GHC.Hs.Pat Methods ppr :: HsPatExpansion a b -> SDoc #
(Outputable r, Outputable b) => Outputable (IfaceBindingX r b)
Instance details Defined in GHC.Iface.Syntax Methods ppr :: IfaceBindingX r b -> SDoc #
Outputable (GenLocated Anchor EpaComment)
Instance details Defined in GHC.Parser.Annotation Methods ppr :: GenLocated Anchor EpaComment -> SDoc #
(Outputable a, Outputable e) => Outputable (GenLocated (SrcSpanAnn' a) e)
Instance details Defined in GHC.Parser.Annotation Methods ppr :: GenLocated (SrcSpanAnn' a) e -> SDoc #
Outputable a => Outputable (GenLocated TokenLocation a)
Instance details Defined in GHC.Parser.Annotation Methods ppr :: GenLocated TokenLocation a -> SDoc #
Outputable e => Outputable (GenLocated RealSrcSpan e)
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: GenLocated RealSrcSpan e -> SDoc #
Outputable a => Outputable (UniqDFM key a)
Instance details Defined in GHC.Types.Unique.DFM Methods ppr :: UniqDFM key a -> SDoc #
Outputable a => Outputable (UniqFM key a)
Instance details Defined in GHC.Types.Unique.FM Methods ppr :: UniqFM key a -> SDoc #
OutputableBndr tv => Outputable (VarBndr tv TyConBndrVis)
Instance details Defined in GHC.Core.TyCon Methods ppr :: VarBndr tv TyConBndrVis -> SDoc #
Outputable tv => Outputable (VarBndr tv ForAllTyFlag)
Instance details Defined in GHC.Types.Var Methods ppr :: VarBndr tv ForAllTyFlag -> SDoc #
Outputable tv => Outputable (VarBndr tv Specificity)
Instance details Defined in GHC.Types.Var Methods ppr :: VarBndr tv Specificity -> SDoc #
(Outputable a, Outputable b) => Outputable (a, b)
Instance details Defined in GHC.Utils.Outputable Methods ppr :: (a, b) -> SDoc #
(Outputable a, Outputable b, Outputable c) => Outputable (a, b, c)
Instance details Defined in GHC.Utils.Outputable Methods ppr :: (a, b, c) -> SDoc #
(Outputable a, Outputable b, Outputable c, Outputable d) => Outputable (a, b, c, d)
Instance details Defined in GHC.Utils.Outputable Methods ppr :: (a, b, c, d) -> SDoc #
(Outputable a, Outputable b, Outputable c, Outputable d, Outputable e) => Outputable (a, b, c, d, e)
Instance details Defined in GHC.Utils.Outputable Methods ppr :: (a, b, c, d, e) -> SDoc #
(Outputable a, Outputable b, Outputable c, Outputable d, Outputable e, Outputable f) => Outputable (a, b, c, d, e, f)
Instance details Defined in GHC.Utils.Outputable Methods ppr :: (a, b, c, d, e, f) -> SDoc #
(Outputable a, Outputable b, Outputable c, Outputable d, Outputable e, Outputable f, Outputable g) => Outputable (a, b, c, d, e, f, g)
Instance details Defined in GHC.Utils.Outputable Methods ppr :: (a, b, c, d, e, f, g) -> SDoc #

data SDocContext #

Constructors

SDC

Fields

sdocStyle :: !PprStyle
sdocColScheme :: !Scheme
sdocLastColour :: !PprColour
The most recently used colour. This allows nesting colours.
sdocShouldUseColor :: !Bool
sdocDefaultDepth :: !Int
sdocLineLength :: !Int
sdocCanUseUnicode :: !Bool
True if Unicode encoding is supported and not disabled by GHC_NO_UNICODE environment variable
sdocHexWordLiterals :: !Bool
sdocPprDebug :: !Bool
sdocPrintUnicodeSyntax :: !Bool
sdocPrintCaseAsLet :: !Bool
sdocPrintTypecheckerElaboration :: !Bool
sdocPrintAxiomIncomps :: !Bool
sdocPrintExplicitKinds :: !Bool
sdocPrintExplicitCoercions :: !Bool
sdocPrintExplicitRuntimeReps :: !Bool
sdocPrintExplicitForalls :: !Bool
sdocPrintPotentialInstances :: !Bool
sdocPrintEqualityRelations :: !Bool
sdocSuppressTicks :: !Bool
sdocSuppressTypeSignatures :: !Bool
sdocSuppressTypeApplications :: !Bool
sdocSuppressIdInfo :: !Bool
sdocSuppressCoercions :: !Bool
sdocSuppressCoercionTypes :: !Bool
sdocSuppressUnfoldings :: !Bool
sdocSuppressVarKinds :: !Bool
sdocSuppressUniques :: !Bool
sdocSuppressModulePrefixes :: !Bool
sdocSuppressStgExts :: !Bool
sdocSuppressStgReps :: !Bool
sdocErrorSpans :: !Bool
sdocStarIsType :: !Bool
sdocLinearTypes :: !Bool
sdocListTuplePuns :: !Bool
sdocPrintTypeAbbreviations :: !Bool
sdocUnitIdForUser :: !(FastString -> SDoc)
Used to map UnitIds to more friendly "package-version:component" strings while pretty-printing.
Use pprWithUnitState to set it. Users should never have to set it to pretty-print SDocs emitted by GHC, otherwise it's a bug. It's an internal field used to thread the UnitState so that the Outputable instance of UnitId can use it.
See Note [Pretty-printing UnitId] in GHC.Unit for more details.
Note that we use FastString instead of UnitId to avoid boring module inter-dependency issues.

data QualifyName #

Constructors

NameUnqual
NameQual ModuleName
NameNotInScope1
NameNotInScope2

Instances

Instances details

Outputable QualifyName
Instance details Defined in GHC.Utils.Outputable Methods ppr :: QualifyName -> SDoc #

newtype IsEmptyOrSingleton #

Constructors

IsEmptyOrSingleton Bool

data PromotedItem #

Constructors

PromotedItemListSyntax IsEmptyOrSingleton
PromotedItemTupleSyntax
PromotedItemDataCon OccName

data PromotionTickContext #

Flags that affect whether a promotion tick is printed.

Constructors

PromTickCtx
Fields ptcListTuplePuns :: !Bool ptcPrintRedundantPromTicks :: !Bool

type QueryPromotionTick = PromotedItem -> Bool #

Given a promoted data constructor, decide whether to print a tick to disambiguate the namespace.

type QueryQualifyPackage = Unit -> Bool #

For a given package, we need to know whether to print it with the component id to disambiguate it.

type QueryQualifyModule = Module -> Bool #

For a given module, we need to know whether to print it with a package name to disambiguate it.

type QueryQualifyName = Module -> OccName -> QualifyName #

Given a Name's Module and OccName, decide whether and how to qualify it.

data NamePprCtx #

When printing code that contains original names, we need to map the original names back to something the user understands. This is the purpose of the triple of functions that gets passed around when rendering SDoc.

Constructors

QueryQualify
Fields queryQualifyName :: QueryQualifyName queryQualifyModule :: QueryQualifyModule queryQualifyPackage :: QueryQualifyPackage queryPromotionTick :: QueryPromotionTick

data Depth #

Constructors

AllTheWay
PartWay Int	0 => stop
DefaultDepth	Use `sdocDefaultDepth` field as depth

data PprStyle #

Constructors

PprUser NamePprCtx Depth Coloured
PprDump NamePprCtx
PprCode	Print code; either C or assembler

Instances

Instances details

Outputable PprStyle
Instance details Defined in GHC.Utils.Outputable Methods ppr :: PprStyle -> SDoc #

data IdDetails #

Identifier Details

The IdDetails of an Id give stable, and necessary, information about the Id.

Constructors

VanillaId
RecSelId	The `Id` for a record selector
Fields sel_tycon :: RecSelParent sel_naughty :: Bool
DataConWorkId DataCon	The `Id` is for a data constructor worker
DataConWrapId DataCon	The `Id` is for a data constructor wrapper
ClassOpId Class	The `Id` is a superclass selector, or class operation of a class
PrimOpId PrimOp Bool	The `Id` is for a primitive operator True = is representation-polymorphic, and hence has no binding This lev-poly flag is used only in GHC.Types.Id.hasNoBinding
FCallId ForeignCall	The `Id` is for a foreign call. Type will be simple: no type families, newtypes, etc
TickBoxOpId TickBoxOp	The `Id` is for a HPC tick box (both traditional and binary)
DFunId Bool	A dictionary function. Bool = True = the class has only one method, so may be implemented with a newtype, so it might be bad to be strict on this dictionary
CoVarId	A coercion variable This only covers un-lifted coercions, of type (t1 ~# t2) or (t1 ~R# t2), not their lifted variants
JoinId JoinArity (Maybe [CbvMark])	An `Id` for a join point taking n arguments Note [Join points] in GHC.Core Can also work as a WorkerLikeId if given `CbvMark`s. See Note [CBV Function Ids] The [CbvMark] is always empty (and ignored) until after Tidy.
WorkerLikeId [CbvMark]	An `Id` for a worker like function, which might expect some arguments to be passed both evaluated and tagged. Worker like functions are create by W/W and SpecConstr and we can expect that they aren't used unapplied. See Note [CBV Function Ids] See Note [Tag Inference] The [CbvMark] is always empty (and ignored) until after Tidy for ids from the current module.

Instances

Instances details

Outputable IdDetails
Instance details Defined in GHC.Types.Id.Info Methods ppr :: IdDetails -> SDoc #

data IdInfo #

Identifier Information

An IdInfo gives optional information about an Id. If present it never lies, but it may not be present, in which case there is always a conservative assumption which can be made.

Two Ids may have different info even though they have the same Unique (and are hence the same Id); for example, one might lack the properties attached to the other.

Most of the IdInfo gives information about the value, or definition, of the Id, independent of its usage. Exceptions to this are demandInfo, occInfo, oneShotInfo and callArityInfo.

Performance note: when we update IdInfo, we have to reallocate this entire record, so it is a good idea not to let this data structure get too big.

data StaticPlugin #

A static plugin with its arguments. For registering compiled-in plugins through the GHC API.

Constructors

StaticPlugin
Fields spPlugin :: PluginWithArgs the actual plugin together with its commandline arguments

data LoadedPlugin #

A plugin with its arguments. The result of loading the plugin.

Constructors

LoadedPlugin
Fields lpPlugin :: PluginWithArgs the actual plugin together with its commandline arguments lpModule :: ModIface the module containing the plugin

data Plugins #

Constructors

Plugins

Fields

staticPlugins :: ![StaticPlugin]
Static plugins which do not need dynamic loading. These plugins are intended to be added by GHC API users directly to this list.
To add dynamically loaded plugins through the GHC API see addPluginModuleName instead.
externalPlugins :: ![ExternalPlugin]
External plugins loaded directly from libraries without loading module interfaces.
loadedPlugins :: ![LoadedPlugin]
Plugins dynamically loaded after processing arguments. What will be loaded here is directed by DynFlags.pluginModNames. Arguments are loaded from DynFlags.pluginModNameOpts.
The purpose of this field is to cache the plugins so they don't have to be loaded each time they are needed. See initializePlugins.
loadedPluginDeps :: !([Linkable], PkgsLoaded)
The object files required by the loaded plugins See Note [Plugin dependencies]

class Uniquable a where #

Class of things that we can obtain a Unique from

Methods

getUnique :: a -> Unique #

Instances

Instances details

Uniquable Label
Instance details Defined in GHC.Cmm.Dataflow.Label Methods getUnique :: Label -> Unique #
Uniquable Class
Instance details Defined in GHC.Core.Class Methods getUnique :: Class -> Unique #
Uniquable CoAxiomRule
Instance details Defined in GHC.Core.Coercion.Axiom Methods getUnique :: CoAxiomRule -> Unique #
Uniquable DataCon
Instance details Defined in GHC.Core.DataCon Methods getUnique :: DataCon -> Unique #
Uniquable PatSyn
Instance details Defined in GHC.Core.PatSyn Methods getUnique :: PatSyn -> Unique #
Uniquable CoercionHole
Instance details Defined in GHC.Core.TyCo.Rep Methods getUnique :: CoercionHole -> Unique #
Uniquable TyCon
Instance details Defined in GHC.Core.TyCon Methods getUnique :: TyCon -> Unique #
Uniquable FastString
Instance details Defined in GHC.Types.Unique Methods getUnique :: FastString -> Unique #
Uniquable Ident
Instance details Defined in GHC.JS.Syntax Methods getUnique :: Ident -> Unique #
Uniquable Name
Instance details Defined in GHC.Types.Name Methods getUnique :: Name -> Unique #
Uniquable OccName
Instance details Defined in GHC.Types.Name.Occurrence Methods getUnique :: OccName -> Unique #
Uniquable Unique
Instance details Defined in GHC.Types.Unique Methods getUnique :: Unique -> Unique #
Uniquable Var
Instance details Defined in GHC.Types.Var Methods getUnique :: Var -> Unique #
Uniquable PackageId
Instance details Defined in GHC.Unit.Info Methods getUnique :: PackageId -> Unique #
Uniquable PackageName
Instance details Defined in GHC.Unit.Info Methods getUnique :: PackageName -> Unique #
Uniquable Module
Instance details Defined in GHC.Unit.Types Methods getUnique :: Module -> Unique #
Uniquable UnitId
Instance details Defined in GHC.Unit.Types Methods getUnique :: UnitId -> Unique #
Uniquable ModuleName
Instance details Defined in GHC.Types.Unique Methods getUnique :: ModuleName -> Unique #
Uniquable Int
Instance details Defined in GHC.Types.Unique Methods getUnique :: Int -> Unique #
Uniquable (CoAxiom br)
Instance details Defined in GHC.Core.Coercion.Axiom Methods getUnique :: CoAxiom br -> Unique #
Uniquable unit => Uniquable (Definite unit)
Instance details Defined in GHC.Unit.Types Methods getUnique :: Definite unit -> Unique #
IsUnitId u => Uniquable (GenUnit u)
Instance details Defined in GHC.Unit.Types Methods getUnique :: GenUnit u -> Unique #

class NamedThing a where #

A class allowing convenient access to the Name of various datatypes

Minimal complete definition

getName

Methods

getOccName :: a -> OccName #

getName :: a -> Name #

Instances

Instances details

NamedThing Class
Instance details Defined in GHC.Core.Class Methods getOccName :: Class -> OccName # getName :: Class -> Name #
NamedThing DataCon
Instance details Defined in GHC.Core.DataCon Methods getOccName :: DataCon -> OccName # getName :: DataCon -> Name #
NamedThing FamInst
Instance details Defined in GHC.Core.FamInstEnv Methods getOccName :: FamInst -> OccName # getName :: FamInst -> Name #
NamedThing ClsInst
Instance details Defined in GHC.Core.InstEnv Methods getOccName :: ClsInst -> OccName # getName :: ClsInst -> Name #
NamedThing PatSyn
Instance details Defined in GHC.Core.PatSyn Methods getOccName :: PatSyn -> OccName # getName :: PatSyn -> Name #
NamedThing TyCon
Instance details Defined in GHC.Core.TyCon Methods getOccName :: TyCon -> OccName # getName :: TyCon -> Name #
NamedThing IfaceClassOp
Instance details Defined in GHC.Iface.Syntax Methods getOccName :: IfaceClassOp -> OccName # getName :: IfaceClassOp -> Name #
NamedThing IfaceConDecl
Instance details Defined in GHC.Iface.Syntax Methods getOccName :: IfaceConDecl -> OccName # getName :: IfaceConDecl -> Name #
NamedThing IfaceDecl
Instance details Defined in GHC.Iface.Syntax Methods getOccName :: IfaceDecl -> OccName # getName :: IfaceDecl -> Name #
NamedThing HoleFitCandidate
Instance details Defined in GHC.Tc.Errors.Hole.FitTypes Methods getOccName :: HoleFitCandidate -> OccName # getName :: HoleFitCandidate -> Name #
NamedThing Name
Instance details Defined in GHC.Types.Name Methods getOccName :: Name -> OccName # getName :: Name -> Name #
NamedThing TyThing
Instance details Defined in GHC.Types.TyThing Methods getOccName :: TyThing -> OccName # getName :: TyThing -> Name #
NamedThing Var
Instance details Defined in GHC.Types.Var Methods getOccName :: Var -> OccName # getName :: Var -> Name #
NamedThing (CoAxiom br)
Instance details Defined in GHC.Core.Coercion.Axiom Methods getOccName :: CoAxiom br -> OccName # getName :: CoAxiom br -> Name #
NamedThing e => NamedThing (Located e)
Instance details Defined in GHC.Types.Name Methods getOccName :: Located e -> OccName # getName :: Located e -> Name #
NamedThing (Located a) => NamedThing (LocatedAn an a)
Instance details Defined in GHC.Parser.Annotation Methods getOccName :: LocatedAn an a -> OccName # getName :: LocatedAn an a -> Name #
NamedThing tv => NamedThing (VarBndr tv flag)
Instance details Defined in GHC.Types.Var Methods getOccName :: VarBndr tv flag -> OccName # getName :: VarBndr tv flag -> Name #

data Name #

A unique, unambiguous name for something, containing information about where that thing originated.

Instances

Instances details

Data Name
Instance details 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 # toConstr :: Name -> Constr # dataTypeOf :: Name -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Name) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name) # gmapT :: (forall b. Data b => b -> b) -> Name -> Name # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r # gmapQr :: 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
Instance details Defined in GHC.Types.Name Methods rnf :: Name -> () #
NamedThing Name
Instance details Defined in GHC.Types.Name Methods getOccName :: Name -> OccName # getName :: Name -> Name #
HasOccName Name
Instance details Defined in GHC.Types.Name Methods occName :: Name -> OccName #
Uniquable Name
Instance details Defined in GHC.Types.Name Methods getUnique :: Name -> Unique #
Binary Name	Assumes that the `Name` is a non-binding one. See `putIfaceTopBndr` and `getIfaceTopBndr` for serializing binding `Name`s. See `UserData` for the rationale for this distinction.
Instance details Defined in GHC.Types.Name Methods put_ :: BinHandle -> Name -> IO () # put :: BinHandle -> Name -> IO (Bin Name) # get :: BinHandle -> IO Name #
Outputable Name
Instance details Defined in GHC.Types.Name Methods ppr :: Name -> SDoc #
OutputableBndr Name
Instance details Defined in GHC.Types.Name Methods pprBndr :: BindingSite -> Name -> SDoc # pprPrefixOcc :: Name -> SDoc # pprInfixOcc :: Name -> SDoc # bndrIsJoin_maybe :: Name -> Maybe Int #
Eq Name	The same comments as for `Name`'s `Ord` instance apply.
Instance details Defined in GHC.Types.Name Methods (==) :: Name -> Name -> Bool # (/=) :: Name -> Name -> Bool #
Ord Name	Caution: This instance is implemented via `nonDetCmpUnique`, which means that the ordering is not stable across deserialization or rebuilds. See `nonDetCmpUnique` for further information, and trac #15240 for a bug caused by improper use of this instance.
Instance details Defined in GHC.Types.Name Methods compare :: Name -> Name -> Ordering # (<) :: Name -> Name -> Bool # (<=) :: Name -> Name -> Bool # (>) :: Name -> Name -> Bool # (>=) :: Name -> Name -> Bool # max :: Name -> Name -> Name # min :: Name -> Name -> Name #
type Anno Name
Instance details Defined in GHC.Hs.Extension type Anno Name = SrcSpanAnnN
type Anno (LocatedN Name)
Instance details Defined in GHC.Hs.Binds type Anno (LocatedN Name) = SrcSpan
type Anno [LocatedN Name]
Instance details Defined in GHC.Hs.Binds type Anno [LocatedN Name] = SrcSpan

type InvisTVBinder = VarBndr TyVar Specificity #

type TcTyVar = Var #

Type variable that might be a metavariable

type TyCoVar = Id #

Type or Coercion Variable

type TyVar = Var #

Type or kind Variable

data Specificity #

Whether an Invisible argument may appear in source Haskell.

Constructors

InferredSpec	the argument may not appear in source Haskell, it is only inferred.
SpecifiedSpec	the argument may appear in source Haskell, but isn't required.

Instances

Instances details

Data Specificity
Instance details Defined in GHC.Types.Var Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Specificity -> c Specificity # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Specificity # toConstr :: Specificity -> Constr # dataTypeOf :: Specificity -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Specificity) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Specificity) # gmapT :: (forall b. Data b => b -> b) -> Specificity -> Specificity # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Specificity -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Specificity -> r # gmapQ :: (forall d. Data d => d -> u) -> Specificity -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Specificity -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Specificity -> m Specificity # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Specificity -> m Specificity # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Specificity -> m Specificity #
Binary Specificity
Instance details Defined in GHC.Types.Var Methods put_ :: BinHandle -> Specificity -> IO () # put :: BinHandle -> Specificity -> IO (Bin Specificity) # get :: BinHandle -> IO Specificity #
Eq Specificity
Instance details Defined in GHC.Types.Var Methods (==) :: Specificity -> Specificity -> Bool # (/=) :: Specificity -> Specificity -> Bool #
Ord Specificity
Instance details Defined in GHC.Types.Var Methods compare :: Specificity -> Specificity -> Ordering # (<) :: Specificity -> Specificity -> Bool # (<=) :: Specificity -> Specificity -> Bool # (>) :: Specificity -> Specificity -> Bool # (>=) :: Specificity -> Specificity -> Bool # max :: Specificity -> Specificity -> Specificity # min :: Specificity -> Specificity -> Specificity #
OutputableBndrFlag Specificity p
Instance details Defined in GHC.Hs.Type Methods pprTyVarBndr :: HsTyVarBndr Specificity (GhcPass p) -> SDoc
Outputable tv => Outputable (VarBndr tv Specificity)
Instance details Defined in GHC.Types.Var Methods ppr :: VarBndr tv Specificity -> SDoc #

data VarBndr var argf #

Constructors

Bndr var argf

Instances

Instances details

(Data var, Data argf) => Data (VarBndr var argf)
Instance details Defined in GHC.Types.Var Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> VarBndr var argf -> c (VarBndr var argf) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (VarBndr var argf) # toConstr :: VarBndr var argf -> Constr # dataTypeOf :: VarBndr var argf -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (VarBndr var argf)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (VarBndr var argf)) # gmapT :: (forall b. Data b => b -> b) -> VarBndr var argf -> VarBndr var argf # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> VarBndr var argf -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> VarBndr var argf -> r # gmapQ :: (forall d. Data d => d -> u) -> VarBndr var argf -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> VarBndr var argf -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> VarBndr var argf -> m (VarBndr var argf) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> VarBndr var argf -> m (VarBndr var argf) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> VarBndr var argf -> m (VarBndr var argf) #
NamedThing tv => NamedThing (VarBndr tv flag)
Instance details Defined in GHC.Types.Var Methods getOccName :: VarBndr tv flag -> OccName # getName :: VarBndr tv flag -> Name #
(Binary tv, Binary vis) => Binary (VarBndr tv vis)
Instance details Defined in GHC.Types.Var Methods put_ :: BinHandle -> VarBndr tv vis -> IO () # put :: BinHandle -> VarBndr tv vis -> IO (Bin (VarBndr tv vis)) # get :: BinHandle -> IO (VarBndr tv vis) #
OutputableBndr tv => Outputable (VarBndr tv TyConBndrVis)
Instance details Defined in GHC.Core.TyCon Methods ppr :: VarBndr tv TyConBndrVis -> SDoc #
Outputable tv => Outputable (VarBndr tv ForAllTyFlag)
Instance details Defined in GHC.Types.Var Methods ppr :: VarBndr tv ForAllTyFlag -> SDoc #
Outputable tv => Outputable (VarBndr tv Specificity)
Instance details Defined in GHC.Types.Var Methods ppr :: VarBndr tv Specificity -> SDoc #

data Var #

Variable

Essentially a typed Name, that may also contain some additional information about the Var and its use sites.

Instances

Instances details

Data Var
Instance details 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 # toConstr :: Var -> Constr # 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 #
NamedThing Var
Instance details Defined in GHC.Types.Var Methods getOccName :: Var -> OccName # getName :: Var -> Name #
HasOccName Var
Instance details Defined in GHC.Types.Var Methods occName :: Var -> OccName #
Uniquable Var
Instance details Defined in GHC.Types.Var Methods getUnique :: Var -> Unique #
Outputable Var
Instance details Defined in GHC.Types.Var Methods ppr :: Var -> SDoc #
Eq Var
Instance details Defined in GHC.Types.Var Methods (==) :: Var -> Var -> Bool # (/=) :: Var -> Var -> Bool #
Ord Var
Instance details Defined in GHC.Types.Var Methods compare :: Var -> Var -> Ordering # (<) :: Var -> Var -> Bool # (<=) :: Var -> Var -> Bool # (>) :: Var -> Var -> Bool # (>=) :: Var -> Var -> Bool # max :: Var -> Var -> Var # min :: Var -> Var -> Var #
Eq (DeBruijn Var)
Instance details Defined in GHC.Core.Map.Type Methods (==) :: DeBruijn Var -> DeBruijn Var -> Bool # (/=) :: DeBruijn Var -> DeBruijn Var -> Bool #
OutputableBndr (Id, TagSig)
Instance details Defined in GHC.Stg.InferTags.TagSig Methods pprBndr :: BindingSite -> (Id, TagSig) -> SDoc # pprPrefixOcc :: (Id, TagSig) -> SDoc # pprInfixOcc :: (Id, TagSig) -> SDoc # bndrIsJoin_maybe :: (Id, TagSig) -> Maybe Int #
type Anno Id
Instance details Defined in GHC.Hs.Extension type Anno Id = SrcSpanAnnN
type Anno (LocatedN Id)
Instance details Defined in GHC.Hs.Binds type Anno (LocatedN Id) = SrcSpan
type Anno [LocatedN Id]
Instance details Defined in GHC.Hs.Binds type Anno [LocatedN Id] = SrcSpan

data FunTyFlag #

The non-dependent version of ForAllTyFlag. See Note [FunTyFlag] Appears here partly so that it's together with its friends ForAllTyFlag and ForallVisFlag, but also because it is used in IfaceType, rather early in the compilation chain

Constructors

FTF_T_T
FTF_T_C
FTF_C_T
FTF_C_C

Instances

Instances details

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

data ForAllTyFlag #

ForAllTyFlag

Is something required to appear in source Haskell (Required), permitted by request (Specified) (visible type application), or prohibited entirely from appearing in source Haskell (Inferred)? See Note [VarBndrs, ForAllTyBinders, TyConBinders, and visibility] in GHC.Core.TyCo.Rep

Constructors

Invisible Specificity
Required

Bundled Patterns

pattern Specified :: ForAllTyFlag
pattern Inferred :: ForAllTyFlag

Instances

Instances details

Data ForAllTyFlag
Instance details Defined in GHC.Types.Var Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForAllTyFlag -> c ForAllTyFlag # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ForAllTyFlag # toConstr :: ForAllTyFlag -> Constr # dataTypeOf :: ForAllTyFlag -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ForAllTyFlag) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ForAllTyFlag) # gmapT :: (forall b. Data b => b -> b) -> ForAllTyFlag -> ForAllTyFlag # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForAllTyFlag -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForAllTyFlag -> r # gmapQ :: (forall d. Data d => d -> u) -> ForAllTyFlag -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ForAllTyFlag -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForAllTyFlag -> m ForAllTyFlag # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForAllTyFlag -> m ForAllTyFlag # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForAllTyFlag -> m ForAllTyFlag #
Binary ForAllTyFlag
Instance details Defined in GHC.Types.Var Methods put_ :: BinHandle -> ForAllTyFlag -> IO () # put :: BinHandle -> ForAllTyFlag -> IO (Bin ForAllTyFlag) # get :: BinHandle -> IO ForAllTyFlag #
Outputable ForAllTyFlag
Instance details Defined in GHC.Types.Var Methods ppr :: ForAllTyFlag -> SDoc #
Eq ForAllTyFlag
Instance details Defined in GHC.Types.Var Methods (==) :: ForAllTyFlag -> ForAllTyFlag -> Bool # (/=) :: ForAllTyFlag -> ForAllTyFlag -> Bool #
Ord ForAllTyFlag
Instance details Defined in GHC.Types.Var Methods compare :: ForAllTyFlag -> ForAllTyFlag -> Ordering # (<) :: ForAllTyFlag -> ForAllTyFlag -> Bool # (<=) :: ForAllTyFlag -> ForAllTyFlag -> Bool # (>) :: ForAllTyFlag -> ForAllTyFlag -> Bool # (>=) :: ForAllTyFlag -> ForAllTyFlag -> Bool # max :: ForAllTyFlag -> ForAllTyFlag -> ForAllTyFlag # min :: ForAllTyFlag -> ForAllTyFlag -> ForAllTyFlag #
Outputable tv => Outputable (VarBndr tv ForAllTyFlag)
Instance details Defined in GHC.Types.Var Methods ppr :: VarBndr tv ForAllTyFlag -> SDoc #

type CoreExpr = Expr CoreBndr #

Expressions where binders are CoreBndrs

type CoreBndr = Var #

The common case for the type of binders and variables when we are manipulating the Core language within GHC

data Expr b #

This is the data type that represents GHCs core intermediate language. Currently GHC uses System FC https://www.microsoft.com/en-us/research/publication/system-f-with-type-equality-coercions/ for this purpose, which is closely related to the simpler and better known System F http://en.wikipedia.org/wiki/System_F.

We get from Haskell source to this Core language in a number of stages:

The source code is parsed into an abstract syntax tree, which is represented by the data type HsExpr with the names being RdrNames
This syntax tree is renamed, which attaches a Unique to every RdrName (yielding a Name) to disambiguate identifiers which are lexically identical. For example, this program:

     f x = let f x = x + 1
           in f (x - 2)

Would be renamed by having Uniques attached so it looked something like this:

     f_1 x_2 = let f_3 x_4 = x_4 + 1
               in f_3 (x_2 - 2)

But see Note [Shadowing] below.

The resulting syntax tree undergoes type checking (which also deals with instantiating type class arguments) to yield a HsExpr type that has Id as it's names.
Finally the syntax tree is desugared from the expressive HsExpr type into this Expr type, which has far fewer constructors and hence is easier to perform optimization, analysis and code generation on.

The type parameter b is for the type of binders in the expression tree.

The language consists of the following elements:

Variables See Note [Variable occurrences in Core]
Primitive literals
Applications: note that the argument may be a Type. See Note [Representation polymorphism invariants]
Lambda abstraction See Note [Representation polymorphism invariants]
Recursive and non recursive lets. Operationally this corresponds to allocating a thunk for the things bound and then executing the sub-expression.

See Note [Core letrec invariant] See Note [Core let-can-float invariant] See Note [Representation polymorphism invariants] See Note [Core type and coercion invariant]

Case expression. Operationally this corresponds to evaluating the scrutinee (expression examined) to weak head normal form and then examining at most one level of resulting constructor (i.e. you cannot do nested pattern matching directly with this).

The binder gets bound to the value of the scrutinee, and the Type must be that of all the case alternatives

IMPORTANT: see Note [Case expression invariants]

Cast an expression to a particular type. This is used to implement newtypes (a newtype constructor or destructor just becomes a Cast in Core) and GADTs.
Ticks. These are used to represent all the source annotation we support: profiling SCCs, HPC ticks, and GHCi breakpoints.
A type: this should only show up at the top level of an Arg
A coercion

Constructors

Var Id
Lit Literal
App (Expr b) (Arg b) infixl 4
Lam b (Expr b)
Let (Bind b) (Expr b)
Case (Expr b) b Type [Alt b]
Cast (Expr b) CoercionR
Tick CoreTickish (Expr b)
Type Type
Coercion Coercion

Instances

Instances details

Data b => Data (Expr b)

Instance details

Defined in GHC.Core

Methods

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

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

toConstr :: Expr b -> Constr #

dataTypeOf :: Expr b -> DataType #

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

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

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

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

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

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

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

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

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

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

type TyConRepName = Name #

type MCoercionN = MCoercion #

type CoercionN = Coercion #

type ThetaType = [PredType] #

A collection of PredTypes

type RuntimeRepType = Type #

Type synonym used for types of kind RuntimeRep.

type PredType = Type #

A type of the form p of constraint kind represents a value whose type is the Haskell predicate p, where a predicate is what occurs before the => in a Haskell type.

We use PredType as documentation to mark those types that we guarantee to have this kind.

It can be expanded into its representation, but:

The type checker must treat it as opaque
The rest of the compiler treats it as transparent

Consider these examples:

f :: (Eq a) => a -> Int
g :: (?x :: Int -> Int) => a -> Int
h :: (r\l) => {r} => {l::Int | r}

Here the Eq a and ?x :: Int -> Int and rl are all called "predicates"

type Mult = Type #

Mult is a type alias for Type.

Mult must contain Type because multiplicity variables are mere type variables (of kind Multiplicity) in Haskell. So the simplest implementation is to make Mult be Type.

Multiplicities can be formed with: - One: GHC.Types.One (= oneDataCon) - Many: GHC.Types.Many (= manyDataCon) - Multiplication: GHC.Types.MultMul (= multMulTyCon)

So that Mult feels a bit more structured, we provide pattern synonyms and smart constructors for these.

data Scaled a #

A shorthand for data with an attached Mult element (the multiplicity).

Instances

Instances details

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

data MCoercion #

A semantically more meaningful type to represent what may or may not be a useful Coercion.

Constructors

MRefl
MCo Coercion

Instances

Instances details

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

data UnivCoProvenance #

For simplicity, we have just one UnivCo that represents a coercion from some type to some other type, with (in general) no restrictions on the type. The UnivCoProvenance specifies more exactly what the coercion really is and why a program should (or shouldn't!) trust the coercion. It is reasonable to consider each constructor of UnivCoProvenance as a totally independent coercion form; their only commonality is that they don't tell you what types they coercion between. (That info is in the UnivCo constructor of Coercion.

Instances

Instances details

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

data CoSel #

Constructors

SelTyCon Int Role
SelFun FunSel
SelForAll

Instances

Instances details

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

newtype NonDetUniqFM key ele #

A wrapper around UniqFM with the sole purpose of informing call sites that the provided Foldable and Traversable instances are nondeterministic. If you use this please provide a justification why it doesn't introduce nondeterminism. See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM to learn about determinism.

Constructors

NonDetUniqFM
Fields getNonDet :: UniqFM key ele

Instances

Instances details

Foldable (NonDetUniqFM key)	Inherently nondeterministic. If you use this please provide a justification why it doesn't introduce nondeterminism. See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM to learn about determinism.
Instance details Defined in GHC.Types.Unique.FM Methods fold :: Monoid m => NonDetUniqFM key m -> m # foldMap :: Monoid m => (a -> m) -> NonDetUniqFM key a -> m # foldMap' :: Monoid m => (a -> m) -> NonDetUniqFM key a -> m # foldr :: (a -> b -> b) -> b -> NonDetUniqFM key a -> b # foldr' :: (a -> b -> b) -> b -> NonDetUniqFM key a -> b # foldl :: (b -> a -> b) -> b -> NonDetUniqFM key a -> b # foldl' :: (b -> a -> b) -> b -> NonDetUniqFM key a -> b # foldr1 :: (a -> a -> a) -> NonDetUniqFM key a -> a # foldl1 :: (a -> a -> a) -> NonDetUniqFM key a -> a # toList :: NonDetUniqFM key a -> [a] # null :: NonDetUniqFM key a -> Bool # length :: NonDetUniqFM key a -> Int # elem :: Eq a => a -> NonDetUniqFM key a -> Bool # maximum :: Ord a => NonDetUniqFM key a -> a # minimum :: Ord a => NonDetUniqFM key a -> a # sum :: Num a => NonDetUniqFM key a -> a # product :: Num a => NonDetUniqFM key a -> a #
Traversable (NonDetUniqFM key)	Inherently nondeterministic. If you use this please provide a justification why it doesn't introduce nondeterminism. See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM to learn about determinism.
Instance details Defined in GHC.Types.Unique.FM Methods traverse :: Applicative f => (a -> f b) -> NonDetUniqFM key a -> f (NonDetUniqFM key b) # sequenceA :: Applicative f => NonDetUniqFM key (f a) -> f (NonDetUniqFM key a) # mapM :: Monad m => (a -> m b) -> NonDetUniqFM key a -> m (NonDetUniqFM key b) # sequence :: Monad m => NonDetUniqFM key (m a) -> m (NonDetUniqFM key a) #
Functor (NonDetUniqFM key)
Instance details Defined in GHC.Types.Unique.FM Methods fmap :: (a -> b) -> NonDetUniqFM key a -> NonDetUniqFM key b # (<$) :: a -> NonDetUniqFM key b -> NonDetUniqFM key a #

data UniqFM key ele #

A finite map from uniques of one type to elements in another type.

The key is just here to keep us honest. It's always safe to use a single type as key. If two types don't overlap in their uniques it's also safe to index the same map at multiple key types. But this is very much discouraged.

Instances

Instances details

Functor (UniqFM key)
Instance details Defined in GHC.Types.Unique.FM Methods fmap :: (a -> b) -> UniqFM key a -> UniqFM key b # (<$) :: a -> UniqFM key b -> UniqFM key a #
(Data key, Data ele) => Data (UniqFM key ele)
Instance details Defined in GHC.Types.Unique.FM Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UniqFM key ele -> c (UniqFM key ele) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UniqFM key ele) # toConstr :: UniqFM key ele -> Constr # dataTypeOf :: UniqFM key ele -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UniqFM key ele)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UniqFM key ele)) # gmapT :: (forall b. Data b => b -> b) -> UniqFM key ele -> UniqFM key ele # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UniqFM key ele -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UniqFM key ele -> r # gmapQ :: (forall d. Data d => d -> u) -> UniqFM key ele -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> UniqFM key ele -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> UniqFM key ele -> m (UniqFM key ele) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UniqFM key ele -> m (UniqFM key ele) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UniqFM key ele -> m (UniqFM key ele) #
Monoid (UniqFM key a)
Instance details Defined in GHC.Types.Unique.FM Methods mempty :: UniqFM key a # mappend :: UniqFM key a -> UniqFM key a -> UniqFM key a # mconcat :: [UniqFM key a] -> UniqFM key a #
Semigroup (UniqFM key a)
Instance details Defined in GHC.Types.Unique.FM Methods (<>) :: UniqFM key a -> UniqFM key a -> UniqFM key a # sconcat :: NonEmpty (UniqFM key a) -> UniqFM key a # stimes :: Integral b => b -> UniqFM key a -> UniqFM key a #
Outputable a => Outputable (UniqFM key a)
Instance details Defined in GHC.Types.Unique.FM Methods ppr :: UniqFM key a -> SDoc #
Eq ele => Eq (UniqFM key ele)
Instance details Defined in GHC.Types.Unique.FM Methods (==) :: UniqFM key ele -> UniqFM key ele -> Bool # (/=) :: UniqFM key ele -> UniqFM key ele -> Bool #

class Monad m => MonadUnique (m :: Type -> Type) where #

A monad for generating unique identifiers

Minimal complete definition

getUniqueSupplyM

Methods

getUniqueSupplyM :: m UniqSupply #

Get a new UniqueSupply

getUniqueM :: m Unique #

Get a new unique identifier

getUniquesM :: m [Unique] #

Get an infinite list of new unique identifiers

Instances

Instances details

MonadUnique CoreM
Instance details Defined in GHC.Core.Opt.Monad Methods getUniqueSupplyM :: CoreM UniqSupply # getUniqueM :: CoreM Unique # getUniquesM :: CoreM [Unique] #
MonadUnique StgM
Instance details Defined in GHC.Stg.Pipeline Methods getUniqueSupplyM :: StgM UniqSupply # getUniqueM :: StgM Unique # getUniquesM :: StgM [Unique] #
MonadUnique TcS
Instance details Defined in GHC.Tc.Solver.Monad Methods getUniqueSupplyM :: TcS UniqSupply # getUniqueM :: TcS Unique # getUniquesM :: TcS [Unique] #
MonadUnique UniqSM
Instance details Defined in GHC.Types.Unique.Supply Methods getUniqueSupplyM :: UniqSM UniqSupply # getUniqueM :: UniqSM Unique # getUniquesM :: UniqSM [Unique] #

data UniqSM result #

A monad which just gives the ability to obtain Uniques

Instances

Instances details

MonadFail UniqSM
Instance details Defined in GHC.Types.Unique.Supply Methods fail :: String -> UniqSM a #
MonadFix UniqSM
Instance details Defined in GHC.Types.Unique.Supply Methods mfix :: (a -> UniqSM a) -> UniqSM a #
Applicative UniqSM
Instance details Defined in GHC.Types.Unique.Supply Methods pure :: a -> UniqSM a # (<>) :: UniqSM (a -> b) -> UniqSM a -> UniqSM b # liftA2 :: (a -> b -> c) -> UniqSM a -> UniqSM b -> UniqSM c # (>) :: UniqSM a -> UniqSM b -> UniqSM b # (<*) :: UniqSM a -> UniqSM b -> UniqSM a #
Functor UniqSM
Instance details Defined in GHC.Types.Unique.Supply Methods fmap :: (a -> b) -> UniqSM a -> UniqSM b # (<$) :: a -> UniqSM b -> UniqSM a #
Monad UniqSM
Instance details Defined in GHC.Types.Unique.Supply Methods (>>=) :: UniqSM a -> (a -> UniqSM b) -> UniqSM b # (>>) :: UniqSM a -> UniqSM b -> UniqSM b # return :: a -> UniqSM a #
MonadUnique UniqSM
Instance details Defined in GHC.Types.Unique.Supply Methods getUniqueSupplyM :: UniqSM UniqSupply # getUniqueM :: UniqSM Unique # getUniquesM :: UniqSM [Unique] #

data UniqSupply #

Unique Supply

A value of type UniqSupply is unique, and it can supply one distinct Unique. Also, from the supply, one can also manufacture an arbitrary number of further UniqueSupply values, which will be distinct from the first and from all others.

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 !Int Layout column (indentation level, begins at 1)
NoLayoutInfo	Empty or compiler-generated blocks do not have layout information associated with them.

Instances

Instances details

Typeable p => Data (LayoutInfo (GhcPass p))

Instance details

Defined in GHC.Hs.Extension

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> 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

Instances details

(KnownSymbol tok, KnownSymbol utok) => Data (HsUniToken tok utok)
Instance details 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)
Instance details Defined in GHC.Hs.Extension type Anno (HsUniToken tok utok) = TokenLocation

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

Instances details

KnownSymbol tok => Data (HsToken tok)
Instance details 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)
Instance details Defined in GHC.Hs.Extension type Anno (HsToken tok) = TokenLocation

type LHsUniToken (tok :: Symbol) (utok :: Symbol) p = XRec p (HsUniToken tok utok) #

type LHsToken (tok :: Symbol) p = XRec p (HsToken tok) #

data ProfAuto #

What kind of {-# SCC #-} to add automatically

Constructors

NoProfAuto	no SCC annotations added
ProfAutoAll	top-level and nested functions are annotated
ProfAutoTop	top-level functions annotated only
ProfAutoExports	exported functions annotated only
ProfAutoCalls	annotate call-sites

Instances

Instances details

Enum ProfAuto
Instance details Defined in GHC.Types.ProfAuto Methods succ :: ProfAuto -> ProfAuto # pred :: ProfAuto -> ProfAuto # toEnum :: Int -> ProfAuto # fromEnum :: ProfAuto -> Int # enumFrom :: ProfAuto -> [ProfAuto] # enumFromThen :: ProfAuto -> ProfAuto -> [ProfAuto] # enumFromTo :: ProfAuto -> ProfAuto -> [ProfAuto] # enumFromThenTo :: ProfAuto -> ProfAuto -> ProfAuto -> [ProfAuto] #
Eq ProfAuto
Instance details Defined in GHC.Types.ProfAuto Methods (==) :: ProfAuto -> ProfAuto -> Bool # (/=) :: ProfAuto -> ProfAuto -> Bool #

type PsLocated = GenLocated PsSpan #

data PsSpan #

Constructors

PsSpan
Fields psRealSpan :: !RealSrcSpan psBufSpan :: !BufSpan

Instances

Instances details

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

data PsLoc #

A location as produced by the parser. Consists of two components:

The location in the file, adjusted for #line and {-# LINE ... #-} pragmas (RealSrcLoc)
The location in the string buffer (BufPos) with monotonicity guarantees (see #17632)

Constructors

PsLoc
Fields psRealLoc :: !RealSrcLoc psBufPos :: !BufPos

Instances

Instances details

Show PsLoc
Instance details Defined in GHC.Types.SrcLoc Methods showsPrec :: Int -> PsLoc -> ShowS # show :: PsLoc -> String # showList :: [PsLoc] -> ShowS #
Eq PsLoc
Instance details Defined in GHC.Types.SrcLoc Methods (==) :: PsLoc -> PsLoc -> Bool # (/=) :: PsLoc -> PsLoc -> Bool #
Ord PsLoc
Instance details Defined in GHC.Types.SrcLoc Methods compare :: PsLoc -> PsLoc -> Ordering # (<) :: PsLoc -> PsLoc -> Bool # (<=) :: PsLoc -> PsLoc -> Bool # (>) :: PsLoc -> PsLoc -> Bool # (>=) :: PsLoc -> PsLoc -> Bool # max :: PsLoc -> PsLoc -> PsLoc # min :: PsLoc -> PsLoc -> PsLoc #

type RealLocated = GenLocated RealSrcSpan #

type Located = GenLocated SrcSpan #

data GenLocated l e #

We attach SrcSpans to lots of things, so let's have a datatype for it.

Constructors

L l e

Instances

Instances details

Foldable (GenLocated l)
Instance details Defined in GHC.Types.SrcLoc Methods fold :: Monoid m => GenLocated l m -> m # foldMap :: Monoid m => (a -> m) -> GenLocated l a -> m # foldMap' :: Monoid m => (a -> m) -> GenLocated l a -> m # foldr :: (a -> b -> b) -> b -> GenLocated l a -> b # foldr' :: (a -> b -> b) -> b -> GenLocated l a -> b # foldl :: (b -> a -> b) -> b -> GenLocated l a -> b # foldl' :: (b -> a -> b) -> b -> GenLocated l a -> b # foldr1 :: (a -> a -> a) -> GenLocated l a -> a # foldl1 :: (a -> a -> a) -> GenLocated l a -> a # toList :: GenLocated l a -> [a] # null :: GenLocated l a -> Bool # length :: GenLocated l a -> Int # elem :: Eq a => a -> GenLocated l a -> Bool # maximum :: Ord a => GenLocated l a -> a # minimum :: Ord a => GenLocated l a -> a # sum :: Num a => GenLocated l a -> a # product :: Num a => GenLocated l a -> a #
Traversable (GenLocated l)
Instance details Defined in GHC.Types.SrcLoc Methods traverse :: Applicative f => (a -> f b) -> GenLocated l a -> f (GenLocated l b) # sequenceA :: Applicative f => GenLocated l (f a) -> f (GenLocated l a) # mapM :: Monad m => (a -> m b) -> GenLocated l a -> m (GenLocated l b) # sequence :: Monad m => GenLocated l (m a) -> m (GenLocated l a) #
Functor (GenLocated l)
Instance details Defined in GHC.Types.SrcLoc Methods fmap :: (a -> b) -> GenLocated l a -> GenLocated l b # (<$) :: a -> GenLocated l b -> GenLocated l a #
NamedThing e => NamedThing (Located e)
Instance details Defined in GHC.Types.Name Methods getOccName :: Located e -> OccName # getName :: Located e -> Name #
Outputable e => Outputable (Located e)
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: Located e -> SDoc #
(Data l, Data e) => Data (GenLocated l e)
Instance details Defined in GHC.Types.SrcLoc Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GenLocated l e -> c (GenLocated l e) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GenLocated l e) # toConstr :: GenLocated l e -> Constr # dataTypeOf :: GenLocated l e -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GenLocated l e)) # dataCast2 :: Typeable t => (forall d e0. (Data d, Data e0) => c (t d e0)) -> Maybe (c (GenLocated l e)) # gmapT :: (forall b. Data b => b -> b) -> GenLocated l e -> GenLocated l e # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GenLocated l e -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GenLocated l e -> r # gmapQ :: (forall d. Data d => d -> u) -> GenLocated l e -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> GenLocated l e -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> GenLocated l e -> m (GenLocated l e) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GenLocated l e -> m (GenLocated l e) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GenLocated l e -> m (GenLocated l e) #
(Show l, Show e) => Show (GenLocated l e)
Instance details Defined in GHC.Types.SrcLoc Methods showsPrec :: Int -> GenLocated l e -> ShowS # show :: GenLocated l e -> String # showList :: [GenLocated l e] -> ShowS #
(NFData l, NFData e) => NFData (GenLocated l e)
Instance details Defined in GHC.Types.SrcLoc Methods rnf :: GenLocated l e -> () #
NamedThing (Located a) => NamedThing (LocatedAn an a)
Instance details Defined in GHC.Parser.Annotation Methods getOccName :: LocatedAn an a -> OccName # getName :: LocatedAn an a -> Name #
Outputable (GenLocated Anchor EpaComment)
Instance details Defined in GHC.Parser.Annotation Methods ppr :: GenLocated Anchor EpaComment -> SDoc #
(Outputable a, Outputable e) => Outputable (GenLocated (SrcSpanAnn' a) e)
Instance details Defined in GHC.Parser.Annotation Methods ppr :: GenLocated (SrcSpanAnn' a) e -> SDoc #
Outputable a => Outputable (GenLocated TokenLocation a)
Instance details Defined in GHC.Parser.Annotation Methods ppr :: GenLocated TokenLocation a -> SDoc #
Outputable e => Outputable (GenLocated RealSrcSpan e)
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: GenLocated RealSrcSpan e -> SDoc #
(Outputable a, OutputableBndr e) => OutputableBndr (GenLocated (SrcSpanAnn' a) e)
Instance details Defined in GHC.Parser.Annotation Methods pprBndr :: BindingSite -> GenLocated (SrcSpanAnn' a) e -> SDoc # pprPrefixOcc :: GenLocated (SrcSpanAnn' a) e -> SDoc # pprInfixOcc :: GenLocated (SrcSpanAnn' a) e -> SDoc # bndrIsJoin_maybe :: GenLocated (SrcSpanAnn' a) e -> Maybe Int #
(Eq l, Eq e) => Eq (GenLocated l e)
Instance details Defined in GHC.Types.SrcLoc Methods (==) :: GenLocated l e -> GenLocated l e -> Bool # (/=) :: GenLocated l e -> GenLocated l e -> Bool #
(Ord l, Ord e) => Ord (GenLocated l e)
Instance details Defined in GHC.Types.SrcLoc Methods compare :: GenLocated l e -> GenLocated l e -> Ordering # (<) :: GenLocated l e -> GenLocated l e -> Bool # (<=) :: GenLocated l e -> GenLocated l e -> Bool # (>) :: GenLocated l e -> GenLocated l e -> Bool # (>=) :: GenLocated l e -> GenLocated l e -> Bool # max :: GenLocated l e -> GenLocated l e -> GenLocated l e # min :: GenLocated l e -> GenLocated l e -> GenLocated l e #
type Anno (LocatedA (IE (GhcPass p)))
Instance details Defined in GHC.Hs.ImpExp type Anno (LocatedA (IE (GhcPass p))) = SrcSpanAnnA
type Anno (LocatedN Name)
Instance details Defined in GHC.Hs.Binds type Anno (LocatedN Name) = SrcSpan
type Anno (LocatedN RdrName)
Instance details Defined in GHC.Hs.Binds type Anno (LocatedN RdrName) = SrcSpan
type Anno (LocatedN Id)
Instance details Defined in GHC.Hs.Binds type Anno (LocatedN Id) = SrcSpan
type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))] = SrcSpanAnnL
type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))] = SrcSpanAnnL
type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))]
Instance details Defined in GHC.Parser.PostProcess type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))]
Instance details Defined in GHC.Parser.Types type Anno [LocatedA (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL
type Anno [LocatedA (IE (GhcPass p))]
Instance details Defined in GHC.Hs.ImpExp type Anno [LocatedA (IE (GhcPass p))] = SrcSpanAnnL
type Anno [LocatedA (ConDeclField (GhcPass _1))]
Instance details Defined in GHC.Hs.Decls type Anno [LocatedA (ConDeclField (GhcPass _1))] = SrcSpanAnnL
type Anno [LocatedA (HsType (GhcPass p))]
Instance details Defined in GHC.Hs.Type type Anno [LocatedA (HsType (GhcPass p))] = SrcSpanAnnC
type Anno [LocatedN Name]
Instance details Defined in GHC.Hs.Binds type Anno [LocatedN Name] = SrcSpan
type Anno [LocatedN RdrName]
Instance details Defined in GHC.Hs.Binds type Anno [LocatedN RdrName] = SrcSpan
type Anno [LocatedN Id]
Instance details Defined in GHC.Hs.Binds type Anno [LocatedN Id] = SrcSpan
type Anno (FamEqn p (LocatedA (HsType p)))
Instance details Defined in GHC.Hs.Decls type Anno (FamEqn p (LocatedA (HsType p))) = SrcSpanAnnA
type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p))))
Instance details Defined in GHC.Hs.Expr type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcAnn NoEpAnns
type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p))))
Instance details Defined in GHC.Hs.Expr type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcAnn NoEpAnns
type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs)))
Instance details Defined in GHC.Parser.PostProcess type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs))) = SrcAnn NoEpAnns
type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))
Instance details Defined in GHC.Hs.Expr type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcSpanAnnA
type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))
Instance details Defined in GHC.Hs.Expr type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpanAnnA
type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs)))
Instance details Defined in GHC.Parser.PostProcess type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA
type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))
Instance details Defined in GHC.Hs.Expr type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr)))) = SrcSpanAnnA
type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))
Instance details Defined in GHC.Parser.PostProcess type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA
type Anno (StmtLR GhcRn GhcRn (LocatedA (body GhcRn)))
Instance details Defined in GHC.Hs.Expr type Anno (StmtLR GhcRn GhcRn (LocatedA (body GhcRn))) = SrcSpanAnnA

data UnhelpfulSpanReason #

Constructors

UnhelpfulNoLocationInfo
UnhelpfulWiredIn
UnhelpfulInteractive
UnhelpfulGenerated
UnhelpfulOther !FastString

Instances

Instances details

Show UnhelpfulSpanReason
Instance details Defined in GHC.Types.SrcLoc Methods showsPrec :: Int -> UnhelpfulSpanReason -> ShowS # show :: UnhelpfulSpanReason -> String # showList :: [UnhelpfulSpanReason] -> ShowS #
Outputable UnhelpfulSpanReason
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: UnhelpfulSpanReason -> SDoc #
Eq UnhelpfulSpanReason
Instance details Defined in GHC.Types.SrcLoc Methods (==) :: UnhelpfulSpanReason -> UnhelpfulSpanReason -> Bool # (/=) :: UnhelpfulSpanReason -> UnhelpfulSpanReason -> Bool #

data SrcSpan #

Source Span

A SrcSpan identifies either a specific portion of a text file or a human-readable description of a location.

Constructors

RealSrcSpan !RealSrcSpan !(Maybe BufSpan)
UnhelpfulSpan !UnhelpfulSpanReason

Instances

Instances details

Data SrcSpan
Instance details 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
Instance details Defined in GHC.Types.SrcLoc Methods showsPrec :: Int -> SrcSpan -> ShowS # show :: SrcSpan -> String # showList :: [SrcSpan] -> ShowS #
NFData SrcSpan
Instance details Defined in GHC.Types.SrcLoc Methods rnf :: SrcSpan -> () #
ToJson SrcSpan
Instance details Defined in GHC.Types.SrcLoc Methods json :: SrcSpan -> JsonDoc #
Outputable SrcSpan
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: SrcSpan -> SDoc #
Eq SrcSpan
Instance details Defined in GHC.Types.SrcLoc Methods (==) :: SrcSpan -> SrcSpan -> Bool # (/=) :: SrcSpan -> SrcSpan -> Bool #
NamedThing e => NamedThing (Located e)
Instance details Defined in GHC.Types.Name Methods getOccName :: Located e -> OccName # getName :: Located e -> Name #
Outputable e => Outputable (Located e)
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: Located e -> SDoc #

data RealSrcSpan #

A RealSrcSpan delimits a portion of a text file. It could be represented by a pair of (line,column) coordinates, but in fact we optimise slightly by using more compact representations for single-line and zero-length spans, both of which are quite common.

The end position is defined to be the column after the end of the span. That is, a span of (1,1)-(1,2) is one character long, and a span of (1,1)-(1,1) is zero characters long.

Real Source Span

Instances

Instances details

Data RealSrcSpan
Instance details Defined in GHC.Types.SrcLoc Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RealSrcSpan -> c RealSrcSpan # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RealSrcSpan # toConstr :: RealSrcSpan -> Constr # dataTypeOf :: RealSrcSpan -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RealSrcSpan) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RealSrcSpan) # gmapT :: (forall b. Data b => b -> b) -> RealSrcSpan -> RealSrcSpan # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RealSrcSpan -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RealSrcSpan -> r # gmapQ :: (forall d. Data d => d -> u) -> RealSrcSpan -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RealSrcSpan -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RealSrcSpan -> m RealSrcSpan # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RealSrcSpan -> m RealSrcSpan # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RealSrcSpan -> m RealSrcSpan #
Show RealSrcSpan
Instance details Defined in GHC.Types.SrcLoc Methods showsPrec :: Int -> RealSrcSpan -> ShowS # show :: RealSrcSpan -> String # showList :: [RealSrcSpan] -> ShowS #
ToJson RealSrcSpan
Instance details Defined in GHC.Types.SrcLoc Methods json :: RealSrcSpan -> JsonDoc #
Outputable RealSrcSpan
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: RealSrcSpan -> SDoc #
Eq RealSrcSpan
Instance details Defined in GHC.Types.SrcLoc Methods (==) :: RealSrcSpan -> RealSrcSpan -> Bool # (/=) :: RealSrcSpan -> RealSrcSpan -> Bool #
Ord RealSrcSpan
Instance details Defined in GHC.Types.SrcLoc Methods compare :: RealSrcSpan -> RealSrcSpan -> Ordering # (<) :: RealSrcSpan -> RealSrcSpan -> Bool # (<=) :: RealSrcSpan -> RealSrcSpan -> Bool # (>) :: RealSrcSpan -> RealSrcSpan -> Bool # (>=) :: RealSrcSpan -> RealSrcSpan -> Bool # max :: RealSrcSpan -> RealSrcSpan -> RealSrcSpan # min :: RealSrcSpan -> RealSrcSpan -> RealSrcSpan #
Outputable e => Outputable (GenLocated RealSrcSpan e)
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: GenLocated RealSrcSpan e -> SDoc #

data BufSpan #

StringBuffer Source Span

Constructors

BufSpan
Fields bufSpanStart :: !BufPos bufSpanEnd :: !BufPos

Instances

Instances details

Data BufSpan
Instance details 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
Instance details Defined in GHC.Types.SrcLoc Methods (<>) :: BufSpan -> BufSpan -> BufSpan # sconcat :: NonEmpty BufSpan -> BufSpan # stimes :: Integral b => b -> BufSpan -> BufSpan #
Show BufSpan
Instance details Defined in GHC.Types.SrcLoc Methods showsPrec :: Int -> BufSpan -> ShowS # show :: BufSpan -> String # showList :: [BufSpan] -> ShowS #
Eq BufSpan
Instance details Defined in GHC.Types.SrcLoc Methods (==) :: BufSpan -> BufSpan -> Bool # (/=) :: BufSpan -> BufSpan -> Bool #
Ord BufSpan
Instance details Defined in GHC.Types.SrcLoc Methods compare :: BufSpan -> BufSpan -> Ordering # (<) :: BufSpan -> BufSpan -> Bool # (<=) :: BufSpan -> BufSpan -> Bool # (>) :: BufSpan -> BufSpan -> Bool # (>=) :: BufSpan -> BufSpan -> Bool # max :: BufSpan -> BufSpan -> BufSpan # min :: BufSpan -> BufSpan -> BufSpan #

data RealSrcLoc #

Real Source Location

Represents a single point within a file

Instances

Instances details

Show RealSrcLoc
Instance details Defined in GHC.Types.SrcLoc Methods showsPrec :: Int -> RealSrcLoc -> ShowS # show :: RealSrcLoc -> String # showList :: [RealSrcLoc] -> ShowS #
Outputable RealSrcLoc
Instance details Defined in GHC.Types.SrcLoc Methods ppr :: RealSrcLoc -> SDoc #
Eq RealSrcLoc
Instance details Defined in GHC.Types.SrcLoc Methods (==) :: RealSrcLoc -> RealSrcLoc -> Bool # (/=) :: RealSrcLoc -> RealSrcLoc -> Bool #
Ord RealSrcLoc
Instance details 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 #

newtype BufPos #

0-based offset identifying the raw location in the StringBuffer.

The lexer increments the BufPos every time a character (UTF-8 code point) is read from the input buffer. As UTF-8 is a variable-length encoding and StringBuffer needs a byte offset for indexing, a BufPos cannot be used for indexing.

The parser guarantees that BufPos are monotonic. See #17632. This means that syntactic constructs that appear later in the StringBuffer are guaranteed to have a higher BufPos. Contrast that with RealSrcLoc, which does *not* make the analogous guarantee about higher line/column numbers.

This is due to #line and {-# LINE ... #-} pragmas that can arbitrarily modify RealSrcLoc. Notice how setSrcLoc and resetAlrLastLoc in GHC.Parser.Lexer update PsLoc, modifying RealSrcLoc but preserving BufPos.

Monotonicity makes BufPos useful to determine the order in which syntactic elements appear in the source. Consider this example (haddockA041 in the test suite):

haddockA041.hs {-# LANGUAGE CPP #-} -- | Module header documentation module Comments_and_CPP_include where #include "IncludeMe.hs"

IncludeMe.hs: -- | Comment on T data T = MkT -- ^ Comment on MkT

After the C preprocessor runs, the StringBuffer will contain a program that looks like this (unimportant lines at the beginning removed):

# 1 "haddockA041.hs" {-# LANGUAGE CPP #-} -- | Module header documentation module Comments_and_CPP_include where # 1 "IncludeMe.hs" 1 -- | Comment on T data T = MkT -- ^ Comment on MkT # 7 "haddockA041.hs" 2

The line pragmas inserted by CPP make the error messages more informative. The downside is that we can't use RealSrcLoc to determine the ordering of syntactic elements.

With RealSrcLoc, we have the following location information recorded in the AST: * The module name is located at haddockA041.hs:3:8-31 * The Haddock comment "Comment on T" is located at IncludeMe:1:1-17 * The data declaration is located at IncludeMe.hs:2:1-32

Is the Haddock comment located between the module name and the data declaration? This is impossible to tell because the locations are not comparable; they even refer to different files.

On the other hand, with BufPos, we have the following location information: * The module name is located at 846-870 * The Haddock comment "Comment on T" is located at 898-915 * The data declaration is located at 916-928

Aside: if you're wondering why the numbers are so high, try running ghc -E haddockA041.hs and see the extra fluff that CPP inserts at the start of the file.

For error messages, BufPos is not useful at all. On the other hand, this is exactly what we need to determine the order of syntactic elements: 870 < 898, therefore the Haddock comment appears *after* the module name. 915 < 916, therefore the Haddock comment appears *before* the data declaration.

We use BufPos in in GHC.Parser.PostProcess.Haddock to associate Haddock comments with parts of the AST using location information (#17544).

Constructors

BufPos
Fields bufPos :: Int

Instances

Instances details

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

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.

data UniqSet a #

Instances

Instances details

Data a => Data (UniqSet a)
Instance details Defined in GHC.Types.Unique.Set Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UniqSet a -> c (UniqSet a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UniqSet a) # toConstr :: UniqSet a -> Constr # dataTypeOf :: UniqSet a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UniqSet a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (UniqSet a)) # gmapT :: (forall b. Data b => b -> b) -> UniqSet a -> UniqSet a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UniqSet a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UniqSet a -> r # gmapQ :: (forall d. Data d => d -> u) -> UniqSet a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> UniqSet a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> UniqSet a -> m (UniqSet a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UniqSet a -> m (UniqSet a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UniqSet a -> m (UniqSet a) #
Monoid (UniqSet a)
Instance details Defined in GHC.Types.Unique.Set Methods mempty :: UniqSet a # mappend :: UniqSet a -> UniqSet a -> UniqSet a # mconcat :: [UniqSet a] -> UniqSet a #
Semigroup (UniqSet a)
Instance details Defined in GHC.Types.Unique.Set Methods (<>) :: UniqSet a -> UniqSet a -> UniqSet a # sconcat :: NonEmpty (UniqSet a) -> UniqSet a # stimes :: Integral b => b -> UniqSet a -> UniqSet a #
Outputable a => Outputable (UniqSet a)
Instance details Defined in GHC.Types.Unique.Set Methods ppr :: UniqSet a -> SDoc #
Eq (UniqSet a)
Instance details Defined in GHC.Types.Unique.Set Methods (==) :: UniqSet a -> UniqSet a -> Bool # (/=) :: UniqSet a -> UniqSet a -> Bool #

data StringLiteral #

A String Literal in the source, including its original raw format for use by source to source manipulation tools.

Constructors

StringLiteral
Fields sl_st :: SourceText sl_fs :: FastString sl_tc :: Maybe RealSrcSpan

Instances

Instances details

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

data FractionalLit #

Fractional Literal

Used (instead of Rational) to represent exactly the floating point literal that we encountered in the user's source program. This allows us to pretty-print exactly what the user wrote, which is important e.g. for floating point numbers that can't represented as Doubles (we used to via Double for pretty-printing). See also #2245. Note [FractionalLit representation] in GHC.HsToCore.Match.Literal The actual value then is: sign * fl_signi * (fl_exp_base^fl_exp) where sign = if fl_neg then (-1) else 1

For example FL { fl_neg = True, fl_signi = 5.3, fl_exp = 4, fl_exp_base = Base10 } denotes -5300

Constructors

FL
Fields fl_text :: SourceText How the value was written in the source fl_neg :: Bool fl_signi :: Rational fl_exp :: Integer fl_exp_base :: FractionalExponentBase

Instances

Instances details

Data FractionalLit
Instance details Defined in GHC.Types.SourceText Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FractionalLit -> c FractionalLit # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FractionalLit # toConstr :: FractionalLit -> Constr # dataTypeOf :: FractionalLit -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FractionalLit) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FractionalLit) # gmapT :: (forall b. Data b => b -> b) -> FractionalLit -> FractionalLit # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FractionalLit -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FractionalLit -> r # gmapQ :: (forall d. Data d => d -> u) -> FractionalLit -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FractionalLit -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FractionalLit -> m FractionalLit # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FractionalLit -> m FractionalLit # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FractionalLit -> m FractionalLit #
Show FractionalLit
Instance details Defined in GHC.Types.SourceText Methods showsPrec :: Int -> FractionalLit -> ShowS # show :: FractionalLit -> String # showList :: [FractionalLit] -> ShowS #
Outputable FractionalLit
Instance details Defined in GHC.Types.SourceText Methods ppr :: FractionalLit -> SDoc #
Eq FractionalLit	Be wary of using this instance to compare for equal values when exponents are large. The same value expressed in different syntactic form won't compare as equal when any of the exponents is >= 100.
Instance details Defined in GHC.Types.SourceText Methods (==) :: FractionalLit -> FractionalLit -> Bool # (/=) :: FractionalLit -> FractionalLit -> Bool #
Ord FractionalLit	Be wary of using this instance to compare for equal values when exponents are large. The same value expressed in different syntactic form won't compare as equal when any of the exponents is >= 100.
Instance details Defined in GHC.Types.SourceText Methods compare :: FractionalLit -> FractionalLit -> Ordering # (<) :: FractionalLit -> FractionalLit -> Bool # (<=) :: FractionalLit -> FractionalLit -> Bool # (>) :: FractionalLit -> FractionalLit -> Bool # (>=) :: FractionalLit -> FractionalLit -> Bool # max :: FractionalLit -> FractionalLit -> FractionalLit # min :: FractionalLit -> FractionalLit -> FractionalLit #

data IntegralLit #

Integral Literal

Used (instead of Integer) to represent negative zegative zero which is required for NegativeLiterals extension to correctly parse `-0::Double` as negative zero. See also #13211.

Constructors

IL
Fields il_text :: SourceText il_neg :: Bool il_value :: Integer

Instances

Instances details

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

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

Instances details

Data SourceText
Instance details 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
Instance details Defined in GHC.Types.SourceText Methods showsPrec :: Int -> SourceText -> ShowS # show :: SourceText -> String # showList :: [SourceText] -> ShowS #
Binary SourceText
Instance details Defined in GHC.Types.SourceText Methods put_ :: BinHandle -> SourceText -> IO () # put :: BinHandle -> SourceText -> IO (Bin SourceText) # get :: BinHandle -> IO SourceText #
Outputable SourceText
Instance details Defined in GHC.Types.SourceText Methods ppr :: SourceText -> SDoc #
Eq SourceText
Instance details Defined in GHC.Types.SourceText Methods (==) :: SourceText -> SourceText -> Bool # (/=) :: SourceText -> SourceText -> Bool #
type Anno (SourceText, RuleName)
Instance details Defined in GHC.Hs.Decls type Anno (SourceText, RuleName) = SrcAnn NoEpAnns

data FieldLabel #

Fields in an algebraic record type; see Note [FieldLabel].

Constructors

FieldLabel
Fields flLabel :: FieldLabelString User-visible label of the field flHasDuplicateRecordFields :: DuplicateRecordFields Was `DuplicateRecordFields` on in the defining module for this datatype? flHasFieldSelector :: FieldSelectors Was `FieldSelectors` enabled in the defining module for this datatype? See Note [NoFieldSelectors] in GHC.Rename.Env flSelector :: Name Record selector function

Instances

Instances details

Data FieldLabel
Instance details 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
Instance details Defined in GHC.Types.FieldLabel Methods rnf :: FieldLabel -> () #
HasOccName FieldLabel
Instance details Defined in GHC.Types.FieldLabel Methods occName :: FieldLabel -> OccName #
Binary Name => Binary FieldLabel	We need the `Binary Name` constraint here even though there is an instance defined in GHC.Types.Name, because the we have a SOURCE import, so the instance is not in scope. And the instance cannot be added to Name.hs-boot because GHC.Utils.Binary itself depends on GHC.Types.Name.
Instance details Defined in GHC.Types.FieldLabel Methods put_ :: BinHandle -> FieldLabel -> IO () # put :: BinHandle -> FieldLabel -> IO (Bin FieldLabel) # get :: BinHandle -> IO FieldLabel #
Outputable FieldLabel
Instance details Defined in GHC.Types.FieldLabel Methods ppr :: FieldLabel -> SDoc #
Eq FieldLabel
Instance details Defined in GHC.Types.FieldLabel Methods (==) :: FieldLabel -> FieldLabel -> Bool # (/=) :: FieldLabel -> FieldLabel -> Bool #

data WarningFlag #

Constructors

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

Instances

Instances details

Enum WarningFlag
Instance details Defined in GHC.Driver.Flags Methods succ :: WarningFlag -> WarningFlag # pred :: WarningFlag -> WarningFlag # toEnum :: Int -> WarningFlag # fromEnum :: WarningFlag -> Int # enumFrom :: WarningFlag -> [WarningFlag] # enumFromThen :: WarningFlag -> WarningFlag -> [WarningFlag] # enumFromTo :: WarningFlag -> WarningFlag -> [WarningFlag] # enumFromThenTo :: WarningFlag -> WarningFlag -> WarningFlag -> [WarningFlag] #
Show WarningFlag
Instance details Defined in GHC.Driver.Flags Methods showsPrec :: Int -> WarningFlag -> ShowS # show :: WarningFlag -> String # showList :: [WarningFlag] -> ShowS #
Eq WarningFlag
Instance details Defined in GHC.Driver.Flags Methods (==) :: WarningFlag -> WarningFlag -> Bool # (/=) :: WarningFlag -> WarningFlag -> Bool #
Ord WarningFlag
Instance details Defined in GHC.Driver.Flags Methods compare :: WarningFlag -> WarningFlag -> Ordering # (<) :: WarningFlag -> WarningFlag -> Bool # (<=) :: WarningFlag -> WarningFlag -> Bool # (>) :: WarningFlag -> WarningFlag -> Bool # (>=) :: WarningFlag -> WarningFlag -> Bool # max :: WarningFlag -> WarningFlag -> WarningFlag # min :: WarningFlag -> WarningFlag -> WarningFlag #

data GeneralFlag #

Enumerates the simple on-or-off dynamic flags

Constructors

Opt_DumpToFile	Append dump output to files instead of stdout.
Opt_DumpWithWays	Use foo.ways.dumpFlag instead of foo.dumpFlag
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	Enable floating out of let-bindings in the simplifier
Opt_LocalFloatOutTopLevel	Enable floating out of let-bindings at the top level in the simplifier N.B. See Note [RHS Floating]
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	deprecated, no effect and behaviour is now default. Allowed switching of a special demand transformer for dictionary selectors
Opt_Loopification
Opt_CfgBlocklayout	Use the cfg based block layout algorithm.
Opt_WeightlessBlocklayout	Layout based on last instruction per block.
Opt_CprAnal
Opt_WorkerWrapper
Opt_WorkerWrapperUnlift	Do W/W split for unlifting even if we won't unbox anything.
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	Ignore manual SCC annotations
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	-fPIC
Opt_PIE	-fPIE
Opt_PICExecutable	-pie
Opt_ExternalDynamicRefs
Opt_Ticky
Opt_Ticky_Allocd
Opt_Ticky_LNE
Opt_Ticky_Dyn_Thunk
Opt_Ticky_Tag
Opt_Ticky_AP	Use regular thunks even when we could use std ap thunks in order to get entry counts
Opt_CmmThreadSanitizer
Opt_RPath
Opt_RelativeDynlibPaths
Opt_CompactUnwind	-fcompact-unwind
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	Suppress timestamps in dumps
Opt_SuppressCoreSizes	Suppress per binding Core size stats in dumps
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

Instances

Instances details

Enum GeneralFlag
Instance details 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
Instance details Defined in GHC.Driver.Flags Methods showsPrec :: Int -> GeneralFlag -> ShowS # show :: GeneralFlag -> String # showList :: [GeneralFlag] -> ShowS #
Eq GeneralFlag
Instance details Defined in GHC.Driver.Flags Methods (==) :: GeneralFlag -> GeneralFlag -> Bool # (/=) :: GeneralFlag -> GeneralFlag -> Bool #

data DumpFlag #

Debugging flags

Constructors

Opt_D_dump_cmm
Opt_D_dump_cmm_from_stg
Opt_D_dump_cmm_raw
Opt_D_dump_cmm_verbose_by_proc
Opt_D_dump_cmm_verbose
Opt_D_dump_cmm_cfg
Opt_D_dump_cmm_cbe
Opt_D_dump_cmm_switch
Opt_D_dump_cmm_proc
Opt_D_dump_cmm_sp
Opt_D_dump_cmm_sink
Opt_D_dump_cmm_caf
Opt_D_dump_cmm_procmap
Opt_D_dump_cmm_split
Opt_D_dump_cmm_info
Opt_D_dump_cmm_cps
Opt_D_dump_cmm_thread_sanitizer
Opt_D_dump_cfg_weights	Dump the cfg used for block layout.
Opt_D_dump_asm
Opt_D_dump_asm_native
Opt_D_dump_asm_liveness
Opt_D_dump_asm_regalloc
Opt_D_dump_asm_regalloc_stages
Opt_D_dump_asm_conflicts
Opt_D_dump_asm_stats
Opt_D_dump_c_backend
Opt_D_dump_llvm
Opt_D_dump_js
Opt_D_dump_core_stats
Opt_D_dump_deriv
Opt_D_dump_ds
Opt_D_dump_ds_preopt
Opt_D_dump_foreign
Opt_D_dump_inlinings
Opt_D_dump_verbose_inlinings
Opt_D_dump_rule_firings
Opt_D_dump_rule_rewrites
Opt_D_dump_simpl_trace
Opt_D_dump_occur_anal
Opt_D_dump_parsed
Opt_D_dump_parsed_ast
Opt_D_dump_rn
Opt_D_dump_rn_ast
Opt_D_dump_simpl
Opt_D_dump_simpl_iterations
Opt_D_dump_spec
Opt_D_dump_prep
Opt_D_dump_late_cc
Opt_D_dump_stg_from_core	Initial STG (CoreToStg output)
Opt_D_dump_stg_unarised	STG after unarise
Opt_D_dump_stg_cg	STG (after stg2stg)
Opt_D_dump_stg_tags	Result of tag inference analysis.
Opt_D_dump_stg_final	Final STG (before cmm gen)
Opt_D_dump_call_arity
Opt_D_dump_exitify
Opt_D_dump_stranal
Opt_D_dump_str_signatures
Opt_D_dump_cpranal
Opt_D_dump_cpr_signatures
Opt_D_dump_tc
Opt_D_dump_tc_ast
Opt_D_dump_hie
Opt_D_dump_types
Opt_D_dump_rules
Opt_D_dump_cse
Opt_D_dump_worker_wrapper
Opt_D_dump_rn_trace
Opt_D_dump_rn_stats
Opt_D_dump_opt_cmm
Opt_D_dump_simpl_stats
Opt_D_dump_cs_trace
Opt_D_dump_tc_trace
Opt_D_dump_ec_trace
Opt_D_dump_if_trace
Opt_D_dump_splices
Opt_D_th_dec_file
Opt_D_dump_BCOs
Opt_D_dump_ticked
Opt_D_dump_rtti
Opt_D_source_stats
Opt_D_verbose_stg2stg
Opt_D_dump_hi
Opt_D_dump_hi_diffs
Opt_D_dump_mod_cycles
Opt_D_dump_mod_map
Opt_D_dump_timings
Opt_D_dump_view_pattern_commoning
Opt_D_verbose_core2core
Opt_D_dump_debug
Opt_D_dump_json
Opt_D_ppr_debug
Opt_D_no_debug_output
Opt_D_dump_faststrings
Opt_D_faststring_stats
Opt_D_ipe_stats

Instances

Instances details

Enum DumpFlag
Instance details Defined in GHC.Driver.Flags Methods succ :: DumpFlag -> DumpFlag # pred :: DumpFlag -> DumpFlag # toEnum :: Int -> DumpFlag # fromEnum :: DumpFlag -> Int # enumFrom :: DumpFlag -> [DumpFlag] # enumFromThen :: DumpFlag -> DumpFlag -> [DumpFlag] # enumFromTo :: DumpFlag -> DumpFlag -> [DumpFlag] # enumFromThenTo :: DumpFlag -> DumpFlag -> DumpFlag -> [DumpFlag] #
Show DumpFlag
Instance details Defined in GHC.Driver.Flags Methods showsPrec :: Int -> DumpFlag -> ShowS # show :: DumpFlag -> String # showList :: [DumpFlag] -> ShowS #
Eq DumpFlag
Instance details Defined in GHC.Driver.Flags Methods (==) :: DumpFlag -> DumpFlag -> Bool # (/=) :: DumpFlag -> DumpFlag -> Bool #

data Language #

Constructors

Haskell98
Haskell2010
GHC2021

Instances

Instances details

Bounded Language
Instance details Defined in GHC.Driver.Flags Methods minBound :: Language # maxBound :: Language #
Enum Language
Instance details Defined in GHC.Driver.Flags Methods succ :: Language -> Language # pred :: Language -> Language # toEnum :: Int -> Language # fromEnum :: Language -> Int # enumFrom :: Language -> [Language] # enumFromThen :: Language -> Language -> [Language] # enumFromTo :: Language -> Language -> [Language] # enumFromThenTo :: Language -> Language -> Language -> [Language] #
Show Language
Instance details Defined in GHC.Driver.Flags Methods showsPrec :: Int -> Language -> ShowS # show :: Language -> String # showList :: [Language] -> ShowS #
NFData Language
Instance details Defined in GHC.Driver.Flags Methods rnf :: Language -> () #
Binary Language
Instance details Defined in GHC.Driver.Flags Methods put_ :: BinHandle -> Language -> IO () # put :: BinHandle -> Language -> IO (Bin Language) # get :: BinHandle -> IO Language #
Outputable Language
Instance details Defined in GHC.Driver.Flags Methods ppr :: Language -> SDoc #
Eq Language
Instance details Defined in GHC.Driver.Flags Methods (==) :: Language -> Language -> Bool # (/=) :: Language -> Language -> Bool #

type ModuleWithIsBoot = GenWithIsBoot Module #

type ModuleNameWithIsBoot = GenWithIsBoot ModuleName #

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 gwib_mod :: mod gwib_isBoot :: IsBootInterface

Instances

Instances details

Foldable GenWithIsBoot
Instance details Defined in GHC.Unit.Types Methods fold :: Monoid m => GenWithIsBoot m -> m # foldMap :: Monoid m => (a -> m) -> GenWithIsBoot a -> m # foldMap' :: Monoid m => (a -> m) -> GenWithIsBoot a -> m # foldr :: (a -> b -> b) -> b -> GenWithIsBoot a -> b # foldr' :: (a -> b -> b) -> b -> GenWithIsBoot a -> b # foldl :: (b -> a -> b) -> b -> GenWithIsBoot a -> b # foldl' :: (b -> a -> b) -> b -> GenWithIsBoot a -> b # foldr1 :: (a -> a -> a) -> GenWithIsBoot a -> a # foldl1 :: (a -> a -> a) -> GenWithIsBoot a -> a # toList :: GenWithIsBoot a -> [a] # null :: GenWithIsBoot a -> Bool # length :: GenWithIsBoot a -> Int # elem :: Eq a => a -> GenWithIsBoot a -> Bool # maximum :: Ord a => GenWithIsBoot a -> a # minimum :: Ord a => GenWithIsBoot a -> a # sum :: Num a => GenWithIsBoot a -> a # product :: Num a => GenWithIsBoot a -> a #
Traversable GenWithIsBoot
Instance details Defined in GHC.Unit.Types Methods traverse :: Applicative f => (a -> f b) -> GenWithIsBoot a -> f (GenWithIsBoot b) # sequenceA :: Applicative f => GenWithIsBoot (f a) -> f (GenWithIsBoot a) # mapM :: Monad m => (a -> m b) -> GenWithIsBoot a -> m (GenWithIsBoot b) # sequence :: Monad m => GenWithIsBoot (m a) -> m (GenWithIsBoot a) #
Functor GenWithIsBoot
Instance details Defined in GHC.Unit.Types Methods fmap :: (a -> b) -> GenWithIsBoot a -> GenWithIsBoot b # (<$) :: a -> GenWithIsBoot b -> GenWithIsBoot a #
Show mod => Show (GenWithIsBoot mod)
Instance details Defined in GHC.Unit.Types Methods showsPrec :: Int -> GenWithIsBoot mod -> ShowS # show :: GenWithIsBoot mod -> String # showList :: [GenWithIsBoot mod] -> ShowS #
Binary a => Binary (GenWithIsBoot a)
Instance details Defined in GHC.Unit.Types Methods put_ :: BinHandle -> GenWithIsBoot a -> IO () # put :: BinHandle -> GenWithIsBoot a -> IO (Bin (GenWithIsBoot a)) # get :: BinHandle -> IO (GenWithIsBoot a) #
Outputable a => Outputable (GenWithIsBoot a)
Instance details Defined in GHC.Unit.Types Methods ppr :: GenWithIsBoot a -> SDoc #
Eq mod => Eq (GenWithIsBoot mod)
Instance details Defined in GHC.Unit.Types Methods (==) :: GenWithIsBoot mod -> GenWithIsBoot mod -> Bool # (/=) :: GenWithIsBoot mod -> GenWithIsBoot mod -> Bool #
Ord mod => Ord (GenWithIsBoot mod)
Instance details Defined in GHC.Unit.Types Methods compare :: GenWithIsBoot mod -> GenWithIsBoot mod -> Ordering # (<) :: GenWithIsBoot mod -> GenWithIsBoot mod -> Bool # (<=) :: GenWithIsBoot mod -> GenWithIsBoot mod -> Bool # (>) :: GenWithIsBoot mod -> GenWithIsBoot mod -> Bool # (>=) :: GenWithIsBoot mod -> GenWithIsBoot mod -> Bool # max :: GenWithIsBoot mod -> GenWithIsBoot mod -> GenWithIsBoot mod # min :: GenWithIsBoot mod -> GenWithIsBoot mod -> GenWithIsBoot mod #

newtype Definite unit #

A definite unit (i.e. without any free module hole)

Constructors

Definite
Fields unDefinite :: unit

Instances

Instances details

Functor Definite
Instance details Defined in GHC.Unit.Types Methods fmap :: (a -> b) -> Definite a -> Definite b # (<$) :: a -> Definite b -> Definite a #
Uniquable unit => Uniquable (Definite unit)
Instance details Defined in GHC.Unit.Types Methods getUnique :: Definite unit -> Unique #
IsUnitId unit => IsUnitId (Definite unit)
Instance details Defined in GHC.Unit.Types Methods unitFS :: Definite unit -> FastString #
Binary unit => Binary (Definite unit)
Instance details Defined in GHC.Unit.Types Methods put_ :: BinHandle -> Definite unit -> IO () # put :: BinHandle -> Definite unit -> IO (Bin (Definite unit)) # get :: BinHandle -> IO (Definite unit) #
Outputable unit => Outputable (Definite unit)
Instance details Defined in GHC.Unit.Types Methods ppr :: Definite unit -> SDoc #
Eq unit => Eq (Definite unit)
Instance details Defined in GHC.Unit.Types Methods (==) :: Definite unit -> Definite unit -> Bool # (/=) :: Definite unit -> Definite unit -> Bool #
Ord unit => Ord (Definite unit)
Instance details 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 # max :: Definite unit -> Definite unit -> Definite unit # min :: Definite unit -> Definite unit -> Definite unit #

type DefUnitId = Definite UnitId #

A DefUnitId is an UnitId with the invariant that it only refers to a definite library; i.e., one we have generated code for.

type Instantiations = GenInstantiations UnitId #

type GenInstantiations unit = [(ModuleName, GenModule (GenUnit unit))] #

type InstantiatedUnit = GenInstantiatedUnit UnitId #

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

instUnitFS :: !FastString
A private, uniquely identifying representation of an InstantiatedUnit. This string is completely private to GHC and is just used to get a unique.
instUnitKey :: !Unique
Cached unique of unitFS.
instUnitInstanceOf :: !unit
The (indefinite) unit being instantiated.
instUnitInsts :: !(GenInstantiations unit)
The sorted (by ModuleName) instantiations of this unit.
instUnitHoles :: UniqDSet ModuleName
A cache of the free module holes of instUnitInsts. This lets us efficiently tell if a GenInstantiatedUnit has been fully instantiated (empty set of free module holes) and whether or not a substitution can have any effect.

Instances

Instances details

Binary InstantiatedUnit
Instance details Defined in GHC.Unit.Types Methods put_ :: BinHandle -> InstantiatedUnit -> IO () # put :: BinHandle -> InstantiatedUnit -> IO (Bin InstantiatedUnit) # get :: BinHandle -> IO InstantiatedUnit #
Outputable InstantiatedModule
Instance details Defined in GHC.Unit.Types Methods ppr :: InstantiatedModule -> SDoc #
Outputable InstantiatedUnit
Instance details Defined in GHC.Unit.Types Methods ppr :: InstantiatedUnit -> SDoc #
Eq (GenInstantiatedUnit unit)
Instance details Defined in GHC.Unit.Types Methods (==) :: GenInstantiatedUnit unit -> GenInstantiatedUnit unit -> Bool # (/=) :: GenInstantiatedUnit unit -> GenInstantiatedUnit unit -> Bool #
Ord (GenInstantiatedUnit unit)
Instance details Defined in GHC.Unit.Types Methods compare :: GenInstantiatedUnit unit -> GenInstantiatedUnit unit -> Ordering # (<) :: GenInstantiatedUnit unit -> GenInstantiatedUnit unit -> Bool # (<=) :: GenInstantiatedUnit unit -> GenInstantiatedUnit unit -> Bool # (>) :: GenInstantiatedUnit unit -> GenInstantiatedUnit unit -> Bool # (>=) :: GenInstantiatedUnit unit -> GenInstantiatedUnit unit -> Bool # max :: GenInstantiatedUnit unit -> GenInstantiatedUnit unit -> GenInstantiatedUnit unit # min :: GenInstantiatedUnit unit -> GenInstantiatedUnit unit -> GenInstantiatedUnit unit #

newtype UnitKey #

A unit key in the database

Constructors

UnitKey FastString

Instances

Instances details

IsUnitId UnitKey
Instance details Defined in GHC.Unit.Types Methods unitFS :: UnitKey -> FastString #

class IsUnitId u where #

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

Instances details

IsUnitId UnitId
Instance details Defined in GHC.Unit.Types Methods unitFS :: UnitId -> FastString #
IsUnitId UnitKey
Instance details Defined in GHC.Unit.Types Methods unitFS :: UnitKey -> FastString #
IsUnitId unit => IsUnitId (Definite unit)
Instance details Defined in GHC.Unit.Types Methods unitFS :: Definite unit -> FastString #
IsUnitId u => IsUnitId (GenUnit u)
Instance details 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 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.

Constructors

ModLocation

Fields

ml_hs_file :: Maybe FilePath
The source file, if we have one. Package modules probably don't have source files.
ml_hi_file :: 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_dyn_hi_file :: FilePath
Where the .dyn_hi file is, whether or not it exists yet.
ml_obj_file :: 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_dyn_obj_file :: FilePath
Where the .dy file is, whether or not it exists yet.
ml_hie_file :: FilePath
Where the .hie file is, whether or not it exists yet.

Instances

Instances details

Show ModLocation
Instance details Defined in GHC.Unit.Module.Location Methods showsPrec :: Int -> ModLocation -> ShowS # show :: ModLocation -> String # showList :: [ModLocation] -> ShowS #
Outputable ModLocation
Instance details Defined in GHC.Unit.Module.Location Methods ppr :: ModLocation -> SDoc #

data InstalledModuleEnv elt #

A map keyed off of InstalledModule

Instances

Instances details

Outputable elt => Outputable (InstalledModuleEnv elt)
Instance details 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)

type ModuleSet = Set NDModule #

A set of GenModules

data ModuleEnv elt #

A map keyed off of GenModules

Instances

Instances details

Outputable a => Outputable (ModuleEnv a)
Instance details Defined in GHC.Unit.Module.Env Methods ppr :: ModuleEnv a -> SDoc #

class HasModule (m :: Type -> Type) where #

Methods

getModule :: m Module #

Instances

Instances details

HasModule CoreM
Instance details Defined in GHC.Core.Opt.Monad Methods getModule :: CoreM Module #
HasModule TcS
Instance details Defined in GHC.Tc.Solver.Monad Methods getModule :: TcS Module #
ContainsModule env => HasModule (IOEnv env)
Instance details Defined in GHC.Data.IOEnv Methods getModule :: IOEnv env Module #

class ContainsModule t where #

Methods

extractModule :: t -> Module #

Instances

Instances details

ContainsModule DsGblEnv
Instance details Defined in GHC.HsToCore.Types Methods extractModule :: DsGblEnv -> Module #
ContainsModule TcGblEnv
Instance details Defined in GHC.Tc.Types Methods extractModule :: TcGblEnv -> Module #
ContainsModule gbl => ContainsModule (Env gbl lcl)
Instance details Defined in GHC.Tc.Types Methods extractModule :: Env gbl lcl -> Module #

type HomeUnit = GenHomeUnit UnitId #

data GenHomeUnit u #

Information about the home unit (i.e., the until that will contain the modules we are compiling)

The unit identifier of the instantiating units is left open to allow switching from UnitKey (what is provided by the user) to UnitId (internal unit identifier) with homeUnitMap.

TODO: this isn't implemented yet. UnitKeys are still converted too early into UnitIds in GHC.Unit.State.readUnitDataBase

Constructors

DefiniteHomeUnit UnitId (Maybe (u, GenInstantiations u))

Definite home unit (i.e. that we can compile).

Nothing: not an instantiated unit Just (i,insts): made definite by instantiating "i" with "insts"

IndefiniteHomeUnit UnitId (GenInstantiations u)

Indefinite home unit (i.e. that we can only typecheck)

All the holes are instantiated with fake modules from the Hole unit. See Note [Representation of module/name variables] in GHC.Unit

data PkgQual #

Package-qualifier after renaming

Renaming detects if "this" or the unit-id of the home-unit was used as a package qualifier.

Constructors

NoPkgQual	No package qualifier
ThisPkg UnitId	Import from home-unit
OtherPkg UnitId	Import from another unit

Instances

Instances details

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

data RawPkgQual #

Package-qualifier as it was parsed

Constructors

NoRawPkgQual	No package qualifier
RawPkgQual StringLiteral	Raw package qualifier string.

Instances

Instances details

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

type LPat p = XRec p (Pat p) #

data Pat p #

Pattern

AnnKeywordId : AnnBang

Constructors

WildPat (XWildPat p)	Wildcard Pattern The sole reason for a type on a WildPat is to support hsPatType :: Pat Id -> Type
VarPat (XVarPat p) (LIdP p)	Variable Pattern
LazyPat (XLazyPat p) (LPat p)	Lazy Pattern ^ - `AnnKeywordId` : `AnnTilde`
AsPat (XAsPat p) (LIdP p) !(LHsToken "@" p) (LPat p)	As pattern ^ - `AnnKeywordId` : `AnnAt`
ParPat
Fields (XParPat p) !(LHsToken "(" p) (LPat p) Parenthesised pattern !(LHsToken ")" p) `AnnKeywordId` : `AnnOpen` `'('`, `AnnClose` `')'`
BangPat (XBangPat p) (LPat p)	Bang pattern ^ - `AnnKeywordId` : `AnnBang`
ListPat (XListPat p) [LPat p]	Syntactic List `AnnKeywordId` : `AnnOpen` `'['`, `AnnClose` `']'`
TuplePat (XTuplePat p) [LPat p] Boxity	Tuple sub-patterns `AnnKeywordId` : `AnnOpen` `'('` or `'(#'`, `AnnClose` `')'` or `'#)'`
SumPat (XSumPat p) (LPat p) ConTag SumWidth	Anonymous sum pattern `AnnKeywordId` : `AnnOpen` `'(#'`, `AnnClose` `'#)'`
ConPat	Constructor Pattern
Fields pat_con_ext :: XConPat p pat_con :: XRec p (ConLikeP p) pat_args :: HsConPatDetails p
ViewPat	`AnnKeywordId` : `AnnRarrow`
Fields (XViewPat p) (LHsExpr p) (LPat p) View Pattern
SplicePat	`AnnKeywordId` : `AnnOpen` `'$('` `AnnClose` `')'`
Fields (XSplicePat p) (HsUntypedSplice p) Splice Pattern (Includes quasi-quotes)
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 `AnnKeywordId` : `AnnVal` `+`
NPlusKPat (XNPlusKPat p) (LIdP p) (XRec p (HsOverLit p)) (HsOverLit p) (SyntaxExpr p) (SyntaxExpr p)	n+k pattern
SigPat	`AnnKeywordId` : `AnnDcolon`
Fields (XSigPat p) (LPat p) (HsPatSigType (NoGhcTc p)) Pattern with a type signature
XPat !(XXPat p)

Instances

Instances details

type Anno (Pat (GhcPass p))
Instance details Defined in GHC.Hs.Pat type Anno (Pat (GhcPass p)) = SrcSpanAnnA

type LHsExpr p #

Arguments

= XRec p (HsExpr p)

May have AnnKeywordId : AnnComma when in a list

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

Instances details

type SyntaxExpr (GhcPass p)
Instance details Defined in GHC.Hs.Expr type SyntaxExpr (GhcPass p) = SyntaxExprGhc p

data GRHSs p body #

Guarded Right-Hand Sides

GRHSs are used both for pattern bindings and for Matches

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

Constructors

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

data MatchGroup p body #

Constructors

MG
Fields mg_ext :: XMG p body mg_alts :: XRec p [LMatch p body]
XMatchGroup !(XXMatchGroup p body)

data HsUntypedSplice id #

Haskell Splice

Constructors

HsUntypedSpliceExpr (XUntypedSpliceExpr id) (LHsExpr id)
HsQuasiQuote (XQuasiQuote id) (IdP id) (XRec id FastString)
XUntypedSplice !(XXUntypedSplice id)

Instances

Instances details

type Anno (HsUntypedSplice (GhcPass p))
Instance details Defined in GHC.Hs.Expr type Anno (HsUntypedSplice (GhcPass p)) = SrcSpanAnnA

data PromotionFlag #

Is a TyCon a promoted data constructor or just a normal type constructor?

Constructors

NotPromoted
IsPromoted

Instances

Instances details

Data PromotionFlag
Instance details 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
Instance details Defined in Language.Haskell.Syntax.Type Methods (==) :: PromotionFlag -> PromotionFlag -> Bool # (/=) :: PromotionFlag -> PromotionFlag -> Bool #

data DefaultingStrategy #

Specify whether to default kind variables, and type variables of kind RuntimeRepLevityMultiplicity.

Constructors

DefaultKindVars

Default kind variables:

default kind variables of kind Type to Type,
default RuntimeRepLevityMultiplicity kind variables to LiftedRepLiftedMany, respectively.

When this strategy is used, it means that we have determined that the variables we are considering defaulting are all kind variables.

Usually, we pass this option when -XNoPolyKinds is enabled.

NonStandardDefaulting NonStandardDefaultingStrategy

Default (or don't default) non-standard variables, of kinds RuntimeRep, Levity and Multiplicity.

Instances

Instances details

Outputable DefaultingStrategy
Instance details Defined in GHC.Types.Basic Methods ppr :: DefaultingStrategy -> SDoc #

data NonStandardDefaultingStrategy #

Specify whether to default type variables of kind RuntimeRepLevityMultiplicity.

Constructors

DefaultNonStandardTyVars

Default type variables of the given kinds:

default RuntimeRep variables to LiftedRep
default Levity variables to Lifted
default Multiplicity variables to Many

TryNotToDefaultNonStandardTyVars

Try not to default type variables of the kinds RuntimeRepLevityMultiplicity.

Note that these might get defaulted anyway, if they are kind variables and `-XNoPolyKinds` is enabled.

Instances

Instances details

Outputable NonStandardDefaultingStrategy
Instance details Defined in GHC.Types.Basic Methods ppr :: NonStandardDefaultingStrategy -> SDoc #

data TypeOrConstraint #

Constructors

TypeLike
ConstraintLike

Instances

Instances details

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

data TypeOrKind #

Flag to see whether we're type-checking terms or kind-checking types

Constructors

TypeLevel
KindLevel

Instances

Instances details

Outputable TypeOrKind
Instance details Defined in GHC.Types.Basic Methods ppr :: TypeOrKind -> SDoc #
Eq TypeOrKind
Instance details Defined in GHC.Types.Basic Methods (==) :: TypeOrKind -> TypeOrKind -> Bool # (/=) :: TypeOrKind -> TypeOrKind -> Bool #

data IntWithInf #

An integer or infinity

Instances

Instances details

Num IntWithInf
Instance details Defined in GHC.Types.Basic Methods (+) :: IntWithInf -> IntWithInf -> IntWithInf # (-) :: IntWithInf -> IntWithInf -> IntWithInf # (*) :: IntWithInf -> IntWithInf -> IntWithInf # negate :: IntWithInf -> IntWithInf # abs :: IntWithInf -> IntWithInf # signum :: IntWithInf -> IntWithInf # fromInteger :: Integer -> IntWithInf #
Outputable IntWithInf
Instance details Defined in GHC.Types.Basic Methods ppr :: IntWithInf -> SDoc #
Eq IntWithInf
Instance details Defined in GHC.Types.Basic Methods (==) :: IntWithInf -> IntWithInf -> Bool # (/=) :: IntWithInf -> IntWithInf -> Bool #
Ord IntWithInf
Instance details Defined in GHC.Types.Basic Methods compare :: IntWithInf -> IntWithInf -> Ordering # (<) :: IntWithInf -> IntWithInf -> Bool # (<=) :: IntWithInf -> IntWithInf -> Bool # (>) :: IntWithInf -> IntWithInf -> Bool # (>=) :: IntWithInf -> IntWithInf -> Bool # max :: IntWithInf -> IntWithInf -> IntWithInf # min :: IntWithInf -> IntWithInf -> IntWithInf #

data UnfoldingSource #

Constructors

VanillaSrc
StableUserSrc
StableSystemSrc
CompulsorySrc

Instances

Instances details

Binary UnfoldingSource
Instance details Defined in GHC.Types.Basic Methods put_ :: BinHandle -> UnfoldingSource -> IO () # put :: BinHandle -> UnfoldingSource -> IO (Bin UnfoldingSource) # get :: BinHandle -> IO UnfoldingSource #
Outputable UnfoldingSource
Instance details Defined in GHC.Types.Basic Methods ppr :: UnfoldingSource -> SDoc #

data InlineSpec #

Inline Specification

Constructors

Inline SourceText
Inlinable SourceText
NoInline SourceText
Opaque SourceText
NoUserInlinePrag

Instances

Instances details

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

data RuleMatchInfo #

Rule Match Information

Constructors

ConLike
FunLike

Instances

Instances details

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

data InlinePragma #

Constructors

InlinePragma
Fields inl_src :: SourceText inl_inline :: InlineSpec inl_sat :: Maybe Arity inl_act :: Activation inl_rule :: RuleMatchInfo

Instances

Instances details

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

data Activation #

Constructors

AlwaysActive
ActiveBefore SourceText PhaseNum
ActiveAfter SourceText PhaseNum
FinalActive
NeverActive

Instances

Instances details

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

data CompilerPhase #

Constructors

InitialPhase
Phase PhaseNum
FinalPhase

Instances

Instances details

Outputable CompilerPhase
Instance details Defined in GHC.Types.Basic Methods ppr :: CompilerPhase -> SDoc #
Eq CompilerPhase
Instance details Defined in GHC.Types.Basic Methods (==) :: CompilerPhase -> CompilerPhase -> Bool # (/=) :: CompilerPhase -> CompilerPhase -> Bool #

type PhaseNum = Int #

Phase Number

data SuccessFlag #

Constructors

Succeeded
Failed

Instances

Instances details

Semigroup SuccessFlag
Instance details Defined in GHC.Types.Basic Methods (<>) :: SuccessFlag -> SuccessFlag -> SuccessFlag # sconcat :: NonEmpty SuccessFlag -> SuccessFlag # stimes :: Integral b => b -> SuccessFlag -> SuccessFlag #
Outputable SuccessFlag
Instance details Defined in GHC.Types.Basic Methods ppr :: SuccessFlag -> SDoc #

data DefMethSpec ty #

Default Method Specification

Constructors

VanillaDM
GenericDM ty

Instances

Instances details

Binary (DefMethSpec IfaceType)
Instance details Defined in GHC.Iface.Type Methods put_ :: BinHandle -> DefMethSpec IfaceType -> IO () # put :: BinHandle -> DefMethSpec IfaceType -> IO (Bin (DefMethSpec IfaceType)) # get :: BinHandle -> IO (DefMethSpec IfaceType) #
Outputable (DefMethSpec ty)
Instance details Defined in GHC.Types.Basic Methods ppr :: DefMethSpec ty -> SDoc #

data TailCallInfo #

Constructors

AlwaysTailCalled JoinArity
NoTailCallInfo

Instances

Instances details

Outputable TailCallInfo
Instance details Defined in GHC.Types.Basic Methods ppr :: TailCallInfo -> SDoc #
Eq TailCallInfo
Instance details Defined in GHC.Types.Basic Methods (==) :: TailCallInfo -> TailCallInfo -> Bool # (/=) :: TailCallInfo -> TailCallInfo -> Bool #

data InsideLam #

Inside Lambda

Constructors

IsInsideLam	Occurs inside a non-linear lambda Substituting a redex for this occurrence is dangerous because it might duplicate work.
NotInsideLam

Instances

Instances details

Monoid InsideLam
Instance details Defined in GHC.Types.Basic Methods mempty :: InsideLam # mappend :: InsideLam -> InsideLam -> InsideLam # mconcat :: [InsideLam] -> InsideLam #
Semigroup InsideLam	If any occurrence of an identifier is inside a lambda, then the occurrence info of that identifier marks it as occurring inside a lambda
Instance details Defined in GHC.Types.Basic Methods (<>) :: InsideLam -> InsideLam -> InsideLam # sconcat :: NonEmpty InsideLam -> InsideLam # stimes :: Integral b => b -> InsideLam -> InsideLam #
Eq InsideLam
Instance details Defined in GHC.Types.Basic Methods (==) :: InsideLam -> InsideLam -> Bool # (/=) :: InsideLam -> InsideLam -> Bool #

data InterestingCxt #

Interesting Context

Constructors

IsInteresting	Function: is applied Data value: scrutinised by a case with at least one non-DEFAULT branch
NotInteresting

Instances

Instances details

Monoid InterestingCxt
Instance details Defined in GHC.Types.Basic Methods mempty :: InterestingCxt # mappend :: InterestingCxt -> InterestingCxt -> InterestingCxt # mconcat :: [InterestingCxt] -> InterestingCxt #
Semigroup InterestingCxt	If there is any `interesting` identifier occurrence, then the aggregated occurrence info of that identifier is considered interesting.
Instance details Defined in GHC.Types.Basic Methods (<>) :: InterestingCxt -> InterestingCxt -> InterestingCxt # sconcat :: NonEmpty InterestingCxt -> InterestingCxt # stimes :: Integral b => b -> InterestingCxt -> InterestingCxt #
Eq InterestingCxt
Instance details Defined in GHC.Types.Basic Methods (==) :: InterestingCxt -> InterestingCxt -> Bool # (/=) :: InterestingCxt -> InterestingCxt -> Bool #

type BranchCount = Int #

data OccInfo #

identifier Occurrence Information

Constructors

ManyOccs	There are many occurrences, or unknown occurrences
Fields occ_tail :: !TailCallInfo
IAmDead	Marks unused variables. Sometimes useful for lambda and case-bound variables.
OneOcc	Occurs exactly once (per branch), not inside a rule
Fields occ_in_lam :: !InsideLam occ_n_br :: !BranchCount occ_int_cxt :: !InterestingCxt occ_tail :: !TailCallInfo
IAmALoopBreaker	This identifier breaks a loop of mutually recursive functions. The field marks whether it is only a loop breaker due to a reference in a rule
Fields occ_rules_only :: !RulesOnly occ_tail :: !TailCallInfo

Instances

Instances details

Outputable OccInfo
Instance details Defined in GHC.Types.Basic Methods ppr :: OccInfo -> SDoc #
Eq OccInfo
Instance details Defined in GHC.Types.Basic Methods (==) :: OccInfo -> OccInfo -> Bool # (/=) :: OccInfo -> OccInfo -> Bool #

data EP a #

Embedding Projection pair

Constructors

EP
Fields fromEP :: a toEP :: a

data UnboxedTupleOrSum #

Are we dealing with an unboxed tuple or an unboxed sum?

Used when validity checking, see check_ubx_tuple_or_sum.

Constructors

UnboxedTupleType
UnboxedSumType

Instances

Instances details

Outputable UnboxedTupleOrSum
Instance details Defined in GHC.Types.Basic Methods ppr :: UnboxedTupleOrSum -> SDoc #
Eq UnboxedTupleOrSum
Instance details Defined in GHC.Types.Basic Methods (==) :: UnboxedTupleOrSum -> UnboxedTupleOrSum -> Bool # (/=) :: UnboxedTupleOrSum -> UnboxedTupleOrSum -> Bool #

data TupleSort #

Constructors

BoxedTuple
UnboxedTuple
ConstraintTuple

Instances

Instances details

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

newtype PprPrec #

A general-purpose pretty-printing precedence type.

Constructors

PprPrec Int

Instances

Instances details

Show PprPrec
Instance details Defined in GHC.Types.Basic Methods showsPrec :: Int -> PprPrec -> ShowS # show :: PprPrec -> String # showList :: [PprPrec] -> ShowS #
Eq PprPrec
Instance details Defined in GHC.Types.Basic Methods (==) :: PprPrec -> PprPrec -> Bool # (/=) :: PprPrec -> PprPrec -> Bool #
Ord PprPrec
Instance details Defined in GHC.Types.Basic Methods compare :: PprPrec -> PprPrec -> Ordering # (<) :: PprPrec -> PprPrec -> Bool # (<=) :: PprPrec -> PprPrec -> Bool # (>) :: PprPrec -> PprPrec -> Bool # (>=) :: PprPrec -> PprPrec -> Bool # max :: PprPrec -> PprPrec -> PprPrec # min :: PprPrec -> PprPrec -> PprPrec #

data OverlapMode #

Constructors

NoOverlap SourceText	This instance must not overlap another `NoOverlap` instance. However, it may be overlapped by `Overlapping` instances, and it may overlap `Overlappable` instances.
Overlappable SourceText	Silently ignore this instance if you find a more specific one that matches the constraint you are trying to resolve Example: constraint (Foo [Int]) instance Foo [Int] instance {-# OVERLAPPABLE #-} Foo [a] Since the second instance has the Overlappable flag, the first instance will be chosen (otherwise its ambiguous which to choose)
Overlapping SourceText	Silently ignore any more general instances that may be used to solve the constraint. Example: constraint (Foo [Int]) instance {-# OVERLAPPING #-} Foo [Int] instance Foo [a] Since the first instance has the Overlapping flag, the second---more general---instance will be ignored (otherwise it is ambiguous which to choose)
Overlaps SourceText	Equivalent to having both `Overlapping` and `Overlappable` flags.
Incoherent SourceText	Behave like Overlappable and Overlapping, and in addition pick an arbitrary one if there are multiple matching candidates, and don't worry about later instantiation Example: constraint (Foo [b]) instance {-# INCOHERENT -} Foo [Int] instance Foo [a] Without the Incoherent flag, we'd complain that instantiating `b` would change which instance was chosen. See also Note [Incoherent instances] in GHC.Core.InstEnv

Instances

Instances details

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

data OverlapFlag #

The semantics allowed for overlapping instances for a particular instance. See Note [Safe Haskell isSafeOverlap] in GHC.Core.InstEnv for a explanation of the isSafeOverlap field.

AnnKeywordId : AnnOpen '{-# OVERLAPPABLE' or '{-# OVERLAPPING' or '{-# OVERLAPS' or '{-# INCOHERENT', AnnClose `#-}`,

Constructors

OverlapFlag
Fields overlapMode :: OverlapMode isSafeOverlap :: Bool

Instances

Instances details

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

data Origin #

Constructors

FromSource
Generated

Instances

Instances details

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

data RecFlag #

Recursivity Flag

Constructors

Recursive
NonRecursive

Instances

Instances details

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

data CbvMark #

Should an argument be passed evaluated *and* tagged.

Constructors

MarkedCbv
NotMarkedCbv

Instances

Instances details

Binary CbvMark
Instance details Defined in GHC.Types.Basic Methods put_ :: BinHandle -> CbvMark -> IO () # put :: BinHandle -> CbvMark -> IO (Bin CbvMark) # get :: BinHandle -> IO CbvMark #
Outputable CbvMark
Instance details Defined in GHC.Types.Basic Methods ppr :: CbvMark -> SDoc #
Eq CbvMark
Instance details Defined in GHC.Types.Basic Methods (==) :: CbvMark -> CbvMark -> Bool # (/=) :: CbvMark -> CbvMark -> Bool #

data TopLevelFlag #

Constructors

TopLevel
NotTopLevel

Instances

Instances details

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

type RuleName = FastString #

data FunctionOrData #

Constructors

IsFunction
IsData

Instances

Instances details

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

data SwapFlag #

Constructors

NotSwapped
IsSwapped

Instances

Instances details

Outputable SwapFlag
Instance details Defined in GHC.Types.Basic Methods ppr :: SwapFlag -> SDoc #

data OneShotInfo #

If the Id is a lambda-bound variable then it may have lambda-bound variable info. Sometimes we know whether the lambda binding this variable is a "one-shot" lambda; that is, whether it is applied at most once.

This information may be useful in optimisation, as computations may safely be floated inside such a lambda without risk of duplicating work.

See also Note [OneShotInfo overview] above.

Constructors

NoOneShotInfo	No information
OneShotLam	The lambda is applied at most once.

Instances

Instances details

Outputable OneShotInfo
Instance details Defined in GHC.Types.Basic Methods ppr :: OneShotInfo -> SDoc #
Eq OneShotInfo
Instance details Defined in GHC.Types.Basic Methods (==) :: OneShotInfo -> OneShotInfo -> Bool # (/=) :: OneShotInfo -> OneShotInfo -> Bool #

data Alignment #

A power-of-two alignment

Instances

Instances details

Outputable Alignment
Instance details Defined in GHC.Types.Basic Methods ppr :: Alignment -> SDoc #
Eq Alignment
Instance details Defined in GHC.Types.Basic Methods (==) :: Alignment -> Alignment -> Bool # (/=) :: Alignment -> Alignment -> Bool #
Ord Alignment
Instance details Defined in GHC.Types.Basic Methods compare :: Alignment -> Alignment -> Ordering # (<) :: Alignment -> Alignment -> Bool # (<=) :: Alignment -> Alignment -> Bool # (>) :: Alignment -> Alignment -> Bool # (>=) :: Alignment -> Alignment -> Bool # max :: Alignment -> Alignment -> Alignment # min :: Alignment -> Alignment -> Alignment #
OutputableP env Alignment
Instance details Defined in GHC.Types.Basic Methods pdoc :: env -> Alignment -> SDoc #

type ConTagZ = Int #

A *zero-indexed* constructor tag

type FullArgCount = Int #

FullArgCount is the number of type or value arguments in an application, or the number of type or value binders in a lambda. Note: it includes both type and value arguments!

type JoinArity = Int #

The number of arguments that a join point takes. Unlike the arity of a function, this is a purely syntactic property and is fixed when the join point is created (or converted from a value). Both type and value arguments are counted.

type RepArity = Int #

Representation Arity

The number of represented arguments that can be applied to a value before it does "real work". So: fib 100 has representation arity 0 x -> fib x has representation arity 1 (# x, y #) -> fib (x + y) has representation arity 2

type Arity = Int #

The number of value arguments that can be applied to a value before it does "real work". So: fib 100 has arity 0 x -> fib x has arity 1 See also Note [Definition of arity] in GHC.Core.Opt.Arity

data LeftOrRight #

Constructors

CLeft
CRight

Instances

Instances details

Data LeftOrRight
Instance details 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
Instance details Defined in GHC.Types.Basic Methods put_ :: BinHandle -> LeftOrRight -> IO () # put :: BinHandle -> LeftOrRight -> IO (Bin LeftOrRight) # get :: BinHandle -> IO LeftOrRight #
Outputable LeftOrRight
Instance details Defined in GHC.Types.Basic Methods ppr :: LeftOrRight -> SDoc #
Eq LeftOrRight
Instance details Defined in GHC.Types.Basic Methods (==) :: LeftOrRight -> LeftOrRight -> Bool # (/=) :: LeftOrRight -> LeftOrRight -> Bool #

data EqSpec #

An EqSpec is a tyvar/type pair representing an equality made in rejigging a GADT constructor

Instances

Instances details

Outputable EqSpec
Instance details Defined in GHC.Core.DataCon Methods ppr :: EqSpec -> SDoc #

data DataConRep #

Data Constructor Representation See Note [Data constructor workers and wrappers]

Constructors

NoDataConRep
DCR
Fields dcr_wrap_id :: Id dcr_boxer :: DataConBoxer dcr_arg_tys :: [Scaled Type] dcr_stricts :: [StrictnessMark] dcr_bangs :: [HsImplBang]

data DataCon #

A data constructor

AnnKeywordId : AnnOpen, AnnClose,AnnComma

Instances

Instances details

Data DataCon
Instance details 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
Instance details Defined in GHC.Core.DataCon Methods getOccName :: DataCon -> OccName # getName :: DataCon -> Name #
Uniquable DataCon
Instance details Defined in GHC.Core.DataCon Methods getUnique :: DataCon -> Unique #
Outputable DataCon
Instance details Defined in GHC.Core.DataCon Methods ppr :: DataCon -> SDoc #
OutputableBndr DataCon
Instance details Defined in GHC.Core.DataCon Methods pprBndr :: BindingSite -> DataCon -> SDoc # pprPrefixOcc :: DataCon -> SDoc # pprInfixOcc :: DataCon -> SDoc # bndrIsJoin_maybe :: DataCon -> Maybe Int #
Eq DataCon
Instance details Defined in GHC.Core.DataCon Methods (==) :: DataCon -> DataCon -> Bool # (/=) :: DataCon -> DataCon -> Bool #

type TidyOccEnv = UniqFM FastString Int #

type OccSet = UniqSet OccName #

data OccEnv a #

Instances

Instances details

Data a => Data (OccEnv a)
Instance details 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)
Instance details Defined in GHC.Types.Name.Occurrence Methods ppr :: OccEnv a -> SDoc #

data NameSpace #

Instances

Instances details

Binary NameSpace
Instance details Defined in GHC.Types.Name.Occurrence Methods put_ :: BinHandle -> NameSpace -> IO () # put :: BinHandle -> NameSpace -> IO (Bin NameSpace) # get :: BinHandle -> IO NameSpace #
Eq NameSpace
Instance details Defined in GHC.Types.Name.Occurrence Methods (==) :: NameSpace -> NameSpace -> Bool # (/=) :: NameSpace -> NameSpace -> Bool #
Ord NameSpace
Instance details Defined in GHC.Types.Name.Occurrence Methods compare :: NameSpace -> NameSpace -> Ordering # (<) :: NameSpace -> NameSpace -> Bool # (<=) :: NameSpace -> NameSpace -> Bool # (>) :: NameSpace -> NameSpace -> Bool # (>=) :: NameSpace -> NameSpace -> Bool # max :: NameSpace -> NameSpace -> NameSpace # min :: NameSpace -> NameSpace -> NameSpace #

data PlatformMisc #

Platform-specific settings formerly hard-coded in Config.hs.

These should probably be all be triaged whether they can be computed from other settings or belong in another another place (like Platform above).

Constructors

PlatformMisc
Fields platformMisc_targetPlatformString :: String platformMisc_ghcWithInterpreter :: Bool platformMisc_libFFI :: Bool platformMisc_llvmTarget :: String

data BuiltInSyntax #

BuiltInSyntax is for things like (:), [] and tuples, which have special syntactic forms. They aren't in scope as such.

Constructors

BuiltInSyntax
UserSyntax

type PiTyVarBinder = PiTyBinder #

PiTyVarBinder is like PiTyBinder, but there can only be Var in the Named field.

data PiTyBinder #

A PiTyBinder represents an argument to a function. PiTyBinders can be dependent (Named) or nondependent (Anon). They may also be visible or not. See Note [PiTyBinders]

Constructors

Named ForAllTyBinder
Anon (Scaled Type) FunTyFlag

Instances

Instances details

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

type ReqTVBinder = VarBndr TyVar () #

type TyVarBinder = VarBndr TyVar ForAllTyFlag #

type ReqTyBinder = VarBndr TyCoVar () #

type InvisTyBinder = VarBndr TyCoVar Specificity #

type ForAllTyBinder = VarBndr TyCoVar ForAllTyFlag #

Variable Binder

A ForAllTyBinder is the binder of a ForAllTy It's convenient to define this synonym here rather its natural home in GHC.Core.TyCo.Rep, because it's used in GHC.Core.DataCon.hs-boot

A TyVarBinder is a binder with only TyVar

type OutId = Id #

type OutCoVar = CoVar #

type OutTyVar = TyVar #

type OutVar = Var #

type InId = Id #

type InCoVar = CoVar #

type InTyVar = TyVar #

type InVar = Var #

type JoinId = Id #

type EqVar = EvId #

Equality Variable

type IpId = EvId #

Implicit parameter Identifier

type DictId = EvId #

Dictionary Identifier

type DFunId = Id #

Dictionary Function Identifier

type EvVar = EvId #

Evidence Variable

type EvId = Id #

Evidence Identifier

type KindVar = Var #

Kind Variable

type TypeVar = Var #

Type Variable

type TKVar = Var #

Type or Kind Variable

type NcId = Id #

type CoVar = Id #

Coercion Variable

type DTyCoVarSet = UniqDSet TyCoVar #

Deterministic Type or Coercion Variable Set

type DTyVarSet = UniqDSet TyVar #

Deterministic Type Variable Set

type DIdSet = UniqDSet Id #

Deterministic Identifier Set

type DVarSet = UniqDSet Var #

Deterministic Variable Set

type TyCoVarSet = UniqSet TyCoVar #

Type or Coercion Variable Set

type CoVarSet = UniqSet CoVar #

Coercion Variable Set

type TyVarSet = UniqSet TyVar #

Type Variable Set

type IdSet = UniqSet Id #

Identifier Set

type VarSet = UniqSet Var #

A non-deterministic Variable Set

A non-deterministic set of variables. See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM for explanation why it's not deterministic and why it matters. Use DVarSet if the set eventually gets converted into a list or folded over in a way where the order changes the generated code, for example when abstracting variables.

type InterestingVarFun = Var -> Bool #

Predicate on possible free variables: returns True iff the variable is interesting

type DTyVarEnv elt = UniqDFM TyVar elt #

Deterministic Type Variable Environment

type DIdEnv elt = UniqDFM Var elt #

Deterministic Identifier Environment Sadly not always indexed by Id, but it is in the common case.

type DVarEnv elt = UniqDFM Var elt #

Deterministic Variable Environment

type CoVarEnv elt = UniqFM CoVar elt #

Coercion Variable Environment

type TyCoVarEnv elt = UniqFM TyCoVar elt #

Type or Coercion Variable Environment

type TyVarEnv elt = UniqFM Var elt #

Type Variable Environment

type IdEnv elt = UniqFM Id elt #

Identifier Environment

type VarEnv elt = UniqFM Var elt #

Variable Environment

type TidyEnv = (TidyOccEnv, VarEnv Var) #

Tidy Environment

When tidying up print names, we keep a mapping of in-scope occ-names (the TidyOccEnv) and a Var-to-Var of the current renamings

data RnEnv2 #

Rename Environment 2

When we are comparing (or matching) types or terms, we are faced with "going under" corresponding binders. E.g. when comparing:

\x. e1     ~   \y. e2

Basically we want to rename [x -> y] or [y -> x], but there are lots of things we must be careful of. In particular, x might be free in e2, or y in e1. So the idea is that we come up with a fresh binder that is free in neither, and rename x and y respectively. That means we must maintain:

A renaming for the left-hand expression
A renaming for the right-hand expressions
An in-scope set

Furthermore, when matching, we want to be able to have an 'occurs check', to prevent:

\x. f   ~   \y. y

matching with [f -> y]. So for each expression we want to know that set of locally-bound variables. That is precisely the domain of the mappings 1. and 2., but we must ensure that we always extend the mappings as we go in.

All of this information is bundled up in the RnEnv2

newtype InScopeSet #

A set of variables that are in scope at some point.

Note that this is a superset of the variables that are currently in scope. See Note [The InScopeSet invariant].

"Secrets of the Glasgow Haskell Compiler inliner" Section 3.2 provides the motivation for this abstraction.

Constructors

InScope VarSet

Instances

Instances details

Outputable InScopeSet
Instance details Defined in GHC.Types.Var.Env Methods ppr :: InScopeSet -> SDoc #

newtype NonCaffySet #

Ids which have no CAF references. This is a result of analysis of C--. It is always safe to use an empty NonCaffySet. TODO Refer to Note.

Constructors

NonCaffySet
Fields ncs_nameSet :: NameSet

Instances

Instances details

Monoid NonCaffySet
Instance details Defined in GHC.Types.Name.Set Methods mempty :: NonCaffySet # mappend :: NonCaffySet -> NonCaffySet -> NonCaffySet # mconcat :: [NonCaffySet] -> NonCaffySet #
Semigroup NonCaffySet
Instance details Defined in GHC.Types.Name.Set Methods (<>) :: NonCaffySet -> NonCaffySet -> NonCaffySet # sconcat :: NonEmpty NonCaffySet -> NonCaffySet # stimes :: Integral b => b -> NonCaffySet -> NonCaffySet #

type DefUses = OrdList DefUse #

A number of DefUses in dependency order: earlier Defs scope over later Uses In a single (def, use) pair, the defs also scope over the uses

type DefUse = (Maybe Defs, Uses) #

(Just ds, us) => The use of any member of the ds implies that all the us are used too. Also, us may mention ds.

Nothing => Nothing is defined in this group, but nevertheless all the uses are essential. Used for instance declarations, for example

type Uses = NameSet #

A set of names that are used somewhere

type Defs = NameSet #

A set of names that are defined somewhere

type FreeVars = NameSet #

type NameSet = UniqSet Name #

type DNameEnv a = UniqDFM Name a #

Deterministic Name Environment

See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM for explanation why we need DNameEnv.

type NameEnv a = UniqFM Name a #

Name Environment

data GreName #

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

Instances details

Data GreName
Instance details 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
Instance details Defined in GHC.Types.Avail Methods rnf :: GreName -> () #
HasOccName GreName
Instance details Defined in GHC.Types.Avail Methods occName :: GreName -> OccName #
Binary GreName
Instance details Defined in GHC.Types.Avail Methods put_ :: BinHandle -> GreName -> IO () # put :: BinHandle -> GreName -> IO (Bin GreName) # get :: BinHandle -> IO GreName #
Outputable GreName
Instance details Defined in GHC.Types.Avail Methods ppr :: GreName -> SDoc #
Eq GreName
Instance details Defined in GHC.Types.Avail Methods (==) :: GreName -> GreName -> Bool # (/=) :: GreName -> GreName -> Bool #
Ord GreName
Instance details Defined in GHC.Types.Avail Methods compare :: GreName -> GreName -> Ordering # (<) :: GreName -> GreName -> Bool # (<=) :: GreName -> GreName -> Bool # (>) :: GreName -> GreName -> Bool # (>=) :: GreName -> GreName -> Bool # max :: GreName -> GreName -> GreName # min :: GreName -> GreName -> 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 is_explicit field is True iff the thing was named explicitly in the import specs rather than being imported as part of a "..." group. Consider:

import C( T(..) )

Here the constructors of T are not named explicitly; only T is named explicitly.

Fields

is_explicit :: Bool
is_iloc :: SrcSpan

Instances

Instances details

Data ImpItemSpec
Instance details 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
Instance details Defined in GHC.Types.Name.Reader Methods (==) :: ImpItemSpec -> ImpItemSpec -> Bool # (/=) :: ImpItemSpec -> ImpItemSpec -> Bool #

data ImpDeclSpec #

Import Declaration Specification

Describes a particular import declaration and is shared among all the Provenances for that decl

Constructors

ImpDeclSpec
Fields is_mod :: ModuleName Module imported, e.g. `import Muggle` Note the `Muggle` may well not be the defining module for this thing! is_as :: ModuleName Import alias, e.g. from `as M` (or `Muggle` if there is no `as` clause) is_qual :: Bool Was this import qualified? is_dloc :: SrcSpan The location of the entire import declaration

Instances

Instances details

Data ImpDeclSpec
Instance details 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
Instance details Defined in GHC.Types.Name.Reader Methods (==) :: ImpDeclSpec -> ImpDeclSpec -> Bool # (/=) :: ImpDeclSpec -> ImpDeclSpec -> Bool #

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 is_decl :: ImpDeclSpec is_item :: ImpItemSpec

Instances

Instances details

Data ImportSpec
Instance details 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
Instance details Defined in GHC.Types.Name.Reader Methods ppr :: ImportSpec -> SDoc #
Eq ImportSpec
Instance details Defined in GHC.Types.Name.Reader Methods (==) :: ImportSpec -> ImportSpec -> Bool # (/=) :: ImportSpec -> ImportSpec -> Bool #

data Parent #

See Note [Parents]

Constructors

NoParent
ParentIs
Fields par_is :: Name

Instances

Instances details

Data Parent
Instance details 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
Instance details Defined in GHC.Types.Name.Reader Methods ppr :: Parent -> SDoc #
Eq Parent
Instance details Defined in GHC.Types.Name.Reader Methods (==) :: Parent -> Parent -> Bool # (/=) :: Parent -> Parent -> Bool #

data GlobalRdrElt #

Global Reader Element

An element of the GlobalRdrEnv

Constructors

GRE
Fields gre_name :: !GreName See Note [GreNames] gre_par :: !Parent See Note [Parents] gre_lcl :: !Bool True = the thing was defined locally gre_imp :: !(Bag ImportSpec) In scope through these imports

Instances

Instances details

Data GlobalRdrElt
Instance details 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
Instance details Defined in GHC.Types.Name.Reader Methods occName :: GlobalRdrElt -> OccName #
Outputable GlobalRdrElt
Instance details 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

Instances details

Outputable LocalRdrEnv
Instance details Defined in GHC.Types.Name.Reader Methods ppr :: LocalRdrEnv -> SDoc #

type SrcSpanAnnA = SrcAnn AnnListItem #

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.

Constructors

SrcSpanAnn
Fields ann :: !a locA :: !SrcSpan

Instances

Instances details

Data a => Data (SrcSpanAnn' a)
Instance details Defined in GHC.Parser.Annotation Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcSpanAnn' a -> c (SrcSpanAnn' a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (SrcSpanAnn' a) # toConstr :: SrcSpanAnn' a -> Constr # dataTypeOf :: SrcSpanAnn' a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (SrcSpanAnn' a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SrcSpanAnn' a)) # gmapT :: (forall b. Data b => b -> b) -> SrcSpanAnn' a -> SrcSpanAnn' a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcSpanAnn' a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SrcSpanAnn' a -> r # gmapQ :: (forall d. Data d => d -> u) -> SrcSpanAnn' a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcSpanAnn' a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SrcSpanAnn' a -> m (SrcSpanAnn' a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcSpanAnn' a -> m (SrcSpanAnn' a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcSpanAnn' a -> m (SrcSpanAnn' a) #
Semigroup an => Semigroup (SrcSpanAnn' an)
Instance details Defined in GHC.Parser.Annotation Methods (<>) :: SrcSpanAnn' an -> SrcSpanAnn' an -> SrcSpanAnn' an # sconcat :: NonEmpty (SrcSpanAnn' an) -> SrcSpanAnn' an # stimes :: Integral b => b -> SrcSpanAnn' an -> SrcSpanAnn' an #
Outputable a => Outputable (SrcSpanAnn' a)
Instance details Defined in GHC.Parser.Annotation Methods ppr :: SrcSpanAnn' a -> SDoc #
Eq a => Eq (SrcSpanAnn' a)
Instance details Defined in GHC.Parser.Annotation Methods (==) :: SrcSpanAnn' a -> SrcSpanAnn' a -> Bool # (/=) :: SrcSpanAnn' a -> SrcSpanAnn' a -> Bool #
NamedThing (Located a) => NamedThing (LocatedAn an a)
Instance details Defined in GHC.Parser.Annotation Methods getOccName :: LocatedAn an a -> OccName # getName :: LocatedAn an a -> Name #
(Outputable a, Outputable e) => Outputable (GenLocated (SrcSpanAnn' a) e)
Instance details Defined in GHC.Parser.Annotation Methods ppr :: GenLocated (SrcSpanAnn' a) e -> SDoc #
(Outputable a, OutputableBndr e) => OutputableBndr (GenLocated (SrcSpanAnn' a) e)
Instance details Defined in GHC.Parser.Annotation Methods pprBndr :: BindingSite -> GenLocated (SrcSpanAnn' a) e -> SDoc # pprPrefixOcc :: GenLocated (SrcSpanAnn' a) e -> SDoc # pprInfixOcc :: GenLocated (SrcSpanAnn' a) e -> SDoc # bndrIsJoin_maybe :: GenLocated (SrcSpanAnn' a) e -> Maybe Int #
type Anno (LocatedA (IE (GhcPass p)))
Instance details Defined in GHC.Hs.ImpExp type Anno (LocatedA (IE (GhcPass p))) = SrcSpanAnnA
type Anno (LocatedN Name)
Instance details Defined in GHC.Hs.Binds type Anno (LocatedN Name) = SrcSpan
type Anno (LocatedN RdrName)
Instance details Defined in GHC.Hs.Binds type Anno (LocatedN RdrName) = SrcSpan
type Anno (LocatedN Id)
Instance details Defined in GHC.Hs.Binds type Anno (LocatedN Id) = SrcSpan
type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))] = SrcSpanAnnL
type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))] = SrcSpanAnnL
type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))]
Instance details Defined in GHC.Parser.PostProcess type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))]
Instance details Defined in GHC.Parser.Types type Anno [LocatedA (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL
type Anno [LocatedA (IE (GhcPass p))]
Instance details Defined in GHC.Hs.ImpExp type Anno [LocatedA (IE (GhcPass p))] = SrcSpanAnnL
type Anno [LocatedA (ConDeclField (GhcPass _1))]
Instance details Defined in GHC.Hs.Decls type Anno [LocatedA (ConDeclField (GhcPass _1))] = SrcSpanAnnL
type Anno [LocatedA (HsType (GhcPass p))]
Instance details Defined in GHC.Hs.Type type Anno [LocatedA (HsType (GhcPass p))] = SrcSpanAnnC
type Anno [LocatedN Name]
Instance details Defined in GHC.Hs.Binds type Anno [LocatedN Name] = SrcSpan
type Anno [LocatedN RdrName]
Instance details Defined in GHC.Hs.Binds type Anno [LocatedN RdrName] = SrcSpan
type Anno [LocatedN Id]
Instance details Defined in GHC.Hs.Binds type Anno [LocatedN Id] = SrcSpan
type Anno (FamEqn p (LocatedA (HsType p)))
Instance details Defined in GHC.Hs.Decls type Anno (FamEqn p (LocatedA (HsType p))) = SrcSpanAnnA
type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p))))
Instance details Defined in GHC.Hs.Expr type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcAnn NoEpAnns
type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p))))
Instance details Defined in GHC.Hs.Expr type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcAnn NoEpAnns
type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs)))
Instance details Defined in GHC.Parser.PostProcess type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs))) = SrcAnn NoEpAnns
type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))
Instance details Defined in GHC.Hs.Expr type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcSpanAnnA
type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))
Instance details Defined in GHC.Hs.Expr type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpanAnnA
type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs)))
Instance details Defined in GHC.Parser.PostProcess type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA
type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))
Instance details Defined in GHC.Hs.Expr type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr)))) = SrcSpanAnnA
type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))
Instance details Defined in GHC.Parser.PostProcess type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA
type Anno (StmtLR GhcRn GhcRn (LocatedA (body GhcRn)))
Instance details Defined in GHC.Hs.Expr type Anno (StmtLR GhcRn GhcRn (LocatedA (body GhcRn))) = SrcSpanAnnA

type OutputableBndrId (pass :: Pass) = (OutputableBndr (IdGhcP pass), OutputableBndr (IdGhcP (NoGhcTcPass pass)), Outputable (GenLocated (Anno (IdGhcP pass)) (IdGhcP pass)), Outputable (GenLocated (Anno (IdGhcP (NoGhcTcPass pass))) (IdGhcP (NoGhcTcPass pass))), IsPass pass) #

Constraint type to bundle up the requirement for OutputableBndr on both the id and the NoGhcTc of it. See Note [NoGhcTc].

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

Equations

NoGhcTcPass 'Typechecked = 'Renamed
NoGhcTcPass other = other

type family IdGhcP (pass :: Pass) where ... #

Maps the "normal" id type for a given GHC pass

Equations

IdGhcP 'Parsed = RdrName
IdGhcP 'Renamed = Name
IdGhcP 'Typechecked = Id

class (NoGhcTcPass (NoGhcTcPass p) ~ NoGhcTcPass p, IsPass (NoGhcTcPass p)) => IsPass (p :: Pass) where #

Allows us to check what phase we're in at GHC's runtime. For example, this class allows us to write > f :: forall p. IsPass p => HsExpr (GhcPass p) -> blah > f e = case ghcPass @p of > GhcPs -> ... in this RHS we have HsExpr GhcPs... > GhcRn -> ... in this RHS we have HsExpr GhcRn... > GhcTc -> ... in this RHS we have HsExpr GhcTc... which is very useful, for example, when pretty-printing. See Note [IsPass].

Methods

ghcPass :: GhcPass p #

Instances

Instances details

IsPass 'Parsed
Instance details Defined in GHC.Hs.Extension Methods ghcPass :: GhcPass 'Parsed #
IsPass 'Renamed
Instance details Defined in GHC.Hs.Extension Methods ghcPass :: GhcPass 'Renamed #
IsPass 'Typechecked
Instance details Defined in GHC.Hs.Extension Methods ghcPass :: GhcPass 'Typechecked #

type GhcTc = GhcPass 'Typechecked #

type GhcRn = GhcPass 'Renamed #

type GhcPs = GhcPass 'Parsed #

data Pass #

Constructors

Parsed
Renamed
Typechecked

Instances

Instances details

Data Pass

Instance details

Defined in GHC.Hs.Extension

Methods

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

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

toConstr :: Pass -> Constr #

dataTypeOf :: Pass -> DataType #

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

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

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

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

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

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

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

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

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

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

data GhcPass (c :: Pass) where #

Used as a data type index for the hsSyn AST; also serves as a singleton type for Pass

Constructors

GhcPs :: GhcPass 'Parsed
GhcRn :: GhcPass 'Renamed
GhcTc :: GhcPass 'Typechecked

Instances

Instances details

Typeable p => Data (GhcPass p)
Instance details Defined in GHC.Hs.Extension Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GhcPass p -> c (GhcPass p) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GhcPass p) # toConstr :: GhcPass p -> Constr # dataTypeOf :: GhcPass p -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GhcPass p)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GhcPass p)) # gmapT :: (forall b. Data b => b -> b) -> GhcPass p -> GhcPass p # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GhcPass p -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GhcPass p -> r # gmapQ :: (forall d. Data d => d -> u) -> GhcPass p -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> GhcPass p -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> GhcPass p -> m (GhcPass p) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GhcPass p -> m (GhcPass p) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GhcPass p -> m (GhcPass p) #
Typeable p => Data (LayoutInfo (GhcPass p))
Instance details Defined in GHC.Hs.Extension Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> 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)) #
DisambECP (PatBuilder GhcPs)
Instance details Defined in GHC.Parser.PostProcess Associated Types type Body (PatBuilder GhcPs) :: Type -> Type # type InfixOp (PatBuilder GhcPs) # type FunArg (PatBuilder GhcPs) # Methods ecpFromCmd' :: LHsCmd GhcPs -> PV (LocatedA (PatBuilder GhcPs)) # ecpFromExp' :: LHsExpr GhcPs -> PV (LocatedA (PatBuilder GhcPs)) # mkHsProjUpdatePV :: SrcSpan -> Located [LocatedAn NoEpAnns (DotFieldOcc GhcPs)] -> LocatedA (PatBuilder GhcPs) -> Bool -> [AddEpAnn] -> PV (LHsRecProj GhcPs (LocatedA (PatBuilder GhcPs))) # mkHsLamPV :: SrcSpan -> (EpAnnComments -> MatchGroup GhcPs (LocatedA (PatBuilder GhcPs))) -> PV (LocatedA (PatBuilder GhcPs)) # mkHsLetPV :: SrcSpan -> LHsToken "let" GhcPs -> HsLocalBinds GhcPs -> LHsToken "in" GhcPs -> LocatedA (PatBuilder GhcPs) -> PV (LocatedA (PatBuilder GhcPs)) # superInfixOp :: (DisambInfixOp (InfixOp (PatBuilder GhcPs)) => PV (LocatedA (PatBuilder GhcPs))) -> PV (LocatedA (PatBuilder GhcPs)) # mkHsOpAppPV :: SrcSpan -> LocatedA (PatBuilder GhcPs) -> LocatedN (InfixOp (PatBuilder GhcPs)) -> LocatedA (PatBuilder GhcPs) -> PV (LocatedA (PatBuilder GhcPs)) # mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> LocatedL [LMatch GhcPs (LocatedA (PatBuilder GhcPs))] -> EpAnnHsCase -> PV (LocatedA (PatBuilder GhcPs)) # mkHsLamCasePV :: SrcSpan -> LamCaseVariant -> LocatedL [LMatch GhcPs (LocatedA (PatBuilder GhcPs))] -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs)) # superFunArg :: (DisambECP (FunArg (PatBuilder GhcPs)) => PV (LocatedA (PatBuilder GhcPs))) -> PV (LocatedA (PatBuilder GhcPs)) # mkHsAppPV :: SrcSpanAnnA -> LocatedA (PatBuilder GhcPs) -> LocatedA (FunArg (PatBuilder GhcPs)) -> PV (LocatedA (PatBuilder GhcPs)) # mkHsAppTypePV :: SrcSpanAnnA -> LocatedA (PatBuilder GhcPs) -> LHsToken "@" GhcPs -> LHsType GhcPs -> PV (LocatedA (PatBuilder GhcPs)) # mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> LocatedA (PatBuilder GhcPs) -> Bool -> LocatedA (PatBuilder GhcPs) -> AnnsIf -> PV (LocatedA (PatBuilder GhcPs)) # mkHsDoPV :: SrcSpan -> Maybe ModuleName -> LocatedL [LStmt GhcPs (LocatedA (PatBuilder GhcPs))] -> AnnList -> PV (LocatedA (PatBuilder GhcPs)) # mkHsParPV :: SrcSpan -> LHsToken "(" GhcPs -> LocatedA (PatBuilder GhcPs) -> LHsToken ")" GhcPs -> PV (LocatedA (PatBuilder GhcPs)) # mkHsVarPV :: LocatedN RdrName -> PV (LocatedA (PatBuilder GhcPs)) # mkHsLitPV :: Located (HsLit GhcPs) -> PV (Located (PatBuilder GhcPs)) # mkHsOverLitPV :: LocatedAn a (HsOverLit GhcPs) -> PV (LocatedAn a (PatBuilder GhcPs)) # mkHsWildCardPV :: SrcSpan -> PV (Located (PatBuilder GhcPs)) # mkHsTySigPV :: SrcSpanAnnA -> LocatedA (PatBuilder GhcPs) -> LHsType GhcPs -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs)) # mkHsExplicitListPV :: SrcSpan -> [LocatedA (PatBuilder GhcPs)] -> AnnList -> PV (LocatedA (PatBuilder GhcPs)) # mkHsSplicePV :: Located (HsUntypedSplice GhcPs) -> PV (Located (PatBuilder GhcPs)) # mkHsRecordPV :: Bool -> SrcSpan -> SrcSpan -> LocatedA (PatBuilder GhcPs) -> ([Fbind (PatBuilder GhcPs)], Maybe SrcSpan) -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs)) # mkHsNegAppPV :: SrcSpan -> LocatedA (PatBuilder GhcPs) -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs)) # mkHsSectionR_PV :: SrcSpan -> LocatedA (InfixOp (PatBuilder GhcPs)) -> LocatedA (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs)) # mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> LocatedA (PatBuilder GhcPs) -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs)) # mkHsAsPatPV :: SrcSpan -> LocatedN RdrName -> LHsToken "@" GhcPs -> LocatedA (PatBuilder GhcPs) -> PV (LocatedA (PatBuilder GhcPs)) # mkHsLazyPatPV :: SrcSpan -> LocatedA (PatBuilder GhcPs) -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs)) # mkHsBangPatPV :: SrcSpan -> LocatedA (PatBuilder GhcPs) -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs)) # mkSumOrTuplePV :: SrcSpanAnnA -> Boxity -> SumOrTuple (PatBuilder GhcPs) -> [AddEpAnn] -> PV (LocatedA (PatBuilder GhcPs)) # rejectPragmaPV :: LocatedA (PatBuilder GhcPs) -> PV () #
DisambECP (HsCmd GhcPs)
Instance details Defined in GHC.Parser.PostProcess Associated Types type Body (HsCmd GhcPs) :: Type -> Type # type InfixOp (HsCmd GhcPs) # type FunArg (HsCmd GhcPs) # Methods ecpFromCmd' :: LHsCmd GhcPs -> PV (LocatedA (HsCmd GhcPs)) # ecpFromExp' :: LHsExpr GhcPs -> PV (LocatedA (HsCmd GhcPs)) # mkHsProjUpdatePV :: SrcSpan -> Located [LocatedAn NoEpAnns (DotFieldOcc GhcPs)] -> LocatedA (HsCmd GhcPs) -> Bool -> [AddEpAnn] -> PV (LHsRecProj GhcPs (LocatedA (HsCmd GhcPs))) # mkHsLamPV :: SrcSpan -> (EpAnnComments -> MatchGroup GhcPs (LocatedA (HsCmd GhcPs))) -> PV (LocatedA (HsCmd GhcPs)) # mkHsLetPV :: SrcSpan -> LHsToken "let" GhcPs -> HsLocalBinds GhcPs -> LHsToken "in" GhcPs -> LocatedA (HsCmd GhcPs) -> PV (LocatedA (HsCmd GhcPs)) # superInfixOp :: (DisambInfixOp (InfixOp (HsCmd GhcPs)) => PV (LocatedA (HsCmd GhcPs))) -> PV (LocatedA (HsCmd GhcPs)) # mkHsOpAppPV :: SrcSpan -> LocatedA (HsCmd GhcPs) -> LocatedN (InfixOp (HsCmd GhcPs)) -> LocatedA (HsCmd GhcPs) -> PV (LocatedA (HsCmd GhcPs)) # mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> LocatedL [LMatch GhcPs (LocatedA (HsCmd GhcPs))] -> EpAnnHsCase -> PV (LocatedA (HsCmd GhcPs)) # mkHsLamCasePV :: SrcSpan -> LamCaseVariant -> LocatedL [LMatch GhcPs (LocatedA (HsCmd GhcPs))] -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs)) # superFunArg :: (DisambECP (FunArg (HsCmd GhcPs)) => PV (LocatedA (HsCmd GhcPs))) -> PV (LocatedA (HsCmd GhcPs)) # mkHsAppPV :: SrcSpanAnnA -> LocatedA (HsCmd GhcPs) -> LocatedA (FunArg (HsCmd GhcPs)) -> PV (LocatedA (HsCmd GhcPs)) # mkHsAppTypePV :: SrcSpanAnnA -> LocatedA (HsCmd GhcPs) -> LHsToken "@" GhcPs -> LHsType GhcPs -> PV (LocatedA (HsCmd GhcPs)) # mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> LocatedA (HsCmd GhcPs) -> Bool -> LocatedA (HsCmd GhcPs) -> AnnsIf -> PV (LocatedA (HsCmd GhcPs)) # mkHsDoPV :: SrcSpan -> Maybe ModuleName -> LocatedL [LStmt GhcPs (LocatedA (HsCmd GhcPs))] -> AnnList -> PV (LocatedA (HsCmd GhcPs)) # mkHsParPV :: SrcSpan -> LHsToken "(" GhcPs -> LocatedA (HsCmd GhcPs) -> LHsToken ")" GhcPs -> PV (LocatedA (HsCmd GhcPs)) # mkHsVarPV :: LocatedN RdrName -> PV (LocatedA (HsCmd GhcPs)) # mkHsLitPV :: Located (HsLit GhcPs) -> PV (Located (HsCmd GhcPs)) # mkHsOverLitPV :: LocatedAn a (HsOverLit GhcPs) -> PV (LocatedAn a (HsCmd GhcPs)) # mkHsWildCardPV :: SrcSpan -> PV (Located (HsCmd GhcPs)) # mkHsTySigPV :: SrcSpanAnnA -> LocatedA (HsCmd GhcPs) -> LHsType GhcPs -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs)) # mkHsExplicitListPV :: SrcSpan -> [LocatedA (HsCmd GhcPs)] -> AnnList -> PV (LocatedA (HsCmd GhcPs)) # mkHsSplicePV :: Located (HsUntypedSplice GhcPs) -> PV (Located (HsCmd GhcPs)) # mkHsRecordPV :: Bool -> SrcSpan -> SrcSpan -> LocatedA (HsCmd GhcPs) -> ([Fbind (HsCmd GhcPs)], Maybe SrcSpan) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs)) # mkHsNegAppPV :: SrcSpan -> LocatedA (HsCmd GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs)) # mkHsSectionR_PV :: SrcSpan -> LocatedA (InfixOp (HsCmd GhcPs)) -> LocatedA (HsCmd GhcPs) -> PV (Located (HsCmd GhcPs)) # mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> LocatedA (HsCmd GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs)) # mkHsAsPatPV :: SrcSpan -> LocatedN RdrName -> LHsToken "@" GhcPs -> LocatedA (HsCmd GhcPs) -> PV (LocatedA (HsCmd GhcPs)) # mkHsLazyPatPV :: SrcSpan -> LocatedA (HsCmd GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs)) # mkHsBangPatPV :: SrcSpan -> LocatedA (HsCmd GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs)) # mkSumOrTuplePV :: SrcSpanAnnA -> Boxity -> SumOrTuple (HsCmd GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs)) # rejectPragmaPV :: LocatedA (HsCmd GhcPs) -> PV () #
DisambECP (HsExpr GhcPs)
Instance details Defined in GHC.Parser.PostProcess Associated Types type Body (HsExpr GhcPs) :: Type -> Type # type InfixOp (HsExpr GhcPs) # type FunArg (HsExpr GhcPs) # Methods ecpFromCmd' :: LHsCmd GhcPs -> PV (LocatedA (HsExpr GhcPs)) # ecpFromExp' :: LHsExpr GhcPs -> PV (LocatedA (HsExpr GhcPs)) # mkHsProjUpdatePV :: SrcSpan -> Located [LocatedAn NoEpAnns (DotFieldOcc GhcPs)] -> LocatedA (HsExpr GhcPs) -> Bool -> [AddEpAnn] -> PV (LHsRecProj GhcPs (LocatedA (HsExpr GhcPs))) # mkHsLamPV :: SrcSpan -> (EpAnnComments -> MatchGroup GhcPs (LocatedA (HsExpr GhcPs))) -> PV (LocatedA (HsExpr GhcPs)) # mkHsLetPV :: SrcSpan -> LHsToken "let" GhcPs -> HsLocalBinds GhcPs -> LHsToken "in" GhcPs -> LocatedA (HsExpr GhcPs) -> PV (LocatedA (HsExpr GhcPs)) # superInfixOp :: (DisambInfixOp (InfixOp (HsExpr GhcPs)) => PV (LocatedA (HsExpr GhcPs))) -> PV (LocatedA (HsExpr GhcPs)) # mkHsOpAppPV :: SrcSpan -> LocatedA (HsExpr GhcPs) -> LocatedN (InfixOp (HsExpr GhcPs)) -> LocatedA (HsExpr GhcPs) -> PV (LocatedA (HsExpr GhcPs)) # mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> LocatedL [LMatch GhcPs (LocatedA (HsExpr GhcPs))] -> EpAnnHsCase -> PV (LocatedA (HsExpr GhcPs)) # mkHsLamCasePV :: SrcSpan -> LamCaseVariant -> LocatedL [LMatch GhcPs (LocatedA (HsExpr GhcPs))] -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) # superFunArg :: (DisambECP (FunArg (HsExpr GhcPs)) => PV (LocatedA (HsExpr GhcPs))) -> PV (LocatedA (HsExpr GhcPs)) # mkHsAppPV :: SrcSpanAnnA -> LocatedA (HsExpr GhcPs) -> LocatedA (FunArg (HsExpr GhcPs)) -> PV (LocatedA (HsExpr GhcPs)) # mkHsAppTypePV :: SrcSpanAnnA -> LocatedA (HsExpr GhcPs) -> LHsToken "@" GhcPs -> LHsType GhcPs -> PV (LocatedA (HsExpr GhcPs)) # mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> LocatedA (HsExpr GhcPs) -> Bool -> LocatedA (HsExpr GhcPs) -> AnnsIf -> PV (LocatedA (HsExpr GhcPs)) # mkHsDoPV :: SrcSpan -> Maybe ModuleName -> LocatedL [LStmt GhcPs (LocatedA (HsExpr GhcPs))] -> AnnList -> PV (LocatedA (HsExpr GhcPs)) # mkHsParPV :: SrcSpan -> LHsToken "(" GhcPs -> LocatedA (HsExpr GhcPs) -> LHsToken ")" GhcPs -> PV (LocatedA (HsExpr GhcPs)) # mkHsVarPV :: LocatedN RdrName -> PV (LocatedA (HsExpr GhcPs)) # mkHsLitPV :: Located (HsLit GhcPs) -> PV (Located (HsExpr GhcPs)) # mkHsOverLitPV :: LocatedAn a (HsOverLit GhcPs) -> PV (LocatedAn a (HsExpr GhcPs)) # mkHsWildCardPV :: SrcSpan -> PV (Located (HsExpr GhcPs)) # mkHsTySigPV :: SrcSpanAnnA -> LocatedA (HsExpr GhcPs) -> LHsType GhcPs -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) # mkHsExplicitListPV :: SrcSpan -> [LocatedA (HsExpr GhcPs)] -> AnnList -> PV (LocatedA (HsExpr GhcPs)) # mkHsSplicePV :: Located (HsUntypedSplice GhcPs) -> PV (Located (HsExpr GhcPs)) # mkHsRecordPV :: Bool -> SrcSpan -> SrcSpan -> LocatedA (HsExpr GhcPs) -> ([Fbind (HsExpr GhcPs)], Maybe SrcSpan) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) # mkHsNegAppPV :: SrcSpan -> LocatedA (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) # mkHsSectionR_PV :: SrcSpan -> LocatedA (InfixOp (HsExpr GhcPs)) -> LocatedA (HsExpr GhcPs) -> PV (Located (HsExpr GhcPs)) # mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> LocatedA (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) # mkHsAsPatPV :: SrcSpan -> LocatedN RdrName -> LHsToken "@" GhcPs -> LocatedA (HsExpr GhcPs) -> PV (LocatedA (HsExpr GhcPs)) # mkHsLazyPatPV :: SrcSpan -> LocatedA (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) # mkHsBangPatPV :: SrcSpan -> LocatedA (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) # mkSumOrTuplePV :: SrcSpanAnnA -> Boxity -> SumOrTuple (HsExpr GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsExpr GhcPs)) # rejectPragmaPV :: LocatedA (HsExpr GhcPs) -> PV () #
DisambInfixOp (HsExpr GhcPs)
Instance details Defined in GHC.Parser.PostProcess Methods mkHsVarOpPV :: LocatedN RdrName -> PV (LocatedN (HsExpr GhcPs)) # mkHsConOpPV :: LocatedN RdrName -> PV (LocatedN (HsExpr GhcPs)) # mkHsInfixHolePV :: SrcSpan -> (EpAnnComments -> EpAnn EpAnnUnboundVar) -> PV (Located (HsExpr GhcPs)) #
DisambTD (HsType GhcPs)
Instance details Defined in GHC.Parser.PostProcess Methods mkHsAppTyHeadPV :: LHsType GhcPs -> PV (LocatedA (HsType GhcPs)) # mkHsAppTyPV :: LocatedA (HsType GhcPs) -> LHsType GhcPs -> PV (LocatedA (HsType GhcPs)) # mkHsAppKindTyPV :: LocatedA (HsType GhcPs) -> SrcSpan -> LHsType GhcPs -> PV (LocatedA (HsType GhcPs)) # mkHsOpTyPV :: PromotionFlag -> LHsType GhcPs -> LocatedN RdrName -> LHsType GhcPs -> PV (LocatedA (HsType GhcPs)) # mkUnpackednessPV :: Located UnpackednessPragma -> LocatedA (HsType GhcPs) -> PV (LocatedA (HsType GhcPs)) #
Binary (WarningTxt GhcRn)
Instance details Defined in GHC.Unit.Module.Warnings Methods put_ :: BinHandle -> WarningTxt GhcRn -> IO () # put :: BinHandle -> WarningTxt GhcRn -> IO (Bin (WarningTxt GhcRn)) # get :: BinHandle -> IO (WarningTxt GhcRn) #
Binary (Warnings GhcRn)
Instance details Defined in GHC.Unit.Module.Warnings Methods put_ :: BinHandle -> Warnings GhcRn -> IO () # put :: BinHandle -> Warnings GhcRn -> IO (Bin (Warnings GhcRn)) # get :: BinHandle -> IO (Warnings GhcRn) #
Outputable (PatBuilder GhcPs)
Instance details Defined in GHC.Parser.Types Methods ppr :: PatBuilder GhcPs -> SDoc #
OutputableBndrId a => Outputable (InstInfo (GhcPass a))
Instance details Defined in GHC.Tc.Utils.Env Methods ppr :: InstInfo (GhcPass a) -> SDoc #
MapXRec (GhcPass p)
Instance details Defined in GHC.Hs.Extension Methods mapXRec :: Anno a ~ Anno b => (a -> b) -> XRec (GhcPass p) a -> XRec (GhcPass p) b #
UnXRec (GhcPass p)
Instance details Defined in GHC.Hs.Extension Methods unXRec :: XRec (GhcPass p) a -> a #
Binary a => Binary (WithHsDocIdentifiers a GhcRn)
Instance details Defined in GHC.Hs.Doc Methods put_ :: BinHandle -> WithHsDocIdentifiers a GhcRn -> IO () # put :: BinHandle -> WithHsDocIdentifiers a GhcRn -> IO (Bin (WithHsDocIdentifiers a GhcRn)) # get :: BinHandle -> IO (WithHsDocIdentifiers a GhcRn) #
type ImportDeclPkgQual GhcPs
Instance details Defined in GHC.Hs.ImpExp type ImportDeclPkgQual GhcPs = RawPkgQual
type ImportDeclPkgQual GhcRn
Instance details Defined in GHC.Hs.ImpExp type ImportDeclPkgQual GhcRn = PkgQual
type ImportDeclPkgQual GhcTc
Instance details Defined in GHC.Hs.ImpExp type ImportDeclPkgQual GhcTc = PkgQual
type XAmbiguous GhcPs
Instance details Defined in GHC.Hs.Type type XAmbiguous GhcPs = NoExtField
type XAmbiguous GhcRn
Instance details Defined in GHC.Hs.Type type XAmbiguous GhcRn = NoExtField
type XAmbiguous GhcTc
Instance details Defined in GHC.Hs.Type type XAmbiguous GhcTc = Id
type XAnyClassStrategy GhcPs
Instance details Defined in GHC.Hs.Decls type XAnyClassStrategy GhcPs = EpAnn [AddEpAnn]
type XAnyClassStrategy GhcRn
Instance details Defined in GHC.Hs.Decls type XAnyClassStrategy GhcRn = NoExtField
type XAnyClassStrategy GhcTc
Instance details Defined in GHC.Hs.Decls type XAnyClassStrategy GhcTc = NoExtField
type XAppTypeE GhcPs
Instance details Defined in GHC.Hs.Expr type XAppTypeE GhcPs = NoExtField
type XAppTypeE GhcRn
Instance details Defined in GHC.Hs.Expr type XAppTypeE GhcRn = NoExtField
type XAppTypeE GhcTc
Instance details Defined in GHC.Hs.Expr type XAppTypeE GhcTc = Type
type XApplicativeArgOne GhcPs
Instance details Defined in GHC.Hs.Expr type XApplicativeArgOne GhcPs = NoExtField
type XApplicativeArgOne GhcRn
Instance details Defined in GHC.Hs.Expr type XApplicativeArgOne GhcRn = FailOperator GhcRn
type XApplicativeArgOne GhcTc
Instance details Defined in GHC.Hs.Expr type XApplicativeArgOne GhcTc = FailOperator GhcTc
type XArithSeq GhcPs
Instance details Defined in GHC.Hs.Expr type XArithSeq GhcPs = EpAnn [AddEpAnn]
type XArithSeq GhcRn
Instance details Defined in GHC.Hs.Expr type XArithSeq GhcRn = NoExtField
type XArithSeq GhcTc
Instance details Defined in GHC.Hs.Expr type XArithSeq GhcTc = PostTcExpr
type XAsPat GhcPs
Instance details Defined in GHC.Hs.Pat type XAsPat GhcPs = EpAnnCO
type XAsPat GhcRn
Instance details Defined in GHC.Hs.Pat type XAsPat GhcRn = NoExtField
type XAsPat GhcTc
Instance details Defined in GHC.Hs.Pat type XAsPat GhcTc = NoExtField
type XBangPat GhcPs
Instance details Defined in GHC.Hs.Pat type XBangPat GhcPs = EpAnn [AddEpAnn]
type XBangPat GhcRn
Instance details Defined in GHC.Hs.Pat type XBangPat GhcRn = NoExtField
type XBangPat GhcTc
Instance details Defined in GHC.Hs.Pat type XBangPat GhcTc = NoExtField
type XCClsInstDecl GhcPs
Instance details Defined in GHC.Hs.Decls type XCClsInstDecl GhcPs = (EpAnn [AddEpAnn], AnnSortKey)
type XCClsInstDecl GhcRn
Instance details Defined in GHC.Hs.Decls type XCClsInstDecl GhcRn = NoExtField
type XCClsInstDecl GhcTc
Instance details Defined in GHC.Hs.Decls type XCClsInstDecl GhcTc = NoExtField
type XCDefaultDecl GhcPs
Instance details Defined in GHC.Hs.Decls type XCDefaultDecl GhcPs = EpAnn [AddEpAnn]
type XCDefaultDecl GhcRn
Instance details Defined in GHC.Hs.Decls type XCDefaultDecl GhcRn = NoExtField
type XCDefaultDecl GhcTc
Instance details Defined in GHC.Hs.Decls type XCDefaultDecl GhcTc = NoExtField
type XCFieldOcc GhcPs
Instance details Defined in GHC.Hs.Type type XCFieldOcc GhcPs = NoExtField
type XCFieldOcc GhcRn
Instance details Defined in GHC.Hs.Type type XCFieldOcc GhcRn = Name
type XCFieldOcc GhcTc
Instance details Defined in GHC.Hs.Type type XCFieldOcc GhcTc = Id
type XCIPBind GhcPs
Instance details Defined in GHC.Hs.Binds type XCIPBind GhcPs = EpAnn [AddEpAnn]
type XCIPBind GhcRn
Instance details Defined in GHC.Hs.Binds type XCIPBind GhcRn = NoExtField
type XCIPBind GhcTc
Instance details Defined in GHC.Hs.Binds type XCIPBind GhcTc = Id
type XCImportDecl GhcPs
Instance details Defined in GHC.Hs.ImpExp type XCImportDecl GhcPs = XImportDeclPass
type XCImportDecl GhcRn
Instance details Defined in GHC.Hs.ImpExp type XCImportDecl GhcRn = XImportDeclPass
type XCImportDecl GhcTc
Instance details Defined in GHC.Hs.ImpExp type XCImportDecl GhcTc = DataConCantHappen
type XCModule GhcPs
Instance details Defined in GHC.Hs type XCModule GhcPs = XModulePs
type XCModule GhcRn
Instance details Defined in GHC.Hs type XCModule GhcRn = DataConCantHappen
type XCModule GhcTc
Instance details Defined in GHC.Hs type XCModule GhcTc = DataConCantHappen
type XCRoleAnnotDecl GhcPs
Instance details Defined in GHC.Hs.Decls type XCRoleAnnotDecl GhcPs = EpAnn [AddEpAnn]
type XCRoleAnnotDecl GhcRn
Instance details Defined in GHC.Hs.Decls type XCRoleAnnotDecl GhcRn = NoExtField
type XCRoleAnnotDecl GhcTc
Instance details Defined in GHC.Hs.Decls type XCRoleAnnotDecl GhcTc = NoExtField
type XCRuleDecls GhcPs
Instance details Defined in GHC.Hs.Decls type XCRuleDecls GhcPs = (EpAnn [AddEpAnn], SourceText)
type XCRuleDecls GhcRn
Instance details Defined in GHC.Hs.Decls type XCRuleDecls GhcRn = SourceText
type XCRuleDecls GhcTc
Instance details Defined in GHC.Hs.Decls type XCRuleDecls GhcTc = SourceText
type XCase GhcPs
Instance details Defined in GHC.Hs.Expr type XCase GhcPs = EpAnn EpAnnHsCase
type XCase GhcRn
Instance details Defined in GHC.Hs.Expr type XCase GhcRn = NoExtField
type XCase GhcTc
Instance details Defined in GHC.Hs.Expr type XCase GhcTc = NoExtField
type XClassDecl GhcPs
Instance details Defined in GHC.Hs.Decls type XClassDecl GhcPs = (EpAnn [AddEpAnn], AnnSortKey)
type XClassDecl GhcRn
Instance details Defined in GHC.Hs.Decls type XClassDecl GhcRn = NameSet
type XClassDecl GhcTc
Instance details Defined in GHC.Hs.Decls type XClassDecl GhcTc = NameSet
type XCmdArrApp GhcPs
Instance details Defined in GHC.Hs.Expr type XCmdArrApp GhcPs = EpAnn AddEpAnn
type XCmdArrApp GhcRn
Instance details Defined in GHC.Hs.Expr type XCmdArrApp GhcRn = NoExtField
type XCmdArrApp GhcTc
Instance details Defined in GHC.Hs.Expr type XCmdArrApp GhcTc = Type
type XCmdArrForm GhcPs
Instance details Defined in GHC.Hs.Expr type XCmdArrForm GhcPs = EpAnn AnnList
type XCmdArrForm GhcRn
Instance details Defined in GHC.Hs.Expr type XCmdArrForm GhcRn = NoExtField
type XCmdArrForm GhcTc
Instance details Defined in GHC.Hs.Expr type XCmdArrForm GhcTc = NoExtField
type XCmdCase GhcPs
Instance details Defined in GHC.Hs.Expr type XCmdCase GhcPs = EpAnn EpAnnHsCase
type XCmdCase GhcRn
Instance details Defined in GHC.Hs.Expr type XCmdCase GhcRn = NoExtField
type XCmdCase GhcTc
Instance details Defined in GHC.Hs.Expr type XCmdCase GhcTc = NoExtField
type XCmdDo GhcPs
Instance details Defined in GHC.Hs.Expr type XCmdDo GhcPs = EpAnn AnnList
type XCmdDo GhcRn
Instance details Defined in GHC.Hs.Expr type XCmdDo GhcRn = NoExtField
type XCmdDo GhcTc
Instance details Defined in GHC.Hs.Expr type XCmdDo GhcTc = Type
type XCmdIf GhcPs
Instance details Defined in GHC.Hs.Expr type XCmdIf GhcPs = EpAnn AnnsIf
type XCmdIf GhcRn
Instance details Defined in GHC.Hs.Expr type XCmdIf GhcRn = NoExtField
type XCmdIf GhcTc
Instance details Defined in GHC.Hs.Expr type XCmdIf GhcTc = NoExtField
type XCmdLet GhcPs
Instance details Defined in GHC.Hs.Expr type XCmdLet GhcPs = EpAnnCO
type XCmdLet GhcRn
Instance details Defined in GHC.Hs.Expr type XCmdLet GhcRn = NoExtField
type XCmdLet GhcTc
Instance details Defined in GHC.Hs.Expr type XCmdLet GhcTc = NoExtField
type XCmdTop GhcPs
Instance details Defined in GHC.Hs.Expr type XCmdTop GhcPs = NoExtField
type XCmdTop GhcRn
Instance details Defined in GHC.Hs.Expr type XCmdTop GhcRn = CmdSyntaxTable GhcRn
type XCmdTop GhcTc
Instance details Defined in GHC.Hs.Expr type XCmdTop GhcTc = CmdTopTc
type XConPat GhcPs
Instance details Defined in GHC.Hs.Pat type XConPat GhcPs = EpAnn [AddEpAnn]
type XConPat GhcRn
Instance details Defined in GHC.Hs.Pat type XConPat GhcRn = NoExtField
type XConPat GhcTc
Instance details Defined in GHC.Hs.Pat type XConPat GhcTc = ConPatTc
type XDataDecl GhcPs
Instance details Defined in GHC.Hs.Decls type XDataDecl GhcPs = EpAnn [AddEpAnn]
type XDataDecl GhcRn
Instance details Defined in GHC.Hs.Decls type XDataDecl GhcRn = DataDeclRn
type XDataDecl GhcTc
Instance details Defined in GHC.Hs.Decls type XDataDecl GhcTc = DataDeclRn
type XDecBrG GhcPs
Instance details Defined in GHC.Hs.Expr type XDecBrG GhcPs = NoExtField
type XDecBrG GhcRn
Instance details Defined in GHC.Hs.Expr type XDecBrG GhcRn = NoExtField
type XDecBrG GhcTc
Instance details Defined in GHC.Hs.Expr type XDecBrG GhcTc = DataConCantHappen
type XDecBrL GhcPs
Instance details Defined in GHC.Hs.Expr type XDecBrL GhcPs = NoExtField
type XDecBrL GhcRn
Instance details Defined in GHC.Hs.Expr type XDecBrL GhcRn = NoExtField
type XDecBrL GhcTc
Instance details Defined in GHC.Hs.Expr type XDecBrL GhcTc = DataConCantHappen
type XDo GhcPs
Instance details Defined in GHC.Hs.Expr type XDo GhcPs = EpAnn AnnList
type XDo GhcRn
Instance details Defined in GHC.Hs.Expr type XDo GhcRn = NoExtField
type XDo GhcTc
Instance details Defined in GHC.Hs.Expr type XDo GhcTc = Type
type XExpBr GhcPs
Instance details Defined in GHC.Hs.Expr type XExpBr GhcPs = NoExtField
type XExpBr GhcRn
Instance details Defined in GHC.Hs.Expr type XExpBr GhcRn = NoExtField
type XExpBr GhcTc
Instance details Defined in GHC.Hs.Expr type XExpBr GhcTc = DataConCantHappen
type XExplicitList GhcPs
Instance details Defined in GHC.Hs.Expr type XExplicitList GhcPs = EpAnn AnnList
type XExplicitList GhcRn
Instance details Defined in GHC.Hs.Expr type XExplicitList GhcRn = NoExtField
type XExplicitList GhcTc
Instance details Defined in GHC.Hs.Expr type XExplicitList GhcTc = Type
type XExplicitListTy GhcPs
Instance details Defined in GHC.Hs.Type type XExplicitListTy GhcPs = EpAnn [AddEpAnn]
type XExplicitListTy GhcRn
Instance details Defined in GHC.Hs.Type type XExplicitListTy GhcRn = NoExtField
type XExplicitListTy GhcTc
Instance details Defined in GHC.Hs.Type type XExplicitListTy GhcTc = Kind
type XExplicitSum GhcPs
Instance details Defined in GHC.Hs.Expr type XExplicitSum GhcPs = EpAnn AnnExplicitSum
type XExplicitSum GhcRn
Instance details Defined in GHC.Hs.Expr type XExplicitSum GhcRn = NoExtField
type XExplicitSum GhcTc
Instance details Defined in GHC.Hs.Expr type XExplicitSum GhcTc = [Type]
type XExplicitTuple GhcPs
Instance details Defined in GHC.Hs.Expr type XExplicitTuple GhcPs = EpAnn [AddEpAnn]
type XExplicitTuple GhcRn
Instance details Defined in GHC.Hs.Expr type XExplicitTuple GhcRn = NoExtField
type XExplicitTuple GhcTc
Instance details Defined in GHC.Hs.Expr type XExplicitTuple GhcTc = NoExtField
type XExplicitTupleTy GhcPs
Instance details Defined in GHC.Hs.Type type XExplicitTupleTy GhcPs = EpAnn [AddEpAnn]
type XExplicitTupleTy GhcRn
Instance details Defined in GHC.Hs.Type type XExplicitTupleTy GhcRn = NoExtField
type XExplicitTupleTy GhcTc
Instance details Defined in GHC.Hs.Type type XExplicitTupleTy GhcTc = [Kind]
type XExprWithTySig GhcPs
Instance details Defined in GHC.Hs.Expr type XExprWithTySig GhcPs = EpAnn [AddEpAnn]
type XExprWithTySig GhcRn
Instance details Defined in GHC.Hs.Expr type XExprWithTySig GhcRn = NoExtField
type XExprWithTySig GhcTc
Instance details Defined in GHC.Hs.Expr type XExprWithTySig GhcTc = NoExtField
type XForeignExport GhcPs
Instance details Defined in GHC.Hs.Decls type XForeignExport GhcPs = EpAnn [AddEpAnn]
type XForeignExport GhcRn
Instance details Defined in GHC.Hs.Decls type XForeignExport GhcRn = NoExtField
type XForeignExport GhcTc
Instance details Defined in GHC.Hs.Decls type XForeignExport GhcTc = Coercion
type XForeignImport GhcPs
Instance details Defined in GHC.Hs.Decls type XForeignImport GhcPs = EpAnn [AddEpAnn]
type XForeignImport GhcRn
Instance details Defined in GHC.Hs.Decls type XForeignImport GhcRn = NoExtField
type XForeignImport GhcTc
Instance details Defined in GHC.Hs.Decls type XForeignImport GhcTc = Coercion
type XGetField GhcPs
Instance details Defined in GHC.Hs.Expr type XGetField GhcPs = EpAnnCO
type XGetField GhcRn
Instance details Defined in GHC.Hs.Expr type XGetField GhcRn = NoExtField
type XGetField GhcTc
Instance details Defined in GHC.Hs.Expr type XGetField GhcTc = DataConCantHappen
type XHsOuterImplicit GhcPs
Instance details Defined in GHC.Hs.Type type XHsOuterImplicit GhcPs = NoExtField
type XHsOuterImplicit GhcRn
Instance details Defined in GHC.Hs.Type type XHsOuterImplicit GhcRn = [Name]
type XHsOuterImplicit GhcTc
Instance details Defined in GHC.Hs.Type type XHsOuterImplicit GhcTc = [TyVar]
type XHsPS GhcPs
Instance details Defined in GHC.Hs.Type type XHsPS GhcPs = EpAnnCO
type XHsPS GhcRn
Instance details Defined in GHC.Hs.Type type XHsPS GhcRn = HsPSRn
type XHsPS GhcTc
Instance details Defined in GHC.Hs.Type type XHsPS GhcTc = HsPSRn
type XHsQTvs GhcPs
Instance details Defined in GHC.Hs.Type type XHsQTvs GhcPs = NoExtField
type XHsQTvs GhcRn
Instance details Defined in GHC.Hs.Type type XHsQTvs GhcRn = HsQTvsRn
type XHsQTvs GhcTc
Instance details Defined in GHC.Hs.Type type XHsQTvs GhcTc = HsQTvsRn
type XHsRule GhcPs
Instance details Defined in GHC.Hs.Decls type XHsRule GhcPs = (EpAnn HsRuleAnn, SourceText)
type XHsRule GhcRn
Instance details Defined in GHC.Hs.Decls type XHsRule GhcRn = (HsRuleRn, SourceText)
type XHsRule GhcTc
Instance details Defined in GHC.Hs.Decls type XHsRule GhcTc = (HsRuleRn, SourceText)
type XIEModuleContents GhcPs
Instance details Defined in GHC.Hs.ImpExp type XIEModuleContents GhcPs = EpAnn [AddEpAnn]
type XIEModuleContents GhcRn
Instance details Defined in GHC.Hs.ImpExp type XIEModuleContents GhcRn = NoExtField
type XIEModuleContents GhcTc
Instance details Defined in GHC.Hs.ImpExp type XIEModuleContents GhcTc = NoExtField
type XIEVar GhcPs
Instance details Defined in GHC.Hs.ImpExp type XIEVar GhcPs = NoExtField
type XIEVar GhcRn
Instance details Defined in GHC.Hs.ImpExp type XIEVar GhcRn = NoExtField
type XIEVar GhcTc
Instance details Defined in GHC.Hs.ImpExp type XIEVar GhcTc = NoExtField
type XIPBinds GhcPs
Instance details Defined in GHC.Hs.Binds type XIPBinds GhcPs = NoExtField
type XIPBinds GhcRn
Instance details Defined in GHC.Hs.Binds type XIPBinds GhcRn = NoExtField
type XIPBinds GhcTc
Instance details Defined in GHC.Hs.Binds type XIPBinds GhcTc = TcEvBinds
type XIPVar GhcPs
Instance details Defined in GHC.Hs.Expr type XIPVar GhcPs = EpAnnCO
type XIPVar GhcRn
Instance details Defined in GHC.Hs.Expr type XIPVar GhcRn = EpAnnCO
type XIPVar GhcTc
Instance details Defined in GHC.Hs.Expr type XIPVar GhcTc = DataConCantHappen
type XIf GhcPs
Instance details Defined in GHC.Hs.Expr type XIf GhcPs = EpAnn AnnsIf
type XIf GhcRn
Instance details Defined in GHC.Hs.Expr type XIf GhcRn = NoExtField
type XIf GhcTc
Instance details Defined in GHC.Hs.Expr type XIf GhcTc = NoExtField
type XLazyPat GhcPs
Instance details Defined in GHC.Hs.Pat type XLazyPat GhcPs = EpAnn [AddEpAnn]
type XLazyPat GhcRn
Instance details Defined in GHC.Hs.Pat type XLazyPat GhcRn = NoExtField
type XLazyPat GhcTc
Instance details Defined in GHC.Hs.Pat type XLazyPat GhcTc = NoExtField
type XLet GhcPs
Instance details Defined in GHC.Hs.Expr type XLet GhcPs = EpAnnCO
type XLet GhcRn
Instance details Defined in GHC.Hs.Expr type XLet GhcRn = NoExtField
type XLet GhcTc
Instance details Defined in GHC.Hs.Expr type XLet GhcTc = NoExtField
type XListPat GhcPs
Instance details Defined in GHC.Hs.Pat type XListPat GhcPs = EpAnn AnnList
type XListPat GhcRn
Instance details Defined in GHC.Hs.Pat type XListPat GhcRn = NoExtField
type XListPat GhcTc
Instance details Defined in GHC.Hs.Pat type XListPat GhcTc = Type
type XMissing GhcPs
Instance details Defined in GHC.Hs.Expr type XMissing GhcPs = EpAnn EpaLocation
type XMissing GhcRn
Instance details Defined in GHC.Hs.Expr type XMissing GhcRn = NoExtField
type XMissing GhcTc
Instance details Defined in GHC.Hs.Expr type XMissing GhcTc = Scaled Type
type XMultiIf GhcPs
Instance details Defined in GHC.Hs.Expr type XMultiIf GhcPs = EpAnn [AddEpAnn]
type XMultiIf GhcRn
Instance details Defined in GHC.Hs.Expr type XMultiIf GhcRn = NoExtField
type XMultiIf GhcTc
Instance details Defined in GHC.Hs.Expr type XMultiIf GhcTc = Type
type XNPat GhcPs
Instance details Defined in GHC.Hs.Pat type XNPat GhcPs = EpAnn [AddEpAnn]
type XNPat GhcRn
Instance details Defined in GHC.Hs.Pat type XNPat GhcRn = EpAnn [AddEpAnn]
type XNPat GhcTc
Instance details Defined in GHC.Hs.Pat type XNPat GhcTc = Type
type XNPlusKPat GhcPs
Instance details Defined in GHC.Hs.Pat type XNPlusKPat GhcPs = EpAnn EpaLocation
type XNPlusKPat GhcRn
Instance details Defined in GHC.Hs.Pat type XNPlusKPat GhcRn = NoExtField
type XNPlusKPat GhcTc
Instance details Defined in GHC.Hs.Pat type XNPlusKPat GhcTc = Type
type XNegApp GhcPs
Instance details Defined in GHC.Hs.Expr type XNegApp GhcPs = EpAnn [AddEpAnn]
type XNegApp GhcRn
Instance details Defined in GHC.Hs.Expr type XNegApp GhcRn = NoExtField
type XNegApp GhcTc
Instance details Defined in GHC.Hs.Expr type XNegApp GhcTc = NoExtField
type XNewtypeStrategy GhcPs
Instance details Defined in GHC.Hs.Decls type XNewtypeStrategy GhcPs = EpAnn [AddEpAnn]
type XNewtypeStrategy GhcRn
Instance details Defined in GHC.Hs.Decls type XNewtypeStrategy GhcRn = NoExtField
type XNewtypeStrategy GhcTc
Instance details Defined in GHC.Hs.Decls type XNewtypeStrategy GhcTc = NoExtField
type XOpApp GhcPs
Instance details Defined in GHC.Hs.Expr type XOpApp GhcPs = EpAnn [AddEpAnn]
type XOpApp GhcRn
Instance details Defined in GHC.Hs.Expr type XOpApp GhcRn = Fixity
type XOpApp GhcTc
Instance details Defined in GHC.Hs.Expr type XOpApp GhcTc = DataConCantHappen
type XOverLabel GhcPs
Instance details Defined in GHC.Hs.Expr type XOverLabel GhcPs = EpAnnCO
type XOverLabel GhcRn
Instance details Defined in GHC.Hs.Expr type XOverLabel GhcRn = EpAnnCO
type XOverLabel GhcTc
Instance details Defined in GHC.Hs.Expr type XOverLabel GhcTc = DataConCantHappen
type XOverLit GhcPs
Instance details Defined in GHC.Hs.Lit type XOverLit GhcPs = NoExtField
type XOverLit GhcRn
Instance details Defined in GHC.Hs.Lit type XOverLit GhcRn = OverLitRn
type XOverLit GhcTc
Instance details Defined in GHC.Hs.Lit type XOverLit GhcTc = OverLitTc
type XPatBr GhcPs
Instance details Defined in GHC.Hs.Expr type XPatBr GhcPs = NoExtField
type XPatBr GhcRn
Instance details Defined in GHC.Hs.Expr type XPatBr GhcRn = NoExtField
type XPatBr GhcTc
Instance details Defined in GHC.Hs.Expr type XPatBr GhcTc = DataConCantHappen
type XProjection GhcPs
Instance details Defined in GHC.Hs.Expr type XProjection GhcPs = EpAnn AnnProjection
type XProjection GhcRn
Instance details Defined in GHC.Hs.Expr type XProjection GhcRn = NoExtField
type XProjection GhcTc
Instance details Defined in GHC.Hs.Expr type XProjection GhcTc = DataConCantHappen
type XRecSel GhcPs
Instance details Defined in GHC.Hs.Expr type XRecSel GhcPs = DataConCantHappen
type XRecSel GhcRn
Instance details Defined in GHC.Hs.Expr type XRecSel GhcRn = NoExtField
type XRecSel GhcTc
Instance details Defined in GHC.Hs.Expr type XRecSel GhcTc = NoExtField
type XRecTy GhcPs
Instance details Defined in GHC.Hs.Type type XRecTy GhcPs = EpAnn AnnList
type XRecTy GhcRn
Instance details Defined in GHC.Hs.Type type XRecTy GhcRn = NoExtField
type XRecTy GhcTc
Instance details Defined in GHC.Hs.Type type XRecTy GhcTc = NoExtField
type XRecordCon GhcPs
Instance details Defined in GHC.Hs.Expr type XRecordCon GhcPs = EpAnn [AddEpAnn]
type XRecordCon GhcRn
Instance details Defined in GHC.Hs.Expr type XRecordCon GhcRn = NoExtField
type XRecordCon GhcTc
Instance details Defined in GHC.Hs.Expr type XRecordCon GhcTc = PostTcExpr
type XRecordUpd GhcPs
Instance details Defined in GHC.Hs.Expr type XRecordUpd GhcPs = EpAnn [AddEpAnn]
type XRecordUpd GhcRn
Instance details Defined in GHC.Hs.Expr type XRecordUpd GhcRn = NoExtField
type XRecordUpd GhcTc
Instance details Defined in GHC.Hs.Expr type XRecordUpd GhcTc = DataConCantHappen
type XSectionL GhcPs
Instance details Defined in GHC.Hs.Expr type XSectionL GhcPs = EpAnnCO
type XSectionL GhcRn
Instance details Defined in GHC.Hs.Expr type XSectionL GhcRn = EpAnnCO
type XSectionL GhcTc
Instance details Defined in GHC.Hs.Expr type XSectionL GhcTc = DataConCantHappen
type XSectionR GhcPs
Instance details Defined in GHC.Hs.Expr type XSectionR GhcPs = EpAnnCO
type XSectionR GhcRn
Instance details Defined in GHC.Hs.Expr type XSectionR GhcRn = EpAnnCO
type XSectionR GhcTc
Instance details Defined in GHC.Hs.Expr type XSectionR GhcTc = DataConCantHappen
type XSigPat GhcPs
Instance details Defined in GHC.Hs.Pat type XSigPat GhcPs = EpAnn [AddEpAnn]
type XSigPat GhcRn
Instance details Defined in GHC.Hs.Pat type XSigPat GhcRn = NoExtField
type XSigPat GhcTc
Instance details Defined in GHC.Hs.Pat type XSigPat GhcTc = Type
type XSplicePat GhcPs
Instance details Defined in GHC.Hs.Pat type XSplicePat GhcPs = NoExtField
type XSplicePat GhcRn
Instance details Defined in GHC.Hs.Pat type XSplicePat GhcRn = HsUntypedSpliceResult (Pat GhcRn)
type XSplicePat GhcTc
Instance details Defined in GHC.Hs.Pat type XSplicePat GhcTc = DataConCantHappen
type XSpliceTy GhcPs
Instance details Defined in GHC.Hs.Type type XSpliceTy GhcPs = NoExtField
type XSpliceTy GhcRn
Instance details Defined in GHC.Hs.Type type XSpliceTy GhcRn = HsUntypedSpliceResult (LHsType GhcRn)
type XSpliceTy GhcTc
Instance details Defined in GHC.Hs.Type type XSpliceTy GhcTc = Kind
type XStandaloneKindSig GhcPs
Instance details Defined in GHC.Hs.Decls type XStandaloneKindSig GhcPs = EpAnn [AddEpAnn]
type XStandaloneKindSig GhcRn
Instance details Defined in GHC.Hs.Decls type XStandaloneKindSig GhcRn = NoExtField
type XStandaloneKindSig GhcTc
Instance details Defined in GHC.Hs.Decls type XStandaloneKindSig GhcTc = NoExtField
type XStatic GhcPs
Instance details Defined in GHC.Hs.Expr type XStatic GhcPs = EpAnn [AddEpAnn]
type XStatic GhcRn
Instance details Defined in GHC.Hs.Expr type XStatic GhcRn = NameSet
type XStatic GhcTc
Instance details Defined in GHC.Hs.Expr type XStatic GhcTc = (NameSet, Type)
type XStockStrategy GhcPs
Instance details Defined in GHC.Hs.Decls type XStockStrategy GhcPs = EpAnn [AddEpAnn]
type XStockStrategy GhcRn
Instance details Defined in GHC.Hs.Decls type XStockStrategy GhcRn = NoExtField
type XStockStrategy GhcTc
Instance details Defined in GHC.Hs.Decls type XStockStrategy GhcTc = NoExtField
type XSumPat GhcPs
Instance details Defined in GHC.Hs.Pat type XSumPat GhcPs = EpAnn EpAnnSumPat
type XSumPat GhcRn
Instance details Defined in GHC.Hs.Pat type XSumPat GhcRn = NoExtField
type XSumPat GhcTc
Instance details Defined in GHC.Hs.Pat type XSumPat GhcTc = [Type]
type XSynDecl GhcPs
Instance details Defined in GHC.Hs.Decls type XSynDecl GhcPs = EpAnn [AddEpAnn]
type XSynDecl GhcRn
Instance details Defined in GHC.Hs.Decls type XSynDecl GhcRn = NameSet
type XSynDecl GhcTc
Instance details Defined in GHC.Hs.Decls type XSynDecl GhcTc = NameSet
type XTuplePat GhcPs
Instance details Defined in GHC.Hs.Pat type XTuplePat GhcPs = EpAnn [AddEpAnn]
type XTuplePat GhcRn
Instance details Defined in GHC.Hs.Pat type XTuplePat GhcRn = NoExtField
type XTuplePat GhcTc
Instance details Defined in GHC.Hs.Pat type XTuplePat GhcTc = [Type]
type XTyFamInstD GhcPs
Instance details Defined in GHC.Hs.Decls type XTyFamInstD GhcPs = NoExtField
type XTyFamInstD GhcRn
Instance details Defined in GHC.Hs.Decls type XTyFamInstD GhcRn = NoExtField
type XTyFamInstD GhcTc
Instance details Defined in GHC.Hs.Decls type XTyFamInstD GhcTc = NoExtField
type XTypBr GhcPs
Instance details Defined in GHC.Hs.Expr type XTypBr GhcPs = NoExtField
type XTypBr GhcRn
Instance details Defined in GHC.Hs.Expr type XTypBr GhcRn = NoExtField
type XTypBr GhcTc
Instance details Defined in GHC.Hs.Expr type XTypBr GhcTc = DataConCantHappen
type XTypedBracket GhcPs
Instance details Defined in GHC.Hs.Expr type XTypedBracket GhcPs = EpAnn [AddEpAnn]
type XTypedBracket GhcRn
Instance details Defined in GHC.Hs.Expr type XTypedBracket GhcRn = NoExtField
type XTypedBracket GhcTc
Instance details Defined in GHC.Hs.Expr type XTypedBracket GhcTc = HsBracketTc
type XTypedSplice GhcPs
Instance details Defined in GHC.Hs.Expr type XTypedSplice GhcPs = (EpAnnCO, EpAnn [AddEpAnn])
type XTypedSplice GhcRn
Instance details Defined in GHC.Hs.Expr type XTypedSplice GhcRn = SplicePointName
type XTypedSplice GhcTc
Instance details Defined in GHC.Hs.Expr type XTypedSplice GhcTc = DelayedSplice
type XUnambiguous GhcPs
Instance details Defined in GHC.Hs.Type type XUnambiguous GhcPs = NoExtField
type XUnambiguous GhcRn
Instance details Defined in GHC.Hs.Type type XUnambiguous GhcRn = Name
type XUnambiguous GhcTc
Instance details Defined in GHC.Hs.Type type XUnambiguous GhcTc = Id
type XUnboundVar GhcPs
Instance details Defined in GHC.Hs.Expr type XUnboundVar GhcPs = EpAnn EpAnnUnboundVar
type XUnboundVar GhcRn
Instance details Defined in GHC.Hs.Expr type XUnboundVar GhcRn = NoExtField
type XUnboundVar GhcTc
Instance details Defined in GHC.Hs.Expr type XUnboundVar GhcTc = HoleExprRef
type XUntypedBracket GhcPs
Instance details Defined in GHC.Hs.Expr type XUntypedBracket GhcPs = EpAnn [AddEpAnn]
type XUntypedBracket GhcRn
Instance details Defined in GHC.Hs.Expr type XUntypedBracket GhcRn = [PendingRnSplice]
type XUntypedBracket GhcTc
Instance details Defined in GHC.Hs.Expr type XUntypedBracket GhcTc = HsBracketTc
type XUntypedSplice GhcPs
Instance details Defined in GHC.Hs.Expr type XUntypedSplice GhcPs = EpAnnCO
type XUntypedSplice GhcRn
Instance details Defined in GHC.Hs.Expr type XUntypedSplice GhcRn = HsUntypedSpliceResult (HsExpr GhcRn)
type XUntypedSplice GhcTc
Instance details Defined in GHC.Hs.Expr type XUntypedSplice GhcTc = DataConCantHappen
type XUntypedSpliceExpr GhcPs
Instance details Defined in GHC.Hs.Expr type XUntypedSpliceExpr GhcPs = EpAnn [AddEpAnn]
type XUntypedSpliceExpr GhcRn
Instance details Defined in GHC.Hs.Expr type XUntypedSpliceExpr GhcRn = EpAnn [AddEpAnn]
type XUntypedSpliceExpr GhcTc
Instance details Defined in GHC.Hs.Expr type XUntypedSpliceExpr GhcTc = DataConCantHappen
type XVarBr GhcPs
Instance details Defined in GHC.Hs.Expr type XVarBr GhcPs = NoExtField
type XVarBr GhcRn
Instance details Defined in GHC.Hs.Expr type XVarBr GhcRn = NoExtField
type XVarBr GhcTc
Instance details Defined in GHC.Hs.Expr type XVarBr GhcTc = DataConCantHappen
type XViaStrategy GhcPs
Instance details Defined in GHC.Hs.Decls type XViaStrategy GhcPs = XViaStrategyPs
type XViaStrategy GhcRn
Instance details Defined in GHC.Hs.Decls type XViaStrategy GhcRn = LHsSigType GhcRn
type XViaStrategy GhcTc
Instance details Defined in GHC.Hs.Decls type XViaStrategy GhcTc = Type
type XViewPat GhcPs
Instance details Defined in GHC.Hs.Pat type XViewPat GhcPs = EpAnn [AddEpAnn]
type XViewPat GhcRn
Instance details Defined in GHC.Hs.Pat type XViewPat GhcRn = Maybe (HsExpr GhcRn)
type XViewPat GhcTc
Instance details Defined in GHC.Hs.Pat type XViewPat GhcTc = Type
type XWarnings GhcPs
Instance details Defined in GHC.Hs.Decls type XWarnings GhcPs = (EpAnn [AddEpAnn], SourceText)
type XWarnings GhcRn
Instance details Defined in GHC.Hs.Decls type XWarnings GhcRn = SourceText
type XWarnings GhcTc
Instance details Defined in GHC.Hs.Decls type XWarnings GhcTc = SourceText
type XWildPat GhcPs
Instance details Defined in GHC.Hs.Pat type XWildPat GhcPs = NoExtField
type XWildPat GhcRn
Instance details Defined in GHC.Hs.Pat type XWildPat GhcRn = NoExtField
type XWildPat GhcTc
Instance details Defined in GHC.Hs.Pat type XWildPat GhcTc = Type
type XXCmd GhcPs
Instance details Defined in GHC.Hs.Expr type XXCmd GhcPs = DataConCantHappen
type XXCmd GhcRn
Instance details Defined in GHC.Hs.Expr type XXCmd GhcRn = DataConCantHappen
type XXCmd GhcTc
Instance details Defined in GHC.Hs.Expr type XXCmd GhcTc = HsWrap HsCmd
type XXExpr GhcPs
Instance details Defined in GHC.Hs.Expr type XXExpr GhcPs = DataConCantHappen
type XXExpr GhcRn
Instance details Defined in GHC.Hs.Expr type XXExpr GhcRn = HsExpansion (HsExpr GhcRn) (HsExpr GhcRn)
type XXExpr GhcTc
Instance details Defined in GHC.Hs.Expr type XXExpr GhcTc = XXExprGhcTc
type XXPat GhcPs
Instance details Defined in GHC.Hs.Pat type XXPat GhcPs = DataConCantHappen
type XXPat GhcRn
Instance details Defined in GHC.Hs.Pat type XXPat GhcRn = HsPatExpansion (Pat GhcRn) (Pat GhcRn)
type XXPat GhcTc
Instance details Defined in GHC.Hs.Pat type XXPat GhcTc = XXPatGhcTc
type XXQuote GhcPs
Instance details Defined in GHC.Hs.Expr type XXQuote GhcPs = DataConCantHappen
type XXQuote GhcRn
Instance details Defined in GHC.Hs.Expr type XXQuote GhcRn = DataConCantHappen
type XXQuote GhcTc
Instance details Defined in GHC.Hs.Expr type XXQuote GhcTc = NoExtField
type XXSig GhcPs
Instance details Defined in GHC.Hs.Binds type XXSig GhcPs = DataConCantHappen
type XXSig GhcRn
Instance details Defined in GHC.Hs.Binds type XXSig GhcRn = IdSig
type XXSig GhcTc
Instance details Defined in GHC.Hs.Binds type XXSig GhcTc = IdSig
type ConLikeP GhcPs
Instance details Defined in GHC.Hs.Pat type ConLikeP GhcPs = RdrName
type ConLikeP GhcRn
Instance details Defined in GHC.Hs.Pat type ConLikeP GhcRn = Name
type ConLikeP GhcTc
Instance details Defined in GHC.Hs.Pat type ConLikeP GhcTc = ConLike
type XHsOuterExplicit GhcPs _1
Instance details Defined in GHC.Hs.Type type XHsOuterExplicit GhcPs _1 = EpAnnForallTy
type XHsOuterExplicit GhcRn _1
Instance details Defined in GHC.Hs.Type type XHsOuterExplicit GhcRn _1 = NoExtField
type XHsOuterExplicit GhcTc flag
Instance details Defined in GHC.Hs.Type type XHsOuterExplicit GhcTc flag = [VarBndr TyVar flag]
type XHsWC GhcPs b
Instance details Defined in GHC.Hs.Type type XHsWC GhcPs b = NoExtField
type XHsWC GhcRn b
Instance details Defined in GHC.Hs.Type type XHsWC GhcRn b = [Name]
type XHsWC GhcTc b
Instance details Defined in GHC.Hs.Type type XHsWC GhcTc b = [Name]
type XMG GhcPs b
Instance details Defined in GHC.Hs.Expr type XMG GhcPs b = Origin
type XMG GhcRn b
Instance details Defined in GHC.Hs.Expr type XMG GhcRn b = Origin
type XMG GhcTc b
Instance details Defined in GHC.Hs.Expr type XMG GhcTc b = MatchGroupTc
type XXHsBindsLR GhcPs pR
Instance details Defined in GHC.Hs.Binds type XXHsBindsLR GhcPs pR = DataConCantHappen
type XXHsBindsLR GhcRn pR
Instance details Defined in GHC.Hs.Binds type XXHsBindsLR GhcRn pR = DataConCantHappen
type XXHsBindsLR GhcTc pR
Instance details Defined in GHC.Hs.Binds type XXHsBindsLR GhcTc pR = AbsBinds
type XPatBind GhcPs (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XPatBind GhcPs (GhcPass pR) = EpAnn [AddEpAnn]
type XPatBind GhcRn (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XPatBind GhcRn (GhcPass pR) = NameSet
type XPatBind GhcTc (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XPatBind GhcTc (GhcPass pR) = (Type, ([CoreTickish], [[CoreTickish]]))
type Body (PatBuilder GhcPs)
Instance details Defined in GHC.Parser.PostProcess type Body (PatBuilder GhcPs) = PatBuilder
type Body (HsCmd GhcPs)
Instance details Defined in GHC.Parser.PostProcess type Body (HsCmd GhcPs) = HsCmd
type Body (HsExpr GhcPs)
Instance details Defined in GHC.Parser.PostProcess type Body (HsExpr GhcPs) = HsExpr
type FunArg (PatBuilder GhcPs)
Instance details Defined in GHC.Parser.PostProcess type FunArg (PatBuilder GhcPs) = PatBuilder GhcPs
type FunArg (HsCmd GhcPs)
Instance details Defined in GHC.Parser.PostProcess type FunArg (HsCmd GhcPs) = HsExpr GhcPs
type FunArg (HsExpr GhcPs)
Instance details Defined in GHC.Parser.PostProcess type FunArg (HsExpr GhcPs) = HsExpr GhcPs
type InfixOp (PatBuilder GhcPs)
Instance details Defined in GHC.Parser.PostProcess type InfixOp (PatBuilder GhcPs) = RdrName
type InfixOp (HsCmd GhcPs)
Instance details Defined in GHC.Parser.PostProcess type InfixOp (HsCmd GhcPs) = HsExpr GhcPs
type InfixOp (HsExpr GhcPs)
Instance details Defined in GHC.Parser.PostProcess type InfixOp (HsExpr GhcPs) = HsExpr GhcPs
type SyntaxExpr (GhcPass p)
Instance details Defined in GHC.Hs.Expr type SyntaxExpr (GhcPass p) = SyntaxExprGhc p
type Anno (LocatedA (IE (GhcPass p)))
Instance details Defined in GHC.Hs.ImpExp type Anno (LocatedA (IE (GhcPass p))) = SrcSpanAnnA
type Anno (FixitySig (GhcPass p))
Instance details Defined in GHC.Hs.Binds type Anno (FixitySig (GhcPass p)) = SrcSpanAnnA
type Anno (IPBind (GhcPass p))
Instance details Defined in GHC.Hs.Binds type Anno (IPBind (GhcPass p)) = SrcSpanAnnA
type Anno (Sig (GhcPass p))
Instance details Defined in GHC.Hs.Binds type Anno (Sig (GhcPass p)) = SrcSpanAnnA
type Anno (AnnDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (AnnDecl (GhcPass p)) = SrcSpanAnnA
type Anno (ClsInstDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (ClsInstDecl (GhcPass p)) = SrcSpanAnnA
type Anno (ConDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (ConDecl (GhcPass p)) = SrcSpanAnnA
type Anno (DataFamInstDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (DataFamInstDecl (GhcPass p)) = SrcSpanAnnA
type Anno (DefaultDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (DefaultDecl (GhcPass p)) = SrcSpanAnnA
type Anno (DerivClauseTys (GhcPass _1))
Instance details Defined in GHC.Hs.Decls type Anno (DerivClauseTys (GhcPass _1)) = SrcSpanAnnC
type Anno (DerivDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (DerivDecl (GhcPass p)) = SrcSpanAnnA
type Anno (DerivStrategy (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (DerivStrategy (GhcPass p)) = SrcAnn NoEpAnns
type Anno (DocDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (DocDecl (GhcPass p)) = SrcSpanAnnA
type Anno (FamilyDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (FamilyDecl (GhcPass p)) = SrcSpanAnnA
type Anno (FamilyResultSig (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (FamilyResultSig (GhcPass p)) = SrcAnn NoEpAnns
type Anno (ForeignDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (ForeignDecl (GhcPass p)) = SrcSpanAnnA
type Anno (FunDep (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (FunDep (GhcPass p)) = SrcSpanAnnA
type Anno (HsDecl (GhcPass _1))
Instance details Defined in GHC.Hs.Decls type Anno (HsDecl (GhcPass _1)) = SrcSpanAnnA
type Anno (HsDerivingClause (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (HsDerivingClause (GhcPass p)) = SrcAnn NoEpAnns
type Anno (InjectivityAnn (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (InjectivityAnn (GhcPass p)) = SrcAnn NoEpAnns
type Anno (InstDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (InstDecl (GhcPass p)) = SrcSpanAnnA
type Anno (RoleAnnotDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (RoleAnnotDecl (GhcPass p)) = SrcSpanAnnA
type Anno (RuleBndr (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (RuleBndr (GhcPass p)) = SrcAnn NoEpAnns
type Anno (RuleDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (RuleDecl (GhcPass p)) = SrcSpanAnnA
type Anno (RuleDecls (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (RuleDecls (GhcPass p)) = SrcSpanAnnA
type Anno (SpliceDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (SpliceDecl (GhcPass p)) = SrcSpanAnnA
type Anno (StandaloneKindSig (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (StandaloneKindSig (GhcPass p)) = SrcSpanAnnA
type Anno (TyClDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (TyClDecl (GhcPass p)) = SrcSpanAnnA
type Anno (TyFamInstDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (TyFamInstDecl (GhcPass p)) = SrcSpanAnnA
type Anno (WarnDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (WarnDecl (GhcPass p)) = SrcSpanAnnA
type Anno (WarnDecls (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (WarnDecls (GhcPass p)) = SrcSpanAnnA
type Anno (DotFieldOcc (GhcPass p))
Instance details Defined in GHC.Hs.Expr type Anno (DotFieldOcc (GhcPass p)) = SrcAnn NoEpAnns
type Anno (FieldLabelStrings (GhcPass p))
Instance details Defined in GHC.Hs.Expr type Anno (FieldLabelStrings (GhcPass p)) = SrcAnn NoEpAnns
type Anno (HsCmd (GhcPass p))
Instance details Defined in GHC.Hs.Expr type Anno (HsCmd (GhcPass p)) = SrcSpanAnnA
type Anno (HsCmdTop (GhcPass p))
Instance details Defined in GHC.Hs.Expr type Anno (HsCmdTop (GhcPass p)) = SrcAnn NoEpAnns
type Anno (HsExpr (GhcPass p))
Instance details Defined in GHC.Hs.Expr type Anno (HsExpr (GhcPass p)) = SrcSpanAnnA
type Anno (HsUntypedSplice (GhcPass p))
Instance details Defined in GHC.Hs.Expr type Anno (HsUntypedSplice (GhcPass p)) = SrcSpanAnnA
type Anno (IE (GhcPass p))
Instance details Defined in GHC.Hs.ImpExp type Anno (IE (GhcPass p)) = SrcSpanAnnA
type Anno (IEWrappedName (GhcPass _1))
Instance details Defined in GHC.Hs.ImpExp type Anno (IEWrappedName (GhcPass _1)) = SrcSpanAnnA
type Anno (ImportDecl (GhcPass p))
Instance details Defined in GHC.Hs.ImpExp type Anno (ImportDecl (GhcPass p)) = SrcSpanAnnA
type Anno (HsOverLit (GhcPass p))
Instance details Defined in GHC.Hs.Pat type Anno (HsOverLit (GhcPass p)) = SrcAnn NoEpAnns
type Anno (Pat (GhcPass p))
Instance details Defined in GHC.Hs.Pat type Anno (Pat (GhcPass p)) = SrcSpanAnnA
type Anno (AmbiguousFieldOcc (GhcPass p))
Instance details Defined in GHC.Hs.Type type Anno (AmbiguousFieldOcc (GhcPass p)) = SrcAnn NoEpAnns
type Anno (BangType (GhcPass p))
Instance details Defined in GHC.Hs.Type type Anno (BangType (GhcPass p)) = SrcSpanAnnA
type Anno (ConDeclField (GhcPass p))
Instance details Defined in GHC.Hs.Type type Anno (ConDeclField (GhcPass p)) = SrcSpanAnnA
type Anno (FieldOcc (GhcPass p))
Instance details Defined in GHC.Hs.Type type Anno (FieldOcc (GhcPass p)) = SrcAnn NoEpAnns
type Anno (HsKind (GhcPass p))
Instance details Defined in GHC.Hs.Type type Anno (HsKind (GhcPass p)) = SrcSpanAnnA
type Anno (HsSigType (GhcPass p))
Instance details Defined in GHC.Hs.Type type Anno (HsSigType (GhcPass p)) = SrcSpanAnnA
type Anno (HsType (GhcPass p))
Instance details Defined in GHC.Hs.Type type Anno (HsType (GhcPass p)) = SrcSpanAnnA
type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))] = SrcSpanAnnL
type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))] = SrcSpanAnnL
type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))]
Instance details Defined in GHC.Parser.PostProcess type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))]
Instance details Defined in GHC.Parser.Types type Anno [LocatedA (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL
type Anno [LocatedA (IE (GhcPass p))]
Instance details Defined in GHC.Hs.ImpExp type Anno [LocatedA (IE (GhcPass p))] = SrcSpanAnnL
type Anno [LocatedA (ConDeclField (GhcPass _1))]
Instance details Defined in GHC.Hs.Decls type Anno [LocatedA (ConDeclField (GhcPass _1))] = SrcSpanAnnL
type Anno [LocatedA (HsType (GhcPass p))]
Instance details Defined in GHC.Hs.Type type Anno [LocatedA (HsType (GhcPass p))] = SrcSpanAnnC
type IdP (GhcPass p)
Instance details Defined in GHC.Hs.Extension type IdP (GhcPass p) = IdGhcP p
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]
Instance details Defined in GHC.Hs.Extension type NoGhcTc (GhcPass pass) = GhcPass (NoGhcTcPass pass)
type XAnnD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XAnnD (GhcPass _1) = NoExtField
type XApp (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XApp (GhcPass _1) = EpAnnCO
type XAppKindTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XAppKindTy (GhcPass _1) = SrcSpan
type XAppTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XAppTy (GhcPass _1) = NoExtField
type XApplicativeArgMany (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XApplicativeArgMany (GhcPass _1) = NoExtField
type XBangTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XBangTy (GhcPass _1) = EpAnn [AddEpAnn]
type XCDerivDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCDerivDecl (GhcPass _1) = EpAnn [AddEpAnn]
type XCDotFieldOcc (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCDotFieldOcc (GhcPass _1) = EpAnn AnnFieldLabel
type XCExport (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCExport (GhcPass _1) = Located SourceText
type XCFamilyDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCFamilyDecl (GhcPass _1) = EpAnn [AddEpAnn]
type XCFunDep (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCFunDep (GhcPass _1) = EpAnn [AddEpAnn]
type XCHsDataDefn (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCHsDataDefn (GhcPass _1) = NoExtField
type XCHsDerivingClause (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCHsDerivingClause (GhcPass _1) = EpAnn [AddEpAnn]
type XCHsGroup (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCHsGroup (GhcPass _1) = NoExtField
type XCImport (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCImport (GhcPass _1) = Located SourceText
type XCInjectivityAnn (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCInjectivityAnn (GhcPass _1) = EpAnn [AddEpAnn]
type XCKindSig (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCKindSig (GhcPass _1) = NoExtField
type XCRuleBndr (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCRuleBndr (GhcPass _1) = EpAnn [AddEpAnn]
type XCTyClGroup (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCTyClGroup (GhcPass _1) = NoExtField
type XCTyFamInstDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XCTyFamInstDecl (GhcPass _1) = EpAnn [AddEpAnn]
type XCharTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XCharTy (GhcPass _1) = SourceText
type XClassOpSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XClassOpSig (GhcPass p) = EpAnn AnnSig
type XClsInstD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XClsInstD (GhcPass _1) = NoExtField
type XCmdApp (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCmdApp (GhcPass _1) = EpAnnCO
type XCmdLam (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCmdLam (GhcPass _1) = NoExtField
type XCmdLamCase (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCmdLamCase (GhcPass _1) = EpAnn [AddEpAnn]
type XCmdPar (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCmdPar (GhcPass _1) = EpAnnCO
type XCmdWrap (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XCmdWrap (GhcPass _1) = NoExtField
type XCompleteMatchSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XCompleteMatchSig (GhcPass p) = (EpAnn [AddEpAnn], SourceText)
type XConDeclField (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XConDeclField (GhcPass _1) = EpAnn [AddEpAnn]
type XConDeclGADT (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XConDeclGADT (GhcPass _1) = EpAnn [AddEpAnn]
type XConDeclH98 (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XConDeclH98 (GhcPass _1) = EpAnn [AddEpAnn]
type XDataFamInstD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XDataFamInstD (GhcPass _1) = NoExtField
type XDctMulti (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XDctMulti (GhcPass _1) = NoExtField
type XDctSingle (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XDctSingle (GhcPass _1) = NoExtField
type XDefD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XDefD (GhcPass _1) = NoExtField
type XDerivD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XDerivD (GhcPass _1) = NoExtField
type XDocD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XDocD (GhcPass _1) = NoExtField
type XDocTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XDocTy (GhcPass _1) = EpAnn [AddEpAnn]
type XFamDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XFamDecl (GhcPass _1) = NoExtField
type XFixSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XFixSig (GhcPass p) = EpAnn [AddEpAnn]
type XFixitySig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XFixitySig (GhcPass p) = NoExtField
type XForAllTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XForAllTy (GhcPass _1) = NoExtField
type XForD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XForD (GhcPass _1) = NoExtField
type XFunTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XFunTy (GhcPass _1) = EpAnnCO
type XHsAnnotation (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XHsAnnotation (GhcPass _1) = (EpAnn AnnPragma, SourceText)
type XHsChar (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsChar (GhcPass _1) = SourceText
type XHsCharPrim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsCharPrim (GhcPass _1) = SourceText
type XHsDoublePrim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsDoublePrim (GhcPass _1) = NoExtField
type XHsFloatPrim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsFloatPrim (GhcPass _1) = NoExtField
type XHsForAllInvis (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XHsForAllInvis (GhcPass _1) = EpAnnForallTy
type XHsForAllVis (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XHsForAllVis (GhcPass _1) = EpAnnForallTy
type XHsInt (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsInt (GhcPass _1) = NoExtField
type XHsInt64Prim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsInt64Prim (GhcPass _1) = SourceText
type XHsIntPrim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsIntPrim (GhcPass _1) = SourceText
type XHsInteger (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsInteger (GhcPass _1) = SourceText
type XHsRat (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsRat (GhcPass _1) = NoExtField
type XHsSig (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XHsSig (GhcPass _1) = NoExtField
type XHsString (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsString (GhcPass _1) = SourceText
type XHsStringPrim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsStringPrim (GhcPass _1) = SourceText
type XHsWord64Prim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsWord64Prim (GhcPass _1) = SourceText
type XHsWordPrim (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XHsWordPrim (GhcPass _1) = SourceText
type XIEDoc (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEDoc (GhcPass _1) = NoExtField
type XIEDocNamed (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEDocNamed (GhcPass _1) = NoExtField
type XIEGroup (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEGroup (GhcPass _1) = NoExtField
type XIEName (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEName (GhcPass _1) = NoExtField
type XIEPattern (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEPattern (GhcPass _1) = EpaLocation
type XIEThingAbs (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEThingAbs (GhcPass _1) = EpAnn [AddEpAnn]
type XIEThingAll (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEThingAll (GhcPass _1) = EpAnn [AddEpAnn]
type XIEThingWith (GhcPass 'Parsed)
Instance details Defined in GHC.Hs.ImpExp type XIEThingWith (GhcPass 'Parsed) = EpAnn [AddEpAnn]
type XIEThingWith (GhcPass 'Renamed)
Instance details Defined in GHC.Hs.ImpExp type XIEThingWith (GhcPass 'Renamed) = [Located FieldLabel]
type XIEThingWith (GhcPass 'Typechecked)
Instance details Defined in GHC.Hs.ImpExp type XIEThingWith (GhcPass 'Typechecked) = NoExtField
type XIEType (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XIEType (GhcPass _1) = EpaLocation
type XIParamTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XIParamTy (GhcPass _1) = EpAnn [AddEpAnn]
type XInlineSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XInlineSig (GhcPass p) = EpAnn [AddEpAnn]
type XInstD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XInstD (GhcPass _1) = NoExtField
type XKindSig (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XKindSig (GhcPass _1) = EpAnn [AddEpAnn]
type XKindSigD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XKindSigD (GhcPass _1) = NoExtField
type XKindedTyVar (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XKindedTyVar (GhcPass _1) = EpAnn [AddEpAnn]
type XLam (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XLam (GhcPass _1) = NoExtField
type XLam (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XLam (GhcPass _1) = NoExtField
type XLamCase (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XLamCase (GhcPass _1) = EpAnn [AddEpAnn]
type XListTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XListTy (GhcPass _1) = EpAnn AnnParen
type XLitE (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XLitE (GhcPass _1) = EpAnnCO
type XLitPat (GhcPass _1)
Instance details Defined in GHC.Hs.Pat type XLitPat (GhcPass _1) = NoExtField
type XMinimalSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XMinimalSig (GhcPass p) = (EpAnn [AddEpAnn], SourceText)
type XNoSig (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XNoSig (GhcPass _1) = NoExtField
type XNumTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XNumTy (GhcPass _1) = SourceText
type XOpTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XOpTy (GhcPass _1) = EpAnn [AddEpAnn]
type XOverLitE (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XOverLitE (GhcPass _1) = EpAnnCO
type XPar (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XPar (GhcPass _1) = EpAnnCO
type XParPat (GhcPass _1)
Instance details Defined in GHC.Hs.Pat type XParPat (GhcPass _1) = EpAnnCO
type XParTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XParTy (GhcPass _1) = EpAnn AnnParen
type XPatSynSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XPatSynSig (GhcPass p) = EpAnn AnnSig
type XPragE (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XPragE (GhcPass _1) = NoExtField
type XPresent (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XPresent (GhcPass _1) = EpAnn [AddEpAnn]
type XProc (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XProc (GhcPass _1) = EpAnn [AddEpAnn]
type XQualTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XQualTy (GhcPass _1) = NoExtField
type XRoleAnnotD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XRoleAnnotD (GhcPass _1) = NoExtField
type XRuleBndrSig (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XRuleBndrSig (GhcPass _1) = EpAnn [AddEpAnn]
type XRuleD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XRuleD (GhcPass _1) = NoExtField
type XSCC (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XSCC (GhcPass _1) = (EpAnn AnnPragma, SourceText)
type XSCCFunSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XSCCFunSig (GhcPass p) = (EpAnn [AddEpAnn], SourceText)
type XSigD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XSigD (GhcPass _1) = NoExtField
type XSpecInstSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XSpecInstSig (GhcPass p) = (EpAnn [AddEpAnn], SourceText)
type XSpecSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XSpecSig (GhcPass p) = EpAnn [AddEpAnn]
type XSpliceD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XSpliceD (GhcPass _1) = NoExtField
type XSpliceDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XSpliceDecl (GhcPass _1) = NoExtField
type XStarTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XStarTy (GhcPass _1) = NoExtField
type XStrTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XStrTy (GhcPass _1) = SourceText
type XSumTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XSumTy (GhcPass _1) = EpAnn AnnParen
type XTupleTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XTupleTy (GhcPass _1) = EpAnn AnnParen
type XTyClD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XTyClD (GhcPass _1) = NoExtField
type XTyLit (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XTyLit (GhcPass _1) = NoExtField
type XTyVar (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XTyVar (GhcPass _1) = EpAnn [AddEpAnn]
type XTyVarSig (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XTyVarSig (GhcPass _1) = NoExtField
type XTypeSig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XTypeSig (GhcPass p) = EpAnn AnnSig
type XUserTyVar (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XUserTyVar (GhcPass _1) = EpAnn [AddEpAnn]
type XValD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XValD (GhcPass _1) = NoExtField
type XVar (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XVar (GhcPass _1) = NoExtField
type XVar (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XVar (GhcPass _1) = NoExtField
type XVarPat (GhcPass _1)
Instance details Defined in GHC.Hs.Pat type XVarPat (GhcPass _1) = NoExtField
type XWarning (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XWarning (GhcPass _1) = EpAnn [AddEpAnn]
type XWarningD (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XWarningD (GhcPass _1) = NoExtField
type XWildCardTy (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XWildCardTy (GhcPass _1) = NoExtField
type XXAmbiguousFieldOcc (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XXAmbiguousFieldOcc (GhcPass _1) = DataConCantHappen
type XXAnnDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXAnnDecl (GhcPass _1) = DataConCantHappen
type XXApplicativeArg (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XXApplicativeArg (GhcPass _1) = DataConCantHappen
type XXClsInstDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXClsInstDecl (GhcPass _1) = DataConCantHappen
type XXCmdTop (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XXCmdTop (GhcPass _1) = DataConCantHappen
type XXConDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXConDecl (GhcPass _1) = DataConCantHappen
type XXConDeclField (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XXConDeclField (GhcPass _1) = DataConCantHappen
type XXDefaultDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXDefaultDecl (GhcPass _1) = DataConCantHappen
type XXDerivClauseTys (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXDerivClauseTys (GhcPass _1) = DataConCantHappen
type XXDerivDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXDerivDecl (GhcPass _1) = DataConCantHappen
type XXDotFieldOcc (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XXDotFieldOcc (GhcPass _1) = DataConCantHappen
type XXFamilyDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXFamilyDecl (GhcPass _1) = DataConCantHappen
type XXFamilyResultSig (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXFamilyResultSig (GhcPass _1) = DataConCantHappen
type XXFieldOcc (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XXFieldOcc (GhcPass _1) = DataConCantHappen
type XXFixitySig (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XXFixitySig (GhcPass p) = DataConCantHappen
type XXForeignDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXForeignDecl (GhcPass _1) = DataConCantHappen
type XXForeignExport (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXForeignExport (GhcPass _1) = DataConCantHappen
type XXForeignImport (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXForeignImport (GhcPass _1) = DataConCantHappen
type XXFunDep (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXFunDep (GhcPass _1) = DataConCantHappen
type XXHsDataDefn (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXHsDataDefn (GhcPass _1) = DataConCantHappen
type XXHsDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXHsDecl (GhcPass _1) = DataConCantHappen
type XXHsDerivingClause (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXHsDerivingClause (GhcPass _1) = DataConCantHappen
type XXHsForAllTelescope (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XXHsForAllTelescope (GhcPass _1) = DataConCantHappen
type XXHsGroup (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXHsGroup (GhcPass _1) = DataConCantHappen
type XXHsIPBinds (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XXHsIPBinds (GhcPass p) = DataConCantHappen
type XXHsOuterTyVarBndrs (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XXHsOuterTyVarBndrs (GhcPass _1) = DataConCantHappen
type XXHsPatSigType (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XXHsPatSigType (GhcPass _1) = DataConCantHappen
type XXHsSigType (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XXHsSigType (GhcPass _1) = DataConCantHappen
type XXIE (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XXIE (GhcPass _1) = DataConCantHappen
type XXIEWrappedName (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XXIEWrappedName (GhcPass _1) = DataConCantHappen
type XXIPBind (GhcPass p)
Instance details Defined in GHC.Hs.Binds type XXIPBind (GhcPass p) = DataConCantHappen
type XXImportDecl (GhcPass _1)
Instance details Defined in GHC.Hs.ImpExp type XXImportDecl (GhcPass _1) = DataConCantHappen
type XXInjectivityAnn (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXInjectivityAnn (GhcPass _1) = DataConCantHappen
type XXInstDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXInstDecl (GhcPass _1) = DataConCantHappen
type XXLHsQTyVars (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XXLHsQTyVars (GhcPass _1) = DataConCantHappen
type XXLit (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XXLit (GhcPass _1) = DataConCantHappen
type XXOverLit (GhcPass _1)
Instance details Defined in GHC.Hs.Lit type XXOverLit (GhcPass _1) = DataConCantHappen
type XXPragE (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XXPragE (GhcPass _1) = DataConCantHappen
type XXRoleAnnotDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXRoleAnnotDecl (GhcPass _1) = DataConCantHappen
type XXRuleBndr (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXRuleBndr (GhcPass _1) = DataConCantHappen
type XXRuleDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXRuleDecl (GhcPass _1) = DataConCantHappen
type XXRuleDecls (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXRuleDecls (GhcPass _1) = DataConCantHappen
type XXSpliceDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXSpliceDecl (GhcPass _1) = DataConCantHappen
type XXStandaloneKindSig (GhcPass p)
Instance details Defined in GHC.Hs.Decls type XXStandaloneKindSig (GhcPass p) = DataConCantHappen
type XXTupArg (GhcPass _1)
Instance details Defined in GHC.Hs.Expr type XXTupArg (GhcPass _1) = DataConCantHappen
type XXTyClDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXTyClDecl (GhcPass _1) = DataConCantHappen
type XXTyClGroup (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXTyClGroup (GhcPass _1) = DataConCantHappen
type XXTyFamInstDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXTyFamInstDecl (GhcPass _1) = DataConCantHappen
type XXTyLit (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XXTyLit (GhcPass _1) = DataConCantHappen
type XXTyVarBndr (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XXTyVarBndr (GhcPass _1) = DataConCantHappen
type XXType (GhcPass _1)
Instance details Defined in GHC.Hs.Type type XXType (GhcPass _1) = HsCoreTy
type XXWarnDecl (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXWarnDecl (GhcPass _1) = DataConCantHappen
type XXWarnDecls (GhcPass _1)
Instance details Defined in GHC.Hs.Decls type XXWarnDecls (GhcPass _1) = DataConCantHappen
type XCFamEqn (GhcPass _1) r
Instance details Defined in GHC.Hs.Decls type XCFamEqn (GhcPass _1) r = EpAnn [AddEpAnn]
type XCGRHS (GhcPass _1) _2
Instance details Defined in GHC.Hs.Expr type XCGRHS (GhcPass _1) _2 = EpAnn GrhsAnn
type XCGRHSs (GhcPass _1) _2
Instance details Defined in GHC.Hs.Expr type XCGRHSs (GhcPass _1) _2 = EpAnnComments
type XCMatch (GhcPass _1) b
Instance details Defined in GHC.Hs.Expr type XCMatch (GhcPass _1) b = EpAnn [AddEpAnn]
type XFunBind (GhcPass pL) GhcPs
Instance details Defined in GHC.Hs.Binds type XFunBind (GhcPass pL) GhcPs = NoExtField
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]
Instance details Defined in GHC.Hs.Binds type XFunBind (GhcPass pL) GhcRn = NameSet
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'.
Instance details Defined in GHC.Hs.Binds type XFunBind (GhcPass pL) GhcTc = (HsWrapper, [CoreTickish])
type XPSB (GhcPass idL) GhcPs
Instance details Defined in GHC.Hs.Binds type XPSB (GhcPass idL) GhcPs = EpAnn [AddEpAnn]
type XPSB (GhcPass idL) GhcRn
Instance details Defined in GHC.Hs.Binds type XPSB (GhcPass idL) GhcRn = NameSet
type XPSB (GhcPass idL) GhcTc
Instance details Defined in GHC.Hs.Binds type XPSB (GhcPass idL) GhcTc = NameSet
type XRec (GhcPass p) a
Instance details Defined in GHC.Hs.Extension type XRec (GhcPass p) a = GenLocated (Anno a) a
type XXFamEqn (GhcPass _1) r
Instance details Defined in GHC.Hs.Decls type XXFamEqn (GhcPass _1) r = DataConCantHappen
type XXGRHS (GhcPass _1) b
Instance details Defined in GHC.Hs.Expr type XXGRHS (GhcPass _1) b = DataConCantHappen
type XXGRHSs (GhcPass _1) _2
Instance details Defined in GHC.Hs.Expr type XXGRHSs (GhcPass _1) _2 = DataConCantHappen
type XXHsWildCardBndrs (GhcPass _1) _2
Instance details Defined in GHC.Hs.Type type XXHsWildCardBndrs (GhcPass _1) _2 = DataConCantHappen
type XXMatch (GhcPass _1) b
Instance details Defined in GHC.Hs.Expr type XXMatch (GhcPass _1) b = DataConCantHappen
type XXMatchGroup (GhcPass _1) b
Instance details Defined in GHC.Hs.Expr type XXMatchGroup (GhcPass _1) b = DataConCantHappen
type XXValBindsLR (GhcPass pL) pR
Instance details Defined in GHC.Hs.Binds type XXValBindsLR (GhcPass pL) pR = NHsValBindsLR (GhcPass pL)
type XApplicativeStmt (GhcPass _1) GhcPs b
Instance details Defined in GHC.Hs.Expr type XApplicativeStmt (GhcPass _1) GhcPs b = NoExtField
type XApplicativeStmt (GhcPass _1) GhcRn b
Instance details Defined in GHC.Hs.Expr type XApplicativeStmt (GhcPass _1) GhcRn b = NoExtField
type XApplicativeStmt (GhcPass _1) GhcTc b
Instance details Defined in GHC.Hs.Expr type XApplicativeStmt (GhcPass _1) GhcTc b = Type
type XBindStmt (GhcPass _1) GhcPs b
Instance details Defined in GHC.Hs.Expr type XBindStmt (GhcPass _1) GhcPs b = EpAnn [AddEpAnn]
type XBindStmt (GhcPass _1) GhcRn b
Instance details Defined in GHC.Hs.Expr type XBindStmt (GhcPass _1) GhcRn b = XBindStmtRn
type XBindStmt (GhcPass _1) GhcTc b
Instance details Defined in GHC.Hs.Expr type XBindStmt (GhcPass _1) GhcTc b = XBindStmtTc
type XBodyStmt (GhcPass _1) GhcPs b
Instance details Defined in GHC.Hs.Expr type XBodyStmt (GhcPass _1) GhcPs b = NoExtField
type XBodyStmt (GhcPass _1) GhcRn b
Instance details Defined in GHC.Hs.Expr type XBodyStmt (GhcPass _1) GhcRn b = NoExtField
type XBodyStmt (GhcPass _1) GhcTc b
Instance details Defined in GHC.Hs.Expr type XBodyStmt (GhcPass _1) GhcTc b = Type
type XParStmt (GhcPass _1) GhcPs b
Instance details Defined in GHC.Hs.Expr type XParStmt (GhcPass _1) GhcPs b = NoExtField
type XParStmt (GhcPass _1) GhcRn b
Instance details Defined in GHC.Hs.Expr type XParStmt (GhcPass _1) GhcRn b = NoExtField
type XParStmt (GhcPass _1) GhcTc b
Instance details Defined in GHC.Hs.Expr type XParStmt (GhcPass _1) GhcTc b = Type
type XRecStmt (GhcPass _1) GhcPs b
Instance details Defined in GHC.Hs.Expr type XRecStmt (GhcPass _1) GhcPs b = EpAnn AnnList
type XRecStmt (GhcPass _1) GhcRn b
Instance details Defined in GHC.Hs.Expr type XRecStmt (GhcPass _1) GhcRn b = NoExtField
type XRecStmt (GhcPass _1) GhcTc b
Instance details Defined in GHC.Hs.Expr type XRecStmt (GhcPass _1) GhcTc b = RecStmtTc
type XTransStmt (GhcPass _1) GhcPs b
Instance details Defined in GHC.Hs.Expr type XTransStmt (GhcPass _1) GhcPs b = EpAnn [AddEpAnn]
type XTransStmt (GhcPass _1) GhcRn b
Instance details Defined in GHC.Hs.Expr type XTransStmt (GhcPass _1) GhcRn b = NoExtField
type XTransStmt (GhcPass _1) GhcTc b
Instance details Defined in GHC.Hs.Expr type XTransStmt (GhcPass _1) GhcTc b = Type
type XEmptyLocalBinds (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XEmptyLocalBinds (GhcPass pL) (GhcPass pR) = NoExtField
type XHsIPBinds (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XHsIPBinds (GhcPass pL) (GhcPass pR) = EpAnn AnnList
type XHsValBinds (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XHsValBinds (GhcPass pL) (GhcPass pR) = EpAnn AnnList
type XParStmtBlock (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Expr type XParStmtBlock (GhcPass pL) (GhcPass pR) = NoExtField
type XPatSynBind (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XPatSynBind (GhcPass pL) (GhcPass pR) = NoExtField
type XValBinds (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XValBinds (GhcPass pL) (GhcPass pR) = AnnSortKey
type XVarBind (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XVarBind (GhcPass pL) (GhcPass pR) = NoExtField
type XXHsLocalBindsLR (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Binds type XXHsLocalBindsLR (GhcPass pL) (GhcPass pR) = DataConCantHappen
type XXParStmtBlock (GhcPass pL) (GhcPass pR)
Instance details Defined in GHC.Hs.Expr type XXParStmtBlock (GhcPass pL) (GhcPass pR) = DataConCantHappen
type XXPatSynBind (GhcPass idL) (GhcPass idR)
Instance details Defined in GHC.Hs.Binds type XXPatSynBind (GhcPass idL) (GhcPass idR) = DataConCantHappen
type XLastStmt (GhcPass _1) (GhcPass _2) b
Instance details Defined in GHC.Hs.Expr type XLastStmt (GhcPass _1) (GhcPass _2) b = NoExtField
type XLetStmt (GhcPass _1) (GhcPass _2) b
Instance details Defined in GHC.Hs.Expr type XLetStmt (GhcPass _1) (GhcPass _2) b = EpAnn [AddEpAnn]
type XXStmtLR (GhcPass _1) (GhcPass _2) b
Instance details Defined in GHC.Hs.Expr type XXStmtLR (GhcPass _1) (GhcPass _2) b = DataConCantHappen
type Anno (HsBindLR (GhcPass idL) (GhcPass idR))
Instance details Defined in GHC.Hs.Binds type Anno (HsBindLR (GhcPass idL) (GhcPass idR)) = SrcSpanAnnA
type Anno (FamEqn (GhcPass p) _1)
Instance details Defined in GHC.Hs.Decls type Anno (FamEqn (GhcPass p) _1) = SrcSpanAnnA
type Anno (FamEqn (GhcPass p) _1)
Instance details Defined in GHC.Hs.Decls type Anno (FamEqn (GhcPass p) _1) = SrcSpanAnnA
type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p))))
Instance details Defined in GHC.Hs.Expr type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcAnn NoEpAnns
type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p))))
Instance details Defined in GHC.Hs.Expr type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcAnn NoEpAnns
type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs)))
Instance details Defined in GHC.Parser.PostProcess type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs))) = SrcAnn NoEpAnns
type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))
Instance details Defined in GHC.Hs.Expr type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcSpanAnnA
type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))
Instance details Defined in GHC.Hs.Expr type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpanAnnA
type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs)))
Instance details Defined in GHC.Parser.PostProcess type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA
type Anno (HsOuterTyVarBndrs _1 (GhcPass _2))
Instance details Defined in GHC.Hs.Type type Anno (HsOuterTyVarBndrs _1 (GhcPass _2)) = SrcSpanAnnA
type Anno (HsTyVarBndr _flag (GhcPass _1))
Instance details Defined in GHC.Hs.Type type Anno (HsTyVarBndr _flag (GhcPass _1)) = SrcSpanAnnA
type Anno (HsTyVarBndr _flag GhcPs)
Instance details Defined in GHC.Hs.Type type Anno (HsTyVarBndr _flag GhcPs) = SrcSpanAnnA
type Anno (HsTyVarBndr _flag GhcRn)
Instance details Defined in GHC.Hs.Type type Anno (HsTyVarBndr _flag GhcRn) = SrcSpanAnnA
type Anno (HsTyVarBndr _flag GhcTc)
Instance details Defined in GHC.Hs.Type type Anno (HsTyVarBndr _flag GhcTc) = SrcSpanAnnA
type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))
Instance details Defined in GHC.Hs.Expr type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr)))) = SrcSpanAnnA
type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))
Instance details Defined in GHC.Parser.PostProcess type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA
type Anno (StmtLR GhcRn GhcRn (LocatedA (body GhcRn)))
Instance details Defined in GHC.Hs.Expr type Anno (StmtLR GhcRn GhcRn (LocatedA (body GhcRn))) = SrcSpanAnnA

type IsSrcSpanAnn (p :: Pass) a = (Anno (IdGhcP p) ~ SrcSpanAnn' (EpAnn a), IsPass p) #

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

Instances details

type Anno (IEWrappedName (GhcPass _1))
Instance details Defined in GHC.Hs.ImpExp type Anno (IEWrappedName (GhcPass _1)) = SrcSpanAnnA

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 `Int` is in the range [0..n], where n is the length of the list.

Instances

Instances details

Data IEWildcard
Instance details 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
Instance details Defined in Language.Haskell.Syntax.ImpExp Methods (==) :: IEWildcard -> IEWildcard -> Bool # (/=) :: IEWildcard -> IEWildcard -> Bool #

type LIE pass #

Arguments

= XRec pass (IE pass)

When in a list this may have

AnnKeywordId : AnnComma

Located Import or Export

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

Instances details

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

data ImportDecl pass #

Import Declaration

A single Haskell import declaration.

Constructors

ImportDecl

Fields

ideclExt :: XCImportDecl pass
ideclName :: XRec pass ModuleName
Module name.
ideclPkgQual :: ImportDeclPkgQual pass
Package qualifier.
ideclSource :: IsBootInterface
IsBoot = {-# SOURCE #-} import
ideclSafe :: Bool
True => safe import
ideclQualified :: ImportDeclQualifiedStyle
If/how the import is qualified.
ideclAs :: Maybe (XRec pass ModuleName)
as Module
ideclImportList :: Maybe (ImportListInterpretation, XRec pass [LIE pass])
Explicit import list (EverythingBut => hiding, names)

XImportDecl !(XXImportDecl pass)

AnnKeywordIds

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

Instances

Instances details

type Anno (ImportDecl (GhcPass p))
Instance details Defined in GHC.Hs.ImpExp type Anno (ImportDecl (GhcPass p)) = SrcSpanAnnA

data ImportDeclQualifiedStyle #

If/how an import is qualified.

Constructors

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

Instances

Instances details

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

type LImportDecl pass #

Arguments

= XRec pass (ImportDecl pass)

When in a list this may have

AnnKeywordId : AnnSemi

Located Import Declaration

data AnnEnv #

A collection of annotations

type CoreAnnTarget = AnnTarget Name #

The kind of annotation target found in the middle end of the compiler

data AnnTarget name #

An annotation target

Constructors

NamedTarget name	We are annotating something with a name: a type or identifier
ModuleTarget Module	We are annotating a particular module

Instances

Instances details

Functor AnnTarget
Instance details Defined in GHC.Types.Annotations Methods fmap :: (a -> b) -> AnnTarget a -> AnnTarget b # (<$) :: a -> AnnTarget b -> AnnTarget a #
Binary name => Binary (AnnTarget name)
Instance details Defined in GHC.Types.Annotations Methods put_ :: BinHandle -> AnnTarget name -> IO () # put :: BinHandle -> AnnTarget name -> IO (Bin (AnnTarget name)) # get :: BinHandle -> IO (AnnTarget name) #
Outputable name => Outputable (AnnTarget name)
Instance details Defined in GHC.Types.Annotations Methods ppr :: AnnTarget name -> SDoc #

type AnnPayload #

Arguments

= Serialized

The "payload" of an annotation allows recovery of its value at a given type, and can be persisted to an interface file

data RuleOpts #

Rule options

data GhcNameVersion #

Settings for what GHC this is.

Constructors

GhcNameVersion
Fields ghcNameVersion_programName :: String ghcNameVersion_projectVersion :: String

data FileSettings #

Paths to various files and directories used by GHC, including those that provide more settings.

Constructors

FileSettings
Fields fileSettings_ghcUsagePath :: FilePath fileSettings_ghciUsagePath :: FilePath fileSettings_toolDir :: Maybe FilePath fileSettings_topDir :: FilePath fileSettings_globalPackageDatabase :: FilePath

data Settings #

Constructors

Settings
Fields sGhcNameVersion :: !GhcNameVersion sFileSettings :: !FileSettings sTargetPlatform :: Platform sToolSettings :: !ToolSettings sPlatformMisc :: !PlatformMisc sRawSettings :: [(String, String)]

newtype PackageName #

Constructors

PackageName
Fields unPackageName :: FastString

Instances

Instances details

Uniquable PackageName
Instance details Defined in GHC.Unit.Info Methods getUnique :: PackageName -> Unique #
Outputable PackageName
Instance details Defined in GHC.Unit.Info Methods ppr :: PackageName -> SDoc #
Eq PackageName
Instance details Defined in GHC.Unit.Info Methods (==) :: PackageName -> PackageName -> Bool # (/=) :: PackageName -> PackageName -> Bool #

newtype PackageId #

Constructors

PackageId FastString

Instances

Instances details

Uniquable PackageId
Instance details Defined in GHC.Unit.Info Methods getUnique :: PackageId -> Unique #
Outputable PackageId
Instance details Defined in GHC.Unit.Info Methods ppr :: PackageId -> SDoc #
Eq PackageId
Instance details Defined in GHC.Unit.Info Methods (==) :: PackageId -> PackageId -> Bool # (/=) :: PackageId -> PackageId -> Bool #

type UnitInfo = GenUnitInfo UnitId #

Information about an installed unit (units are identified by their internal UnitId)

type UnitKeyInfo = GenUnitInfo UnitKey #

Information about an installed unit (units are identified by their database UnitKey)

type GenUnitInfo unit = GenericUnitInfo PackageId PackageName unit ModuleName (GenModule (GenUnit unit)) #

Information about an installed unit

We parameterize on the unit identifier: * UnitKey: identifier used in the database (cf UnitKeyInfo) * UnitId: identifier used to generate code (cf UnitInfo)

These two identifiers are different for wired-in packages. See Note [About units] in GHC.Unit

newtype Hsc a #

The Hsc monad: Passing an environment and diagnostic state

Constructors

Hsc (HscEnv -> Messages GhcMessage -> IO (a, Messages GhcMessage))

Instances

Instances details

MonadIO Hsc
Instance details Defined in GHC.Driver.Env.Types Methods liftIO :: IO a -> Hsc a #
Applicative Hsc
Instance details Defined in GHC.Driver.Env.Types Methods pure :: a -> Hsc a # (<>) :: Hsc (a -> b) -> Hsc a -> Hsc b # liftA2 :: (a -> b -> c) -> Hsc a -> Hsc b -> Hsc c # (>) :: Hsc a -> Hsc b -> Hsc b # (<*) :: Hsc a -> Hsc b -> Hsc a #
Functor Hsc
Instance details Defined in GHC.Driver.Env.Types Methods fmap :: (a -> b) -> Hsc a -> Hsc b # (<$) :: a -> Hsc b -> Hsc a #
Monad Hsc
Instance details Defined in GHC.Driver.Env.Types Methods (>>=) :: Hsc a -> (a -> Hsc b) -> Hsc b # (>>) :: Hsc a -> Hsc b -> Hsc b # return :: a -> Hsc a #
HasDynFlags Hsc
Instance details Defined in GHC.Driver.Env.Types Methods getDynFlags :: Hsc DynFlags #
HasLogger Hsc
Instance details Defined in GHC.Driver.Env.Types Methods getLogger :: Hsc Logger #

data LiftingContext #

Constructors

LC Subst LiftCoEnv

Instances

Instances details

Outputable LiftingContext
Instance details Defined in GHC.Core.Coercion Methods ppr :: LiftingContext -> SDoc #

data FunDep pass #

Constructors

FunDep (XCFunDep pass) [LIdP pass] [LIdP pass]
XFunDep !(XXFunDep pass)

Instances

Instances details

type Anno (FunDep (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (FunDep (GhcPass p)) = SrcSpanAnnA

data TyConFlavour #

Paints a picture of what a TyCon represents, in broad strokes. This is used towards more informative error messages.

Constructors

ClassFlavour
TupleFlavour Boxity
SumFlavour
DataTypeFlavour
NewtypeFlavour
AbstractTypeFlavour
DataFamilyFlavour (Maybe TyCon)
OpenTypeFamilyFlavour (Maybe TyCon)
ClosedTypeFamilyFlavour
TypeSynonymFlavour
BuiltInTypeFlavour	e.g., the `(->)` `TyCon`.
PromotedDataConFlavour

Instances

Instances details

Outputable TyConFlavour
Instance details Defined in GHC.Core.TyCon Methods ppr :: TyConFlavour -> SDoc #
Eq TyConFlavour
Instance details Defined in GHC.Core.TyCon Methods (==) :: TyConFlavour -> TyConFlavour -> Bool # (/=) :: TyConFlavour -> TyConFlavour -> Bool #

data ExpandSynResult tyco #

Constructors

NoExpansion
ExpandsSyn [(TyVar, tyco)] Type [tyco]

data PrimElemRep #

Constructors

Int8ElemRep
Int16ElemRep
Int32ElemRep
Int64ElemRep
Word8ElemRep
Word16ElemRep
Word32ElemRep
Word64ElemRep
FloatElemRep
DoubleElemRep

Instances

Instances details

Data PrimElemRep
Instance details Defined in GHC.Core.TyCon Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PrimElemRep -> c PrimElemRep # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PrimElemRep # toConstr :: PrimElemRep -> Constr # dataTypeOf :: PrimElemRep -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PrimElemRep) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrimElemRep) # gmapT :: (forall b. Data b => b -> b) -> PrimElemRep -> PrimElemRep # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PrimElemRep -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PrimElemRep -> r # gmapQ :: (forall d. Data d => d -> u) -> PrimElemRep -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> PrimElemRep -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PrimElemRep -> m PrimElemRep # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PrimElemRep -> m PrimElemRep # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PrimElemRep -> m PrimElemRep #
Enum PrimElemRep
Instance details Defined in GHC.Core.TyCon Methods succ :: PrimElemRep -> PrimElemRep # pred :: PrimElemRep -> PrimElemRep # toEnum :: Int -> PrimElemRep # fromEnum :: PrimElemRep -> Int # enumFrom :: PrimElemRep -> [PrimElemRep] # enumFromThen :: PrimElemRep -> PrimElemRep -> [PrimElemRep] # enumFromTo :: PrimElemRep -> PrimElemRep -> [PrimElemRep] # enumFromThenTo :: PrimElemRep -> PrimElemRep -> PrimElemRep -> [PrimElemRep] #
Show PrimElemRep
Instance details Defined in GHC.Core.TyCon Methods showsPrec :: Int -> PrimElemRep -> ShowS # show :: PrimElemRep -> String # showList :: [PrimElemRep] -> ShowS #
Binary PrimElemRep
Instance details Defined in GHC.Core.TyCon Methods put_ :: BinHandle -> PrimElemRep -> IO () # put :: BinHandle -> PrimElemRep -> IO (Bin PrimElemRep) # get :: BinHandle -> IO PrimElemRep #
Outputable PrimElemRep
Instance details Defined in GHC.Core.TyCon Methods ppr :: PrimElemRep -> SDoc #
Eq PrimElemRep
Instance details Defined in GHC.Core.TyCon Methods (==) :: PrimElemRep -> PrimElemRep -> Bool # (/=) :: PrimElemRep -> PrimElemRep -> Bool #
Ord PrimElemRep
Instance details Defined in GHC.Core.TyCon Methods compare :: PrimElemRep -> PrimElemRep -> Ordering # (<) :: PrimElemRep -> PrimElemRep -> Bool # (<=) :: PrimElemRep -> PrimElemRep -> Bool # (>) :: PrimElemRep -> PrimElemRep -> Bool # (>=) :: PrimElemRep -> PrimElemRep -> Bool # max :: PrimElemRep -> PrimElemRep -> PrimElemRep # min :: PrimElemRep -> PrimElemRep -> PrimElemRep #

data PrimRep #

A PrimRep is an abstraction of a type. It contains information that the code generator needs in order to pass arguments, return results, and store values of this type. See also Note [RuntimeRep and PrimRep] in GHC.Types.RepType and Note [VoidRep] in GHC.Types.RepType.

Constructors

VoidRep
LiftedRep
UnliftedRep	Unlifted pointer
Int8Rep	Signed, 8-bit value
Int16Rep	Signed, 16-bit value
Int32Rep	Signed, 32-bit value
Int64Rep	Signed, 64 bit value
IntRep	Signed, word-sized value
Word8Rep	Unsigned, 8 bit value
Word16Rep	Unsigned, 16 bit value
Word32Rep	Unsigned, 32 bit value
Word64Rep	Unsigned, 64 bit value
WordRep	Unsigned, word-sized value
AddrRep	A pointer, but not to a Haskell value (use '(Un)liftedRep')
FloatRep
DoubleRep
VecRep Int PrimElemRep	A vector

Instances

Instances details

Data PrimRep
Instance details Defined in GHC.Core.TyCon Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PrimRep -> c PrimRep # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PrimRep # toConstr :: PrimRep -> Constr # dataTypeOf :: PrimRep -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PrimRep) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrimRep) # gmapT :: (forall b. Data b => b -> b) -> PrimRep -> PrimRep # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PrimRep -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PrimRep -> r # gmapQ :: (forall d. Data d => d -> u) -> PrimRep -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> PrimRep -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PrimRep -> m PrimRep # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PrimRep -> m PrimRep # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PrimRep -> m PrimRep #
Show PrimRep
Instance details Defined in GHC.Core.TyCon Methods showsPrec :: Int -> PrimRep -> ShowS # show :: PrimRep -> String # showList :: [PrimRep] -> ShowS #
Binary PrimRep
Instance details Defined in GHC.Core.TyCon Methods put_ :: BinHandle -> PrimRep -> IO () # put :: BinHandle -> PrimRep -> IO (Bin PrimRep) # get :: BinHandle -> IO PrimRep #
Outputable PrimRep
Instance details Defined in GHC.Core.TyCon Methods ppr :: PrimRep -> SDoc #
Eq PrimRep
Instance details Defined in GHC.Core.TyCon Methods (==) :: PrimRep -> PrimRep -> Bool # (/=) :: PrimRep -> PrimRep -> Bool #
Ord PrimRep
Instance details Defined in GHC.Core.TyCon Methods compare :: PrimRep -> PrimRep -> Ordering # (<) :: PrimRep -> PrimRep -> Bool # (<=) :: PrimRep -> PrimRep -> Bool # (>) :: PrimRep -> PrimRep -> Bool # (>=) :: PrimRep -> PrimRep -> Bool # max :: PrimRep -> PrimRep -> PrimRep # min :: PrimRep -> PrimRep -> PrimRep #

data FamTyConFlav #

Information pertaining to the expansion of a type synonym (type)

Constructors

DataFamilyTyCon TyConRepName	Represents an open type family without a fixed right hand side. Additional instances can appear at any time. These are introduced by either a top level declaration: data family T a :: * Or an associated data type declaration, within a class declaration: class C a b where data T b :: *
OpenSynFamilyTyCon	An open type synonym family e.g. `type family F x y :: * -> *`
ClosedSynFamilyTyCon (Maybe (CoAxiom Branched))	A closed type synonym family e.g. `type family F x where { F Int = Bool }`
AbstractClosedSynFamilyTyCon	A closed type synonym family declared in an hs-boot file with type family F a where ..
BuiltInSynFamTyCon BuiltInSynFamily	Built-in type family used by the TypeNats solver

Instances

Instances details

Outputable FamTyConFlav
Instance details Defined in GHC.Core.TyCon Methods ppr :: FamTyConFlav -> SDoc #

data Injectivity #

Constructors

NotInjective
Injective [Bool]

Instances

Instances details

Binary Injectivity
Instance details Defined in GHC.Core.TyCon Methods put_ :: BinHandle -> Injectivity -> IO () # put :: BinHandle -> Injectivity -> IO (Bin Injectivity) # get :: BinHandle -> IO Injectivity #
Eq Injectivity
Instance details Defined in GHC.Core.TyCon Methods (==) :: Injectivity -> Injectivity -> Bool # (/=) :: Injectivity -> Injectivity -> Bool #

data AlgTyConFlav #

Describes the flavour of an algebraic type constructor. For classes and data families, this flavour includes a reference to the parent TyCon.

Constructors

VanillaAlgTyCon TyConRepName	An ordinary algebraic type constructor. This includes unlifted and representation-polymorphic datatypes and newtypes and unboxed tuples, but NOT unboxed sums; see UnboxedSumTyCon.
UnboxedSumTyCon	An unboxed sum type constructor. This is distinct from VanillaAlgTyCon because we currently don't allow unboxed sums to be Typeable since there are too many of them. See #13276.
ClassTyCon Class TyConRepName	Type constructors representing a class dictionary. See Note [ATyCon for classes] in GHC.Core.TyCo.Rep
DataFamInstTyCon (CoAxiom Unbranched) TyCon [Type]	Type constructors representing an instance of a data family. Parameters: 1) The type family in question 2) Instance types; free variables are the `tyConTyVars` of the current `TyCon` (not the family one). INVARIANT: the number of types matches the arity of the family `TyCon` 3) A `CoTyCon` identifying the representation type with the type instance family

Instances

Instances details

Outputable AlgTyConFlav
Instance details Defined in GHC.Core.TyCon Methods ppr :: AlgTyConFlav -> SDoc #

data PromDataConInfo #

Some promoted datacons signify extra info relevant to GHC. For example, the IntRep constructor of RuntimeRep corresponds to the IntRep constructor of PrimRep. This data structure allows us to store this information right in the TyCon. The other approach would be to look up things like RuntimeRep's PrimRep by known-key every time. See also Note [Getting from RuntimeRep to PrimRep] in GHC.Types.RepType

Constructors

NoPromInfo	an ordinary promoted data con
RuntimeRep ([Type] -> [PrimRep])	A constructor of `RuntimeRep`. The argument to the function should be the list of arguments to the promoted datacon.
VecCount Int	A constructor of `VecCount`
VecElem PrimElemRep	A constructor of `VecElem`
Levity Levity	A constructor of `PromDataConInfo`

data AlgTyConRhs #

Represents right-hand-sides of TyCons for algebraic types

Constructors

AbstractTyCon	Says that we know nothing about this data type, except that it's represented by a pointer. Used when we export a data type abstractly into an .hi file.
DataTyCon	Information about those `TyCon`s derived from a `data` declaration. This includes data types with no constructors at all.
Fields data_cons :: [DataCon] The data type constructors; can be empty if the user declares the type to have no constructors INVARIANT: Kept in order of increasing `DataCon` tag (see the tag assignment in mkTyConTagMap) data_cons_size :: Int Cached value: length data_cons is_enum :: Bool Cached value: is this an enumeration type? See Note [Enumeration types] is_type_data :: Bool data_fixed_lev :: Bool `True` if the data type constructor has a known, fixed levity when fully applied to its arguments, False otherwise. This can only be `False` with UnliftedDatatypes, e.g. data A :: TYPE (BoxedRep l) where { MkA :: Int -> A } This boolean is cached to make it cheaper to check for levity and representation-polymorphism in tcHasFixedRuntimeRep.
TupleTyCon
Fields data_con :: DataCon The unique constructor for the `newtype`. It has no existentials tup_sort :: TupleSort Is this a boxed, unboxed or constraint tuple?
SumTyCon	An unboxed sum type.
Fields data_cons :: [DataCon] The data type constructors; can be empty if the user declares the type to have no constructors INVARIANT: Kept in order of increasing `DataCon` tag (see the tag assignment in mkTyConTagMap) data_cons_size :: Int Cached value: length data_cons
NewTyCon	Information about those `TyCon`s derived from a `newtype` declaration
Fields data_con :: DataCon The unique constructor for the `newtype`. It has no existentials nt_rhs :: Type Cached value: the argument type of the constructor, which is just the representation type of the `TyCon` (remember that `newtype`s do not exist at runtime so need a different representation type). The free `TyVar`s of this type are the `tyConTyVars` from the corresponding `TyCon` nt_etad_rhs :: ([TyVar], Type) Same as the `nt_rhs`, but this time eta-reduced. Hence the list of `TyVar`s in this field may be shorter than the declared arity of the `TyCon`. nt_co :: CoAxiom Unbranched nt_fixed_rep :: Bool `True` if the newtype has a known, fixed representation when fully applied to its arguments, `False` otherwise. This can only ever be `False` with UnliftedNewtypes. Example: newtype N (a :: TYPE r) = MkN a Invariant: nt_fixed_rep nt = tcHasFixedRuntimeRep (nt_rhs nt) This boolean is cached to make it cheaper to check if a variable binding is representation-polymorphic in tcHasFixedRuntimeRep.

data TyConBndrVis #

Constructors

NamedTCB ForAllTyFlag
AnonTCB FunTyFlag

Instances

Instances details

Binary TyConBndrVis
Instance details Defined in GHC.Core.TyCon Methods put_ :: BinHandle -> TyConBndrVis -> IO () # put :: BinHandle -> TyConBndrVis -> IO (Bin TyConBndrVis) # get :: BinHandle -> IO TyConBndrVis #
Outputable TyConBndrVis
Instance details Defined in GHC.Core.TyCon Methods ppr :: TyConBndrVis -> SDoc #
OutputableBndr tv => Outputable (VarBndr tv TyConBndrVis)
Instance details Defined in GHC.Core.TyCon Methods ppr :: VarBndr tv TyConBndrVis -> SDoc #

type TyConPiTyBinder = VarBndr TyCoVar TyConBndrVis #

type TyConBinder = VarBndr TyVar TyConBndrVis #

data TyCoFolder env a #

Constructors

TyCoFolder
Fields tcf_view :: Type -> Maybe Type tcf_tyvar :: env -> TyVar -> a tcf_covar :: env -> CoVar -> a tcf_hole :: env -> CoercionHole -> a What to do with coercion holes. See Note [Coercion holes] in GHC.Core.TyCo.Rep. tcf_tycobinder :: env -> TyCoVar -> ForAllTyFlag -> env The returned env is used in the extended scope

data CoercionHole #

A coercion to be filled in by the type-checker. See Note [Coercion holes]

Constructors

CoercionHole
Fields ch_co_var :: CoVar ch_ref :: IORef (Maybe Coercion)

Instances

Instances details

Data CoercionHole
Instance details 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
Instance details Defined in GHC.Core.TyCo.Rep Methods getUnique :: CoercionHole -> Unique #
Outputable CoercionHole
Instance details Defined in GHC.Core.TyCo.Rep Methods ppr :: CoercionHole -> SDoc #

type MCoercionR = MCoercion #

type CoercionP = Coercion #

type CoercionR = Coercion #

data FunSel #

Constructors

SelMult
SelArg
SelRes

Instances

Instances details

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

type KnotTied ty = ty #

A type labeled KnotTied might have knot-tied tycons in it. See Note [Type checking recursive type and class declarations] in GHC.Tc.TyCl

type FRRType = Type #

type KindOrType = Type #

The key representation of types within the compiler

type CvSubstEnv = CoVarEnv Coercion #

A substitution of Coercions for CoVars

type TvSubstEnv = TyVarEnv Type #

A substitution of Types for TyVars and Kinds for KindVars

type IdSubstEnv = IdEnv CoreExpr #

A substitution of Exprs for non-coercion Ids

data TyCoMapper env (m :: Type -> Type) #

This describes how a "map" operation over a type/coercion should behave

Constructors

TyCoMapper

Fields

tcm_tyvar :: env -> TyVar -> m Type
tcm_covar :: env -> CoVar -> m Coercion
tcm_hole :: env -> CoercionHole -> m Coercion
What to do with coercion holes. See Note [Coercion holes] in GHC.Core.TyCo.Rep.
tcm_tycobinder :: env -> TyCoVar -> ForAllTyFlag -> m (env, TyCoVar)
The returned env is used in the extended scope
tcm_tycon :: TyCon -> m TyCon
This is used only for TcTyCons a) To zonk TcTyCons b) To turn TcTyCons into TyCons. See Note [Type checking recursive type and class declarations] in GHC.Tc.TyCl

data OverLitVal #

Overloaded Literal Value

Constructors

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

Instances

Instances details

Data OverLitVal
Instance details 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
Instance details Defined in Language.Haskell.Syntax.Lit Methods (==) :: OverLitVal -> OverLitVal -> Bool # (/=) :: OverLitVal -> OverLitVal -> Bool #
Ord OverLitVal
Instance details 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 #

data HsOverLit p #

Haskell Overloaded Literal

Constructors

OverLit
Fields ol_ext :: XOverLit p ol_val :: OverLitVal
XOverLit !(XXOverLit p)

Instances

Instances details

Eq (XXOverLit p) => Eq (HsOverLit p)
Instance details Defined in Language.Haskell.Syntax.Lit Methods (==) :: HsOverLit p -> HsOverLit p -> Bool # (/=) :: HsOverLit p -> HsOverLit p -> Bool #
Ord (XXOverLit p) => Ord (HsOverLit p)
Instance details Defined in Language.Haskell.Syntax.Lit Methods compare :: HsOverLit p -> HsOverLit p -> Ordering # (<) :: HsOverLit p -> HsOverLit p -> Bool # (<=) :: HsOverLit p -> HsOverLit p -> Bool # (>) :: HsOverLit p -> HsOverLit p -> Bool # (>=) :: HsOverLit p -> HsOverLit p -> Bool # max :: HsOverLit p -> HsOverLit p -> HsOverLit p # min :: HsOverLit p -> HsOverLit p -> HsOverLit p #
type Anno (HsOverLit (GhcPass p))
Instance details Defined in GHC.Hs.Pat type Anno (HsOverLit (GhcPass p)) = SrcAnn NoEpAnns

data HsLit x #

Haskell Literal

Constructors

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

Instances

Instances details

Eq (HsLit x)
Instance details Defined in Language.Haskell.Syntax.Lit Methods (==) :: HsLit x -> HsLit x -> Bool # (/=) :: HsLit x -> HsLit x -> Bool #

data LitNumType #

Numeric literal type

Constructors

LitNumBigNat	`Bignat` (see Note [BigNum literals])
LitNumInt	`Int#` - according to target machine
LitNumInt8	`Int8#` - exactly 8 bits
LitNumInt16	`Int16#` - exactly 16 bits
LitNumInt32	`Int32#` - exactly 32 bits
LitNumInt64	`Int64#` - exactly 64 bits
LitNumWord	`Word#` - according to target machine
LitNumWord8	`Word8#` - exactly 8 bits
LitNumWord16	`Word16#` - exactly 16 bits
LitNumWord32	`Word32#` - exactly 32 bits
LitNumWord64	`Word64#` - exactly 64 bits

Instances

Instances details

Data LitNumType
Instance details Defined in GHC.Types.Literal Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LitNumType -> c LitNumType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LitNumType # toConstr :: LitNumType -> Constr # dataTypeOf :: LitNumType -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c LitNumType) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LitNumType) # gmapT :: (forall b. Data b => b -> b) -> LitNumType -> LitNumType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LitNumType -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LitNumType -> r # gmapQ :: (forall d. Data d => d -> u) -> LitNumType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> LitNumType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> LitNumType -> m LitNumType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LitNumType -> m LitNumType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LitNumType -> m LitNumType #
Enum LitNumType
Instance details Defined in GHC.Types.Literal Methods succ :: LitNumType -> LitNumType # pred :: LitNumType -> LitNumType # toEnum :: Int -> LitNumType # fromEnum :: LitNumType -> Int # enumFrom :: LitNumType -> [LitNumType] # enumFromThen :: LitNumType -> LitNumType -> [LitNumType] # enumFromTo :: LitNumType -> LitNumType -> [LitNumType] # enumFromThenTo :: LitNumType -> LitNumType -> LitNumType -> [LitNumType] #
Binary LitNumType
Instance details Defined in GHC.Types.Literal Methods put_ :: BinHandle -> LitNumType -> IO () # put :: BinHandle -> LitNumType -> IO (Bin LitNumType) # get :: BinHandle -> IO LitNumType #
Eq LitNumType
Instance details Defined in GHC.Types.Literal Methods (==) :: LitNumType -> LitNumType -> Bool # (/=) :: LitNumType -> LitNumType -> Bool #
Ord LitNumType
Instance details Defined in GHC.Types.Literal Methods compare :: LitNumType -> LitNumType -> Ordering # (<) :: LitNumType -> LitNumType -> Bool # (<=) :: LitNumType -> LitNumType -> Bool # (>) :: LitNumType -> LitNumType -> Bool # (>=) :: LitNumType -> LitNumType -> Bool # max :: LitNumType -> LitNumType -> LitNumType # min :: LitNumType -> LitNumType -> LitNumType #

data Literal #

So-called Literals are one of:

An unboxed numeric literal or floating-point literal which is presumed to be surrounded by appropriate constructors (Int#, etc.), so that the overall thing makes sense.

We maintain the invariant that the Integer in the LitNumber constructor is actually in the (possibly target-dependent) range. The mkLit{Int,Word}*Wrap smart constructors ensure this by applying the target machine's wrapping semantics. Use these in situations where you know the wrapping semantics are correct.

The literal derived from the label mentioned in a "foreign label" declaration (LitLabel)
A LitRubbish to be used in place of values that are never used.
A character
A string
The NULL pointer

Constructors

LitChar Char	`Char#` - at least 31 bits. Create with `mkLitChar`
LitNumber !LitNumType !Integer	Any numeric literal that can be internally represented with an Integer.
LitString !ByteString	A string-literal: stored and emitted UTF-8 encoded, we'll arrange to decode it at runtime. Also emitted with a `'\0'` terminator. Create with `mkLitString`
LitNullAddr	The `NULL` pointer, the only pointer value that can be represented as a Literal. Create with `nullAddrLit`
LitRubbish TypeOrConstraint RuntimeRepType	A nonsense value; See Note [Rubbish literals].
LitFloat Rational	`Float#`. Create with `mkLitFloat`
LitDouble Rational	`Double#`. Create with `mkLitDouble`
LitLabel FastString (Maybe Int) FunctionOrData	A label literal. Parameters: 1) The name of the symbol mentioned in the declaration 2) The size (in bytes) of the arguments the label expects. Only applicable with `stdcall` labels. `Just x` => `<x>` will be appended to label name when emitting assembly. 3) Flag indicating whether the symbol references a function or a data

Instances

Instances details

Data Literal
Instance details Defined in GHC.Types.Literal Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Literal -> c Literal # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Literal # toConstr :: Literal -> Constr # dataTypeOf :: Literal -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Literal) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Literal) # gmapT :: (forall b. Data b => b -> b) -> Literal -> Literal # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Literal -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Literal -> r # gmapQ :: (forall d. Data d => d -> u) -> Literal -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Literal -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Literal -> m Literal # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Literal -> m Literal # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Literal -> m Literal #
Binary Literal
Instance details Defined in GHC.Types.Literal Methods put_ :: BinHandle -> Literal -> IO () # put :: BinHandle -> Literal -> IO (Bin Literal) # get :: BinHandle -> IO Literal #
Outputable Literal
Instance details Defined in GHC.Types.Literal Methods ppr :: Literal -> SDoc #
Eq Literal
Instance details Defined in GHC.Types.Literal Methods (==) :: Literal -> Literal -> Bool # (/=) :: Literal -> Literal -> Bool #
Ord Literal	Needed for the `Ord` instance of `AltCon`, which in turn is needed in `CoreMap`.
Instance details Defined in GHC.Types.Literal Methods compare :: Literal -> Literal -> Ordering # (<) :: Literal -> Literal -> Bool # (<=) :: Literal -> Literal -> Bool # (>) :: Literal -> Literal -> Bool # (>=) :: Literal -> Literal -> Bool # max :: Literal -> Literal -> Literal # min :: Literal -> Literal -> Literal #

type LiftCoEnv = VarEnv Coercion #

data NormaliseStepResult ev #

The result of stepping in a normalisation function. See topNormaliseTypeX.

Constructors

NS_Done	Nothing more to do
NS_Abort	Utter failure. The outer function should fail too.
NS_Step RecTcChecker Type ev	We stepped, yielding new bits; ^ ev is evidence; Usually a co :: old type ~ new type

Instances

Instances details

Functor NormaliseStepResult
Instance details Defined in GHC.Core.Coercion Methods fmap :: (a -> b) -> NormaliseStepResult a -> NormaliseStepResult b # (<$) :: a -> NormaliseStepResult b -> NormaliseStepResult a #
Outputable ev => Outputable (NormaliseStepResult ev)
Instance details Defined in GHC.Core.Coercion Methods ppr :: NormaliseStepResult ev -> SDoc #

type NormaliseStepper ev = RecTcChecker -> TyCon -> [Type] -> NormaliseStepResult ev #

A function to check if we can reduce a type by one step. Used with topNormaliseTypeX.

data GhcHint #

A type for hints emitted by GHC. A hint suggests a possible way to deal with a particular warning or error.

Constructors

(Outputable a, Typeable a) => UnknownHint a	An "unknown" hint. This type constructor allows arbitrary -- hints to be embedded. The typical use case would be GHC plugins -- willing to emit hints alongside their custom diagnostics.
SuggestExtension !LanguageExtensionHint	Suggests adding a particular language extension. GHC will do its best trying to guess when the user is using the syntax of a particular language extension without having the relevant extension enabled. Example: If the user uses the keyword "mdo" (and we are in a monadic block), but the relevant extension is not enabled, GHC will emit a 'SuggestExtension RecursiveDo'. Test case(s): parsershould_failT12429, parsershould_failT8501c, parsershould_failT18251e, ... (and many more)
SuggestCorrectPragmaName ![String]	Suggests possible corrections of a misspelled pragma. Its argument represents all applicable suggestions. Example: {-# LNGUAGE BangPatterns #-} Test case(s): parsershould_compileT21589
SuggestMissingDo	Suggests that a monadic code block is probably missing a "do" keyword. Example: main = putStrLn "hello" putStrLn "world" Test case(s): parsershould_failT8501a, parsershould_failreadFail007, parsershould_failInfixAppPatErr, parsershould_failT984
SuggestLetInDo	Suggests that a "let" expression is needed in a "do" block. Test cases: None (that explicitly test this particular hint is emitted).
SuggestAddSignatureCabalFile !ModuleName	Suggests to add an ".hsig" signature file to the Cabal manifest. Triggered by: `DriverUnexpectedSignature`, if Cabal is being used. Example: See comment of `DriverUnexpectedSignature`. Test case(s): driver/T12955
SuggestSignatureInstantiations !ModuleName [InstantiationSuggestion]	Suggests to explicitly list the instantiations for the signatures in the GHC invocation command. Triggered by: `DriverUnexpectedSignature`, if Cabal is not being used. Example: See comment of `DriverUnexpectedSignature`. Test case(s): driver/T12955
SuggestUseSpaces	Suggests to use spaces instead of tabs. Triggered by: `PsWarnTab`. Examples: None Test Case(s): None
SuggestUseWhitespaceAfter !OperatorWhitespaceSymbol	Suggests adding a whitespace after the given symbol. Examples: None Test Case(s): parsershould_compileT18834a.hs
SuggestUseWhitespaceAround !String !OperatorWhitespaceOccurrence	Suggests adding a whitespace around the given operator symbol, as it might be repurposed as special syntax by a future language extension. The second parameter is how such operator occurred, if in a prefix, suffix or tight infix position. Triggered by: `PsWarnOperatorWhitespace`. Example: h a b = a+b -- not OK, no spaces around `+`. Test Case(s): parsershould_compileT18834b.hs
SuggestParentheses	Suggests wrapping an expression in parentheses Examples: None Test Case(s): None
SuggestIncreaseMaxPmCheckModels	Suggests to increase the -fmax-pmcheck-models limit for the pattern match checker. Triggered by: `DsMaxPmCheckModelsReached` Test case(s): pmcheckshould_compileTooManyDeltas pmcheckshould_compileTooManyDeltas pmcheckshould_compileT11822
SuggestAddTypeSignatures AvailableBindings	Suggests adding a type signature, typically to resolve ambiguity or help GHC inferring types.
SuggestBindToWildcard !(LHsExpr GhcTc)	Suggests to explicitly discard the result of a monadic action by binding the result to the '_' wilcard. Example: main = do _ <- getCurrentTime
SuggestAddInlineOrNoInlinePragma !Var !Activation
SuggestAddPhaseToCompetingRule !RuleName
SuggestAddToHSigExportList !Name !(Maybe Module)	Suggests adding an identifier to the export list of a signature.
SuggestIncreaseSimplifierIterations	Suggests increasing the limit for the number of iterations in the simplifier.
SuggestUseTypeFromDataKind (Maybe RdrName)	Suggests to explicitly import `Type` from the `Kind` module, because using "*" to mean `Type` relies on the StarIsType extension, which will become deprecated in the future. Triggered by: `PsWarnStarIsType` Example: None Test case(s): wcompat-warnings/WCompatWarningsOn.hs
SuggestQualifiedAfterModuleName	Suggests placing the `qualified` keyword after the module name. Triggered by: `PsWarnImportPreQualified` Example: None Test case(s): module/mod184.hs
SuggestThQuotationSyntax	Suggests using TemplateHaskell quotation syntax. Triggered by: `PsErrEmptyDoubleQuotes` only if TemplateHaskell is enabled. Example: None Test case(s): parsershould_failT13450TH.hs
SuggestRoles [Role]	Suggests alternative roles in case we found an illegal one. Triggered by: `PsErrIllegalRoleName` Example: None Test case(s): rolesshould_failRoles7.hs
SuggestQualifyStarOperator	Suggests qualifying the `*` operator in modules where StarIsType is enabled. Triggered by: `PsWarnStarBinder` Test case(s): warningsshould_compileStarBinder.hs
SuggestTypeSignatureForm	Suggests that a type signature should have form variable :: type in order to be accepted by GHC. Triggered by: `PsErrInvalidTypeSignature` Test case(s): parsershould_failT3811
SuggestFixOrphanInstance	Suggests to move an orphan instance or to newtype-wrap it. Triggered by: `TcRnOrphanInstance` Test cases(s): warningsshould_compileT9178 typecheckshould_compileT4912
SuggestAddStandaloneDerivation	Suggests to use a standalone deriving declaration when GHC can't derive a typeclass instance in a trivial way. Triggered by: `DerivBadErrConstructor` Test cases(s): typecheckshould_failtcfail086
SuggestFillInWildcardConstraint	Suggests the user to fill in the wildcard constraint to disambiguate which constraint that is. Example: deriving instance _ => Eq (Foo f a) Triggered by: `DerivBadErrConstructor` Test cases(s): partial-sigsshould_failT13324_fail2
SuggestRenameForall	Suggests to use an identifier other than `forall` Triggered by: `TcRnForallIdentifier`
SuggestAppropriateTHTick NameSpace	Suggests to use the appropriate Template Haskell tick: a single tick for a term-level `NameSpace`, or a double tick for a type-level `NameSpace`. Triggered by: `TcRnIncorrectNameSpace`.
SuggestDumpSlices	Suggests enabling -ddump-splices to help debug an issue when a `Name` is not in scope or is used in multiple different namespaces (e.g. both as a data constructor and a type constructor). Concomitant with `NoExactName` or `SameName` errors, see e.g. "GHC.Rename.Env.lookupExactOcc_either". Test cases: T5971, T7241, T13937.
SuggestAddTick UntickedPromotedThing	Suggests adding a tick to refer to something which has been promoted to the type level, e.g. a data constructor. Test cases: T9778, T19984.
SuggestMoveToDeclarationSite	Something is split off from its corresponding declaration. For example, a datatype is given a role declaration in a different module. Test cases: T495, T8485, T2713, T5533.
Fields SDoc fixity declaration, role annotation, type signature, ... RdrName the `RdrName` for the declaration site
SuggestSimilarNames RdrName (NonEmpty SimilarName)	Suggest a similar name that the user might have meant, e.g. suggest `traverse` when the user has written `travrese`. Test case: mod73.
RemindFieldSelectorSuppressed	Remind the user that the field selector has been suppressed because of -XNoFieldSelectors. Test cases: NFSSuppressed, records-nofieldselectors.
Fields suppressed_selector :: RdrName suppressed_parents :: [Name]
ImportSuggestion ImportSuggestion	Suggest importing from a module, removing a `hiding` clause, or explain to the user that we couldn't find a module with the given `ModuleName`. Test cases: mod28, mod36, mod87, mod114, ...
SuggestImportingDataCon	Suggest importing a data constructor to bring it into scope Triggered by: `TcRnTypeCannotBeMarshaled` Test cases: ccfail004
SuggestPlacePragmaInHeader
SuggestPatternMatchingSyntax	Suggest using pattern matching syntax for a non-bidirectional pattern synonym Test cases: patsynshould_failrecord-exquant typecheckshould_failT3176
SuggestSpecialiseVisibilityHints Name	Suggest tips for making a definition visible for the purpose of writing a SPECIALISE pragma for it in a different module. Test cases: none
LoopySuperclassSolveHint PredType ClsInstOrQC

data LanguageExtensionHint #

Constructors

SuggestSingleExtension !SDoc !Extension	Suggest to enable the input extension. This is the hint that GHC emits if this is not a "known" fix, i.e. this is GHC giving its best guess on what extension might be necessary to make a certain program compile. For example, GHC might suggests to enable `BlockArguments` when the user simply formatted incorrectly the input program, so GHC here is trying to be as helpful as possible. If the input `SDoc` is not empty, it will contain some extra information about the why the extension is required, but it's totally irrelevant/redundant for IDEs and other tools.
SuggestAnyExtension !SDoc [Extension]	Suggest to enable the input extensions. The list is to be intended as disjunctive i.e. the user is suggested to enable any of the extensions listed. If the input `SDoc` is not empty, it will contain some extra information about the why the extensions are required, but it's totally irrelevant/redundant for IDEs and other tools.
SuggestExtensions !SDoc [Extension]	Suggest to enable the input extensions. The list is to be intended as conjunctive i.e. the user is suggested to enable all the extensions listed. If the input `SDoc` is not empty, it will contain some extra information about the why the extensions are required, but it's totally irrelevant/redundant for IDEs and other tools.
SuggestExtensionInOrderTo !SDoc !Extension	Suggest to enable the input extension in order to fix a certain problem. This is the suggestion that GHC emits when is more-or-less clear "what's going on". For example, if both `DeriveAnyClass` and `GeneralizedNewtypeDeriving` are turned on, the right thing to do is to enabled `DerivingStrategies`, so in contrast to `SuggestSingleExtension` GHC will be a bit more "imperative" (i.e. "Use X Y Z in order to ... "). If the input `SDoc` is not empty, it will contain some extra information about the why the extensions are required, but it's totally irrelevant/redundant for IDEs and other tools.

data AvailableBindings #

The bindings we have available in scope when suggesting an explicit type signature.

Constructors

NamedBindings (NonEmpty Name)
UnnamedBinding	An unknown binding (i.e. too complicated to turn into a `Name`)

data DiagnosticCode #

A diagnostic code is a namespaced numeric identifier unique to the given diagnostic (error or warning).

All diagnostic codes defined within GHC are given the GHC namespace.

See Note [Diagnostic codes] in GHC.Types.Error.Codes.

Constructors

DiagnosticCode
Fields diagnosticCodeNameSpace :: String diagnostic code prefix (e.g. GHC) diagnosticCodeNumber :: Natural the actual diagnostic code

Instances

Instances details

Outputable DiagnosticCode
Instance details Defined in GHC.Types.Error Methods ppr :: DiagnosticCode -> SDoc #

data Severity #

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

Instances details

Show Severity
Instance details Defined in GHC.Types.Error Methods showsPrec :: Int -> Severity -> ShowS # show :: Severity -> String # showList :: [Severity] -> ShowS #
ToJson Severity
Instance details Defined in GHC.Types.Error Methods json :: Severity -> JsonDoc #
Outputable Severity
Instance details Defined in GHC.Types.Error Methods ppr :: Severity -> SDoc #
Eq Severity
Instance details Defined in GHC.Types.Error Methods (==) :: Severity -> Severity -> Bool # (/=) :: Severity -> Severity -> Bool #

data MessageClass #

The class for a diagnostic message. The main purpose is to classify a message within GHC, to distinguish it from a debug/dump message vs a proper diagnostic, for which we include a DiagnosticReason.

Constructors

MCOutput
MCFatal
MCInteractive
MCDump	Log message intended for compiler developers No file/line/column stuff
MCInfo	Log messages intended for end users. No file/line/column stuff.
MCDiagnostic Severity DiagnosticReason (Maybe DiagnosticCode)	Diagnostics from the compiler. This constructor is very powerful as it allows the construction of a `MessageClass` with a completely arbitrary permutation of `Severity` and `DiagnosticReason`. As such, users are encouraged to use the `mkMCDiagnostic` smart constructor instead. Use this constructor directly only if you need to construct and manipulate diagnostic messages directly, for example inside `Error`. In all the other circumstances, especially when emitting compiler diagnostics, use the smart constructor. The `Maybe DiagnosticCode` field carries a code (if available) for this diagnostic. If you are creating a message not tied to any error-message type, then use Nothing. In the long run, this really should always have a `DiagnosticCode`. See Note [Diagnostic codes].

Instances

Instances details

ToJson MessageClass
Instance details Defined in GHC.Types.Error Methods json :: MessageClass -> JsonDoc #

data MsgEnvelope e #

An envelope for GHC's facts about a running program, parameterised over the domain-specific (i.e. parsing, typecheck-renaming, etc) diagnostics.

To say things differently, GHC emits diagnostics about the running program, each of which is wrapped into a MsgEnvelope that carries specific information like where the error happened, etc. Finally, multiple MsgEnvelopes are aggregated into Messages that are returned to the user.

Constructors

MsgEnvelope
Fields errMsgSpan :: SrcSpan The SrcSpan is used for sorting errors into line-number order errMsgContext :: NamePprCtx errMsgDiagnostic :: e errMsgSeverity :: Severity

Instances

Instances details

Foldable MsgEnvelope
Instance details Defined in GHC.Types.Error Methods fold :: Monoid m => MsgEnvelope m -> m # foldMap :: Monoid m => (a -> m) -> MsgEnvelope a -> m # foldMap' :: Monoid m => (a -> m) -> MsgEnvelope a -> m # foldr :: (a -> b -> b) -> b -> MsgEnvelope a -> b # foldr' :: (a -> b -> b) -> b -> MsgEnvelope a -> b # foldl :: (b -> a -> b) -> b -> MsgEnvelope a -> b # foldl' :: (b -> a -> b) -> b -> MsgEnvelope a -> b # foldr1 :: (a -> a -> a) -> MsgEnvelope a -> a # foldl1 :: (a -> a -> a) -> MsgEnvelope a -> a # toList :: MsgEnvelope a -> [a] # null :: MsgEnvelope a -> Bool # length :: MsgEnvelope a -> Int # elem :: Eq a => a -> MsgEnvelope a -> Bool # maximum :: Ord a => MsgEnvelope a -> a # minimum :: Ord a => MsgEnvelope a -> a # sum :: Num a => MsgEnvelope a -> a # product :: Num a => MsgEnvelope a -> a #
Traversable MsgEnvelope
Instance details Defined in GHC.Types.Error Methods traverse :: Applicative f => (a -> f b) -> MsgEnvelope a -> f (MsgEnvelope b) # sequenceA :: Applicative f => MsgEnvelope (f a) -> f (MsgEnvelope a) # mapM :: Monad m => (a -> m b) -> MsgEnvelope a -> m (MsgEnvelope b) # sequence :: Monad m => MsgEnvelope (m a) -> m (MsgEnvelope a) #
Functor MsgEnvelope
Instance details Defined in GHC.Types.Error Methods fmap :: (a -> b) -> MsgEnvelope a -> MsgEnvelope b # (<$) :: a -> MsgEnvelope b -> MsgEnvelope a #
Show (MsgEnvelope DiagnosticMessage)
Instance details Defined in GHC.Types.Error Methods showsPrec :: Int -> MsgEnvelope DiagnosticMessage -> ShowS # show :: MsgEnvelope DiagnosticMessage -> String # showList :: [MsgEnvelope DiagnosticMessage] -> ShowS #

data DiagnosticReason #

The reason why a Diagnostic was emitted in the first place. Diagnostic messages are born within GHC with a very precise reason, which can be completely statically-computed (i.e. this is an error or a warning no matter what), or influenced by the specific state of the DynFlags at the moment of the creation of a new Diagnostic. For example, a parsing error is always going to be an error, whereas a 'WarningWithoutFlag Opt_WarnUnusedImports' might turn into an error due to '-Werror' or '-Werror=warn-unused-imports'. Interpreting a DiagnosticReason together with its associated Severity gives us the full picture.

Constructors

WarningWithoutFlag	Born as a warning.
WarningWithFlag !WarningFlag	Warning was enabled with the flag.
ErrorWithoutFlag	Born as an error.

Instances

Instances details

Show DiagnosticReason
Instance details Defined in GHC.Types.Error Methods showsPrec :: Int -> DiagnosticReason -> ShowS # show :: DiagnosticReason -> String # showList :: [DiagnosticReason] -> ShowS #
Outputable DiagnosticReason
Instance details Defined in GHC.Types.Error Methods ppr :: DiagnosticReason -> SDoc #
Eq DiagnosticReason
Instance details Defined in GHC.Types.Error Methods (==) :: DiagnosticReason -> DiagnosticReason -> Bool # (/=) :: DiagnosticReason -> DiagnosticReason -> Bool #

data DiagnosticMessage #

A generic Diagnostic message, without any further classification or provenance: By looking at a DiagnosticMessage we don't know neither where it was generated nor how to intepret its payload (as it's just a structured document). All we can do is to print it out and look at its DiagnosticReason.

Constructors

DiagnosticMessage
Fields diagMessage :: !DecoratedSDoc diagReason :: !DiagnosticReason diagHints :: [GhcHint]

Instances

Instances details

Diagnostic DiagnosticMessage
Instance details Defined in GHC.Types.Error Associated Types type DiagnosticOpts DiagnosticMessage # Methods defaultDiagnosticOpts :: DiagnosticOpts DiagnosticMessage # diagnosticMessage :: DiagnosticOpts DiagnosticMessage -> DiagnosticMessage -> DecoratedSDoc # diagnosticReason :: DiagnosticMessage -> DiagnosticReason # diagnosticHints :: DiagnosticMessage -> [GhcHint] # diagnosticCode :: DiagnosticMessage -> Maybe DiagnosticCode #
Show (MsgEnvelope DiagnosticMessage)
Instance details Defined in GHC.Types.Error Methods showsPrec :: Int -> MsgEnvelope DiagnosticMessage -> ShowS # show :: MsgEnvelope DiagnosticMessage -> String # showList :: [MsgEnvelope DiagnosticMessage] -> ShowS #
type DiagnosticOpts DiagnosticMessage
Instance details Defined in GHC.Types.Error type DiagnosticOpts DiagnosticMessage = NoDiagnosticOpts

data DiagnosticHint #

A generic Hint message, to be used with DiagnosticMessage.

Constructors

DiagnosticHint !SDoc

Instances

Instances details

Outputable DiagnosticHint
Instance details Defined in GHC.Types.Error Methods ppr :: DiagnosticHint -> SDoc #

data NoDiagnosticOpts #

Constructors

NoDiagnosticOpts

data UnknownDiagnostic where #

An existential wrapper around an unknown diagnostic.

Constructors

UnknownDiagnostic :: forall a. (DiagnosticOpts a ~ NoDiagnosticOpts, Diagnostic a, Typeable a) => a -> UnknownDiagnostic

Instances

Instances details

Diagnostic UnknownDiagnostic
Instance details Defined in GHC.Types.Error Associated Types type DiagnosticOpts UnknownDiagnostic # Methods defaultDiagnosticOpts :: DiagnosticOpts UnknownDiagnostic # diagnosticMessage :: DiagnosticOpts UnknownDiagnostic -> UnknownDiagnostic -> DecoratedSDoc # diagnosticReason :: UnknownDiagnostic -> DiagnosticReason # diagnosticHints :: UnknownDiagnostic -> [GhcHint] # diagnosticCode :: UnknownDiagnostic -> Maybe DiagnosticCode #
type DiagnosticOpts UnknownDiagnostic
Instance details Defined in GHC.Types.Error type DiagnosticOpts UnknownDiagnostic = NoDiagnosticOpts

class Diagnostic a where #

A class identifying a diagnostic. Dictionary.com defines a diagnostic as:

"a message output by a computer diagnosing an error in a computer program, computer system, or component device".

A Diagnostic carries the actual description of the message (which, in GHC's case, it can be an error or a warning) and the reason why such message was generated in the first place.

Associated Types

type DiagnosticOpts a #

Type of configuration options for the diagnostic.

Methods

defaultDiagnosticOpts :: DiagnosticOpts a #

diagnosticMessage :: DiagnosticOpts a -> a -> DecoratedSDoc #

Extract the error message text from a Diagnostic.

diagnosticReason :: a -> DiagnosticReason #

Extract the reason for this diagnostic. For warnings, a DiagnosticReason includes the warning flag.

diagnosticHints :: a -> [GhcHint] #

Extract any hints a user might use to repair their code to avoid this diagnostic.

diagnosticCode :: a -> Maybe DiagnosticCode #

Get the DiagnosticCode associated with this Diagnostic. This can return Nothing for at least two reasons:

The message might be from a plugin that does not supply codes.
The message might not yet have been assigned a code. See the Diagnostic instance for DiagnosticMessage.

Ideally, case (2) would not happen, but because some errors in GHC still use the old system of just writing the error message in-place (instead of using a dedicated error type and constructor), we do not have error codes for all errors. #18516 tracks our progress toward this goal.

Instances

Instances details

Diagnostic DiagnosticMessage
Instance details Defined in GHC.Types.Error Associated Types type DiagnosticOpts DiagnosticMessage # Methods defaultDiagnosticOpts :: DiagnosticOpts DiagnosticMessage # diagnosticMessage :: DiagnosticOpts DiagnosticMessage -> DiagnosticMessage -> DecoratedSDoc # diagnosticReason :: DiagnosticMessage -> DiagnosticReason # diagnosticHints :: DiagnosticMessage -> [GhcHint] # diagnosticCode :: DiagnosticMessage -> Maybe DiagnosticCode #
Diagnostic UnknownDiagnostic
Instance details Defined in GHC.Types.Error Associated Types type DiagnosticOpts UnknownDiagnostic # Methods defaultDiagnosticOpts :: DiagnosticOpts UnknownDiagnostic # diagnosticMessage :: DiagnosticOpts UnknownDiagnostic -> UnknownDiagnostic -> DecoratedSDoc # diagnosticReason :: UnknownDiagnostic -> DiagnosticReason # diagnosticHints :: UnknownDiagnostic -> [GhcHint] # diagnosticCode :: UnknownDiagnostic -> Maybe DiagnosticCode #

type family DiagnosticOpts a #

Type of configuration options for the diagnostic.

Instances

Instances details

type DiagnosticOpts DriverMessage
Instance details Defined in GHC.Driver.Errors.Ppr type DiagnosticOpts DriverMessage = DriverMessageOpts
type DiagnosticOpts GhcMessage
Instance details Defined in GHC.Driver.Errors.Ppr type DiagnosticOpts GhcMessage = GhcMessageOpts
type DiagnosticOpts DsMessage
Instance details Defined in GHC.HsToCore.Errors.Ppr type DiagnosticOpts DsMessage = NoDiagnosticOpts
type DiagnosticOpts PsMessage
Instance details Defined in GHC.Parser.Errors.Ppr type DiagnosticOpts PsMessage = NoDiagnosticOpts
type DiagnosticOpts TcRnMessage
Instance details Defined in GHC.Tc.Errors.Ppr type DiagnosticOpts TcRnMessage = TcRnMessageOpts
type DiagnosticOpts DiagnosticMessage
Instance details Defined in GHC.Types.Error type DiagnosticOpts DiagnosticMessage = NoDiagnosticOpts
type DiagnosticOpts UnknownDiagnostic
Instance details Defined in GHC.Types.Error type DiagnosticOpts UnknownDiagnostic = NoDiagnosticOpts

data DecoratedSDoc #

A DecoratedSDoc is isomorphic to a '[SDoc]' but it carries the invariant that the input '[SDoc]' needs to be rendered decorated into its final form, where the typical case would be adding bullets between each elements of the list. The type of decoration depends on the formatting function used, but in practice GHC uses the formatBulleted.

data Messages e #

A collection of messages emitted by GHC during error reporting. A diagnostic message is typically a warning or an error. See Note [Messages].

INVARIANT: All the messages in this collection must be relevant, i.e. their Severity should not be SevIgnore. The smart constructor mkMessages will filter out any message which Severity is SevIgnore.

Instances

Instances details

Foldable Messages
Instance details Defined in GHC.Types.Error Methods fold :: Monoid m => Messages m -> m # foldMap :: Monoid m => (a -> m) -> Messages a -> m # foldMap' :: Monoid m => (a -> m) -> Messages a -> m # foldr :: (a -> b -> b) -> b -> Messages a -> b # foldr' :: (a -> b -> b) -> b -> Messages a -> b # foldl :: (b -> a -> b) -> b -> Messages a -> b # foldl' :: (b -> a -> b) -> b -> Messages a -> b # foldr1 :: (a -> a -> a) -> Messages a -> a # foldl1 :: (a -> a -> a) -> Messages a -> a # toList :: Messages a -> [a] # null :: Messages a -> Bool # length :: Messages a -> Int # elem :: Eq a => a -> Messages a -> Bool # maximum :: Ord a => Messages a -> a # minimum :: Ord a => Messages a -> a # sum :: Num a => Messages a -> a # product :: Num a => Messages a -> a #
Traversable Messages
Instance details Defined in GHC.Types.Error Methods traverse :: Applicative f => (a -> f b) -> Messages a -> f (Messages b) # sequenceA :: Applicative f => Messages (f a) -> f (Messages a) # mapM :: Monad m => (a -> m b) -> Messages a -> m (Messages b) # sequence :: Monad m => Messages (m a) -> m (Messages a) #
Functor Messages
Instance details Defined in GHC.Types.Error Methods fmap :: (a -> b) -> Messages a -> Messages b # (<$) :: a -> Messages b -> Messages a #
Monoid (Messages e)
Instance details Defined in GHC.Types.Error Methods mempty :: Messages e # mappend :: Messages e -> Messages e -> Messages e # mconcat :: [Messages e] -> Messages e #
Semigroup (Messages e)
Instance details Defined in GHC.Types.Error Methods (<>) :: Messages e -> Messages e -> Messages e # sconcat :: NonEmpty (Messages e) -> Messages e # stimes :: Integral b => b -> Messages e -> Messages e #
Diagnostic e => Outputable (Messages e)
Instance details Defined in GHC.Types.Error Methods ppr :: Messages e -> SDoc #

type Validity = Validity' SDoc #

Monomorphic version of Validity' specialised for SDocs.

data Validity' a #

Constructors

IsValid	Everything is fine
NotValid a	A problem, and some indication of why

Instances

Instances details

Functor Validity'
Instance details Defined in GHC.Utils.Error Methods fmap :: (a -> b) -> Validity' a -> Validity' b # (<$) :: a -> Validity' b -> Validity' a #

data DiagOpts #

Constructors

DiagOpts
Fields diag_warning_flags :: !(EnumSet WarningFlag) Enabled warnings diag_fatal_warning_flags :: !(EnumSet WarningFlag) Fatal warnings diag_warn_is_error :: !Bool Treat warnings as errors diag_reverse_errors :: !Bool Reverse error reporting order diag_max_errors :: !(Maybe Int) Max reported error count diag_ppr_ctx :: !SDocContext Error printing context

data Tick #

Instances

Instances details

Outputable Tick
Instance details Defined in GHC.Core.Opt.Stats Methods ppr :: Tick -> SDoc #
Eq Tick
Instance details Defined in GHC.Core.Opt.Stats Methods (==) :: Tick -> Tick -> Bool # (/=) :: Tick -> Tick -> Bool #
Ord Tick
Instance details Defined in GHC.Core.Opt.Stats Methods compare :: Tick -> Tick -> Ordering # (<) :: Tick -> Tick -> Bool # (<=) :: Tick -> Tick -> Bool # (>) :: Tick -> Tick -> Bool # (>=) :: Tick -> Tick -> Bool # max :: Tick -> Tick -> Tick # min :: Tick -> Tick -> Tick #

data SimplCount #

data StrictnessMark #

Constructors

MarkedStrict
NotMarkedStrict

Instances

Instances details

Binary StrictnessMark
Instance details Defined in GHC.Core.DataCon Methods put_ :: BinHandle -> StrictnessMark -> IO () # put :: BinHandle -> StrictnessMark -> IO (Bin StrictnessMark) # get :: BinHandle -> IO StrictnessMark #
Outputable StrictnessMark
Instance details Defined in GHC.Core.DataCon Methods ppr :: StrictnessMark -> SDoc #
Eq StrictnessMark
Instance details 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

Instances details

Data HsImplBang
Instance details 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
Instance details Defined in GHC.Core.DataCon Methods ppr :: HsImplBang -> SDoc #

data HsSrcBang #

Haskell Source Bang

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

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

Constructors

HsSrcBang SourceText SrcUnpackedness SrcStrictness

Instances

Instances details

Data HsSrcBang
Instance details Defined in 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
Instance details Defined in GHC.Core.DataCon Methods ppr :: HsSrcBang -> SDoc #

type DataConEnv a = UniqFM DataCon a #

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

Instances details

type Anno (AmbiguousFieldOcc (GhcPass p))
Instance details Defined in GHC.Hs.Type type Anno (AmbiguousFieldOcc (GhcPass p)) = SrcAnn NoEpAnns

type LAmbiguousFieldOcc pass = XRec pass (AmbiguousFieldOcc pass) #

Located Ambiguous Field Occurence

data FieldOcc pass #

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 foExt :: XCFieldOcc pass foLabel :: XRec pass RdrName
XFieldOcc !(XXFieldOcc pass)

Instances

Instances details

(Eq (XRec pass RdrName), Eq (XCFieldOcc pass), Eq (XXFieldOcc pass)) => Eq (FieldOcc pass)
Instance details Defined in Language.Haskell.Syntax.Type Methods (==) :: FieldOcc pass -> FieldOcc pass -> Bool # (/=) :: FieldOcc pass -> FieldOcc pass -> Bool #
type Anno (FieldOcc (GhcPass p))
Instance details Defined in GHC.Hs.Type type Anno (FieldOcc (GhcPass p)) = SrcAnn NoEpAnns

type LFieldOcc pass = XRec pass (FieldOcc pass) #

Located Field Occurrence

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

data HsArg tm ty #

Arguments in an expression/type after splitting

Constructors

HsValArg tm
HsTypeArg SrcSpan ty
HsArgPar SrcSpan

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 HsConDeclH98Details in GHC.Hs.Decls).
The arguments in constructor patterns in case/function definitions (see HsConPatDetails in GHC.Hs.Pat).
The left-hand side arguments in a pattern synonym binding (see HsPatSynDetails in 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).

Constructors

PrefixCon [tyarg] [arg]
RecCon rec
InfixCon arg arg

Instances

Instances details

(Data tyarg, Data rec, Data arg) => Data (HsConDetails tyarg arg rec)

Instance details

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

data ConDeclField pass #

Constructor Declaration Field

Constructors

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

Instances

Instances details

type Anno (ConDeclField (GhcPass p))
Instance details Defined in GHC.Hs.Type type Anno (ConDeclField (GhcPass p)) = SrcSpanAnnA
type Anno [LocatedA (ConDeclField (GhcPass _1))]
Instance details Defined in GHC.Hs.Decls type Anno [LocatedA (ConDeclField (GhcPass _1))] = SrcSpanAnnL

type LConDeclField pass #

Arguments

= XRec pass (ConDeclField pass)

May have AnnKeywordId : AnnComma when in a list

Located Constructor Declaration Field

data HsTupleSort #

Haskell Tuple Sort

Constructors

HsUnboxedTuple
HsBoxedOrConstraintTuple

Instances

Instances details

Data HsTupleSort

Instance details

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 #

data HsScaled pass a #

This is used in the syntax. In constructor declaration. It must keep the arrow representation.

Constructors

HsScaled (HsArrow pass) a

data HsLinearArrowTokens pass #

Constructors

HsPct1 !(LHsToken "%1" pass) !(LHsUniToken "->" "\8594" pass)
HsLolly !(LHsToken "\8888" pass)

data HsArrow 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 `HsType` so as to preserve the syntax as written in the program.

data HsTyLit pass #

Haskell Type Literal

Constructors

HsNumTy (XNumTy pass) Integer
HsStrTy (XStrTy pass) FastString
HsCharTy (XCharTy pass) Char
XTyLit !(XXTyLit pass)

data HsType pass #

Haskell Type

Constructors

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

Instances

Instances details

DisambTD (HsType GhcPs)
Instance details Defined in GHC.Parser.PostProcess Methods mkHsAppTyHeadPV :: LHsType GhcPs -> PV (LocatedA (HsType GhcPs)) # mkHsAppTyPV :: LocatedA (HsType GhcPs) -> LHsType GhcPs -> PV (LocatedA (HsType GhcPs)) # mkHsAppKindTyPV :: LocatedA (HsType GhcPs) -> SrcSpan -> LHsType GhcPs -> PV (LocatedA (HsType GhcPs)) # mkHsOpTyPV :: PromotionFlag -> LHsType GhcPs -> LocatedN RdrName -> LHsType GhcPs -> PV (LocatedA (HsType GhcPs)) # mkUnpackednessPV :: Located UnpackednessPragma -> LocatedA (HsType GhcPs) -> PV (LocatedA (HsType GhcPs)) #
type Anno (BangType (GhcPass p))
Instance details Defined in GHC.Hs.Type type Anno (BangType (GhcPass p)) = SrcSpanAnnA
type Anno (HsKind (GhcPass p))
Instance details Defined in GHC.Hs.Type type Anno (HsKind (GhcPass p)) = SrcSpanAnnA
type Anno (HsType (GhcPass p))
Instance details Defined in GHC.Hs.Type type Anno (HsType (GhcPass p)) = SrcSpanAnnA
type Anno [LocatedA (HsType (GhcPass p))]
Instance details Defined in GHC.Hs.Type type Anno [LocatedA (HsType (GhcPass p))] = SrcSpanAnnC
type Anno (FamEqn p (LocatedA (HsType p)))
Instance details Defined in GHC.Hs.Decls type Anno (FamEqn p (LocatedA (HsType p))) = SrcSpanAnnA

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)	`AnnKeywordId` : `AnnOpen`, `AnnDcolon`, `AnnClose`
XTyVarBndr !(XXTyVarBndr pass)

Instances

Instances details

type Anno (HsTyVarBndr _flag (GhcPass _1))
Instance details Defined in GHC.Hs.Type type Anno (HsTyVarBndr _flag (GhcPass _1)) = SrcSpanAnnA
type Anno (HsTyVarBndr _flag GhcPs)
Instance details Defined in GHC.Hs.Type type Anno (HsTyVarBndr _flag GhcPs) = SrcSpanAnnA
type Anno (HsTyVarBndr _flag GhcRn)
Instance details Defined in GHC.Hs.Type type Anno (HsTyVarBndr _flag GhcRn) = SrcSpanAnnA
type Anno (HsTyVarBndr _flag GhcTc)
Instance details Defined in GHC.Hs.Type type Anno (HsTyVarBndr _flag GhcTc) = SrcSpanAnnA

newtype HsIPName #

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

Constructors

HsIPName FastString

Instances

Instances details

Data HsIPName
Instance details 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
Instance details Defined in Language.Haskell.Syntax.Type Methods (==) :: HsIPName -> HsIPName -> Bool # (/=) :: HsIPName -> HsIPName -> Bool #
type Anno HsIPName
Instance details Defined in GHC.Hs.Type type Anno HsIPName = SrcAnn NoEpAnns

data HsSigType pass #

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
Fields sig_ext :: XHsSig pass sig_bndrs :: HsOuterSigTyVarBndrs pass sig_body :: LHsType pass
XHsSigType !(XXHsSigType pass)

Instances

Instances details

type Anno (HsSigType (GhcPass p))
Instance details Defined in GHC.Hs.Type type Anno (HsSigType (GhcPass p)) = SrcSpanAnnA

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
Fields hsps_ext :: XHsPS pass After renamer: `HsPSRn` hsps_body :: LHsType pass Main payload (the type itself)
XHsPatSigType !(XXHsPatSigType pass)

data HsWildCardBndrs pass thing #

Haskell Wildcard Binders

Constructors

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

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., `f :: a -> b -> b`
Fields hso_ximplicit :: XHsOuterImplicit pass
HsOuterExplicit	Explicit forall, e.g., `f :: forall a b. a -> b -> b`
Fields hso_xexplicit :: XHsOuterExplicit pass flag hso_bndrs :: [LHsTyVarBndr flag (NoGhcTc pass)]
XHsOuterTyVarBndrs !(XXHsOuterTyVarBndrs pass)

Instances

Instances details

type Anno (HsOuterTyVarBndrs _1 (GhcPass _2))
Instance details Defined in GHC.Hs.Type type Anno (HsOuterTyVarBndrs _1 (GhcPass _2)) = SrcSpanAnnA

data LHsQTyVars pass #

Located Haskell Quantified Type Variables

Constructors

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

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 `forall` (e.g., `forall a -> {...}`). These do not have any notion of specificity, so we use `()` as a placeholder value.
Fields hsf_xvis :: XHsForAllVis pass hsf_vis_bndrs :: [LHsTyVarBndr () pass]
HsForAllInvis	An invisible `forall` (e.g., `forall a {b} c. {...}`), where each binder has a `Specificity`.
Fields hsf_xinvis :: XHsForAllInvis pass hsf_invis_bndrs :: [LHsTyVarBndr Specificity pass]
XHsForAllTelescope !(XXHsForAllTelescope pass)

type LHsKind pass #

Arguments

= XRec pass (HsKind pass)

AnnKeywordId : AnnDcolon

Located Haskell Kind

type HsKind pass = HsType pass #

Haskell Kind

type LHsType pass #

Arguments

= XRec pass (HsType pass)

May have AnnKeywordId : AnnComma when in a list

Located Haskell Type

type HsContext pass = [LHsType pass] #

Haskell Context

type LHsContext pass #

Arguments

= XRec pass (HsContext pass)

AnnKeywordId : AnnUnit For details on above see Note [exact print annotations] in GHC.Parser.Annotation

Located Haskell Context

type BangType pass = HsType pass #

Bang Type

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

type LBangType pass = XRec pass (BangType pass) #

Located Bang Type

data HsFieldBind lhs rhs #

Haskell Field Binding

AnnKeywordId : AnnEqual,

For details on above see Note [exact print annotations] in GHC.Parser.Annotation

Constructors

HsFieldBind
Fields hfbAnn :: XHsFieldBind lhs hfbLHS :: lhs hfbRHS :: rhs Filled in by renamer when punning hfbPun :: Bool Note [Punning]

Instances

Instances details

Foldable (HsFieldBind lhs)
Instance details 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)
Instance details 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)
Instance details Defined in Language.Haskell.Syntax.Pat Methods fmap :: (a -> b) -> HsFieldBind lhs a -> HsFieldBind lhs b # (<$) :: a -> HsFieldBind lhs b -> HsFieldBind lhs a #
type Anno (HsFieldBind lhs rhs)
Instance details Defined in GHC.Hs.Pat type Anno (HsFieldBind lhs rhs) = SrcSpanAnnA

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

Instances

Instances details

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

data HsRecFields p arg #

Haskell Record Fields

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

Constructors

HsRecFields
Fields rec_flds :: [LHsRecField p arg] rec_dotdot :: Maybe (XRec p RecFieldsDotDot)

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)

type family ConLikeP x #

Instances

Instances details

type ConLikeP GhcPs
Instance details Defined in GHC.Hs.Pat type ConLikeP GhcPs = RdrName
type ConLikeP GhcRn
Instance details Defined in GHC.Hs.Pat type ConLikeP GhcRn = Name
type ConLikeP GhcTc
Instance details Defined in GHC.Hs.Pat type ConLikeP GhcTc = ConLike

data HsPatSynDir id #

Haskell Pattern Synonym Direction

Constructors

Unidirectional
ImplicitBidirectional
ExplicitBidirectional (MatchGroup id (LHsExpr id))

data RecordPatSynField pass #

Record Pattern Synonym Field

Constructors

RecordPatSynField
Fields recordPatSynField :: FieldOcc pass Field label visible in rest of the file recordPatSynPatVar :: LIdP pass Filled in by renamer, the name used internally by the pattern

type HsPatSynDetails pass = HsConDetails Void (LIdP pass) [RecordPatSynField pass] #

Haskell Pattern Synonym Details

data FixitySig pass #

Fixity Signature

Constructors

FixitySig (XFixitySig pass) [LIdP pass] Fixity
XFixitySig !(XXFixitySig pass)

Instances

Instances details

type Anno (FixitySig (GhcPass p))
Instance details Defined in GHC.Hs.Binds type Anno (FixitySig (GhcPass p)) = SrcSpanAnnA

type LFixitySig pass = XRec pass (FixitySig pass) #

Located Fixity Signature

data Sig pass #

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 `_ -> _a -> Bool`, the renamer will leave the unnamed wildcard `_` untouched, and the named wildcard `_a` is then replaced with fresh meta vars in the type. Their names are stored in the type signature that brought them into scope, in this third field to be more specific. `AnnKeywordId` : `AnnDcolon`, `AnnComma`
PatSynSig (XPatSynSig pass) [LIdP pass] (LHsSigType pass)	A pattern synonym type signature pattern Single :: () => (Show a) => a -> [a] `AnnKeywordId` : `AnnPattern`, `AnnDcolon`,`AnnForall` `AnnDot`,`AnnDarrow`
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 `AnnKeywordId` : `AnnDefault`, `AnnDcolon`
FixSig (XFixSig pass) (FixitySig pass)	An ordinary fixity declaration infixl 8 *** `AnnKeywordId` : `AnnInfix`, `AnnVal`
InlineSig (XInlineSig pass) (LIdP pass) InlinePragma	An inline pragma {#- INLINE f #-} `AnnKeywordId` : `AnnOpen` `'{-# INLINE'` and `'['`, `AnnClose`,`AnnOpen`, `AnnVal`,`AnnTilde`, `AnnClose`
SpecSig (XSpecSig pass) (LIdP pass) [LHsSigType pass] InlinePragma	A specialisation pragma {-# SPECIALISE f :: Int -> Int #-} `AnnKeywordId` : `AnnOpen`, `AnnOpen` `'{-# SPECIALISE'` and `'['`, `AnnTilde`, `AnnVal`, `AnnClose` `']'` and `'#-}'`, `AnnDcolon`
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 `AnnKeywordId` : `AnnOpen`, `AnnInstance`,`AnnClose`
MinimalSig (XMinimalSig pass) (LBooleanFormula (LIdP pass))	A minimal complete definition pragma {-# MINIMAL a \| (b, c \| (d \| e)) #-} `AnnKeywordId` : `AnnOpen`, `AnnVbar`,`AnnComma`, `AnnClose`
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)

Instances

Instances details

type Anno (Sig (GhcPass p))
Instance details Defined in GHC.Hs.Binds type Anno (Sig (GhcPass p)) = SrcSpanAnnA

type LSig pass = XRec pass (Sig pass) #

Located Signature

data IPBind id #

Implicit parameter bindings.

AnnKeywordId : AnnEqual

Constructors

IPBind (XCIPBind id) (XRec id HsIPName) (LHsExpr id)
XIPBind !(XXIPBind id)

Instances

Instances details

type Anno (IPBind (GhcPass p))
Instance details Defined in GHC.Hs.Binds type Anno (IPBind (GhcPass p)) = SrcSpanAnnA

type LIPBind id = XRec id (IPBind id) #

Located Implicit Parameter Binding

May have AnnKeywordId : AnnSemi when in a list

data HsIPBinds id #

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 psb_ext :: XPSB idL idR psb_id :: LIdP idL Name of the pattern synonym psb_args :: HsPatSynDetails idR Formal parameter names psb_def :: LPat idR Right-hand side psb_dir :: HsPatSynDir idR Directionality
XPatSynBind !(XXPatSynBind idL idR)

data HsBindLR idL idR #

Haskell Binding with separate Left and Right id's

Constructors

FunBind	Function-like Binding FunBind is used for both functions `f x = e` and variables `f = x -> e` and strict variables `!x = x + 1` Reason 1: Special case for type inference: see `tcMonoBinds`. Reason 2: Instance decls can only have FunBinds, which is convenient. If you change this, you'll need to change e.g. rnMethodBinds But note that the form `f :: a->a = ...` parses as a pattern binding, just like `(f :: a -> a) = ...` Strict bindings have their strictness recorded in the `SrcStrictness` of their `MatchContext`. See Note [FunBind vs PatBind] for details about the relationship between FunBind and PatBind. `AnnKeywordId`s `AnnFunId`, attached to each element of fun_matches `AnnEqual`,`AnnWhere`, `AnnOpen`,`AnnClose`,
Fields fun_ext :: XFunBind idL idR fun_id :: LIdP idL fun_matches :: MatchGroup idR (LHsExpr idR) The payload
PatBind	Pattern Binding The pattern is never a simple variable; That case is done by FunBind. See Note [FunBind vs PatBind] for details about the relationship between FunBind and PatBind.
Fields pat_ext :: XPatBind idL idR pat_lhs :: LPat idL pat_rhs :: GRHSs idR (LHsExpr idR)
VarBind	Variable Binding Dictionary binding and suchlike. All VarBinds are introduced by the type checker
Fields var_ext :: XVarBind idL idR var_id :: IdP idL var_rhs :: LHsExpr idR Located only for consistency
PatSynBind	Patterns Synonym Binding
Fields (XPatSynBind idL idR) (PatSynBind idL idR) `AnnKeywordId` : `AnnPattern`, `AnnLarrow`,`AnnEqual`, `AnnWhere` `AnnOpen` `'{'`,`AnnClose` `'}'`
XHsBindsLR !(XXHsBindsLR idL idR)

Instances

Instances details

type Anno (HsBindLR (GhcPass idL) (GhcPass idR))
Instance details Defined in GHC.Hs.Binds type Anno (HsBindLR (GhcPass idL) (GhcPass idR)) = SrcSpanAnnA

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 HsBind id = HsBindLR id id #

Haskell Binding

type LHsBinds id = LHsBindsLR id id #

Located Haskell Bindings

type LHsBind id = LHsBindLR id id #

Located Haskell Binding

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.

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)

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)]	`AnnKeywordId` : `AnnType`, `AnnRole`
XRoleAnnotDecl !(XXRoleAnnotDecl pass)

Instances

Instances details

type Anno (RoleAnnotDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (RoleAnnotDecl (GhcPass p)) = SrcSpanAnnA

type LRoleAnnotDecl pass = XRec pass (RoleAnnotDecl pass) #

Located Role Annotation Declaration

data AnnProvenance pass #

Annotation Provenance

Constructors

ValueAnnProvenance (LIdP pass)
TypeAnnProvenance (LIdP pass)
ModuleAnnProvenance

type LAnnDecl pass = XRec pass (AnnDecl pass) #

Located Annotation Declaration

data WarnDecl pass #

Warning pragma Declaration

Constructors

Warning (XWarning pass) [LIdP pass] (WarningTxt pass)
XWarnDecl !(XXWarnDecl pass)

Instances

Instances details

type Anno (WarnDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (WarnDecl (GhcPass p)) = SrcSpanAnnA

type LWarnDecl pass = XRec pass (WarnDecl pass) #

Located Warning pragma Declaration

data WarnDecls pass #

Warning pragma Declarations

Constructors

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

Instances

Instances details

type Anno (WarnDecls (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (WarnDecls (GhcPass p)) = SrcSpanAnnA

type LWarnDecls pass = XRec pass (WarnDecls pass) #

Located Warning Declarations

data DocDecl pass #

Documentation comment Declaration

Constructors

DocCommentNext (LHsDoc pass)
DocCommentPrev (LHsDoc pass)
DocCommentNamed String (LHsDoc pass)
DocGroup Int (LHsDoc pass)

Instances

Instances details

(Data pass, Data (IdP pass)) => Data (DocDecl pass)
Instance details 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) #
type Anno (DocDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (DocDecl (GhcPass p)) = SrcSpanAnnA

type LDocDecl pass = XRec pass (DocDecl pass) #

Located Documentation comment Declaration

data RuleBndr pass #

Rule Binder

Constructors

RuleBndr (XCRuleBndr pass) (LIdP pass)
RuleBndrSig (XRuleBndrSig pass) (LIdP pass) (HsPatSigType pass)
XRuleBndr !(XXRuleBndr pass)	`AnnKeywordId` : `AnnOpen`, `AnnDcolon`,`AnnClose`

Instances

Instances details

type Anno (RuleBndr (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (RuleBndr (GhcPass p)) = SrcAnn NoEpAnns

type LRuleBndr pass = XRec pass (RuleBndr pass) #

Located Rule Binder

data RuleDecl pass #

Rule Declaration

Constructors

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

Instances

Instances details

type Anno (RuleDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (RuleDecl (GhcPass p)) = SrcSpanAnnA

type LRuleDecl pass = XRec pass (RuleDecl pass) #

Located Rule Declaration

data RuleDecls pass #

Rule Declarations

Constructors

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

Instances

Instances details

type Anno (RuleDecls (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (RuleDecls (GhcPass p)) = SrcSpanAnnA

type LRuleDecls pass = XRec pass (RuleDecls pass) #

Located Rule Declarations

data ForeignExport pass #

Constructors

CExport (XCExport pass) (XRec pass CExportSpec)
XForeignExport !(XXForeignExport pass)

data CImportSpec #

Constructors

CLabel CLabelString
CFunction CCallTarget
CWrapper

Instances

Instances details

Data CImportSpec

Instance details

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)

data ForeignDecl pass #

Foreign Declaration

Constructors

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

Instances

Instances details

type Anno (ForeignDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (ForeignDecl (GhcPass p)) = SrcSpanAnnA

type LForeignDecl pass = XRec pass (ForeignDecl pass) #

Located Foreign Declaration

data DefaultDecl pass #

Default Declaration

Constructors

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

Instances

Instances details

type Anno (DefaultDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (DefaultDecl (GhcPass p)) = SrcSpanAnnA

type LDefaultDecl pass = XRec pass (DefaultDecl pass) #

Located Default Declaration

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., `Eq`, `Show`, `Functor` when `-XDeriveFunctor` is enabled, etc.)
AnyclassStrategy (XAnyClassStrategy pass)	-XDeriveAnyClass
NewtypeStrategy (XNewtypeStrategy pass)	-XGeneralizedNewtypeDeriving
ViaStrategy (XViaStrategy pass)	-XDerivingVia

Instances

Instances details

type Anno (DerivStrategy (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (DerivStrategy (GhcPass p)) = SrcAnn NoEpAnns

type LDerivStrategy pass = XRec pass (DerivStrategy pass) #

A Located DerivStrategy.

data DerivDecl pass #

Stand-alone 'deriving instance' declaration

Constructors

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

Instances

Instances details

type Anno (DerivDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (DerivDecl (GhcPass p)) = SrcSpanAnnA

type LDerivDecl pass = XRec pass (DerivDecl pass) #

Located stand-alone 'deriving instance' declaration

data InstDecl pass #

Instance Declaration

Constructors

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

Instances

Instances details

type Anno (InstDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (InstDecl (GhcPass p)) = SrcSpanAnnA

type LInstDecl pass = XRec pass (InstDecl pass) #

Located Instance Declaration

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 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) `AnnKeywordId` : `AnnOpen`, `AnnClose`,
XClsInstDecl !(XXClsInstDecl pass)

Instances

Instances details

type Anno (ClsInstDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (ClsInstDecl (GhcPass p)) = SrcSpanAnnA

type LClsInstDecl pass = XRec pass (ClsInstDecl pass) #

Located Class Instance Declaration

data FamEqn pass rhs #

Family Equation

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

Constructors

FamEqn
Fields feqn_ext :: XCFamEqn pass rhs feqn_tycon :: LIdP pass feqn_bndrs :: HsOuterFamEqnTyVarBndrs pass Optional quantified type vars feqn_pats :: HsTyPats pass feqn_fixity :: LexicalFixity Fixity used in the declaration feqn_rhs :: rhs `AnnKeywordId` : `AnnEqual`
XFamEqn !(XXFamEqn pass rhs)

Instances

Instances details

type Anno (FamEqn (GhcPass p) _1)
Instance details Defined in GHC.Hs.Decls type Anno (FamEqn (GhcPass p) _1) = SrcSpanAnnA
type Anno (FamEqn (GhcPass p) _1)
Instance details Defined in GHC.Hs.Decls type Anno (FamEqn (GhcPass p) _1) = SrcSpanAnnA
type Anno (FamEqn p (LocatedA (HsType p)))
Instance details Defined in GHC.Hs.Decls type Anno (FamEqn p (LocatedA (HsType p))) = SrcSpanAnnA

newtype DataFamInstDecl pass #

Data Family Instance Declaration

Constructors

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

Instances

Instances details

type Anno (DataFamInstDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (DataFamInstDecl (GhcPass p)) = SrcSpanAnnA

type LDataFamInstDecl pass = XRec pass (DataFamInstDecl pass) #

Located Data Family Instance Declaration

data TyFamInstDecl pass #

Type Family Instance Declaration

Constructors

TyFamInstDecl	`AnnKeywordId` : `AnnType`, `AnnInstance`,
Fields tfid_xtn :: XCTyFamInstDecl pass tfid_eqn :: TyFamInstEqn pass
XTyFamInstDecl !(XXTyFamInstDecl pass)

Instances

Instances details

type Anno (TyFamInstDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (TyFamInstDecl (GhcPass p)) = SrcSpanAnnA

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 AnnKeywordId : AnnSemi when in a list

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)

type HsConDeclH98Details pass = HsConDetails Void (HsScaled pass (LBangType pass)) (XRec pass [LConDeclField pass]) #

The arguments in a Haskell98-style data constructor.

data ConDecl pass #

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

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

data T = Int MkT Int
       | MkT2

data T a where
     Int MkT Int :: T Int

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

data Constructor Declaration

Constructors

ConDeclGADT
Fields con_g_ext :: XConDeclGADT pass con_names :: NonEmpty (LIdP pass) con_dcolon :: !(LHsUniToken "::" "\8759" pass) con_bndrs :: XRec pass (HsOuterSigTyVarBndrs pass) The outermost type variable binders, be they explicit or implicit. The `XRec` is used to anchor exact print annotations, AnnForall and AnnDot. con_mb_cxt :: Maybe (LHsContext pass) User-written context (if any) con_g_args :: HsConDeclGADTDetails pass Arguments; never infix con_res_ty :: LHsType pass Result type con_doc :: Maybe (LHsDoc pass) A possible Haddock comment.
ConDeclH98
Fields con_ext :: XConDeclH98 pass con_name :: LIdP pass con_forall :: Bool True = explicit user-written forall e.g. data T a = forall b. MkT b (b->a) con_ex_tvs = {b} False => con_ex_tvs is empty con_ex_tvs :: [LHsTyVarBndr Specificity pass] Existentials only con_mb_cxt :: Maybe (LHsContext pass) User-written context (if any) con_args :: HsConDeclH98Details pass Arguments; can be infix con_doc :: Maybe (LHsDoc pass) A possible Haddock comment.
XConDecl !(XXConDecl pass)

Instances

Instances details

type Anno (ConDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (ConDecl (GhcPass p)) = SrcSpanAnnA

type LConDecl pass #

Arguments

= XRec pass (ConDecl pass)

May have AnnKeywordId : AnnSemi when in a GADT constructor list

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

Instances details

Foldable DataDefnCons
Instance details 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
Instance details 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
Instance details Defined in Language.Haskell.Syntax.Decls Methods fmap :: (a -> b) -> DataDefnCons a -> DataDefnCons b # (<$) :: a -> DataDefnCons b -> DataDefnCons a #
Data a => Data (DataDefnCons a)
Instance details 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) #
Eq a => Eq (DataDefnCons a)
Instance details Defined in Language.Haskell.Syntax.Decls Methods (==) :: DataDefnCons a -> DataDefnCons a -> Bool # (/=) :: DataDefnCons a -> DataDefnCons a -> Bool #

data NewOrData #

When we only care whether a data-type declaration is `data` or `newtype`, but not what constructors it has

Constructors

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

Instances

Instances details

Data NewOrData
Instance details 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
Instance details Defined in Language.Haskell.Syntax.Decls Methods (==) :: NewOrData -> NewOrData -> Bool # (/=) :: NewOrData -> NewOrData -> Bool #

data StandaloneKindSig pass #

Constructors

StandaloneKindSig (XStandaloneKindSig pass) (LIdP pass) (LHsSigType pass)
XStandaloneKindSig !(XXStandaloneKindSig pass)

Instances

Instances details

type Anno (StandaloneKindSig (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (StandaloneKindSig (GhcPass p)) = SrcSpanAnnA

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 deriving clause with a single type. Moreover, that type can only be a type constructor without any arguments.

Example: deriving Eq

DctMulti (XDctMulti pass) [LHsSigType pass]

A deriving clause with a comma-separated list of types, surrounded by enclosing parentheses.

Example: deriving (Eq, C a)

XDerivClauseTys !(XXDerivClauseTys pass)

Instances

Instances details

type Anno (DerivClauseTys (GhcPass _1))
Instance details Defined in GHC.Hs.Decls type Anno (DerivClauseTys (GhcPass _1)) = SrcSpanAnnC

type LDerivClauseTys pass = XRec pass (DerivClauseTys pass) #

data HsDerivingClause pass #

A single deriving clause of a data declaration.

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

Constructors

HsDerivingClause
Fields deriv_clause_ext :: XCHsDerivingClause pass deriv_clause_strategy :: Maybe (LDerivStrategy pass) The user-specified strategy (if any) to use when deriving `deriv_clause_tys`. deriv_clause_tys :: LDerivClauseTys pass The types to derive.
XHsDerivingClause !(XXHsDerivingClause pass)

Instances

Instances details

type Anno (HsDerivingClause (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (HsDerivingClause (GhcPass p)) = SrcAnn NoEpAnns

type LHsDerivingClause pass = XRec pass (HsDerivingClause pass) #

type HsDeriving pass #

Arguments

= [LHsDerivingClause pass]

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

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

Haskell Deriving clause

data HsDataDefn pass #

Haskell Data type Definition

Constructors

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

data FamilyInfo pass #

Constructors

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

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]	`AnnKeywordId` : `AnnRarrow`, `AnnVbar`
XInjectivityAnn !(XXInjectivityAnn pass)

Instances

Instances details

type Anno (InjectivityAnn (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (InjectivityAnn (GhcPass p)) = SrcAnn NoEpAnns

type LInjectivityAnn pass = XRec pass (InjectivityAnn pass) #

Located Injectivity Annotation

data FamilyDecl pass #

type Family Declaration

Constructors

FamilyDecl
Fields 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)	`AnnKeywordId` : `AnnType`, `AnnData`, `AnnFamily`, `AnnWhere`, `AnnOpenP`, `AnnDcolon`, `AnnCloseP`, `AnnEqual`, `AnnRarrow`, `AnnVbar`

Instances

Instances details

type Anno (FamilyDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (FamilyDecl (GhcPass p)) = SrcSpanAnnA

type LFamilyDecl pass = XRec pass (FamilyDecl pass) #

Located type Family Declaration

data FamilyResultSig pass #

type Family Result Signature

Constructors

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

Instances

Instances details

type Anno (FamilyResultSig (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (FamilyResultSig (GhcPass p)) = SrcAnn NoEpAnns

type LFamilyResultSig pass = XRec pass (FamilyResultSig pass) #

Located type Family Result Signature

data TyClGroup pass #

Type or Class Group

Constructors

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

type LHsFunDep pass = XRec pass (FunDep pass) #

data TyClDecl pass #

A type or class declaration.

Constructors

FamDecl	type/data family T :: -> `AnnKeywordId` : `AnnType`, `AnnData`, `AnnFamily`,`AnnDcolon`, `AnnWhere`,`AnnOpenP`, `AnnDcolon`,`AnnCloseP`, `AnnEqual`,`AnnRarrow`, `AnnVbar`
Fields tcdFExt :: XFamDecl pass tcdFam :: FamilyDecl pass
SynDecl	`type` declaration `AnnKeywordId` : `AnnType`, `AnnEqual`,
Fields tcdSExt :: XSynDecl pass Post renamer, FVs tcdLName :: LIdP pass Type constructor tcdTyVars :: LHsQTyVars pass Type variables; for an associated type these include outer binders tcdFixity :: LexicalFixity Fixity used in the declaration tcdRhs :: LHsType pass RHS of type declaration
DataDecl	`data` declaration `AnnKeywordId` : `AnnData`, `AnnFamily`, `AnnNewType`, `AnnNewType`,`AnnDcolon` `AnnWhere`,
Fields tcdDExt :: XDataDecl pass Post renamer, CUSK flag, FVs tcdLName :: LIdP pass Type constructor tcdTyVars :: LHsQTyVars pass Type variables; for an associated type these include outer binders tcdFixity :: LexicalFixity Fixity used in the declaration tcdDataDefn :: HsDataDefn pass
ClassDecl	`AnnKeywordId` : `AnnClass`, `AnnWhere`,`AnnOpen`, `AnnClose` The tcdFDs will have `AnnVbar`, `AnnComma` `AnnRarrow` For details on above see Note [exact print annotations] in GHC.Parser.Annotation
Fields tcdCExt :: XClassDecl pass Post renamer, FVs tcdLayout :: !(LayoutInfo pass) Explicit or virtual braces See Note [Class LayoutInfo] tcdCtxt :: Maybe (LHsContext pass) Context... tcdLName :: LIdP pass Type constructor tcdTyVars :: LHsQTyVars pass Type variables; for an associated type these include outer binders tcdFixity :: LexicalFixity Fixity used in the declaration tcdFDs :: [LHsFunDep pass] Functional deps tcdSigs :: [LSig pass] Methods' signatures tcdMeths :: LHsBinds pass Default methods tcdATs :: [LFamilyDecl pass] Associated types; tcdATDefs :: [LTyFamDefltDecl pass] Associated type defaults tcdDocs :: [LDocDecl pass] Haddock docs
XTyClDecl !(XXTyClDecl pass)

Instances

Instances details

type Anno (TyClDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (TyClDecl (GhcPass p)) = SrcSpanAnnA

type LTyClDecl pass = XRec pass (TyClDecl pass) #

Located Declaration of a Type or Class

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

Instances details

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

data SpliceDecl p #

Splice Declaration

Constructors

SpliceDecl (XSpliceDecl p) (XRec p (HsUntypedSplice p)) SpliceDecoration
XSpliceDecl !(XXSpliceDecl p)

Instances

Instances details

type Anno (SpliceDecl (GhcPass p))
Instance details Defined in GHC.Hs.Decls type Anno (SpliceDecl (GhcPass p)) = SrcSpanAnnA

type LSpliceDecl pass = XRec pass (SpliceDecl pass) #

Located Splice Declaration

data HsGroup p #

Haskell Group

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

Constructors

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

data HsDecl p #

A Haskell Declaration

Constructors

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

Instances

Instances details

type Anno (HsDecl (GhcPass _1))
Instance details Defined in GHC.Hs.Decls type Anno (HsDecl (GhcPass _1)) = SrcSpanAnnA

type LHsDecl p #

Arguments

= XRec p (HsDecl p)

When in a list this may have

AnnKeywordId : AnnSemi

data HsDoFlavour #

Constructors

DoExpr (Maybe ModuleName)	ModuleName. do { ... }
MDoExpr (Maybe ModuleName)	ModuleName. mdo { ... } ie recursive do-expression
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

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 mc_fun :: LIdP (NoGhcTc p) function binder of `f` See Note [mc_fun field of FunRhs] See #20415 for a long discussion about this field and why it uses NoGhcTc. mc_fixity :: LexicalFixity fixing of `f` mc_strictness :: SrcStrictness was `f` banged? See Note [FunBind vs PatBind]
LambdaExpr	Patterns of a lambda
CaseAlt	Patterns and guards in a case alternative
LamCaseAlt LamCaseVariant	Patterns and guards in `case` and `cases`
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

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)

data HsQuote p #

Haskell (Untyped) Quote = Expr + Pat + Type + Var

Constructors

ExpBr (XExpBr p) (LHsExpr p)
PatBr (XPatBr p) (LPat p)
DecBrL (XDecBrL p) [LHsDecl p]
DecBrG (XDecBrG p) (HsGroup p)
TypBr (XTypBr p) (LHsType p)
VarBr (XVarBr p) Bool (LIdP p)
XQuote !(XXQuote p)

data ApplicativeArg idL #

Applicative Argument

Constructors

ApplicativeArgOne
Fields xarg_app_arg_one :: XApplicativeArgOne idL The fail operator, after renaming The fail operator is needed if this is a BindStmt where the pattern can fail. E.g.: (Just a) <- stmt The fail operator will be invoked if the pattern match fails. It is also used for guards in MonadComprehensions. The fail operator is Nothing if the pattern match can't fail app_arg_pattern :: LPat idL arg_expr :: LHsExpr idL is_body_stmt :: Bool True = was a BodyStmt, False = was a BindStmt. See Note [Applicative BodyStmt]
ApplicativeArgMany
Fields xarg_app_arg_many :: XApplicativeArgMany idL app_stmts :: [ExprLStmt idL] final_expr :: HsExpr idL bv_pattern :: LPat idL stmt_context :: HsDoFlavour context of the do expression, used in pprArg
XApplicativeArg !(XXApplicativeArg idL)

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)

data TransForm #

Constructors

ThenForm
GroupForm

Instances

Instances details

Data TransForm

Instance details

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 #

data StmtLR idL idR body #

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 (XBindStmt idL idR body) Post renaming has optional fail and bind / (>>=) operator. Post typechecking, also has multiplicity of the argument and the result type of the function passed to bind; that is, (P, S) in (>>=) :: Q -> (R % P -> S) -> T See Note [The type of bind in Stmts] (LPat idL) body
ApplicativeStmt (XApplicativeStmt idL idR body) [(SyntaxExpr idR, ApplicativeArg idL)] (Maybe (SyntaxExpr idR))	`ApplicativeStmt` represents an applicative expression built with `<$>` and `<*>`. It is generated by the renamer, and is desugared into the appropriate applicative expression by the desugarer, but it is intended to be invisible in error messages. For full details, see Note [ApplicativeDo] in GHC.Rename.Expr
BodyStmt (XBodyStmt idL idR body) body (SyntaxExpr idR) (SyntaxExpr idR)
LetStmt (XLetStmt idL idR body) (HsLocalBindsLR idL idR)	`AnnKeywordId` : `AnnLet` `AnnOpen` `'{'`,`AnnClose` `'}'`,
ParStmt (XParStmt idL idR body) [ParStmtBlock idL idR] (HsExpr idR) (SyntaxExpr idR)
TransStmt
Fields trS_ext :: XTransStmt idL idR body trS_form :: TransForm trS_stmts :: [ExprLStmt idL] trS_bndrs :: [(IdP idR, IdP idR)] trS_using :: LHsExpr idR trS_by :: Maybe (LHsExpr idR) trS_ret :: SyntaxExpr idR trS_bind :: SyntaxExpr idR trS_fmap :: HsExpr idR
RecStmt	`AnnKeywordId` : `AnnRec`
Fields recS_ext :: XRecStmt idL idR body recS_stmts :: 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)

Instances

Instances details

type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsExpr (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))]
Instance details Defined in GHC.Parser.Types type Anno [LocatedA (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL
type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr))))
Instance details Defined in GHC.Hs.Expr type Anno (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (body (GhcPass pr)))) = SrcSpanAnnA
type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs)))
Instance details Defined in GHC.Parser.PostProcess type Anno (StmtLR GhcPs GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA
type Anno (StmtLR GhcRn GhcRn (LocatedA (body GhcRn)))
Instance details Defined in GHC.Hs.Expr type Anno (StmtLR GhcRn GhcRn (LocatedA (body GhcRn))) = SrcSpanAnnA

type GhciStmt id = Stmt id (LHsExpr id) #

Ghci Statement

type GhciLStmt id = LStmt id (LHsExpr id) #

Ghci Located Statement

type GuardStmt id = Stmt id (LHsExpr id) #

Guard Statement

type GuardLStmt id = LStmt id (LHsExpr id) #

Guard Located Statement

type ExprStmt id = Stmt id (LHsExpr id) #

Expression Statement

type ExprLStmt id = LStmt id (LHsExpr id) #

Expression Located Statement

type CmdStmt id = Stmt id (LHsCmd id) #

Command Statement

type CmdLStmt id = LStmt id (LHsCmd id) #

Command Located Statement

type Stmt id body = StmtLR id id body #

do block Statement

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

Located Statement with separate Left and Right id's

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

Located do block Statement

data GRHS p body #

Guarded Right Hand Side.

Constructors

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

Instances

Instances details

type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p))))
Instance details Defined in GHC.Hs.Expr type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcAnn NoEpAnns
type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p))))
Instance details Defined in GHC.Hs.Expr type Anno (GRHS (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcAnn NoEpAnns
type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs)))
Instance details Defined in GHC.Parser.PostProcess type Anno (GRHS GhcPs (LocatedA (PatBuilder GhcPs))) = SrcAnn NoEpAnns

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

Located Guarded Right-Hand Side

data Match p body #

Constructors

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

Instances

Instances details

type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))] = SrcSpanAnnL
type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))] = SrcSpanAnnL
type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))]
Instance details Defined in GHC.Parser.PostProcess type Anno [LocatedA (Match GhcPs (LocatedA (PatBuilder GhcPs)))] = SrcSpanAnnL
type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))
Instance details Defined in GHC.Hs.Expr type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcSpanAnnA
type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p))))
Instance details Defined in GHC.Hs.Expr type Anno (Match (GhcPass p) (LocatedA (HsExpr (GhcPass p)))) = SrcSpanAnnA
type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs)))
Instance details Defined in GHC.Parser.PostProcess type Anno (Match GhcPs (LocatedA (PatBuilder GhcPs))) = SrcSpanAnnA

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

data HsCmdTop p #

Haskell Top-level Command

Constructors

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

Instances

Instances details

type Anno (HsCmdTop (GhcPass p))
Instance details Defined in GHC.Hs.Expr type Anno (HsCmdTop (GhcPass p)) = SrcAnn NoEpAnns

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

Instances details

Data HsArrAppType

Instance details

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 #

data HsCmd id #

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

Constructors

HsCmdArrApp (XCmdArrApp id) (LHsExpr id) (LHsExpr id) HsArrAppType Bool	`AnnKeywordId` : `Annlarrowtail`, `Annrarrowtail`,`AnnLarrowtail`, `AnnRarrowtail`
HsCmdArrForm (XCmdArrForm id) (LHsExpr id) LexicalFixity (Maybe Fixity) [LHsCmdTop id]	`AnnKeywordId` : `AnnOpenB` `'(\|'`, `AnnCloseB` `'\|)'`
HsCmdApp (XCmdApp id) (LHsCmd id) (LHsExpr id)
HsCmdLam (XCmdLam id) (MatchGroup id (LHsCmd id))	`AnnKeywordId` : `AnnLam`, `AnnRarrow`,
HsCmdPar (XCmdPar id) !(LHsToken "(" id) (LHsCmd id) !(LHsToken ")" id)	`AnnKeywordId` : `AnnOpen` `'('`, `AnnClose` `')'`
HsCmdCase (XCmdCase id) (LHsExpr id) (MatchGroup id (LHsCmd id))	`AnnKeywordId` : `AnnCase`, `AnnOf`,`AnnOpen` `'{'`, `AnnClose` `'}'`
HsCmdLamCase (XCmdLamCase id) LamCaseVariant (MatchGroup id (LHsCmd id))	Lambda-case `AnnKeywordId` : `AnnLam`, `AnnCase`,`AnnOpen` `'{'`, `AnnClose` `'}'` `AnnKeywordId` : `AnnLam`, `AnnCases`,`AnnOpen` `'{'`, `AnnClose` `'}'`
HsCmdIf (XCmdIf id) (SyntaxExpr id) (LHsExpr id) (LHsCmd id) (LHsCmd id)	`AnnKeywordId` : `AnnIf`, `AnnSemi`, `AnnThen`,`AnnSemi`, `AnnElse`,
HsCmdLet (XCmdLet id) !(LHsToken "let" id) (HsLocalBinds id) !(LHsToken "in" id) (LHsCmd id)	`AnnKeywordId` : `AnnLet`, `AnnOpen` `'{'`, `AnnClose` `'}'`,`AnnIn`
HsCmdDo (XCmdDo id) (XRec id [CmdLStmt id])	`AnnKeywordId` : `AnnDo`, `AnnOpen`, `AnnSemi`, `AnnVbar`, `AnnClose`
XCmd !(XXCmd id)

Instances

Instances details

DisambECP (HsCmd GhcPs)
Instance details Defined in GHC.Parser.PostProcess Associated Types type Body (HsCmd GhcPs) :: Type -> Type # type InfixOp (HsCmd GhcPs) # type FunArg (HsCmd GhcPs) # Methods ecpFromCmd' :: LHsCmd GhcPs -> PV (LocatedA (HsCmd GhcPs)) # ecpFromExp' :: LHsExpr GhcPs -> PV (LocatedA (HsCmd GhcPs)) # mkHsProjUpdatePV :: SrcSpan -> Located [LocatedAn NoEpAnns (DotFieldOcc GhcPs)] -> LocatedA (HsCmd GhcPs) -> Bool -> [AddEpAnn] -> PV (LHsRecProj GhcPs (LocatedA (HsCmd GhcPs))) # mkHsLamPV :: SrcSpan -> (EpAnnComments -> MatchGroup GhcPs (LocatedA (HsCmd GhcPs))) -> PV (LocatedA (HsCmd GhcPs)) # mkHsLetPV :: SrcSpan -> LHsToken "let" GhcPs -> HsLocalBinds GhcPs -> LHsToken "in" GhcPs -> LocatedA (HsCmd GhcPs) -> PV (LocatedA (HsCmd GhcPs)) # superInfixOp :: (DisambInfixOp (InfixOp (HsCmd GhcPs)) => PV (LocatedA (HsCmd GhcPs))) -> PV (LocatedA (HsCmd GhcPs)) # mkHsOpAppPV :: SrcSpan -> LocatedA (HsCmd GhcPs) -> LocatedN (InfixOp (HsCmd GhcPs)) -> LocatedA (HsCmd GhcPs) -> PV (LocatedA (HsCmd GhcPs)) # mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> LocatedL [LMatch GhcPs (LocatedA (HsCmd GhcPs))] -> EpAnnHsCase -> PV (LocatedA (HsCmd GhcPs)) # mkHsLamCasePV :: SrcSpan -> LamCaseVariant -> LocatedL [LMatch GhcPs (LocatedA (HsCmd GhcPs))] -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs)) # superFunArg :: (DisambECP (FunArg (HsCmd GhcPs)) => PV (LocatedA (HsCmd GhcPs))) -> PV (LocatedA (HsCmd GhcPs)) # mkHsAppPV :: SrcSpanAnnA -> LocatedA (HsCmd GhcPs) -> LocatedA (FunArg (HsCmd GhcPs)) -> PV (LocatedA (HsCmd GhcPs)) # mkHsAppTypePV :: SrcSpanAnnA -> LocatedA (HsCmd GhcPs) -> LHsToken "@" GhcPs -> LHsType GhcPs -> PV (LocatedA (HsCmd GhcPs)) # mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> LocatedA (HsCmd GhcPs) -> Bool -> LocatedA (HsCmd GhcPs) -> AnnsIf -> PV (LocatedA (HsCmd GhcPs)) # mkHsDoPV :: SrcSpan -> Maybe ModuleName -> LocatedL [LStmt GhcPs (LocatedA (HsCmd GhcPs))] -> AnnList -> PV (LocatedA (HsCmd GhcPs)) # mkHsParPV :: SrcSpan -> LHsToken "(" GhcPs -> LocatedA (HsCmd GhcPs) -> LHsToken ")" GhcPs -> PV (LocatedA (HsCmd GhcPs)) # mkHsVarPV :: LocatedN RdrName -> PV (LocatedA (HsCmd GhcPs)) # mkHsLitPV :: Located (HsLit GhcPs) -> PV (Located (HsCmd GhcPs)) # mkHsOverLitPV :: LocatedAn a (HsOverLit GhcPs) -> PV (LocatedAn a (HsCmd GhcPs)) # mkHsWildCardPV :: SrcSpan -> PV (Located (HsCmd GhcPs)) # mkHsTySigPV :: SrcSpanAnnA -> LocatedA (HsCmd GhcPs) -> LHsType GhcPs -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs)) # mkHsExplicitListPV :: SrcSpan -> [LocatedA (HsCmd GhcPs)] -> AnnList -> PV (LocatedA (HsCmd GhcPs)) # mkHsSplicePV :: Located (HsUntypedSplice GhcPs) -> PV (Located (HsCmd GhcPs)) # mkHsRecordPV :: Bool -> SrcSpan -> SrcSpan -> LocatedA (HsCmd GhcPs) -> ([Fbind (HsCmd GhcPs)], Maybe SrcSpan) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs)) # mkHsNegAppPV :: SrcSpan -> LocatedA (HsCmd GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs)) # mkHsSectionR_PV :: SrcSpan -> LocatedA (InfixOp (HsCmd GhcPs)) -> LocatedA (HsCmd GhcPs) -> PV (Located (HsCmd GhcPs)) # mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> LocatedA (HsCmd GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs)) # mkHsAsPatPV :: SrcSpan -> LocatedN RdrName -> LHsToken "@" GhcPs -> LocatedA (HsCmd GhcPs) -> PV (LocatedA (HsCmd GhcPs)) # mkHsLazyPatPV :: SrcSpan -> LocatedA (HsCmd GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs)) # mkHsBangPatPV :: SrcSpan -> LocatedA (HsCmd GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs)) # mkSumOrTuplePV :: SrcSpanAnnA -> Boxity -> SumOrTuple (HsCmd GhcPs) -> [AddEpAnn] -> PV (LocatedA (HsCmd GhcPs)) # rejectPragmaPV :: LocatedA (HsCmd GhcPs) -> PV () #
type Body (HsCmd GhcPs)
Instance details Defined in GHC.Parser.PostProcess type Body (HsCmd GhcPs) = HsCmd
type FunArg (HsCmd GhcPs)
Instance details Defined in GHC.Parser.PostProcess type FunArg (HsCmd GhcPs) = HsExpr GhcPs
type InfixOp (HsCmd GhcPs)
Instance details Defined in GHC.Parser.PostProcess type InfixOp (HsCmd GhcPs) = HsExpr GhcPs
type Anno (HsCmd (GhcPass p))
Instance details Defined in GHC.Hs.Expr type Anno (HsCmd (GhcPass p)) = SrcSpanAnnA
type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL
type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))]
Instance details Defined in GHC.Hs.Expr type Anno [LocatedA (StmtLR (GhcPass pl) (GhcPass pr) (LocatedA (HsCmd (GhcPass pr))))] = SrcSpanAnnL
type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p))))
Instance details Defined in GHC.Hs.Expr type Anno (GRHS (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcAnn NoEpAnns
type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p))))
Instance details Defined in GHC.Hs.Expr type Anno (Match (GhcPass p) (LocatedA (HsCmd (GhcPass p)))) = SrcSpanAnnA

type LHsCmd id = XRec id (HsCmd id) #

Located Haskell Command (for arrow syntax)

data LamCaseVariant #

Which kind of lambda case are we dealing with?

Constructors

LamCase	`case`
LamCases	`cases`

Instances

Instances details

Data LamCaseVariant
Instance details 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
Instance details Defined in Language.Haskell.Syntax.Expr Methods (==) :: LamCaseVariant -> LamCaseVariant -> Bool # (/=) :: LamCaseVariant -> LamCaseVariant -> Bool #

data HsTupArg id #

AnnKeywordId : AnnComma

Haskell Tuple Argument

Constructors

Present (XPresent id) (LHsExpr id)	The argument
Missing (XMissing id)	The argument is missing, but this is its type
XTupArg !(XXTupArg id)	Extension point; see Note [Trees That Grow] in Language.Haskell.Syntax.Extension

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

data HsPragE p #

A pragma, written as {-# ... #-}, that may appear within an expression.

Constructors

HsPragSCC (XSCC p) StringLiteral
XHsPragE !(XXPragE p)	`AnnKeywordId` : `AnnOpen`, `AnnOpen` `'{-# GENERATED'`, `AnnVal`,`AnnVal`, `AnnColon`,`AnnVal`, `AnnMinus`, `AnnVal`,`AnnColon`, `AnnVal`, `AnnClose` `'#-}'`

data DotFieldOcc p #

Constructors

DotFieldOcc
Fields dfoExt :: XCDotFieldOcc p dfoLabel :: XRec p FieldLabelString
XDotFieldOcc !(XXDotFieldOcc p)

Instances

Instances details

type Anno (DotFieldOcc (GhcPass p))
Instance details Defined in GHC.Hs.Expr type Anno (DotFieldOcc (GhcPass p)) = SrcAnn NoEpAnns

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

Instances details

type Anno (FieldLabelStrings (GhcPass p))
Instance details Defined in GHC.Hs.Expr type Anno (FieldLabelStrings (GhcPass p)) = SrcAnn NoEpAnns

type LFieldLabelStrings p = XRec p (FieldLabelStrings p) #

RecordDotSyntax field updates

data HsModule p #

Haskell Module

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

Constructors

HsModule

AnnKeywordIds

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

Fields

hsmodExt :: XCModule p
HsModule extension point
hsmodName :: Maybe (XRec p ModuleName)
Nothing: "module X where" is omitted (in which case the next field is Nothing too)
hsmodExports :: Maybe (XRec p [LIE p])
Export list
- Nothing: export list omitted, so export everything
- Just []: export nothing
- Just [...]: as you would expect...
- AnnKeywordIds : AnnOpen ,AnnClose
hsmodImports :: [LImportDecl p]
hsmodDecls :: [LHsDecl p]
Type, class, value, and interface signature decls

XModule !(XXModule p)

data AnnBind bndr annot #

A clone of the Bind type but allowing annotation at every tree node

Constructors

AnnNonRec bndr (AnnExpr bndr annot)
AnnRec [(bndr, AnnExpr bndr annot)]

data AnnAlt bndr annot #

A clone of the Alt type but allowing annotation at every tree node

Constructors

AnnAlt AltCon [bndr] (AnnExpr bndr annot)

data AnnExpr' bndr annot #

A clone of the Expr type but allowing annotation at every tree node

Constructors

AnnVar Id
AnnLit Literal
AnnLam bndr (AnnExpr bndr annot)
AnnApp (AnnExpr bndr annot) (AnnExpr bndr annot)
AnnCase (AnnExpr bndr annot) bndr Type [AnnAlt bndr annot]
AnnLet (AnnBind bndr annot) (AnnExpr bndr annot)
AnnCast (AnnExpr bndr annot) (annot, Coercion)
AnnTick CoreTickish (AnnExpr bndr annot)
AnnType Type
AnnCoercion Coercion

type AnnExpr bndr annot = (annot, AnnExpr' bndr annot) #

Annotated core: allows annotation at every node in the tree

type TaggedAlt t = Alt (TaggedBndr t) #

type TaggedArg t = Arg (TaggedBndr t) #

type TaggedExpr t = Expr (TaggedBndr t) #

type TaggedBind t = Bind (TaggedBndr t) #

data TaggedBndr t #

Binders are tagged with a t

Constructors

TB CoreBndr t

Instances

Instances details

Outputable b => Outputable (TaggedBndr b)
Instance details Defined in GHC.Core Methods ppr :: TaggedBndr b -> SDoc #

type CoreAlt = Alt CoreBndr #

Case alternatives where binders are CoreBndrs

type CoreBind = Bind CoreBndr #

Binding groups where binders are CoreBndrs

type CoreArg = Arg CoreBndr #

Argument expressions where binders are CoreBndrs

type CoreProgram = [CoreBind] #

data UnfoldingGuidance #

UnfoldingGuidance says when unfolding should take place

Constructors

UnfWhen
Fields ug_arity :: Arity ug_unsat_ok :: Bool ug_boring_ok :: Bool
UnfIfGoodArgs
Fields ug_args :: [Int] ug_size :: Int ug_res :: Int
UnfNever

Instances

Instances details

Eq UnfoldingGuidance
Instance details Defined in GHC.Core Methods (==) :: UnfoldingGuidance -> UnfoldingGuidance -> Bool # (/=) :: UnfoldingGuidance -> UnfoldingGuidance -> Bool #

data UnfoldingCache #

Properties of a CoreUnfolding that could be computed on-demand from its template. See Note [UnfoldingCache]

Constructors

UnfoldingCache
Fields uf_is_value :: !Bool uf_is_conlike :: !Bool uf_is_work_free :: !Bool uf_expandable :: !Bool

Instances

Instances details

Eq UnfoldingCache
Instance details Defined in GHC.Core Methods (==) :: UnfoldingCache -> UnfoldingCache -> Bool # (/=) :: UnfoldingCache -> UnfoldingCache -> Bool #

data Unfolding #

Records the unfolding of an identifier, which is approximately the form the identifier would have if we substituted its definition in for the identifier. This type should be treated as abstract everywhere except in GHC.Core.Unfold

Constructors

NoUnfolding	We have no information about the unfolding.
BootUnfolding	We have no information about the unfolding, because this `Id` came from an `hi-boot` file. See Note [Inlining and hs-boot files] in GHC.CoreToIface for what this is used for.
OtherCon [AltCon]	It ain't one of these constructors. `OtherCon xs` also indicates that something has been evaluated and hence there's no point in re-evaluating it. `OtherCon []` is used even for non-data-type values to indicated evaluated-ness. Notably: data C = C !(Int -> Int) case x of { C f -> ... } Here, `f` gets an `OtherCon []` unfolding.
DFunUnfolding
Fields df_bndrs :: [Var] df_con :: DataCon df_args :: [CoreExpr]
CoreUnfolding	An unfolding with redundant cached information. Parameters: uf_tmpl: Template used to perform unfolding; NB: Occurrence info is guaranteed correct: see Note [OccInfo in unfoldings and rules] uf_is_top: Is this a top level binding? uf_is_value: `exprIsHNF` template (cached); it is ok to discard a `seq` on this variable uf_is_work_free: Does this waste only a little work if we expand it inside an inlining? Basically this is a cached version of `exprIsWorkFree` uf_guidance: Tells us about the size of the unfolding template
Fields uf_tmpl :: CoreExpr uf_src :: UnfoldingSource uf_is_top :: Bool uf_cache :: UnfoldingCache uf_guidance :: UnfoldingGuidance

type IdUnfoldingFun = Id -> Unfolding #

data InScopeEnv #

The InScopeSet in the InScopeEnv is a superset of variables that are currently in scope. See Note [The InScopeSet invariant].

Constructors

ISE InScopeSet IdUnfoldingFun

type RuleFun = RuleOpts -> InScopeEnv -> Id -> [CoreExpr] -> Maybe CoreExpr #

data CoreRule #

A CoreRule is:

"Local" if the function it is a rule for is defined in the same module as the rule itself.
"Orphan" if nothing on the LHS is defined in the same module as the rule itself

Constructors

Rule
Fields ru_name :: RuleName Name of the rule, for communication with the user ru_act :: Activation When the rule is active ru_fn :: !Name Name of the `Id` at the head of this rule ru_rough :: [Maybe Name] Name at the head of each argument to the left hand side ru_bndrs :: [CoreBndr] Variables quantified over ru_args :: [CoreExpr] Left hand side arguments ru_rhs :: CoreExpr Right hand side of the rule Occurrence info is guaranteed correct See Note [OccInfo in unfoldings and rules] ru_auto :: Bool `True` = this rule is auto-generated (notably by Specialise or SpecConstr) `False` = generated at the user's behest See Note [Trimming auto-rules] in GHC.Iface.Tidy for the sole purpose of this field. ru_origin :: !Module `GenModule` the rule was defined in, used to test if we should see an orphan rule. ru_orphan :: !IsOrphan Whether or not the rule is an orphan. ru_local :: Bool `True` iff the fn at the head of the rule is defined in the same module as the rule and is not an implicit `Id` (like a record selector, class operation, or data constructor). This is different from `ru_orphan`, where a rule can avoid being an orphan if any Name in LHS of the rule was defined in the same module as the rule.
BuiltinRule	Built-in rules are used for constant folding and suchlike. They have no free variables. A built-in rule is always visible (there is no such thing as an orphan built-in rule.)
Fields ru_name :: RuleName Name of the rule, for communication with the user ru_fn :: Name Name of the `Id` at the head of this rule ru_nargs :: Int Number of arguments that `ru_try` consumes, if it fires, including type arguments ru_try :: RuleFun This function does the rewrite. It given too many arguments, it simply discards them; the returned `CoreExpr` is just the rewrite of `ru_fn` applied to the first `ru_nargs` args

data IsOrphan #

Is this instance an orphan? If it is not an orphan, contains an OccName witnessing the instance's non-orphanhood. See Note [Orphans]

Constructors

IsOrphan
NotOrphan !OccName

Instances

Instances details

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

type MOutCoercion = MCoercion #

type OutArg = CoreArg #

type OutAlt = CoreAlt #

type OutExpr = CoreExpr #

type OutBind = CoreBind #

type OutCoercion = Coercion #

type OutKind = Kind #

type OutType = Type #

type OutBndr = CoreBndr #

type InCoercion = Coercion #

type InArg = CoreArg #

type InAlt = CoreAlt #

type InExpr = CoreExpr #

type InBind = CoreBind #

type InKind = Kind #

type InType = Type #

type InBndr = CoreBndr #

data Bind b #

Binding, used for top level bindings in a module and local bindings in a let.

Constructors

NonRec b (Expr b)
Rec [(b, Expr b)]

Instances

Instances details

Data b => Data (Bind b)

Instance details

Defined in GHC.Core

Methods

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

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

toConstr :: Bind b -> Constr #

dataTypeOf :: Bind b -> DataType #

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

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

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

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

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

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

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

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

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

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

data AltCon #

A case alternative constructor (i.e. pattern match)

Constructors

DataAlt DataCon
LitAlt Literal	A literal: `case e of { 1 -> ... }` Invariant: always an unlifted literal See Note [Literal alternatives]
DEFAULT	Trivial alternative: `case e of { _ -> ... }`

Instances

Instances details

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

data LambdaFormInfo #

Information about an identifier, from the code generator's point of view. Every identifier is bound to a LambdaFormInfo in the environment, which gives the code generator enough info to be able to tail call or return that identifier.

Instances

Instances details

Outputable LambdaFormInfo
Instance details Defined in GHC.StgToCmm.Types Methods ppr :: LambdaFormInfo -> SDoc #

data TickBoxOp #

Tick box for Hpc-style coverage

Constructors

TickBox Module !TickBoxId

Instances

Instances details

Outputable TickBoxOp
Instance details Defined in GHC.Types.Id.Info Methods ppr :: TickBoxOp -> SDoc #

type TickBoxId = Int #

data CafInfo #

Constant applicative form Information

Records whether an Id makes Constant Applicative Form references

Constructors

MayHaveCafRefs

Indicates that the Id is for either:

A function or static constructor that refers to one or more CAFs, or
A real live CAF

NoCafRefs

A function or static constructor that refers to no CAFs.

Instances

Instances details

Outputable CafInfo
Instance details Defined in GHC.Types.Id.Info Methods ppr :: CafInfo -> SDoc #
Eq CafInfo
Instance details Defined in GHC.Types.Id.Info Methods (==) :: CafInfo -> CafInfo -> Bool # (/=) :: CafInfo -> CafInfo -> Bool #
Ord CafInfo
Instance details Defined in GHC.Types.Id.Info Methods compare :: CafInfo -> CafInfo -> Ordering # (<) :: CafInfo -> CafInfo -> Bool # (<=) :: CafInfo -> CafInfo -> Bool # (>) :: CafInfo -> CafInfo -> Bool # (>=) :: CafInfo -> CafInfo -> Bool # max :: CafInfo -> CafInfo -> CafInfo # min :: CafInfo -> CafInfo -> CafInfo #

data RuleInfo #

Rule Information

Records the specializations of this Id that we know about in the form of rewrite CoreRules that target them

Constructors

RuleInfo [CoreRule] DVarSet

type InlinePragInfo = InlinePragma #

Inline Pragma Information

Tells when the inlining is active. When it is active the thing may be inlined, depending on how big it is.

If there was an INLINE pragma, then as a separate matter, the RHS will have been made to look small with a Core inline Note

The default InlinePragInfo is AlwaysActive, so the info serves entirely as a way to inhibit inlining until we want it

type ArityInfo = Arity #

Arity Information

An ArityInfo of n tells us that partial application of this Id to up to n-1 value arguments does essentially no work.

That is not necessarily the same as saying that it has n leading lambdas, because coerces may get in the way.

The arity might increase later in the compilation process, if an extra lambda floats up to the binding site.

Invariant: the Arity of an Id must never exceed the number of value arguments that appear in the type of the Id. See Note [Arity and function types].

data RecSelParent #

Recursive Selector Parent

Constructors

RecSelData TyCon
RecSelPatSyn PatSyn

Instances

Instances details

Outputable RecSelParent
Instance details Defined in GHC.Types.Id.Info Methods ppr :: RecSelParent -> SDoc #
Eq RecSelParent
Instance details Defined in GHC.Types.Id.Info Methods (==) :: RecSelParent -> RecSelParent -> Bool # (/=) :: RecSelParent -> RecSelParent -> Bool #

data BoxingInfo b #

Constructors

BI_NoBoxNeeded
BI_NoBoxAvailable
BI_Box
Fields bi_data_con :: DataCon bi_inst_con :: Expr b bi_boxed_type :: Type

type CoreAltWithFVs = AnnAlt Id FVAnn #

Every node in an expression annotated with its (non-global) free variables, both Ids and TyVars, and type.

type CoreExprWithFVs' = AnnExpr' Id FVAnn #

type CoreExprWithFVs = AnnExpr Id FVAnn #

Every node in an expression annotated with its (non-global) free variables, both Ids and TyVars, and type. NB: see Note [The FVAnn invariant]

type CoreBindWithFVs = AnnBind Id FVAnn #

Every node in a binding group annotated with its (non-global) free variables, both Ids and TyVars, and type.

type FVAnn = DVarSet #

type CheapAppFun = Id -> Arity -> Bool #

data FloatBind #

Constructors

FloatLet CoreBind
FloatCase CoreExpr Id AltCon [Var]

Instances

Instances details

Outputable FloatBind
Instance details Defined in GHC.Core.Make Methods ppr :: FloatBind -> SDoc #

data MkStringIds #

Constructors

MkStringIds
Fields unpackCStringId :: !Id unpackCStringUtf8Id :: !Id

data CompilerInfo #

Constructors

GCC
Clang
AppleClang
AppleClang51
Emscripten
UnknownCC

Instances

Instances details

Eq CompilerInfo
Instance details Defined in GHC.Driver.Session Methods (==) :: CompilerInfo -> CompilerInfo -> Bool # (/=) :: CompilerInfo -> CompilerInfo -> Bool #

data LinkerInfo #

Constructors

GnuLD [Option]
GnuGold [Option]
LlvmLLD [Option]
DarwinLD [Option]
SolarisLD [Option]
AixLD [Option]
UnknownLD

Instances

Instances details

Eq LinkerInfo
Instance details Defined in GHC.Driver.Session Methods (==) :: LinkerInfo -> LinkerInfo -> Bool # (/=) :: LinkerInfo -> LinkerInfo -> Bool #

data PkgDbRef #

Constructors

GlobalPkgDb
UserPkgDb
PkgDbPath FilePath

Instances

Instances details

Eq PkgDbRef
Instance details Defined in GHC.Driver.Session Methods (==) :: PkgDbRef -> PkgDbRef -> Bool # (/=) :: PkgDbRef -> PkgDbRef -> Bool #

data FlagSpec flag #

Constructors

FlagSpec
Fields flagSpecName :: String Flag in string form flagSpecFlag :: flag Flag in internal form flagSpecAction :: TurnOnFlag -> DynP () Extra action to run when the flag is found Typically, emit a warning or error flagSpecGhcMode :: GhcFlagMode In which ghc mode the flag has effect

type TurnOnFlag = Bool #

newtype CmdLineP s a #

Constructors

CmdLineP (forall (m :: Type -> Type). Monad m => StateT s m a)

Instances

Instances details

Applicative (CmdLineP s)
Instance details Defined in GHC.Driver.Session Methods pure :: a -> CmdLineP s a # (<>) :: CmdLineP s (a -> b) -> CmdLineP s a -> CmdLineP s b # liftA2 :: (a -> b -> c) -> CmdLineP s a -> CmdLineP s b -> CmdLineP s c # (>) :: CmdLineP s a -> CmdLineP s b -> CmdLineP s b # (<*) :: CmdLineP s a -> CmdLineP s b -> CmdLineP s a #
Functor (CmdLineP s)
Instance details Defined in GHC.Driver.Session Methods fmap :: (a -> b) -> CmdLineP s a -> CmdLineP s b # (<$) :: a -> CmdLineP s b -> CmdLineP s a #
Monad (CmdLineP s)
Instance details Defined in GHC.Driver.Session Methods (>>=) :: CmdLineP s a -> (a -> CmdLineP s b) -> CmdLineP s b # (>>) :: CmdLineP s a -> CmdLineP s b -> CmdLineP s b # return :: a -> CmdLineP s a #

data OnOff a #

Constructors

On a
Off a

Instances

Instances details

Show a => Show (OnOff a)
Instance details Defined in GHC.Driver.Session Methods showsPrec :: Int -> OnOff a -> ShowS # show :: OnOff a -> String # showList :: [OnOff a] -> ShowS #
Outputable a => Outputable (OnOff a)
Instance details Defined in GHC.Driver.Session Methods ppr :: OnOff a -> SDoc #
Eq a => Eq (OnOff a)
Instance details Defined in GHC.Driver.Session Methods (==) :: OnOff a -> OnOff a -> Bool # (/=) :: OnOff a -> OnOff a -> Bool #

newtype FlushOut #

Constructors

FlushOut (IO ())

type FatalMessager = String -> IO () #

data DynamicTooState #

Constructors

DT_Dont	Don't try to build dynamic objects too
DT_OK	Will still try to generate dynamic objects
DT_Dyn	Currently generating dynamic objects (in the backend)

Instances

Instances details

Show DynamicTooState
Instance details Defined in GHC.Driver.Session Methods showsPrec :: Int -> DynamicTooState -> ShowS # show :: DynamicTooState -> String # showList :: [DynamicTooState] -> ShowS #
Eq DynamicTooState
Instance details Defined in GHC.Driver.Session Methods (==) :: DynamicTooState -> DynamicTooState -> Bool # (/=) :: DynamicTooState -> DynamicTooState -> Bool #
Ord DynamicTooState
Instance details Defined in GHC.Driver.Session Methods compare :: DynamicTooState -> DynamicTooState -> Ordering # (<) :: DynamicTooState -> DynamicTooState -> Bool # (<=) :: DynamicTooState -> DynamicTooState -> Bool # (>) :: DynamicTooState -> DynamicTooState -> Bool # (>=) :: DynamicTooState -> DynamicTooState -> Bool # max :: DynamicTooState -> DynamicTooState -> DynamicTooState # min :: DynamicTooState -> DynamicTooState -> DynamicTooState #

data RtsOptsEnabled #

Constructors

RtsOptsNone
RtsOptsIgnore
RtsOptsIgnoreAll
RtsOptsSafeOnly
RtsOptsAll

Instances

Instances details

Show RtsOptsEnabled
Instance details Defined in GHC.Driver.Session Methods showsPrec :: Int -> RtsOptsEnabled -> ShowS # show :: RtsOptsEnabled -> String # showList :: [RtsOptsEnabled] -> ShowS #

data DynLibLoader #

Constructors

Deployable
SystemDependent

Instances

Instances details

Eq DynLibLoader
Instance details Defined in GHC.Driver.Session Methods (==) :: DynLibLoader -> DynLibLoader -> Bool # (/=) :: DynLibLoader -> DynLibLoader -> Bool #

data PackageDBFlag #

Constructors

PackageDB PkgDbRef
NoUserPackageDB
NoGlobalPackageDB
ClearPackageDBs

Instances

Instances details

Eq PackageDBFlag
Instance details Defined in GHC.Driver.Session Methods (==) :: PackageDBFlag -> PackageDBFlag -> Bool # (/=) :: PackageDBFlag -> PackageDBFlag -> Bool #

data PackageFlag #

Flags for manipulating packages visibility.

Constructors

ExposePackage String PackageArg ModRenaming	`-package`, `-package-id`
HidePackage String	-hide-package

Instances

Instances details

Outputable PackageFlag
Instance details Defined in GHC.Driver.Session Methods ppr :: PackageFlag -> SDoc #
Eq PackageFlag
Instance details Defined in GHC.Driver.Session Methods (==) :: PackageFlag -> PackageFlag -> Bool # (/=) :: PackageFlag -> PackageFlag -> Bool #

data TrustFlag #

Flags for manipulating package trust.

Constructors

TrustPackage String	-trust
DistrustPackage String	-distrust

Instances

Instances details

Eq TrustFlag
Instance details Defined in GHC.Driver.Session Methods (==) :: TrustFlag -> TrustFlag -> Bool # (/=) :: TrustFlag -> TrustFlag -> Bool #

newtype IgnorePackageFlag #

Flags for manipulating the set of non-broken packages.

Constructors

IgnorePackage String

-ignore-package

Instances

Instances details

Eq IgnorePackageFlag
Instance details Defined in GHC.Driver.Session Methods (==) :: IgnorePackageFlag -> IgnorePackageFlag -> Bool # (/=) :: IgnorePackageFlag -> IgnorePackageFlag -> Bool #

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:

-package foo is ModRenaming True []
-package foo () is ModRenaming False []
-package foo (A) is ModRenaming False [(A, A)]
-package foo (A as B) is ModRenaming False [(A, B)]
-package foo with (A as B) is ModRenaming True [(A, B)]

Constructors

ModRenaming
Fields modRenamingWithImplicit :: Bool Bring all exposed modules into scope? modRenamings :: [(ModuleName, ModuleName)] Bring module `m` into scope under name `n`.

Instances

Instances details

Outputable ModRenaming
Instance details Defined in GHC.Driver.Session Methods ppr :: ModRenaming -> SDoc #
Eq ModRenaming
Instance details Defined in GHC.Driver.Session Methods (==) :: ModRenaming -> ModRenaming -> Bool # (/=) :: ModRenaming -> ModRenaming -> Bool #

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	`-package`, by `PackageName`
UnitIdArg Unit	`-package-id`, by `Unit`

Instances

Instances details

Show PackageArg
Instance details Defined in GHC.Driver.Session Methods showsPrec :: Int -> PackageArg -> ShowS # show :: PackageArg -> String # showList :: [PackageArg] -> ShowS #
Outputable PackageArg
Instance details Defined in GHC.Driver.Session Methods ppr :: PackageArg -> SDoc #
Eq PackageArg
Instance details Defined in GHC.Driver.Session Methods (==) :: PackageArg -> PackageArg -> Bool # (/=) :: PackageArg -> PackageArg -> Bool #

data GhcLink #

What to do in the link step, if there is one.

Constructors

NoLink	Don't link at all
LinkBinary	Link object code into a binary
LinkInMemory	Use the in-memory dynamic linker (works for both bytecode and object code).
LinkDynLib	Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)
LinkStaticLib	Link objects into a static lib
LinkMergedObj	Link objects into a merged "GHCi object"

Instances

Instances details

Show GhcLink
Instance details Defined in GHC.Driver.Session Methods showsPrec :: Int -> GhcLink -> ShowS # show :: GhcLink -> String # showList :: [GhcLink] -> ShowS #
Eq GhcLink
Instance details Defined in GHC.Driver.Session Methods (==) :: GhcLink -> GhcLink -> Bool # (/=) :: GhcLink -> GhcLink -> Bool #

data GhcMode #

The GhcMode tells us whether we're doing multi-module compilation (controlled via the GHC API) or one-shot (single-module) compilation. This makes a difference primarily to the GHC.Unit.Finder: in one-shot mode we look for interface files for imported modules, but in multi-module mode we look for source files in order to check whether they need to be recompiled.

Constructors

CompManager	`--make`, GHCi, etc.
OneShot	ghc -c Foo.hs
MkDepend	`ghc -M`, see GHC.Unit.Finder for why we need this

Instances

Instances details

Outputable GhcMode
Instance details Defined in GHC.Driver.Session Methods ppr :: GhcMode -> SDoc #
Eq GhcMode
Instance details Defined in GHC.Driver.Session Methods (==) :: GhcMode -> GhcMode -> Bool # (/=) :: GhcMode -> GhcMode -> Bool #

class ContainsDynFlags t where #

Methods

extractDynFlags :: t -> DynFlags #

Instances

Instances details

ContainsDynFlags HscEnv
Instance details Defined in GHC.Driver.Env.Types Methods extractDynFlags :: HscEnv -> DynFlags #
ContainsDynFlags (Env gbl lcl)
Instance details Defined in GHC.Tc.Types Methods extractDynFlags :: Env gbl lcl -> DynFlags #

class HasDynFlags (m :: Type -> Type) where #

Methods

getDynFlags :: m DynFlags #

Instances

Instances details

HasDynFlags CoreM
Instance details Defined in GHC.Core.Opt.Monad Methods getDynFlags :: CoreM DynFlags #
HasDynFlags Hsc
Instance details Defined in GHC.Driver.Env.Types Methods getDynFlags :: Hsc DynFlags #
HasDynFlags TcS
Instance details Defined in GHC.Tc.Solver.Monad Methods getDynFlags :: TcS DynFlags #
ContainsDynFlags env => HasDynFlags (IOEnv env)
Instance details Defined in GHC.Data.IOEnv Methods getDynFlags :: IOEnv env DynFlags #
(Monad m, HasDynFlags m) => HasDynFlags (MaybeT m)
Instance details Defined in GHC.Driver.Session Methods getDynFlags :: MaybeT m DynFlags #
(Monad m, HasDynFlags m) => HasDynFlags (ExceptT e m)
Instance details Defined in GHC.Driver.Session Methods getDynFlags :: ExceptT e m DynFlags #
(Monad m, HasDynFlags m) => HasDynFlags (ReaderT a m)
Instance details Defined in GHC.Driver.Session Methods getDynFlags :: ReaderT a m DynFlags #
(Monoid a, Monad m, HasDynFlags m) => HasDynFlags (WriterT a m)
Instance details Defined in GHC.Driver.Session Methods getDynFlags :: WriterT a m DynFlags #

data IncludeSpecs #

Used to differentiate the scope an include needs to apply to. We have to split the include paths to avoid accidentally forcing recursive includes since -I overrides the system search paths. See #14312.

Constructors

IncludeSpecs
Fields includePathsQuote :: [String] includePathsGlobal :: [String] includePathsQuoteImplicit :: [String] See Note [Implicit include paths]

Instances

Instances details

Show IncludeSpecs
Instance details Defined in GHC.Driver.Session Methods showsPrec :: Int -> IncludeSpecs -> ShowS # show :: IncludeSpecs -> String # showList :: [IncludeSpecs] -> ShowS #

data HoleFit #

HoleFit is the type we use for valid hole fits. It contains the element that was checked, the Id of that element as found by tcLookup, and the refinement level of the fit, which is the number of extra argument holes that this fit uses (e.g. if hfRefLvl is 2, the fit is for `Id _ _`).

Constructors

HoleFit
Fields hfId :: Id The elements id in the TcM hfCand :: HoleFitCandidate The candidate that was checked. hfType :: TcType The type of the id, possibly zonked. hfRefLvl :: Int The number of holes in this fit. hfWrap :: [TcType] The wrapper for the match. hfMatches :: [TcType] What the refinement variables got matched with, if anything hfDoc :: Maybe [HsDocString] Documentation of this HoleFit, if available.
RawHoleFit SDoc	A fit that is just displayed as is. Here so thatHoleFitPlugins can inject any fit they want.

Instances

Instances details

Outputable HoleFit
Instance details Defined in GHC.Tc.Errors.Hole.FitTypes Methods ppr :: HoleFit -> SDoc #
Eq HoleFit
Instance details Defined in GHC.Tc.Errors.Hole.FitTypes Methods (==) :: HoleFit -> HoleFit -> Bool # (/=) :: HoleFit -> HoleFit -> Bool #
Ord HoleFit
Instance details Defined in GHC.Tc.Errors.Hole.FitTypes Methods compare :: HoleFit -> HoleFit -> Ordering # (<) :: HoleFit -> HoleFit -> Bool # (<=) :: HoleFit -> HoleFit -> Bool # (>) :: HoleFit -> HoleFit -> Bool # (>=) :: HoleFit -> HoleFit -> Bool # max :: HoleFit -> HoleFit -> HoleFit # min :: HoleFit -> HoleFit -> HoleFit #

data HoleFitPlugin #

A HoleFitPlugin is a pair of candidate and fit plugins.

Constructors

HoleFitPlugin
Fields candPlugin :: CandPlugin fitPlugin :: FitPlugin

data HoleFitCandidate #

HoleFitCandidates are passed to hole fit plugins and then checked whether they fit a given typed-hole.

Constructors

IdHFCand Id
NameHFCand Name
GreHFCand GlobalRdrElt

Instances

Instances details

NamedThing HoleFitCandidate
Instance details Defined in GHC.Tc.Errors.Hole.FitTypes Methods getOccName :: HoleFitCandidate -> OccName # getName :: HoleFitCandidate -> Name #
HasOccName HoleFitCandidate
Instance details Defined in GHC.Tc.Errors.Hole.FitTypes Methods occName :: HoleFitCandidate -> OccName #
Outputable HoleFitCandidate
Instance details Defined in GHC.Tc.Errors.Hole.FitTypes Methods ppr :: HoleFitCandidate -> SDoc #
Eq HoleFitCandidate
Instance details Defined in GHC.Tc.Errors.Hole.FitTypes Methods (==) :: HoleFitCandidate -> HoleFitCandidate -> Bool # (/=) :: HoleFitCandidate -> HoleFitCandidate -> Bool #
Ord HoleFitCandidate
Instance details Defined in GHC.Tc.Errors.Hole.FitTypes Methods compare :: HoleFitCandidate -> HoleFitCandidate -> Ordering # (<) :: HoleFitCandidate -> HoleFitCandidate -> Bool # (<=) :: HoleFitCandidate -> HoleFitCandidate -> Bool # (>) :: HoleFitCandidate -> HoleFitCandidate -> Bool # (>=) :: HoleFitCandidate -> HoleFitCandidate -> Bool # max :: HoleFitCandidate -> HoleFitCandidate -> HoleFitCandidate # min :: HoleFitCandidate -> HoleFitCandidate -> HoleFitCandidate #

type ShHoleSubst = ModuleNameEnv Module #

Substitution on module variables, mapping module names to module identifiers.

data UnitErr #

Constructors

CloseUnitErr !UnitId !(Maybe UnitId)
PackageFlagErr !PackageFlag ![(UnitInfo, UnusableUnitReason)]
TrustFlagErr !TrustFlag ![(UnitInfo, UnusableUnitReason)]

Instances

Instances details

Outputable UnitErr
Instance details Defined in GHC.Unit.State Methods ppr :: UnitErr -> SDoc #

data ModuleSuggestion #

Constructors

SuggestVisible ModuleName Module ModuleOrigin
SuggestHidden ModuleName Module ModuleOrigin

data LookupResult #

The result of performing a lookup

Constructors

LookupFound Module (UnitInfo, ModuleOrigin)	Found the module uniquely, nothing else to do
LookupMultiple [(Module, ModuleOrigin)]	Multiple modules with the same name in scope
LookupHidden [(Module, ModuleOrigin)] [(Module, ModuleOrigin)]	No modules found, but there were some hidden ones with an exact name match. First is due to package hidden, second is due to module being hidden
LookupUnusable [(Module, ModuleOrigin)]	No modules found, but there were some unusable ones with an exact name match
LookupNotFound [ModuleSuggestion]	Nothing found, here are some suggested different names

data UnusableUnitReason #

The reason why a unit is unusable.

Constructors

IgnoredWithFlag	We ignored it explicitly using `-ignore-package`.
BrokenDependencies [UnitId]	This unit transitively depends on a unit that was never present in any of the provided databases.
CyclicDependencies [UnitId]	This unit transitively depends on a unit involved in a cycle. Note that the list of `UnitId` reports the direct dependencies of this unit that (transitively) depended on the cycle, and not the actual cycle itself (which we report separately at high verbosity.)
IgnoredDependencies [UnitId]	This unit transitively depends on a unit which was ignored.
ShadowedDependencies [UnitId]	This unit transitively depends on a unit which was shadowed by an ABI-incompatible unit.

Instances

Instances details

Outputable UnusableUnitReason
Instance details Defined in GHC.Unit.State Methods ppr :: UnusableUnitReason -> SDoc #

type UnitInfoMap = Map UnitId UnitInfo #

data UnitDatabase unit #

Unit database

Constructors

UnitDatabase
Fields unitDatabasePath :: FilePath unitDatabaseUnits :: [GenUnitInfo unit]

Instances

Instances details

Outputable u => Outputable (UnitDatabase u)
Instance details Defined in GHC.Unit.State Methods ppr :: UnitDatabase u -> SDoc #

data UnitState #

Constructors

UnitState

Fields

unitInfoMap :: UnitInfoMap
A mapping of Unit to UnitInfo. This list is adjusted so that only valid units are here. UnitInfo reflects what was stored *on disk*, except for the trusted flag, which is adjusted at runtime. (In particular, some units in this map may have the exposed flag be False.)
preloadClosure :: PreloadUnitClosure
The set of transitively reachable units according to the explicitly provided command line arguments. A fully instantiated VirtUnit may only be replaced by a RealUnit from this set. See Note [VirtUnit to RealUnit improvement]
packageNameMap :: UniqFM PackageName UnitId
A mapping of PackageName to UnitId. If several units have the same package name (e.g. different instantiations), then we return one of them... This is used when users refer to packages in Backpack includes. And also to resolve package qualifiers with the PackageImports extension.
wireMap :: Map UnitId UnitId
A mapping from database unit keys to wired in unit ids.
unwireMap :: Map UnitId UnitId
A mapping from wired in unit ids to unit keys from the database.
preloadUnits :: [UnitId]
The units we're going to link in eagerly. This list should be in reverse dependency order; that is, a unit is always mentioned before the units it depends on.
explicitUnits :: [(Unit, Maybe PackageArg)]
Units which we explicitly depend on (from a command line flag). We'll use this to generate version macros and the unused packages warning. The original flag which was used to bring the unit into scope is recorded for the -Wunused-packages warning.
homeUnitDepends :: [UnitId]
moduleNameProvidersMap :: !ModuleNameProvidersMap
This is a full map from ModuleName to all modules which may possibly be providing it. These providers may be hidden (but we'll still want to report them in error messages), or it may be an ambiguous import.
pluginModuleNameProvidersMap :: !ModuleNameProvidersMap
A map, like moduleNameProvidersMap, but controlling plugin visibility.
requirementContext :: Map ModuleName [InstantiatedModule]
A map saying, for each requirement, what interfaces must be merged together when we use them. For example, if our dependencies are p[A=<A>] and q[A=<A>,B=r[C=<A>]:B], then the interfaces to merge for A are p[A=<A>]:A, q[A=<A>,B=r[C=<A>]:B]:A and r[C=<A>]:C.
There's an entry in this map for each hole in our home library.
allowVirtualUnits :: !Bool
Indicate if we can instantiate units on-the-fly.
This should only be true when we are type-checking an indefinite unit. See Note [About units] in GHC.Unit.

type PreloadUnitClosure = UniqSet UnitId #

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 fromOrigUnit :: Maybe Bool `Just False` means that this module is in someone's `exported-modules` list, but that package is hidden; `Just True` means that it is available; `Nothing` means neither applies. fromExposedReexport :: [UnitInfo] Is the module available from a reexport of an exposed package? There could be multiple. fromHiddenReexport :: [UnitInfo] Is the module available from a reexport of a hidden package? fromPackageFlag :: Bool Did the module export come from a package flag? (ToDo: track more information.

Instances

Instances details

Monoid ModuleOrigin
Instance details Defined in GHC.Unit.State Methods mempty :: ModuleOrigin # mappend :: ModuleOrigin -> ModuleOrigin -> ModuleOrigin # mconcat :: [ModuleOrigin] -> ModuleOrigin #
Semigroup ModuleOrigin
Instance details Defined in GHC.Unit.State Methods (<>) :: ModuleOrigin -> ModuleOrigin -> ModuleOrigin # sconcat :: NonEmpty ModuleOrigin -> ModuleOrigin # stimes :: Integral b => b -> ModuleOrigin -> ModuleOrigin #
Outputable ModuleOrigin
Instance details Defined in GHC.Unit.State Methods ppr :: ModuleOrigin -> SDoc #

data FinderOpts #

Locations and information the finder cares about.

Should be taken from DynFlags via initFinderOpts.

Constructors

FinderOpts

Fields

finder_importPaths :: [FilePath]
Where are we allowed to look for Modules and Source files
finder_lookupHomeInterfaces :: Bool
When looking up a home module:
- True: search interface files (e.g. in '-c' mode)
- False: search source files (e.g. in '--make' mode)
finder_bypassHiFileCheck :: Bool
Don't check that an imported interface file actually exists if it can only be at one location. The interface will be reported as InstalledFound even if the file doesn't exist, so this is only useful in specific cases (e.g. to generate dependencies with `ghc -M`)
finder_ways :: Ways
finder_enableSuggestions :: Bool
If we encounter unknown modules, should we suggest modules that have a similar name.
finder_workingDirectory :: Maybe FilePath
finder_thisPackageName :: Maybe FastString
finder_hiddenModules :: Set ModuleName
finder_reexportedModules :: Set ModuleName
finder_hieDir :: Maybe FilePath
finder_hieSuf :: String
finder_hiDir :: Maybe FilePath
finder_hiSuf :: String
finder_dynHiSuf :: String
finder_objectDir :: Maybe FilePath
finder_objectSuf :: String
finder_dynObjectSuf :: String
finder_stubDir :: Maybe FilePath

Instances

Instances details

Show FinderOpts
Instance details Defined in GHC.Unit.Finder.Types Methods showsPrec :: Int -> FinderOpts -> ShowS # show :: FinderOpts -> String # showList :: [FinderOpts] -> ShowS #

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 fr_paths :: [FilePath] Places where I looked fr_pkg :: Maybe Unit Just p => module is in this unit's manifest, but couldn't find the .hi file fr_mods_hidden :: [Unit] Module is in these units, but the module is hidden fr_pkgs_hidden :: [Unit] Module is in these units, but the unit is hidden fr_unusables :: [(Unit, UnusableUnitReason)] Module is in these units, but it is unusable fr_suggestions :: [ModuleSuggestion] Possible mis-spelled modules

data InstalledFindResult #

Constructors

InstalledFound ModLocation InstalledModule
InstalledNoPackage UnitId
InstalledNotFound [FilePath] (Maybe UnitId)

data FinderCache #

data HsParsedModule #

Constructors

HsParsedModule
Fields hpm_module :: Located (HsModule GhcPs) hpm_src_files :: [FilePath] extra source files (e.g. from #includes). The lexer collects these from '# file line' pragmas, which the C preprocessor leaves behind. These files and their timestamps are stored in the .hi file, so that we can force recompilation if any of them change (#3589)

data CgGuts #

A restricted form of ModGuts for code generation purposes

Constructors

CgGuts

Fields

cg_module :: !Module
Module being compiled
cg_tycons :: [TyCon]
Algebraic data types (including ones that started life as classes); generate constructors and info tables. Includes newtypes, just for the benefit of External Core
cg_binds :: CoreProgram
The tidied main bindings, including previously-implicit bindings for record and class selectors, and data constructor wrappers. But *not* data constructor workers; reason: we regard them as part of the code-gen of tycons
cg_ccs :: [CostCentre]
cg_foreign :: !ForeignStubs
Foreign export stubs
cg_foreign_files :: ![(ForeignSrcLang, FilePath)]
cg_dep_pkgs :: !(Set UnitId)
Dependent packages, used to generate #includes for C code gen
cg_hpc_info :: !HpcInfo
Program coverage tick box information
cg_modBreaks :: !(Maybe ModBreaks)
Module breakpoints
cg_spt_entries :: [SptEntry]
Static pointer table entries for static forms defined in the module. See Note [Grand plan for static forms] in GHC.Iface.Tidy.StaticPtrTable

data 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

mg_module :: !Module
Module being compiled
mg_hsc_src :: HscSource
Whether it's an hs-boot module
mg_loc :: SrcSpan
For error messages from inner passes
mg_exports :: ![AvailInfo]
What it exports
mg_deps :: !Dependencies
What it depends on, directly or otherwise
mg_usages :: ![Usage]
What was used? Used for interfaces.
mg_used_th :: !Bool
Did we run a TH splice?
mg_rdr_env :: !GlobalRdrEnv
Top-level lexical environment
mg_fix_env :: !FixityEnv
Fixities declared in this module. Used for creating interface files.
mg_tcs :: ![TyCon]
TyCons declared in this module (includes TyCons for classes)
mg_insts :: ![ClsInst]
Class instances declared in this module
mg_fam_insts :: ![FamInst]
Family instances declared in this module
mg_patsyns :: ![PatSyn]
Pattern synonyms declared in this module
mg_rules :: ![CoreRule]
Before the core pipeline starts, contains See Note [Overall plumbing for rules] in GHC.Core.Rules
mg_binds :: !CoreProgram
Bindings for this module
mg_foreign :: !ForeignStubs
Foreign exports declared in this module
mg_foreign_files :: ![(ForeignSrcLang, FilePath)]
Files to be compiled with the C compiler
mg_warns :: !(Warnings GhcRn)
Warnings declared in the module
mg_anns :: [Annotation]
Annotations declared in this module
mg_complete_matches :: [CompleteMatch]
Complete Matches
mg_hpc_info :: !HpcInfo
Coverage tick boxes in the module
mg_modBreaks :: !(Maybe ModBreaks)
Breakpoints for the module
mg_inst_env :: InstEnv
Class instance environment for home-package modules (including this one); c.f. tcg_inst_env
mg_fam_inst_env :: FamInstEnv
Type-family instance environment for home-package modules (including this one); c.f. tcg_fam_inst_env
mg_boot_exports :: !NameSet
mg_safe_haskell :: SafeHaskellMode
Safe Haskell mode
mg_trust_pkg :: Bool
Do we need to trust our own package for Safe Haskell? See Note [Trust Own Package] in GHC.Rename.Names
mg_docs :: !(Maybe Docs)
Documentation.

data RuleEnv #

A full rule environment which we can apply rules from. Like a RuleBase, but it also includes the set of visible orphans we use to filter out orphan rules which are not visible (even though we can see them...) See Note [Orphans] in GHC.Core

Constructors

RuleEnv
Fields re_local_rules :: !RuleBase re_home_rules :: !RuleBase re_eps_rules :: !RuleBase re_visible_orphs :: !ModuleSet

type RuleBase = NameEnv [CoreRule] #

Gathers a collection of CoreRules. Maps (the name of) an Id to its rules

type WhetherHasFamInst = Bool #

Does this module define family instances?

type WhetherHasOrphans = Bool #

Records whether a module has orphans. An "orphan" is one of:

An instance declaration in a module other than the definition module for one of the type constructors or classes in the instance head
A rewrite rule in a module other than the one defining the function in the head of the rule

type IfaceExport = AvailInfo #

The original names declared of a certain module that are exported

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

mi_module :: !Module
Name of the module we are for
mi_sig_of :: !(Maybe Module)
Are we a sig of another mod?
mi_hsc_src :: !HscSource
Boot? Signature?
mi_deps :: Dependencies
The dependencies of the module. This is consulted for directly-imported modules, but not for anything else (hence lazy)
mi_usages :: [Usage]
Usages; kept sorted so that it's easy to decide whether to write a new iface file (changing usages doesn't affect the hash of this module) NOT STRICT! we read this field lazily from the interface file It is *only* consulted by the recompilation checker
mi_exports :: ![IfaceExport]
Exports Kept sorted by (mod,occ), to make version comparisons easier Records the modules that are the declaration points for things exported by this module, and the OccNames of those things
mi_used_th :: !Bool
Module required TH splices when it was compiled. This disables recompilation avoidance (see #481).
mi_fixities :: [(OccName, Fixity)]
Fixities NOT STRICT! we read this field lazily from the interface file
mi_warns :: Warnings GhcRn
Warnings NOT STRICT! we read this field lazily from the interface file
mi_anns :: [IfaceAnnotation]
Annotations NOT STRICT! we read this field lazily from the interface file
mi_decls :: [IfaceDeclExts phase]
Type, class and variable declarations The hash of an Id changes if its fixity or deprecations change (as well as its type of course) Ditto data constructors, class operations, except that the hash of the parent class/tycon changes
mi_extra_decls :: Maybe [IfaceBindingX IfaceMaybeRhs IfaceTopBndrInfo]
Extra variable definitions which are **NOT** exposed but when combined with mi_decls allows us to restart code generation. See Note [Interface Files with Core Definitions] and Note [Interface File with Core: Sharing RHSs]
mi_globals :: !(Maybe GlobalRdrEnv)
Binds all the things defined at the top level in the original source code for this module. which is NOT the same as mi_exports, nor mi_decls (which may contains declarations for things not actually defined by the user). Used for GHCi and for inspecting the contents of modules via the GHC API only.
(We need the source file to figure out the top-level environment, if we didn't compile this module from source then this field contains Nothing).
Strictly speaking this field should live in the HomeModInfo, but that leads to more plumbing.
mi_insts :: [IfaceClsInst]
Sorted class instance
mi_fam_insts :: [IfaceFamInst]
Sorted family instances
mi_rules :: [IfaceRule]
Sorted rules
mi_hpc :: !AnyHpcUsage
True if this program uses Hpc at any point in the program.
mi_trust :: !IfaceTrustInfo
Safe Haskell Trust information for this module.
mi_trust_pkg :: !Bool
Do we require the package this module resides in be trusted to trust this module? This is used for the situation where a module is Safe (so doesn't require the package be trusted itself) but imports some trustworthy modules from its own package (which does require its own package be trusted). See Note [Trust Own Package] in GHC.Rename.Names
mi_complete_matches :: ![IfaceCompleteMatch]
mi_docs :: !(Maybe Docs)
Docstrings and related data for use by haddock, the ghci :doc command, and other tools.
Just _ = the module was built with -haddock.
mi_final_exts :: !(IfaceBackendExts phase)
Either () or ModIfaceBackend for a fully instantiated interface.
mi_ext_fields :: !ExtensibleFields
Additional optional fields, where the Map key represents the field name, resulting in a (size, serialized data) pair. Because the data is intended to be serialized through the internal Binary class (increasing compatibility with types using Name and FastString, such as HIE), this format is chosen over ByteStrings.
mi_src_hash :: !Fingerprint
Hash of the .hs source, used for recompilation checking.

Instances

Instances details

Binary ModIface
Instance details Defined in GHC.Unit.Module.ModIface Methods put_ :: BinHandle -> ModIface -> IO () # put :: BinHandle -> ModIface -> IO (Bin ModIface) # get :: BinHandle -> IO ModIface #
(NFData (IfaceBackendExts phase), NFData (IfaceDeclExts phase)) => NFData (ModIface_ phase)
Instance details Defined in GHC.Unit.Module.ModIface Methods rnf :: ModIface_ phase -> () #

type ModIface = ModIface_ 'ModIfaceFinal #

type family IfaceBackendExts (phase :: ModIfacePhase) = (bk :: Type) | bk -> phase where ... #

Equations

IfaceBackendExts 'ModIfaceCore = ()
IfaceBackendExts 'ModIfaceFinal = ModIfaceBackend

type family IfaceDeclExts (phase :: ModIfacePhase) = (decl :: Type) | decl -> phase where ... #

Selects a IfaceDecl representation. For fully instantiated interfaces we also maintain a fingerprint, which is used for recompilation checks.

Equations

IfaceDeclExts 'ModIfaceCore = IfaceDecl
IfaceDeclExts 'ModIfaceFinal = (Fingerprint, IfaceDecl)

data ModIfaceBackend #

Extends a PartialModIface with information which is either: * Computed after codegen * Or computed just before writing the iface to disk. (Hashes) In order to fully instantiate it.

Constructors

ModIfaceBackend

Fields

mi_iface_hash :: !Fingerprint
Hash of the whole interface
mi_mod_hash :: !Fingerprint
Hash of the ABI only
mi_flag_hash :: !Fingerprint
Hash of the important flags used when compiling the module, excluding optimisation flags
mi_opt_hash :: !Fingerprint
Hash of optimisation flags
mi_hpc_hash :: !Fingerprint
Hash of hpc flags
mi_plugin_hash :: !Fingerprint
Hash of plugins
mi_orphan :: !WhetherHasOrphans
Whether this module has orphans
mi_finsts :: !WhetherHasFamInst
Whether this module has family instances. See Note [The type family instance consistency story].
mi_exp_hash :: !Fingerprint
Hash of export list
mi_orphan_hash :: !Fingerprint
Hash for orphan rules, class and family instances combined
mi_warn_fn :: !(OccName -> Maybe (WarningTxt GhcRn))
Cached lookup for mi_warns
mi_fix_fn :: !(OccName -> Maybe Fixity)
Cached lookup for mi_fixities
mi_hash_fn :: !(OccName -> Maybe (OccName, Fingerprint))
Cached lookup for mi_decls. The Nothing in mi_hash_fn means that the thing isn't in decls. It's useful to know that when seeing if we are up to date wrt. the old interface. The OccName is the parent of the name, if it has one.

Instances

Instances details

NFData ModIfaceBackend
Instance details Defined in GHC.Unit.Module.ModIface Methods rnf :: ModIfaceBackend -> () #

type PartialModIface = ModIface_ 'ModIfaceCore #

data HscBackendAction #

Action to perform in backend compilation

Constructors

HscUpdate ModIface	Update the boot and signature file results.
HscRecomp	Recompile this module.
Fields hscs_guts :: CgGuts Information for the code generator. hscs_mod_location :: !ModLocation Module info hscs_partial_iface :: !PartialModIface Partial interface hscs_old_iface_hash :: !(Maybe Fingerprint) Old interface hash for this compilation, if an old interface file exists. Pass to `hscMaybeWriteIface` when writing the interface to avoid updating the existing interface when the interface isn't changed.

Instances

Instances details

Outputable HscBackendAction
Instance details Defined in GHC.Unit.Module.Status Methods ppr :: HscBackendAction -> SDoc #

data HscRecompStatus #

Status of a module in incremental compilation

Constructors

HscUpToDate ModIface HomeModLinkable	Nothing to do because code already exists.
HscRecompNeeded (Maybe Fingerprint)	Recompilation of module, or update of interface is required. Optionally pass the old interface hash to avoid updating the existing interface when it has not changed.

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

ms_mod :: Module
Identity of the module
ms_hsc_src :: HscSource
The module source either plain Haskell, hs-boot, or hsig
ms_location :: ModLocation
Location of the various files belonging to the module
ms_hs_hash :: Fingerprint
Content hash of source file
ms_obj_date :: Maybe UTCTime
Timestamp of object, if we have one
ms_dyn_obj_date :: !(Maybe UTCTime)
Timestamp of dynamic object, if we have one
ms_iface_date :: Maybe UTCTime
Timestamp of hi file, if we have one See Note [When source is considered modified] and #9243
ms_hie_date :: Maybe UTCTime
Timestamp of hie file, if we have one
ms_srcimps :: [(PkgQual, Located ModuleName)]
Source imports of the module
ms_textual_imps :: [(PkgQual, Located ModuleName)]
Non-source imports of the module from the module *text*
ms_ghc_prim_import :: !Bool
Whether the special module GHC.Prim was imported explicitly
ms_parsed_mod :: Maybe HsParsedModule
The parsed, nonrenamed source, if we have it. This is also used to support "inline module syntax" in Backpack files.
ms_hspp_file :: FilePath
Filename of preprocessed source file
ms_hspp_opts :: DynFlags
Cached flags from OPTIONS, INCLUDE and LANGUAGE pragmas in the modules source code
ms_hspp_buf :: Maybe StringBuffer
The actual preprocessed source, if we have it

Instances

Instances details

Outputable ModSummary
Instance details Defined in GHC.Unit.Module.ModSummary Methods ppr :: ModSummary -> SDoc #

data FileHeaderPragmaType #

Constructors

OptionsPrag
IncludePrag
LanguagePrag
DocOptionsPrag

data TransLayoutReason #

Constructors

TransLayout_Where	"`where' clause at the same depth as implicit layout block"
TransLayout_Pipe	"`\|' at the same depth as implicit layout block")

data CmmParserError #

Errors from the Cmm parser

Constructors

CmmUnknownPrimitive !FastString	Unknown Cmm primitive
CmmUnknownMacro !FastString	Unknown macro
CmmUnknownCConv !String	Unknown calling convention
CmmUnrecognisedSafety !String	Unrecognised safety
CmmUnrecognisedHint !String	Unrecognised hint

data LexErr #

Constructors

LexError	Lexical error
LexUnknownPragma	Unknown pragma
LexErrorInPragma	Lexical error in pragma
LexNumEscapeRange	Numeric escape sequence out of range
LexStringCharLit	Lexical error in string/character literal
LexStringCharLitEOF	Unexpected end-of-file in string/character literal
LexUnterminatedComment	Unterminated `{-'
LexUnterminatedOptions	Unterminated OPTIONS pragma
LexUnterminatedQQ	Unterminated quasiquotation

data LexErrKind #

Constructors

LexErrKind_EOF	End of input
LexErrKind_UTF8	UTF-8 decoding error
LexErrKind_Char !Char	Error at given character

Instances

Instances details

Show LexErrKind
Instance details Defined in GHC.Parser.Errors.Types Methods showsPrec :: Int -> LexErrKind -> ShowS # show :: LexErrKind -> String # showList :: [LexErrKind] -> ShowS #
Eq LexErrKind
Instance details Defined in GHC.Parser.Errors.Types Methods (==) :: LexErrKind -> LexErrKind -> Bool # (/=) :: LexErrKind -> LexErrKind -> Bool #
Ord LexErrKind
Instance details Defined in GHC.Parser.Errors.Types Methods compare :: LexErrKind -> LexErrKind -> Ordering # (<) :: LexErrKind -> LexErrKind -> Bool # (<=) :: LexErrKind -> LexErrKind -> Bool # (>) :: LexErrKind -> LexErrKind -> Bool # (>=) :: LexErrKind -> LexErrKind -> Bool # max :: LexErrKind -> LexErrKind -> LexErrKind # min :: LexErrKind -> LexErrKind -> LexErrKind #

data NumUnderscoreReason #

Constructors

NumUnderscore_Integral
NumUnderscore_Float

Instances

Instances details

Show NumUnderscoreReason
Instance details Defined in GHC.Parser.Errors.Types Methods showsPrec :: Int -> NumUnderscoreReason -> ShowS # show :: NumUnderscoreReason -> String # showList :: [NumUnderscoreReason] -> ShowS #
Eq NumUnderscoreReason
Instance details Defined in GHC.Parser.Errors.Types Methods (==) :: NumUnderscoreReason -> NumUnderscoreReason -> Bool # (/=) :: NumUnderscoreReason -> NumUnderscoreReason -> Bool #
Ord NumUnderscoreReason
Instance details Defined in GHC.Parser.Errors.Types Methods compare :: NumUnderscoreReason -> NumUnderscoreReason -> Ordering # (<) :: NumUnderscoreReason -> NumUnderscoreReason -> Bool # (<=) :: NumUnderscoreReason -> NumUnderscoreReason -> Bool # (>) :: NumUnderscoreReason -> NumUnderscoreReason -> Bool # (>=) :: NumUnderscoreReason -> NumUnderscoreReason -> Bool # max :: NumUnderscoreReason -> NumUnderscoreReason -> NumUnderscoreReason # min :: NumUnderscoreReason -> NumUnderscoreReason -> NumUnderscoreReason #

data PsErrInPatDetails #

Constructors

PEIP_NegApp	Negative application pattern?
PEIP_TypeArgs [HsConPatTyArg GhcPs]	The list of type arguments for the pattern
PEIP_RecPattern
Fields [LPat GhcPs] The pattern arguments !PatIsRecursive Is the parsed pattern recursive? !ParseContext
PEIP_OtherPatDetails !ParseContext

data ParseContext #

Extra information for the expression GHC is currently inspecting/parsing. It can be used to generate more informative parser diagnostics and hints.

Constructors

ParseContext
Fields is_infix :: !(Maybe RdrName) If `Just`, this is an infix pattern with the bound operator name incomplete_do_block :: !PatIncompleteDoBlock Did the parser likely fail due to an incomplete do block?

Instances

Instances details

Eq ParseContext
Instance details Defined in GHC.Parser.Errors.Types Methods (==) :: ParseContext -> ParseContext -> Bool # (/=) :: ParseContext -> ParseContext -> Bool #

data PatIncompleteDoBlock #

Constructors

YesIncompleteDoBlock
NoIncompleteDoBlock

Instances

Instances details

Eq PatIncompleteDoBlock
Instance details Defined in GHC.Parser.Errors.Types Methods (==) :: PatIncompleteDoBlock -> PatIncompleteDoBlock -> Bool # (/=) :: PatIncompleteDoBlock -> PatIncompleteDoBlock -> Bool #

data PatIsRecursive #

Is the parsed pattern recursive?

Constructors

YesPatIsRecursive
NoPatIsRecursive

data PsErrParseDetails #

Extra details about a parse error, which helps us in determining which should be the hints to suggest.

Constructors

PsErrParseDetails
Fields ped_th_enabled :: !Bool ped_do_in_last_100 :: !Bool Is there a 'do' in the last 100 characters? ped_mdo_in_last_100 :: !Bool Is there an `mdo` in the last 100 characters? ped_pat_syn_enabled :: !Bool Is `PatternSynonyms` enabled? ped_pattern_parsed :: !Bool Did we parse a "pattern" keyword?

data PsMessage #

Constructors

PsUnknownMessage UnknownDiagnostic	An "unknown" message from the parser. This type constructor allows arbitrary messages to be embedded. The typical use case would be GHC plugins willing to emit custom diagnostics.
PsHeaderMessage !PsHeaderMessage	A group of parser messages emitted in `Header`. See Note [Messages from GHC.Parser.Header].
PsWarnBidirectionalFormatChars (NonEmpty (PsLoc, Char, String))	PsWarnBidirectionalFormatChars is a warning (controlled by the -Wwarn-bidirectional-format-characters flag) that occurs when unicode bi-directional format characters are found within in a file The `PsLoc` contains the exact position in the buffer the character occurred, and the string contains a description of the character.
PsWarnTab	PsWarnTab is a warning (controlled by the -Wwarn-tabs flag) that occurs when tabulations (tabs) are found within a file. Test case(s): parsershould_failT12610 parsershould_compileT9723b parsershould_compileT9723a parsershould_compileread043 parsershould_failT16270 warningsshould_compileT9230
Fields !Word Number of other occurrences other than the first one
PsWarnTransitionalLayout !TransLayoutReason	PsWarnTransitionalLayout is a warning (controlled by the -Walternative-layout-rule-transitional flag) that occurs when pipes ('\|') or 'where' are at the same depth of an implicit layout block. Example(s): f :: IO () f \| True = do let x = () y = () return () \| True = return () Test case(s): layout/layout006 layout/layout003 layout/layout001
PsWarnUnrecognisedPragma !String ![String]	Unrecognised pragma. First field is the actual pragma name which might be empty. Second field is the set of valid candidate pragmas.
PsWarnMisplacedPragma !FileHeaderPragmaType
PsWarnHaddockInvalidPos	Invalid Haddock comment position
PsWarnHaddockIgnoreMulti	Multiple Haddock comment for the same entity
PsWarnStarBinder	Found binding occurrence of "*" while StarIsType is enabled
PsWarnStarIsType	Using "*" for Type without StarIsType enabled
PsWarnImportPreQualified	Pre qualified import with `WarnPrepositiveQualifiedModule` enabled
PsWarnOperatorWhitespaceExtConflict !OperatorWhitespaceSymbol
PsWarnOperatorWhitespace !FastString !OperatorWhitespaceOccurrence
PsErrLambdaCase	LambdaCase syntax used without the extension enabled
PsErrEmptyLambda	A lambda requires at least one parameter
PsErrNumUnderscores !NumUnderscoreReason	Underscores in literals without the extension enabled
PsErrPrimStringInvalidChar	Invalid character in primitive string
PsErrMissingBlock	Missing block
PsErrLexer !LexErr !LexErrKind	Lexer error
PsErrSuffixAT	Suffix occurrence of `@`
PsErrParse !String !PsErrParseDetails	Parse errors
PsErrCmmLexer	Cmm lexer error
PsErrUnsupportedBoxedSumExpr !(SumOrTuple (HsExpr GhcPs))	Unsupported boxed sum in expression
PsErrUnsupportedBoxedSumPat !(SumOrTuple (PatBuilder GhcPs))	Unsupported boxed sum in pattern
PsErrUnexpectedQualifiedConstructor !RdrName	Unexpected qualified constructor
PsErrTupleSectionInPat	Tuple section in pattern context
PsErrIllegalBangPattern !(Pat GhcPs)	Bang-pattern without BangPattterns enabled
PsErrOpFewArgs !StarIsType !RdrName	Operator applied to too few arguments
PsErrImportQualifiedTwice	Import: multiple occurrences of `qualified`
PsErrImportPostQualified	Post qualified import without `ImportQualifiedPost`
PsErrIllegalExplicitNamespace	Explicit namespace keyword without `ExplicitNamespaces`
PsErrVarForTyCon !RdrName	Expecting a type constructor but found a variable
PsErrIllegalPatSynExport	Illegal export form allowed by PatternSynonyms
PsErrMalformedEntityString	Malformed entity string
PsErrDotsInRecordUpdate	Dots used in record update
PsErrPrecedenceOutOfRange !Int	Precedence out of range
PsErrOverloadedRecordDotInvalid	Invalid use of record dot syntax `.`
PsErrOverloadedRecordUpdateNotEnabled	`OverloadedRecordUpdate` is not enabled.
PsErrOverloadedRecordUpdateNoQualifiedFields	Can't use qualified fields when OverloadedRecordUpdate is enabled.
PsErrInvalidDataCon !(HsType GhcPs)	Cannot parse data constructor in a data/newtype declaration
PsErrInvalidInfixDataCon !(HsType GhcPs) !RdrName !(HsType GhcPs)	Cannot parse data constructor in a data/newtype declaration
PsErrIllegalPromotionQuoteDataCon !RdrName	Illegal DataKinds quote mark in data/newtype constructor declaration
PsErrUnpackDataCon	UNPACK applied to a data constructor
PsErrUnexpectedKindAppInDataCon !DataConBuilder !(HsType GhcPs)	Unexpected kind application in data/newtype declaration
PsErrInvalidRecordCon !(PatBuilder GhcPs)	Not a record constructor
PsErrIllegalUnboxedStringInPat !(HsLit GhcPs)	Illegal unboxed string literal in pattern
PsErrIllegalUnboxedFloatingLitInPat !(HsLit GhcPs)	Illegal primitive floating point literal in pattern
PsErrDoNotationInPat	Do-notation in pattern
PsErrIfThenElseInPat	If-then-else syntax in pattern
PsErrLambdaCaseInPat LamCaseVariant	Lambda-case in pattern
PsErrCaseInPat	case..of in pattern
PsErrLetInPat	let-syntax in pattern
PsErrLambdaInPat	Lambda-syntax in pattern
PsErrArrowExprInPat !(HsExpr GhcPs)	Arrow expression-syntax in pattern
PsErrArrowCmdInPat !(HsCmd GhcPs)	Arrow command-syntax in pattern
PsErrArrowCmdInExpr !(HsCmd GhcPs)	Arrow command-syntax in expression
PsErrViewPatInExpr !(LHsExpr GhcPs) !(LHsExpr GhcPs)	View-pattern in expression
PsErrTypeAppWithoutSpace !RdrName !(LHsExpr GhcPs)	Type-application without space before `@`
PsErrLazyPatWithoutSpace !(LHsExpr GhcPs)	Lazy-pattern (`~`) without space after it
PsErrBangPatWithoutSpace !(LHsExpr GhcPs)	Bang-pattern (`!`) without space after it
PsErrUnallowedPragma !(HsPragE GhcPs)	Pragma not allowed in this position
PsErrQualifiedDoInCmd !ModuleName	Qualified do block in command
PsErrInvalidInfixHole	Invalid infix hole, expected an infix operator
PsErrSemiColonsInCondExpr	Unexpected semi-colons in conditional expression
Fields !(HsExpr GhcPs) conditional expr !Bool "then" semi-colon? !(HsExpr GhcPs) "then" expr !Bool "else" semi-colon? !(HsExpr GhcPs) "else" expr
PsErrSemiColonsInCondCmd	Unexpected semi-colons in conditional command
Fields !(HsExpr GhcPs) conditional expr !Bool "then" semi-colon? !(HsCmd GhcPs) "then" expr !Bool "else" semi-colon? !(HsCmd GhcPs) "else" expr
PsErrAtInPatPos	@-operator in a pattern position
PsErrLambdaCmdInFunAppCmd !(LHsCmd GhcPs)	Unexpected lambda command in function application
PsErrCaseCmdInFunAppCmd !(LHsCmd GhcPs)	Unexpected case command in function application
PsErrLambdaCaseCmdInFunAppCmd !LamCaseVariant !(LHsCmd GhcPs)	Unexpected case(s) command in function application
PsErrIfCmdInFunAppCmd !(LHsCmd GhcPs)	Unexpected if command in function application
PsErrLetCmdInFunAppCmd !(LHsCmd GhcPs)	Unexpected let command in function application
PsErrDoCmdInFunAppCmd !(LHsCmd GhcPs)	Unexpected do command in function application
PsErrDoInFunAppExpr !(Maybe ModuleName) !(LHsExpr GhcPs)	Unexpected do block in function application
PsErrMDoInFunAppExpr !(Maybe ModuleName) !(LHsExpr GhcPs)	Unexpected mdo block in function application
PsErrLambdaInFunAppExpr !(LHsExpr GhcPs)	Unexpected lambda expression in function application
PsErrCaseInFunAppExpr !(LHsExpr GhcPs)	Unexpected case expression in function application
PsErrLambdaCaseInFunAppExpr !LamCaseVariant !(LHsExpr GhcPs)	Unexpected case(s) expression in function application
PsErrLetInFunAppExpr !(LHsExpr GhcPs)	Unexpected let expression in function application
PsErrIfInFunAppExpr !(LHsExpr GhcPs)	Unexpected if expression in function application
PsErrProcInFunAppExpr !(LHsExpr GhcPs)	Unexpected proc expression in function application
PsErrMalformedTyOrClDecl !(LHsType GhcPs)	Malformed head of type or class declaration
PsErrIllegalWhereInDataDecl	Illegal 'where' keyword in data declaration
PsErrIllegalDataTypeContext !(LHsContext GhcPs)	Illegal datatype context
PsErrParseErrorOnInput !OccName	Parse error on input
PsErrMalformedDecl !SDoc !RdrName	Malformed ... declaration for ...
PsErrUnexpectedTypeAppInDecl !(LHsType GhcPs) !SDoc !RdrName	Unexpected type application in a declaration
PsErrNotADataCon !RdrName	Not a data constructor
PsErrRecordSyntaxInPatSynDecl !(LPat GhcPs)	Record syntax used in pattern synonym declaration
PsErrEmptyWhereInPatSynDecl !RdrName	Empty 'where' clause in pattern-synonym declaration
PsErrInvalidWhereBindInPatSynDecl !RdrName !(HsDecl GhcPs)	Invalid binding name in 'where' clause of pattern-synonym declaration
PsErrNoSingleWhereBindInPatSynDecl !RdrName !(HsDecl GhcPs)	Multiple bindings in 'where' clause of pattern-synonym declaration
PsErrDeclSpliceNotAtTopLevel !(SpliceDecl GhcPs)	Declaration splice not a top-level
PsErrInferredTypeVarNotAllowed	Inferred type variables not allowed here
PsErrMultipleNamesInStandaloneKindSignature [LIdP GhcPs]	Multiple names in standalone kind signatures
PsErrIllegalImportBundleForm	Illegal import bundle form
PsErrIllegalRoleName !FastString [Role]	Illegal role name
PsErrInvalidTypeSignature !(LHsExpr GhcPs)	Invalid type signature
PsErrUnexpectedTypeInDecl !(LHsType GhcPs) !SDoc !RdrName [LHsTypeArg GhcPs] !SDoc	Unexpected type in declaration
PsErrExpectedHyphen	Expected a hyphen
PsErrSpaceInSCC	Found a space in a SCC
PsErrEmptyDoubleQuotes	Found two single quotes
Fields !Bool Is TH on?
PsErrInvalidPackageName !FastString	Invalid package name
PsErrInvalidRuleActivationMarker	Invalid rule activation marker
PsErrLinearFunction	Linear function found but LinearTypes not enabled
PsErrMultiWayIf	Multi-way if-expression found but MultiWayIf not enabled
PsErrExplicitForall	Explicit forall found but no extension allowing it is enabled
Fields !Bool is Unicode forall?
PsErrIllegalQualifiedDo !SDoc	Found qualified-do without QualifiedDo enabled
PsErrCmmParser !CmmParserError	Cmm parser error
PsErrIllegalTraditionalRecordSyntax !SDoc	Illegal traditional record syntax TODO: distinguish errors without using SDoc
PsErrParseErrorInCmd !SDoc	Parse error in command TODO: distinguish errors without using SDoc
PsErrInPat !(PatBuilder GhcPs) !PsErrInPatDetails	Parse error in pattern
PsErrParseRightOpSectionInPat !RdrName !(PatBuilder GhcPs)	Parse error in right operator section pattern TODO: embed the proper operator, if possible
PsErrIllegalGadtRecordMultiplicity !(HsArrow GhcPs)	Illegal linear arrow or multiplicity annotation in GADT record syntax
PsErrInvalidCApiImport
PsErrMultipleConForNewtype !RdrName !Int
PsErrUnicodeCharLooksLike
Fields Char the problematic character Char the character it looks like String the name of the character that it looks like

Instances

Instances details

Generic PsMessage
Instance details Defined in GHC.Parser.Errors.Types Associated Types type Rep PsMessage :: Type -> Type # Methods from :: PsMessage -> Rep PsMessage x # to :: Rep PsMessage x -> PsMessage #
type Rep PsMessage
Instance details Defined in GHC.Parser.Errors.Types type Rep PsMessage = D1 ('MetaData "PsMessage" "GHC.Parser.Errors.Types" "ghc" 'False) ((((((C1 ('MetaCons "PsUnknownMessage" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 UnknownDiagnostic)) :+: (C1 ('MetaCons "PsHeaderMessage" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 PsHeaderMessage)) :+: C1 ('MetaCons "PsWarnBidirectionalFormatChars" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (NonEmpty (PsLoc, Char, String)))))) :+: ((C1 ('MetaCons "PsWarnTab" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedUnpack) (Rec0 Word)) :+: C1 ('MetaCons "PsWarnTransitionalLayout" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 TransLayoutReason))) :+: (C1 ('MetaCons "PsWarnUnrecognisedPragma" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 String) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 [String])) :+: C1 ('MetaCons "PsWarnMisplacedPragma" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 FileHeaderPragmaType))))) :+: ((C1 ('MetaCons "PsWarnHaddockInvalidPos" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "PsWarnHaddockIgnoreMulti" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "PsWarnStarBinder" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "PsWarnStarIsType" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "PsWarnImportPreQualified" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "PsWarnOperatorWhitespaceExtConflict" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 OperatorWhitespaceSymbol)) :+: C1 ('MetaCons "PsWarnOperatorWhitespace" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 FastString) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 OperatorWhitespaceOccurrence)))))) :+: (((C1 ('MetaCons "PsErrLambdaCase" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "PsErrEmptyLambda" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "PsErrNumUnderscores" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 NumUnderscoreReason)))) :+: ((C1 ('MetaCons "PsErrPrimStringInvalidChar" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "PsErrMissingBlock" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "PsErrLexer" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 LexErr) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 LexErrKind)) :+: C1 ('MetaCons "PsErrSuffixAT" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "PsErrParse" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 String) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 PsErrParseDetails)) :+: C1 ('MetaCons "PsErrCmmLexer" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "PsErrUnsupportedBoxedSumExpr" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (SumOrTuple (HsExpr GhcPs)))) :+: C1 ('MetaCons "PsErrUnsupportedBoxedSumPat" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (SumOrTuple (PatBuilder GhcPs)))))) :+: ((C1 ('MetaCons "PsErrUnexpectedQualifiedConstructor" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 RdrName)) :+: C1 ('MetaCons "PsErrTupleSectionInPat" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "PsErrIllegalBangPattern" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Pat GhcPs))) :+: C1 ('MetaCons "PsErrOpFewArgs" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 StarIsType) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 RdrName))))))) :+: ((((C1 ('MetaCons "PsErrImportQualifiedTwice" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "PsErrImportPostQualified" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "PsErrIllegalExplicitNamespace" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "PsErrVarForTyCon" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 RdrName)) :+: C1 ('MetaCons "PsErrIllegalPatSynExport" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "PsErrMalformedEntityString" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "PsErrDotsInRecordUpdate" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: ((C1 ('MetaCons "PsErrPrecedenceOutOfRange" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedUnpack) (Rec0 Int)) :+: (C1 ('MetaCons "PsErrOverloadedRecordDotInvalid" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "PsErrOverloadedRecordUpdateNotEnabled" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "PsErrOverloadedRecordUpdateNoQualifiedFields" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "PsErrInvalidDataCon" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (HsType GhcPs)))) :+: (C1 ('MetaCons "PsErrInvalidInfixDataCon" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (HsType GhcPs)) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 RdrName) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (HsType GhcPs)))) :+: C1 ('MetaCons "PsErrIllegalPromotionQuoteDataCon" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 RdrName)))))) :+: (((C1 ('MetaCons "PsErrUnpackDataCon" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "PsErrUnexpectedKindAppInDataCon" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 DataConBuilder) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (HsType GhcPs))) :+: C1 ('MetaCons "PsErrInvalidRecordCon" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (PatBuilder GhcPs))))) :+: ((C1 ('MetaCons "PsErrIllegalUnboxedStringInPat" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (HsLit GhcPs))) :+: C1 ('MetaCons "PsErrIllegalUnboxedFloatingLitInPat" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (HsLit GhcPs)))) :+: (C1 ('MetaCons "PsErrDoNotationInPat" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "PsErrIfThenElseInPat" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "PsErrLambdaCaseInPat" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 LamCaseVariant)) :+: C1 ('MetaCons "PsErrCaseInPat" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "PsErrLetInPat" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "PsErrLambdaInPat" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "PsErrArrowExprInPat" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (HsExpr GhcPs))) :+: C1 ('MetaCons "PsErrArrowCmdInPat" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (HsCmd GhcPs)))) :+: (C1 ('MetaCons "PsErrArrowCmdInExpr" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (HsCmd GhcPs))) :+: C1 ('MetaCons "PsErrViewPatInExpr" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (LHsExpr GhcPs)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (LHsExpr GhcPs))))))))) :+: (((((C1 ('MetaCons "PsErrTypeAppWithoutSpace" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 RdrName) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (LHsExpr GhcPs))) :+: (C1 ('MetaCons "PsErrLazyPatWithoutSpace" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (LHsExpr GhcPs))) :+: C1 ('MetaCons "PsErrBangPatWithoutSpace" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (LHsExpr GhcPs))))) :+: ((C1 ('MetaCons "PsErrUnallowedPragma" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (HsPragE GhcPs))) :+: C1 ('MetaCons "PsErrQualifiedDoInCmd" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 ModuleName))) :+: (C1 ('MetaCons "PsErrInvalidInfixHole" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "PsErrSemiColonsInCondExpr" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (HsExpr GhcPs)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Bool)) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (HsExpr GhcPs)) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Bool) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (HsExpr GhcPs)))))))) :+: ((C1 ('MetaCons "PsErrSemiColonsInCondCmd" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (HsExpr GhcPs)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Bool)) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (HsCmd GhcPs)) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Bool) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (HsCmd GhcPs))))) :+: (C1 ('MetaCons "PsErrAtInPatPos" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "PsErrLambdaCmdInFunAppCmd" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (LHsCmd GhcPs))))) :+: ((C1 ('MetaCons "PsErrCaseCmdInFunAppCmd" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (LHsCmd GhcPs))) :+: C1 ('MetaCons "PsErrLambdaCaseCmdInFunAppCmd" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 LamCaseVariant) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (LHsCmd GhcPs)))) :+: (C1 ('MetaCons "PsErrIfCmdInFunAppCmd" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (LHsCmd GhcPs))) :+: C1 ('MetaCons "PsErrLetCmdInFunAppCmd" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (LHsCmd GhcPs))))))) :+: (((C1 ('MetaCons "PsErrDoCmdInFunAppCmd" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (LHsCmd GhcPs))) :+: (C1 ('MetaCons "PsErrDoInFunAppExpr" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Maybe ModuleName)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (LHsExpr GhcPs))) :+: C1 ('MetaCons "PsErrMDoInFunAppExpr" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (Maybe ModuleName)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (LHsExpr GhcPs))))) :+: ((C1 ('MetaCons "PsErrLambdaInFunAppExpr" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (LHsExpr GhcPs))) :+: C1 ('MetaCons "PsErrCaseInFunAppExpr" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (LHsExpr GhcPs)))) :+: (C1 ('MetaCons "PsErrLambdaCaseInFunAppExpr" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 LamCaseVariant) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (LHsExpr GhcPs))) :+: C1 ('MetaCons "PsErrLetInFunAppExpr" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (LHsExpr GhcPs)))))) :+: (((C1 ('MetaCons "PsErrIfInFunAppExpr" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (LHsExpr GhcPs))) :+: C1 ('MetaCons "PsErrProcInFunAppExpr" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (LHsExpr GhcPs)))) :+: (C1 ('MetaCons "PsErrMalformedTyOrClDecl" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (LHsType GhcPs))) :+: C1 ('MetaCons "PsErrIllegalWhereInDataDecl" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "PsErrIllegalDataTypeContext" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (LHsContext GhcPs))) :+: C1 ('MetaCons "PsErrParseErrorOnInput" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 OccName))) :+: (C1 ('MetaCons "PsErrMalformedDecl" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 SDoc) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 RdrName)) :+: C1 ('MetaCons "PsErrUnexpectedTypeAppInDecl" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (LHsType GhcPs)) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 SDoc) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 RdrName)))))))) :+: ((((C1 ('MetaCons "PsErrNotADataCon" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 RdrName)) :+: (C1 ('MetaCons "PsErrRecordSyntaxInPatSynDecl" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (LPat GhcPs))) :+: C1 ('MetaCons "PsErrEmptyWhereInPatSynDecl" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 RdrName)))) :+: ((C1 ('MetaCons "PsErrInvalidWhereBindInPatSynDecl" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 RdrName) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (HsDecl GhcPs))) :+: C1 ('MetaCons "PsErrNoSingleWhereBindInPatSynDecl" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 RdrName) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (HsDecl GhcPs)))) :+: (C1 ('MetaCons "PsErrDeclSpliceNotAtTopLevel" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (SpliceDecl GhcPs))) :+: C1 ('MetaCons "PsErrInferredTypeVarNotAllowed" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "PsErrMultipleNamesInStandaloneKindSignature" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [LIdP GhcPs])) :+: C1 ('MetaCons "PsErrIllegalImportBundleForm" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "PsErrIllegalRoleName" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 FastString) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Role])) :+: C1 ('MetaCons "PsErrInvalidTypeSignature" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (LHsExpr GhcPs))))) :+: ((C1 ('MetaCons "PsErrUnexpectedTypeInDecl" 'PrefixI 'False) ((S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (LHsType GhcPs)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 SDoc)) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 RdrName) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [LHsTypeArg GhcPs]) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 SDoc)))) :+: C1 ('MetaCons "PsErrExpectedHyphen" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "PsErrSpaceInSCC" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "PsErrEmptyDoubleQuotes" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Bool)))))) :+: (((C1 ('MetaCons "PsErrInvalidPackageName" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 FastString)) :+: (C1 ('MetaCons "PsErrInvalidRuleActivationMarker" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "PsErrLinearFunction" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "PsErrMultiWayIf" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "PsErrExplicitForall" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Bool))) :+: (C1 ('MetaCons "PsErrIllegalQualifiedDo" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 SDoc)) :+: C1 ('MetaCons "PsErrCmmParser" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 CmmParserError))))) :+: (((C1 ('MetaCons "PsErrIllegalTraditionalRecordSyntax" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 SDoc)) :+: C1 ('MetaCons "PsErrParseErrorInCmd" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 SDoc))) :+: (C1 ('MetaCons "PsErrInPat" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (PatBuilder GhcPs)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 PsErrInPatDetails)) :+: C1 ('MetaCons "PsErrParseRightOpSectionInPat" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 RdrName) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (PatBuilder GhcPs))))) :+: ((C1 ('MetaCons "PsErrIllegalGadtRecordMultiplicity" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 (HsArrow GhcPs))) :+: C1 ('MetaCons "PsErrInvalidCApiImport" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "PsErrMultipleConForNewtype" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 RdrName) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedUnpack) (Rec0 Int)) :+: C1 ('MetaCons "PsErrUnicodeCharLooksLike" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Char) :: (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Char) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String))))))))))
type DiagnosticOpts PsMessage
Instance details Defined in GHC.Parser.Errors.Ppr type DiagnosticOpts PsMessage = NoDiagnosticOpts

data PsHeaderMessage #

Constructors

PsErrParseLanguagePragma
PsErrUnsupportedExt !String ![String]
PsErrParseOptionsPragma !String
PsErrUnknownOptionsPragma !String	PsErrUnsupportedOptionsPragma is an error that occurs when an unknown OPTIONS_GHC pragma is supplied is found. Example(s): {-# OPTIONS_GHC foo #-} Test case(s): testssafeHaskellflags/SafeFlags28 testssafeHaskellflags/SafeFlags19 testssafeHaskellflags/SafeFlags29 testsparsershould_fail/T19923c testsparsershould_fail/T19923b testsparsershould_fail/readFail044 testsdriverT2499

Instances

Instances details

Generic PsHeaderMessage
Instance details Defined in GHC.Parser.Errors.Types Associated Types type Rep PsHeaderMessage :: Type -> Type # Methods from :: PsHeaderMessage -> Rep PsHeaderMessage x # to :: Rep PsHeaderMessage x -> PsHeaderMessage #
type Rep PsHeaderMessage
Instance details Defined in GHC.Parser.Errors.Types type Rep PsHeaderMessage = D1 ('MetaData "PsHeaderMessage" "GHC.Parser.Errors.Types" "ghc" 'False) ((C1 ('MetaCons "PsErrParseLanguagePragma" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "PsErrUnsupportedExt" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 String) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 [String]))) :+: (C1 ('MetaCons "PsErrParseOptionsPragma" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 String)) :+: C1 ('MetaCons "PsErrUnknownOptionsPragma" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 String))))

type PsError = PsMessage #

type PsWarning = PsMessage #

data HscEnv #

HscEnv is like Session, except that some of the fields are immutable. An HscEnv is used to compile a single module from plain Haskell source code (after preprocessing) to either C, assembly or C--. 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.

Constructors

HscEnv

Fields

hsc_dflags :: DynFlags
The dynamic flag settings
hsc_targets :: [Target]
The targets (or roots) of the current session
hsc_mod_graph :: ModuleGraph
The module graph of the current session
hsc_IC :: InteractiveContext
The context for evaluating interactive statements
hsc_NC :: !NameCache
Global Name cache so that each Name gets a single Unique. Also track the origin of the Names.
hsc_FC :: !FinderCache
The cached result of performing finding in the file system
hsc_type_env_vars :: 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]
hsc_interp :: Maybe Interp
target code interpreter (if any) to use for TH and GHCi. See Note [Target code interpreter]
hsc_plugins :: !Plugins
Plugins
hsc_unit_env :: UnitEnv
Unit environment (unit state, home unit, etc.).
Initialized from the databases cached in hsc_unit_dbs and from the DynFlags.
hsc_logger :: !Logger
Logger with its flags.
Don't forget to update the logger flags if the logging related DynFlags change. Or better, use hscSetFlags setter which does it.
hsc_hooks :: !Hooks
Hooks
hsc_tmpfs :: !TmpFs
Temporary files
hsc_llvm_config :: !LlvmConfigCache
LLVM configuration cache.

Instances

Instances details

ContainsDynFlags HscEnv
Instance details Defined in GHC.Driver.Env.Types Methods extractDynFlags :: HscEnv -> DynFlags #

data CoreM a #

The monad used by Core-to-Core passes to register simplification statistics. Also used to have common state (in the form of UniqueSupply) for generating Uniques.

Instances

Instances details

MonadIO CoreM
Instance details Defined in GHC.Core.Opt.Monad Methods liftIO :: IO a -> CoreM a #
Alternative CoreM
Instance details Defined in GHC.Core.Opt.Monad Methods empty :: CoreM a # (<\|>) :: CoreM a -> CoreM a -> CoreM a # some :: CoreM a -> CoreM [a] # many :: CoreM a -> CoreM [a] #
Applicative CoreM
Instance details Defined in GHC.Core.Opt.Monad Methods pure :: a -> CoreM a # (<>) :: CoreM (a -> b) -> CoreM a -> CoreM b # liftA2 :: (a -> b -> c) -> CoreM a -> CoreM b -> CoreM c # (>) :: CoreM a -> CoreM b -> CoreM b # (<*) :: CoreM a -> CoreM b -> CoreM a #
Functor CoreM
Instance details Defined in GHC.Core.Opt.Monad Methods fmap :: (a -> b) -> CoreM a -> CoreM b # (<$) :: a -> CoreM b -> CoreM a #
Monad CoreM
Instance details Defined in GHC.Core.Opt.Monad Methods (>>=) :: CoreM a -> (a -> CoreM b) -> CoreM b # (>>) :: CoreM a -> CoreM b -> CoreM b # return :: a -> CoreM a #
MonadPlus CoreM
Instance details Defined in GHC.Core.Opt.Monad Methods mzero :: CoreM a # mplus :: CoreM a -> CoreM a -> CoreM a #
HasDynFlags CoreM
Instance details Defined in GHC.Core.Opt.Monad Methods getDynFlags :: CoreM DynFlags #
MonadUnique CoreM
Instance details Defined in GHC.Core.Opt.Monad Methods getUniqueSupplyM :: CoreM UniqSupply # getUniqueM :: CoreM Unique # getUniquesM :: CoreM [Unique] #
HasModule CoreM
Instance details Defined in GHC.Core.Opt.Monad Methods getModule :: CoreM Module #
HasLogger CoreM
Instance details Defined in GHC.Core.Opt.Monad Methods getLogger :: CoreM Logger #

type MetaHook (f :: Type -> Type) = MetaRequest -> LHsExpr GhcTc -> f MetaResult #

data MetaResult #

data constructors not exported to ensure correct result type

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)

data CoreToDo #

Instances

Instances details

Outputable CoreToDo
Instance details Defined in GHC.Core.Opt.Pipeline.Types Methods ppr :: CoreToDo -> SDoc #

type CorePluginPass = ModGuts -> CoreM ModGuts #

A description of the plugin pass itself

type DefaultingPlugin = [CommandLineOption] -> Maybe DefaultingPlugin #

type TcPlugin = [CommandLineOption] -> Maybe TcPlugin #

data HoleFitPluginR #

HoleFitPluginR adds a TcRef to hole fit plugins so that plugins can track internal state. Note the existential quantification, ensuring that the state cannot be modified from outside the plugin.

Constructors

HoleFitPluginR
Fields hfPluginInit :: TcM (TcRef s) Initializes the TcRef to be passed to the plugin hfPluginRun :: TcRef s -> HoleFitPlugin The function defining the plugin itself hfPluginStop :: TcRef s -> TcM () Cleanup of state, guaranteed to be called even on error

type FitPlugin = TypedHole -> [HoleFit] -> TcM [HoleFit] #

A plugin for modifying hole fits *after* they've been found.

type CandPlugin = TypedHole -> [HoleFitCandidate] -> TcM [HoleFitCandidate] #

A plugin for modifying the candidate hole fits *before* they're checked.

data TypedHole #

Constructors

TypedHole
Fields th_relevant_cts :: Bag CtEvidence Any relevant Cts to the hole th_implics :: [Implication] The nested implications of the hole with the innermost implication first. th_hole :: Maybe Hole The hole itself, if available.

Instances

Instances details

Outputable TypedHole
Instance details Defined in GHC.Tc.Errors.Hole.FitTypes Methods ppr :: TypedHole -> SDoc #

type FrontendPluginAction = [String] -> [(String, Maybe Phase)] -> Ghc () #

type CorePlugin = [CommandLineOption] -> [CoreToDo] -> CoreM [CoreToDo] #

data PluginRecompile #

Constructors

ForceRecompile
NoForceRecompile
MaybeRecompile Fingerprint

Instances

Instances details

Monoid PluginRecompile
Instance details Defined in GHC.Driver.Plugins Methods mempty :: PluginRecompile # mappend :: PluginRecompile -> PluginRecompile -> PluginRecompile # mconcat :: [PluginRecompile] -> PluginRecompile #
Semigroup PluginRecompile
Instance details Defined in GHC.Driver.Plugins Methods (<>) :: PluginRecompile -> PluginRecompile -> PluginRecompile # sconcat :: NonEmpty PluginRecompile -> PluginRecompile # stimes :: Integral b => b -> PluginRecompile -> PluginRecompile #
Outputable PluginRecompile
Instance details Defined in GHC.Driver.Plugins Methods ppr :: PluginRecompile -> SDoc #

data ExternalPlugin #

External plugin loaded directly from a library without loading module interfaces

Constructors

ExternalPlugin
Fields epPlugin :: PluginWithArgs Plugin with its arguments epUnit :: String UnitId epModule :: String Module name

data PluginWithArgs #

Constructors

PluginWithArgs
Fields paPlugin :: Plugin the actual callable plugin paArguments :: [CommandLineOption] command line arguments for the plugin

data ParsedResult #

Result of running the parser and the parser plugin

Constructors

ParsedResult
Fields parsedResultModule :: HsParsedModule Parsed module, potentially modified by a plugin parsedResultMessages :: PsMessages Warnings and errors from parser, potentially modified by a plugin

data PsMessages #

Errors and warnings produced by the parser

Constructors

PsMessages
Fields psWarnings :: Messages PsWarning psErrors :: Messages PsError

type CommandLineOption = String #

Command line options gathered from the -PModule.Name:stuff syntax are given to you as this type

data TcRnExprMode #

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

Constructors

TM_Inst	Instantiate inferred quantifiers only (:type)
TM_Default	Instantiate all quantifiers, and do eager defaulting (:type +d)

data CgInteractiveGuts #

type Messager = HscEnv -> (Int, Int) -> RecompileRequired -> ModuleGraphNode -> IO () #

data Serialized #

Represents a serialized value of a particular type. Attempts can be made to deserialize it at certain types

Constructors

Serialized TypeRep [Word8]

Instances

Instances details

Outputable Serialized
Instance details Defined in GHC.Utils.Outputable Methods ppr :: Serialized -> SDoc #

pattern ManyTy :: Mult #

pattern OneTy :: Mult #

try :: Exception e => IO a -> IO (Either e a) #

Similar to catch, but returns an Either result which is (Right a) if no exception of type e was raised, or (Left ex) if an exception of type 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)

count :: (a -> Bool) -> [a] -> Int #

rational :: Rational -> SDoc #

double :: IsLine doc => Double -> doc #

space :: IsLine doc => doc #

lengthAtLeast :: [a] -> Int -> Bool #

(lengthAtLeast xs n) = (length xs >= n)

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.

liftIO :: MonadIO m => IO a -> m a #

Lift a computation from the IO monad. This allows us to run IO computations in any monadic stack, so long as it supports these kinds of operations (i.e. IO is the base monad for the stack).

Example

Expand

import Control.Monad.Trans.State -- from the "transformers" library

printState :: Show s => StateT s IO ()
printState = do
  state <- get
  liftIO $ print state

Had we omitted liftIO, we would have ended up with this error:

• Couldn't match type ‘IO’ with ‘StateT s IO’
 Expected type: StateT s IO ()
   Actual type: IO ()

The important part here is the mismatch between StateT s IO () and IO ().

Luckily, we know of a function that takes an IO a and returns an (m a): liftIO, enabling us to run the program and see the expected results:

> evalStateT printState "hello"
"hello"

> evalStateT printState 3
3

srcLocFile :: RealSrcLoc -> FastString #

Gives the filename of the RealSrcLoc

foldl1' :: HasCallStack => (a -> a -> a) -> [a] -> a #

A strict version of foldl1.

appPrec :: PprPrec #

infinity :: IntWithInf #

A representation of infinity

applyWhen :: Bool -> (a -> a) -> a -> a #

Apply a function iff some condition is met.

parens :: IsLine doc => doc -> doc #

fingerprintString :: String -> Fingerprint #

fingerprintFingerprints :: [Fingerprint] -> Fingerprint #

funResultTy :: HasDebugCallStack => Type -> Type #

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

mkFunTy :: HasDebugCallStack => FunTyFlag -> Mult -> Type -> Type -> Type infixr 3 #

splitTyConApp :: Type -> (TyCon, [Type]) #

Attempts to tease a type apart into a type constructor and the application of a number of arguments to that constructor. Panics if that is not possible. See also splitTyConApp_maybe

singleton :: a -> [a] #

fingerprint0 :: Fingerprint #

fingerprintData :: Ptr Word8 -> Int -> IO Fingerprint #

getFileHash :: FilePath -> IO Fingerprint #

Computes the hash of a given file. This function loops over the handle, running in constant memory.

Since: base-4.7.0.0

sortWith :: Ord b => (a -> b) -> [a] -> [a] #

The sortWith function sorts a list of elements using the user supplied function to project something out of each element

In general if the user supplied function is expensive to compute then you should probably be using sortOn, as it only needs to compute it once for each element. sortWith, on the other hand must compute the mapping function for every comparison that it performs.

isAlgType :: Type -> Bool #

See Type for what an algebraic type is. Should only be applied to types, as opposed to e.g. partially saturated type constructors

mkNoRepType :: String -> DataType #

Constructs a non-representation for a non-representable type

spanEnd :: (a -> Bool) -> [a] -> ([a], [a]) #

spanEnd p l == reverse (span p (reverse l)). The first list returns actually comes after the second list (when you look at the input list).

readRational :: String -> Rational #

isEmpty :: SDocContext -> SDoc -> Bool #

split :: Char -> String -> [String] #

compareLength :: [a] -> [b] -> Ordering #

word :: Integer -> SDoc #

unzipWith :: (a -> b -> c) -> [(a, b)] -> [c] #

pprWithUnitState :: UnitState -> SDoc -> SDoc #

Print unit-ids with UnitInfo found in the given UnitState

mkTyConTy :: TyCon -> Type #

(mkTyConTy tc) returns (TyConApp tc []) but arranges to share that TyConApp among all calls See Note [Sharing nullary TyConApps] So it's just an alias for tyConNullaryTy!

mkCoreApps infixl 4 #

Arguments

:: CoreExpr	function
-> [CoreExpr]	arguments
-> CoreExpr

Construct an expression which represents the application of a number of expressions to another. The leftmost expression in the list is applied first

mkCoreConApps :: DataCon -> [CoreExpr] -> CoreExpr #

Construct an expression which represents the application of a number of expressions to that of a data constructor expression. The leftmost expression in the list is applied first

mkIntExpr :: Platform -> Integer -> CoreExpr #

Create a CoreExpr which will evaluate to the given Int

mkWordExpr :: Platform -> Integer -> CoreExpr #

Create a CoreExpr which will evaluate to a Word with the given value

mkCharExpr :: Char -> CoreExpr #

Create a CoreExpr which will evaluate to the given Char

mkStringExpr :: MonadThings m => String -> m CoreExpr #

Create a CoreExpr which will evaluate to the given String

mkFloatExpr :: Float -> CoreExpr #

Create a CoreExpr which will evaluate to the given Float

mkDoubleExpr :: Double -> CoreExpr #

Create a CoreExpr which will evaluate to the given Double

mkCoreLams :: [CoreBndr] -> CoreExpr -> CoreExpr #

Create a lambda where the given expression has a number of variables bound over it. The leftmost binder is that bound by the outermost lambda in the result

mkCoreLets :: [CoreBind] -> CoreExpr -> CoreExpr #

Bind a list of binding groups over an expression. The leftmost binding group becomes the outermost group in the resulting expression

mkCoreLet :: CoreBind -> CoreExpr -> CoreExpr #

Bind a binding group over an expression, using a let or case as appropriate (see GHC.Core)

typeLevity_maybe :: HasDebugCallStack => Type -> Maybe Levity #

Tries to compute the PromDataConInfo of the given type. Returns either a definite PromDataConInfo, or Nothing if we aren't sure (e.g. the type is representation-polymorphic).

Panics if the kind does not have the shape TYPE r.

expandTypeSynonyms :: Type -> Type #

Expand out all type synonyms. Actually, it'd suffice to expand out just the ones that discard type variables (e.g. type Funny a = Int) But we don't know which those are currently, so we just expand all.

expandTypeSynonyms only expands out type synonyms mentioned in the type, not in the kinds of any TyCon or TyVar mentioned in the type.

Keep this synchronized with synonymTyConsOfType

dropList :: [b] -> [a] -> [a] #

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.

nTimes :: Int -> (a -> a) -> a -> a #

Apply a function n times to a given value.

const2 :: a -> b -> c -> a #

fstOf3 :: (a, b, c) -> a #

sndOf3 :: (a, b, c) -> b #

thdOf3 :: (a, b, c) -> c #

fst3 :: (a -> d) -> (a, b, c) -> (d, b, c) #

snd3 :: (b -> d) -> (a, b, c) -> (a, d, c) #

third3 :: (c -> d) -> (a, b, c) -> (a, b, d) #

uncurry3 :: (a -> b -> c -> d) -> (a, b, c) -> d #

filterOut :: (a -> Bool) -> [a] -> [a] #

Like filter, only it reverses the sense of the test

partitionWith :: (a -> Either b c) -> [a] -> ([b], [c]) #

Uses a function to determine which of two output lists an input element should join

chkAppend :: [a] -> [a] -> [a] #

zipEqual :: HasDebugCallStack => String -> [a] -> [b] -> [(a, b)] #

zipWithEqual :: HasDebugCallStack => String -> (a -> b -> c) -> [a] -> [b] -> [c] #

zipWith3Equal :: HasDebugCallStack => String -> (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d] #

zipWith4Equal :: HasDebugCallStack => String -> (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e] #

filterByList :: [Bool] -> [a] -> [a] #

filterByList takes a list of Bools and a list of some elements and filters out these elements for which the corresponding value in the list of Bools is False. This function does not check whether the lists have equal length.

filterByLists :: [Bool] -> [a] -> [a] -> [a] #

filterByLists takes a list of Bools and two lists as input, and outputs a new list consisting of elements from the last two input lists. For each Bool in the list, if it is True, then it takes an element from the former list. If it is False, it takes an element from the latter list. The elements taken correspond to the index of the Bool in its list. For example:

filterByLists [True, False, True, False] "abcd" "wxyz" = "axcz"

This function does not check whether the lists have equal length.

partitionByList :: [Bool] -> [a] -> ([a], [a]) #

partitionByList takes a list of Bools and a list of some elements and partitions the list according to the list of Bools. Elements corresponding to True go to the left; elements corresponding to False go to the right. For example, partitionByList [True, False, True] [1,2,3] == ([1,3], [2]) This function does not check whether the lists have equal length; when one list runs out, the function stops.

stretchZipWith :: (a -> Bool) -> b -> (a -> b -> c) -> [a] -> [b] -> [c] #

stretchZipWith p z f xs ys stretches ys by inserting z in the places where p returns True

mapFst :: Functor f => (a -> c) -> f (a, b) -> f (c, b) #

mapSnd :: Functor f => (b -> c) -> f (a, b) -> f (a, c) #

mapAndUnzip :: (a -> (b, c)) -> [a] -> ([b], [c]) #

mapAndUnzip3 :: (a -> (b, c, d)) -> [a] -> ([b], [c], [d]) #

zipWithAndUnzip :: (a -> b -> (c, d)) -> [a] -> [b] -> ([c], [d]) #

zipAndUnzip :: [a] -> [b] -> ([a], [b]) #

This has the effect of making the two lists have equal length by dropping the tail of the longer one.

atLength :: ([a] -> b) -> b -> [a] -> Int -> b #

atLength atLen atEnd ls n unravels list ls to position n. Precisely:

 atLength atLenPred atEndPred ls n
  | n < 0         = atLenPred ls
  | length ls < n = atEndPred (n - length ls)
  | otherwise     = atLenPred (drop n ls)

lengthExceeds :: [a] -> Int -> Bool #

(lengthExceeds xs n) = (length xs > n)

lengthIs :: [a] -> Int -> Bool #

(lengthIs xs n) = (length xs == n)

lengthIsNot :: [a] -> Int -> Bool #

(lengthIsNot xs n) = (length xs /= n)

lengthAtMost :: [a] -> Int -> Bool #

(lengthAtMost xs n) = (length xs <= n)

lengthLessThan :: [a] -> Int -> Bool #

(lengthLessThan xs n) == (length xs < n)

listLengthCmp :: [a] -> Int -> Ordering #

equalLength :: [a] -> [b] -> Bool #

True if length xs == length ys

leLength :: [a] -> [b] -> Bool #

True if length xs <= length ys

ltLength :: [a] -> [b] -> Bool #

True if length xs < length ys

isSingleton :: [a] -> Bool #

notNull :: Foldable f => f a -> Bool #

only :: [a] -> a #

Utility function to go from a singleton list to it's element.

Wether or not the argument is a singleton list is only checked in debug builds.

expectOnly :: HasCallStack => String -> [a] -> a #

Extract the single element of a list and panic with the given message if there are more elements or the list was empty. Like expectJust, but for lists.

chunkList :: Int -> [a] -> [[a]] #

Split a list into chunks of n elements

holes :: [a] -> [(a, [a])] #

Compute all the ways of removing a single element from a list.

holes [1,2,3] = [(1, [2,3]), (2, [1,3]), (3, [1,2])]

changeLast :: [a] -> a -> [a] #

Replace the last element of a list with another element.

mapLastM :: Functor f => (a -> f a) -> NonEmpty a -> f (NonEmpty a) #

Apply an effectful function to the last list element.

whenNonEmpty :: Applicative m => [a] -> (NonEmpty a -> m ()) -> m () #

mergeListsBy :: (a -> a -> Ordering) -> [[a]] -> [a] #

Merge an unsorted list of sorted lists, for example:

mergeListsBy compare [ [2,5,15], [1,10,100] ] = [1,2,5,10,15,100]

$ O(n \log{} k) $

isSortedBy :: (a -> a -> Ordering) -> [a] -> Bool #

minWith :: Ord b => (a -> b) -> [a] -> a #

nubSort :: Ord a => [a] -> [a] #

ordNub :: Ord a => [a] -> [a] #

Remove duplicates but keep elements in order. O(n * log n)

ordNubOn :: Ord b => (a -> b) -> [a] -> [a] #

Remove duplicates but keep elements in order. O(n * log n)

transitiveClosure :: (a -> [a]) -> (a -> a -> Bool) -> [a] -> [a] #

foldl2 :: (acc -> a -> b -> acc) -> acc -> [a] -> [b] -> acc #

all2 :: (a -> b -> Bool) -> [a] -> [b] -> Bool #

countWhile :: (a -> Bool) -> [a] -> Int #

takeList :: [b] -> [a] -> [a] #

splitAtList :: [b] -> [a] -> ([a], [a]) #

Given two lists xs and ys, return `splitAt (length xs) ys`.

dropTail :: Int -> [a] -> [a] #

drop from the end of a list

dropWhileEndLE :: (a -> Bool) -> [a] -> [a] #

last2 :: [a] -> Maybe (a, a) #

Get the last two elements in a list.

lastMaybe :: [a] -> Maybe a #

onJust :: b -> Maybe a -> (a -> b) -> b #

onJust x m f applies f to the value inside the Just or returns the default.

snocView :: [a] -> Maybe ([a], a) #

Split a list into its last element and the initial part of the list. snocView xs = Just (init xs, last xs) for non-empty lists. snocView xs = Nothing otherwise. Unless both parts of the result are guaranteed to be used prefer separate calls to last + init. If you are guaranteed to use both, this will be more efficient.

capitalise :: String -> String #

Convert a word to title case by capitalising the first letter

isEqual :: Ordering -> Bool #

removeSpaces :: String -> String #

(<&&>) :: Applicative f => f Bool -> f Bool -> f Bool infixr 3 #

(<||>) :: Applicative f => f Bool -> f Bool -> f Bool infixr 2 #

fuzzyMatch :: String -> [String] -> [String] #

fuzzyLookup :: String -> [(String, a)] -> [a] #

Search for possible matches to the users input in the given list, returning a small number of ranked results

seqList :: [a] -> b -> b #

strictMap :: (a -> b) -> [a] -> [b] #

strictZipWith :: (a -> b -> c) -> [a] -> [b] -> [c] #

strictZipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d] #

looksLikeModuleName :: String -> Bool #

looksLikePackageName :: String -> Bool #

exactLog2 :: Integer -> Maybe Integer #

Determine the $log_2$ of exact powers of 2

readSignificandExponentPair :: String -> (Integer, Integer) #

Parse a string into a significand and exponent. A trivial example might be: ghci> readSignificandExponentPair "1E2" (1,2) In a more complex case we might return a exponent different than that which the user wrote. This is needed in order to use a Integer significand. ghci> readSignificandExponentPair "-1.11E5" (-111,3)

readHexRational :: String -> Rational #

readHexSignificandExponentPair :: String -> (Integer, Integer) #

Parse a string into a significand and exponent according to the "Hexadecimal Floats in Haskell" proposal. A trivial example might be: ghci> readHexSignificandExponentPair "0x1p+1" (1,1) Behaves similar to readSignificandExponentPair but the base is 16 and numbers are given in hexadecimal: ghci> readHexSignificandExponentPair "0xAp-4" (10,-4) ghci> readHexSignificandExponentPair "0x1.2p3" (18,-1)

doesDirNameExist :: FilePath -> IO Bool #

getModificationUTCTime :: FilePath -> IO UTCTime #

modificationTimeIfExists :: FilePath -> IO (Maybe UTCTime) #

fileHashIfExists :: FilePath -> IO (Maybe Fingerprint) #

withAtomicRename :: MonadIO m => FilePath -> (FilePath -> m a) -> m a #

splitLongestPrefix :: String -> (Char -> Bool) -> (String, String) #

escapeSpaces :: String -> String #

reslash :: Direction -> FilePath -> FilePath #

makeRelativeTo :: FilePath -> FilePath -> FilePath #

abstractConstr :: String -> Constr #

abstractDataType :: String -> DataType #

charToC :: Word8 -> String #

hashString :: String -> Int32 #

A sample hash function for Strings. We keep multiplying by the golden ratio and adding. The implementation is:

hashString = foldl' f golden
  where f m c = fromIntegral (ord c) * magic + hashInt32 m
        magic = 0xdeadbeef

Where hashInt32 works just as hashInt shown above.

Knuth argues that repeated multiplication by the golden ratio will minimize gaps in the hash space, and thus it's a good choice for combining together multiple keys to form one.

Here we know that individual characters c are often small, and this produces frequent collisions if we use ord c alone. A particular problem are the shorter low ASCII and ISO-8859-1 character strings. We pre-multiply by a magic twiddle factor to obtain a good distribution. In fact, given the following test:

testp :: Int32 -> Int
testp k = (n - ) . length . group . sort . map hs . take n $ ls
  where ls = [] : [c : l | l <- ls, c <- ['\0'..'\xff']]
        hs = foldl' f golden
        f m c = fromIntegral (ord c) * k + hashInt32 m
        n = 100000

We discover that testp magic = 0.

mapMaybe' :: Foldable f => (a -> Maybe b) -> f a -> [b] #

bytesFS :: FastString -> ByteString #

Gives the Modified UTF-8 encoded bytes corresponding to a FastString

fastStringToByteString :: FastString -> ByteString #

Gives the Modified UTF-8 encoded bytes corresponding to a FastString

fastStringToShortByteString :: FastString -> ShortByteString #

fastZStringToByteString :: FastZString -> ByteString #

unsafeMkByteString :: String -> ByteString #

hPutFZS :: Handle -> FastZString -> IO () #

zString :: FastZString -> String #

zStringTakeN :: Int -> FastZString -> String #

zStringTakeN n = take n . zString but is performed in $O(\min(n,l))$ rather than $O(l)$, where $l$ is the length of the FastZString.

lengthFZS :: FastZString -> Int #

lexicalCompareFS :: FastString -> FastString -> Ordering #

Compare FastString lexically

If you don't care about the lexical ordering, use uniqCompareFS instead.

uniqCompareFS :: FastString -> FastString -> Ordering #

Compare FastString by their Unique (not lexically).

Much cheaper than lexicalCompareFS but non-deterministic!

mkFastString# :: Addr# -> FastString #

mkFastStringBytes :: Ptr Word8 -> Int -> FastString #

mkFastStringByteString :: ByteString -> FastString #

Create a FastString by copying an existing ByteString

mkFastStringShortByteString :: ShortByteString -> FastString #

Create a FastString from an existing ShortByteString without copying.

mkFastString :: String -> FastString #

Creates a UTF-8 encoded FastString from a String

mkFastStringByteList :: [Word8] -> FastString #

Creates a FastString from a UTF-8 encoded [Word8]

lengthFS :: FastString -> Int #

Returns the length of the FastString in characters

nullFS :: FastString -> Bool #

Returns True if the FastString is empty

unpackFS :: FastString -> String #

Lazily unpacks and decodes the FastString

zEncodeFS :: FastString -> FastZString #

Returns a Z-encoded version of a FastString. This might be the original, if it was already Z-encoded. The first time this function is applied to a particular FastString, the results are memoized.

appendFS :: FastString -> FastString -> FastString #

concatFS :: [FastString] -> FastString #

consFS :: Char -> FastString -> FastString #

unconsFS :: FastString -> Maybe (Char, FastString) #

uniqueOfFS :: FastString -> Int #

nilFS :: FastString #

getFastStringTable :: IO [[[FastString]]] #

getFastStringZEncCounter :: IO Int #

hPutFS :: Handle -> FastString -> IO () #

Outputs a FastString with no decoding at all, that is, you get the actual bytes in the FastString written to the Handle.

mkPtrString# :: Addr# -> PtrString #

Wrap an unboxed address into a PtrString.

unpackPtrString :: PtrString -> String #

Decode a PtrString back into a String using Latin-1 encoding. This does not free the memory associated with PtrString.

unpackPtrStringTakeN :: Int -> PtrString -> String #

unpackPtrStringTakeN n = take n . unpackPtrString but is performed in $O(\min(n,l))$ rather than $O(l)$, where $l$ is the length of the PtrString.

lengthPS :: PtrString -> Int #

Return the length of a PtrString

fsLit :: String -> FastString #

ptext :: PtrString -> SDoc #

semi :: IsLine doc => doc #

comma :: IsLine doc => doc #

colon :: IsLine doc => doc #

equals :: IsLine doc => doc #

lparen :: IsLine doc => doc #

rparen :: IsLine doc => doc #

lbrack :: IsLine doc => doc #

rbrack :: IsLine doc => doc #

lbrace :: IsLine doc => doc #

rbrace :: IsLine doc => doc #

int :: IsLine doc => Int -> doc #

integer :: IsLine doc => Integer -> doc #

float :: IsLine doc => Float -> doc #

quotes :: SDoc -> SDoc #

quote :: SDoc -> SDoc #

doubleQuotes :: IsLine doc => doc -> doc #

brackets :: IsLine doc => doc -> doc #

braces :: IsLine doc => doc -> doc #

nest :: Int -> SDoc -> SDoc #

Indent SDoc some specified amount

hang #

Arguments

:: SDoc	The header
-> Int	Amount to indent the hung body
-> SDoc	The hung body, indented and placed below the header
-> SDoc

hangNotEmpty :: SDoc -> Int -> SDoc -> SDoc #

This behaves like hang, but does not indent the second document when the header is empty.

punctuate #

Arguments

:: IsLine doc
=> doc	The punctuation
-> [doc]	The list that will have punctuation added between every adjacent pair of elements
-> [doc]	Punctuated list

($+$) :: SDoc -> SDoc -> SDoc #

Join two SDoc together vertically

cat :: [SDoc] -> SDoc #

A paragraph-fill combinator. It's much like sep, only it keeps fitting things on one line until it can't fit any more.

fcat :: [SDoc] -> SDoc #

This behaves like fsep, but it uses <> for horizontal composition rather than <+>

isBoxed :: Boxity -> Bool #

noExtField :: NoExtField #

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.

parseModuleName :: ReadP ModuleName #

mkVarOccFS :: FastString -> OccName #

mkRecFldSelOcc :: FastString -> OccName #

isListEmptyOrSingleton :: [a] -> IsEmptyOrSingleton #

reallyAlwaysQualifyNames :: QueryQualifyName #

alwaysQualifyNames :: QueryQualifyName #

NB: This won't ever show package IDs

neverQualifyNames :: QueryQualifyName #

alwaysQualifyModules :: QueryQualifyModule #

neverQualifyModules :: QueryQualifyModule #

alwaysQualifyPackages :: QueryQualifyPackage #

neverQualifyPackages :: QueryQualifyPackage #

alwaysPrintPromTick :: QueryPromotionTick #

reallyAlwaysQualify :: NamePprCtx #

alwaysQualify :: NamePprCtx #

neverQualify :: NamePprCtx #

defaultUserStyle :: PprStyle #

defaultDumpStyle :: PprStyle #

mkDumpStyle :: NamePprCtx -> PprStyle #

defaultErrStyle :: PprStyle #

Default style for error messages, when we don't know NamePprCtx It's a bit of a hack because it doesn't take into account what's in scope Only used for desugarer warnings, and typechecker errors in interface sigs

mkErrStyle :: NamePprCtx -> PprStyle #

Style for printing error messages

cmdlineParserStyle :: PprStyle #

mkUserStyle :: NamePprCtx -> Depth -> PprStyle #

withUserStyle :: NamePprCtx -> Depth -> SDoc -> SDoc #

withErrStyle :: NamePprCtx -> SDoc -> SDoc #

setStyleColoured :: Bool -> PprStyle -> PprStyle #

runSDoc :: SDoc -> SDocContext -> Doc #

defaultSDocContext :: SDocContext #

Default pretty-printing options

traceSDocContext :: SDocContext #

withPprStyle :: PprStyle -> SDoc -> SDoc #

pprDeeper :: SDoc -> SDoc #

pprDeeperList :: ([SDoc] -> SDoc) -> [SDoc] -> SDoc #

Truncate a list that is longer than the current depth.

pprSetDepth :: Depth -> SDoc -> SDoc #

getPprStyle :: (PprStyle -> SDoc) -> SDoc #

sdocWithContext :: (SDocContext -> SDoc) -> SDoc #

sdocOption :: (SDocContext -> a) -> (a -> SDoc) -> SDoc #

updSDocContext :: (SDocContext -> SDocContext) -> SDoc -> SDoc #

qualName :: PprStyle -> QueryQualifyName #

qualModule :: PprStyle -> QueryQualifyModule #

qualPackage :: PprStyle -> QueryQualifyPackage #

promTick :: PprStyle -> QueryPromotionTick #

queryQual :: PprStyle -> NamePprCtx #

codeStyle :: PprStyle -> Bool #

dumpStyle :: PprStyle -> Bool #

userStyle :: PprStyle -> Bool #

getPprDebug :: IsOutput doc => (Bool -> doc) -> doc #

Indicate if -dppr-debug mode is enabled

ifPprDebug :: IsOutput doc => doc -> doc -> doc #

Says what to do with and without -dppr-debug

whenPprDebug :: IsOutput doc => doc -> doc #

Says what to do with -dppr-debug; without, return empty

printSDoc :: SDocContext -> Mode -> Handle -> SDoc -> IO () #

The analog of printDoc_ for SDoc, which tries to make sure the terminal doesn't get screwed up by the ANSI color codes if an exception is thrown during pretty-printing.

printSDocLn :: SDocContext -> Mode -> Handle -> SDoc -> IO () #

Like printSDoc but appends an extra newline.

bufLeftRenderSDoc :: SDocContext -> BufHandle -> SDoc -> IO () #

An efficient variant of printSDoc specialized for LeftMode that outputs to a BufHandle.

pprCode :: SDoc -> SDoc #

renderWithContext :: SDocContext -> SDoc -> String #

showSDocOneLine :: SDocContext -> SDoc -> String #

showSDocUnsafe :: SDoc -> String #

showPprUnsafe :: Outputable a => a -> String #

pprDebugAndThen :: SDocContext -> (String -> a) -> SDoc -> SDoc -> a #

docToSDoc :: Doc -> SDoc #

doublePrec :: Int -> Double -> SDoc #

doublePrec p n shows a floating point number n with p digits of precision after the decimal point.

angleBrackets :: IsLine doc => doc -> doc #

cparen :: Bool -> SDoc -> SDoc #

blankLine :: SDoc #

dcolon :: SDoc #

arrow :: SDoc #

lollipop :: SDoc #

larrow :: SDoc #

darrow :: SDoc #

arrowt :: SDoc #

larrowt :: SDoc #

arrowtt :: SDoc #

larrowtt :: SDoc #

lambda :: SDoc #

underscore :: IsLine doc => doc #

dot :: IsLine doc => doc #

vbar :: IsLine doc => doc #

forAllLit :: SDoc #

bullet :: SDoc #

unicodeSyntax :: SDoc -> SDoc -> SDoc #

ppWhen :: IsOutput doc => Bool -> doc -> doc #

ppUnless :: IsOutput doc => Bool -> doc -> doc #

ppWhenOption :: (SDocContext -> Bool) -> SDoc -> SDoc #

ppUnlessOption :: IsLine doc => (SDocContext -> Bool) -> doc -> doc #

coloured :: PprColour -> SDoc -> SDoc #

Apply the given colour/style for the argument.

Only takes effect if colours are enabled.

keyword :: SDoc -> SDoc #

pprModuleName :: IsLine doc => ModuleName -> doc #

pprHsChar :: Char -> SDoc #

Special combinator for showing character literals.

pprHsString :: FastString -> SDoc #

Special combinator for showing string literals.

pprHsBytes :: ByteString -> SDoc #

Special combinator for showing bytestring literals.

primCharSuffix :: SDoc #

primFloatSuffix :: SDoc #

primIntSuffix :: SDoc #

primDoubleSuffix :: SDoc #

primWordSuffix :: SDoc #

primInt8Suffix :: SDoc #

primWord8Suffix :: SDoc #

primInt16Suffix :: SDoc #

primWord16Suffix :: SDoc #

primInt32Suffix :: SDoc #

primWord32Suffix :: SDoc #

primInt64Suffix :: SDoc #

primWord64Suffix :: SDoc #

pprPrimChar :: Char -> SDoc #

Special combinator for showing unboxed literals.

pprPrimInt :: Integer -> SDoc #

pprPrimWord :: Integer -> SDoc #

pprPrimInt8 :: Integer -> SDoc #

pprPrimInt16 :: Integer -> SDoc #

pprPrimInt32 :: Integer -> SDoc #

pprPrimInt64 :: Integer -> SDoc #

pprPrimWord8 :: Integer -> SDoc #

pprPrimWord16 :: Integer -> SDoc #

pprPrimWord32 :: Integer -> SDoc #

pprPrimWord64 :: Integer -> SDoc #

pprPrefixVar :: Bool -> SDoc -> SDoc #

pprInfixVar :: Bool -> SDoc -> SDoc #

pprFastFilePath :: FastString -> SDoc #

pprFilePathString :: IsLine doc => FilePath -> doc #

Normalise, escape and render a string representing a path

e.g. "c:\whatever"

pprWithCommas #

Arguments

:: (a -> SDoc)	The pretty printing function to use
-> [a]	The things to be pretty printed
-> SDoc	`SDoc` where the things have been pretty printed, comma-separated and finally packed into a paragraph.

pprWithBars #

Arguments

:: (a -> SDoc)	The pretty printing function to use
-> [a]	The things to be pretty printed
-> SDoc	`SDoc` where the things have been pretty printed, bar-separated and finally packed into a paragraph.

spaceIfSingleQuote :: SDoc -> SDoc #

interppSP :: Outputable a => [a] -> SDoc #

Returns the separated concatenation of the pretty printed things.

interpp'SP :: Outputable a => [a] -> SDoc #

Returns the comma-separated concatenation of the pretty printed things.

interpp'SP' :: (a -> SDoc) -> [a] -> SDoc #

pprQuotedList :: Outputable a => [a] -> SDoc #

Returns the comma-separated concatenation of the quoted pretty printed things.

[x,y,z]  ==>  `x', `y', `z'

quotedListWithOr :: [SDoc] -> SDoc #

quotedListWithNor :: [SDoc] -> SDoc #

intWithCommas :: Integral a => a -> SDoc #

speakNth :: Int -> SDoc #

Converts an integer to a verbal index:

speakNth 1 = text "first"
speakNth 5 = text "fifth"
speakNth 21 = text "21st"

speakN :: Int -> SDoc #

Converts an integer to a verbal multiplicity:

speakN 0 = text "none"
speakN 5 = text "five"
speakN 10 = text "10"

speakNOf :: Int -> SDoc -> SDoc #

Converts an integer and object description to a statement about the multiplicity of those objects:

speakNOf 0 (text "melon") = text "no melons"
speakNOf 1 (text "melon") = text "one melon"
speakNOf 3 (text "melon") = text "three melons"

plural :: [a] -> SDoc #

Determines the pluralisation suffix appropriate for the length of a list:

plural [] = char 's'
plural ["Hello"] = empty
plural ["Hello", "World"] = char 's'

singular :: [a] -> SDoc #

Determines the singular verb suffix appropriate for the length of a list:

singular [] = empty
singular["Hello"] = char 's'
singular ["Hello", "World"] = empty

isOrAre :: [a] -> SDoc #

Determines the form of to be appropriate for the length of a list:

isOrAre [] = text "are"
isOrAre ["Hello"] = text "is"
isOrAre ["Hello", "World"] = text "are"

doOrDoes :: [a] -> SDoc #

Determines the form of to do appropriate for the length of a list:

doOrDoes [] = text "do"
doOrDoes ["Hello"] = text "does"
doOrDoes ["Hello", "World"] = text "do"

itsOrTheir :: [a] -> SDoc #

Determines the form of possessive appropriate for the length of a list:

itsOrTheir [x]   = text "its"
itsOrTheir [x,y] = text "their"
itsOrTheir []    = text "their"  -- probably avoid this

thisOrThese :: [a] -> SDoc #

Determines the form of subject appropriate for the length of a list:

thisOrThese [x]   = text "This"
thisOrThese [x,y] = text "These"
thisOrThese []    = text "These"  -- probably avoid this

hasOrHave :: [a] -> SDoc #

"has" or "have" depending on the length of a list.

bPutHDoc :: BufHandle -> SDocContext -> HDoc -> IO () #

showException :: Exception e => e -> String #

Show an exception as a string.

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

panicDoc :: String -> SDoc -> a #

Throw an exception saying "bug in GHC"

sorryDoc :: String -> SDoc -> a #

Throw an exception saying "this isn't finished yet"

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

pprIdDetails :: IdDetails -> SDoc #

isCoVarDetails :: IdDetails -> Bool #

Check if an IdDetails says CoVarId.

coVarDetails :: IdDetails #

Just a synonym for CoVarId. Written separately so it can be exported in the hs-boot file.

vanillaIdInfo :: IdInfo #

Basic IdInfo that carries no useful information whatsoever

emptyPlugins :: Plugins #

tidyNameOcc :: Name -> OccName -> Name #

nameOccName :: Name -> OccName #

setNameUnique :: Name -> Unique -> Name #

nameUnique :: Name -> Unique #

idName :: Id -> Name #

mkPrelTyConRepName :: Name -> TyConRepName #

Make a Name for the Typeable representation of the given wired-in type

tyConRepName_maybe :: TyCon -> Maybe TyConRepName #

isUnboxedTupleTyCon :: TyCon -> Bool #

Is this the TyCon for an unboxed tuple?

isTupleTyCon :: TyCon -> Bool #

Does this TyCon represent a tuple?

NB: when compiling Data.Tuple, the tycons won't reply True to isTupleTyCon, because they are built as AlgTyCons. However they get spat into the interface file as tuple tycons, so I don't think it matters.

mkForAllTy :: ForAllTyBinder -> Type -> Type #

Like mkTyCoForAllTy, but does not check the occurrence of the binder See Note [Unused coercion variable in ForAllTy]

pprCo :: Coercion -> SDoc #

noFreeVarsOfType :: Type -> Bool #

emptyUFM :: UniqFM key elt #

isNullUFM :: UniqFM key elt -> Bool #

unitUFM :: Uniquable key => key -> elt -> UniqFM key elt #

unitDirectlyUFM :: Unique -> elt -> UniqFM key elt #

zipToUFM :: Uniquable key => [key] -> [elt] -> UniqFM key elt #

listToUFM :: Uniquable key => [(key, elt)] -> UniqFM key elt #

listToUFM_Directly :: [(Unique, elt)] -> UniqFM key elt #

listToIdentityUFM :: Uniquable key => [key] -> UniqFM key key #

listToUFM_C :: Uniquable key => (elt -> elt -> elt) -> [(key, elt)] -> UniqFM key elt #

addToUFM :: Uniquable key => UniqFM key elt -> key -> elt -> UniqFM key elt #

addListToUFM :: Uniquable key => UniqFM key elt -> [(key, elt)] -> UniqFM key elt #

addListToUFM_Directly :: UniqFM key elt -> [(Unique, elt)] -> UniqFM key elt #

addToUFM_Directly :: UniqFM key elt -> Unique -> elt -> UniqFM key elt #

addToUFM_C :: Uniquable key => (elt -> elt -> elt) -> UniqFM key elt -> key -> elt -> UniqFM key elt #

addToUFM_Acc :: Uniquable key => (elt -> elts -> elts) -> (elt -> elts) -> UniqFM key elts -> key -> elt -> UniqFM key elts #

addToUFM_L :: Uniquable key => (key -> elt -> elt -> elt) -> key -> elt -> UniqFM key elt -> (Maybe elt, UniqFM key elt) #

Add an element, returns previous lookup result and new map. If old element doesn't exist, add the passed element directly, otherwise compute the element to add using the passed function.

alterUFM :: Uniquable key => (Maybe elt -> Maybe elt) -> UniqFM key elt -> key -> UniqFM key elt #

addListToUFM_C :: Uniquable key => (elt -> elt -> elt) -> UniqFM key elt -> [(key, elt)] -> UniqFM key elt #

Add elements to the map, combining existing values with inserted ones using the given function.

adjustUFM :: Uniquable key => (elt -> elt) -> UniqFM key elt -> key -> UniqFM key elt #

adjustUFM_Directly :: (elt -> elt) -> UniqFM key elt -> Unique -> UniqFM key elt #

delFromUFM :: Uniquable key => UniqFM key elt -> key -> UniqFM key elt #

delListFromUFM :: Uniquable key => UniqFM key elt -> [key] -> UniqFM key elt #

delListFromUFM_Directly :: UniqFM key elt -> [Unique] -> UniqFM key elt #

delFromUFM_Directly :: UniqFM key elt -> Unique -> UniqFM key elt #

plusUFM :: UniqFM key elt -> UniqFM key elt -> UniqFM key elt #

plusUFM_C :: (elt -> elt -> elt) -> UniqFM key elt -> UniqFM key elt -> UniqFM key elt #

plusUFM_CD :: (elta -> eltb -> eltc) -> UniqFM key elta -> elta -> UniqFM key eltb -> eltb -> UniqFM key eltc #

`plusUFM_CD f m1 d1 m2 d2` merges the maps using f as the combinding function and d1 resp. d2 as the default value if there is no entry in m1 reps. m2. The domain is the union of the domains of m1 and m2.

IMPORTANT NOTE: This function strictly applies the modification function and forces the result unlike most the other functions in this module.

Representative example:

plusUFM_CD f {A: 1, B: 2} 23 {B: 3, C: 4} 42
   == {A: f 1 42, B: f 2 3, C: f 23 4 }

plusUFM_CD2 :: (Maybe elta -> Maybe eltb -> eltc) -> UniqFM key elta -> UniqFM key eltb -> UniqFM key eltc #

`plusUFM_CD2 f m1 m2` merges the maps using f as the combining function. Unlike plusUFM_CD, a missing value is not defaulted: it is instead passed as Nothing to f. f can never have both its arguments be Nothing.

IMPORTANT NOTE: This function strictly applies the modification function and forces the result.

`plusUFM_CD2 f m1 m2` is the same as `plusUFM_CD f (mapUFM Just m1) Nothing (mapUFM Just m2) Nothing`.

mergeUFM :: (elta -> eltb -> Maybe eltc) -> (UniqFM key elta -> UniqFM key eltc) -> (UniqFM key eltb -> UniqFM key eltc) -> UniqFM key elta -> UniqFM key eltb -> UniqFM key eltc #

plusMaybeUFM_C :: (elt -> elt -> Maybe elt) -> UniqFM key elt -> UniqFM key elt -> UniqFM key elt #

plusUFMList :: [UniqFM key elt] -> UniqFM key elt #

sequenceUFMList :: [UniqFM key elt] -> UniqFM key [elt] #

minusUFM :: UniqFM key elt1 -> UniqFM key elt2 -> UniqFM key elt1 #

minusUFM_C :: (elt1 -> elt2 -> Maybe elt1) -> UniqFM key elt1 -> UniqFM key elt2 -> UniqFM key elt1 #

minusUFC_C f map1 map2 returns map1, except that every mapping key |-> value1 in map1 that shares a key with a mapping key |-> value2 in map2 is altered by f: value1 is replaced by f value1 value2, where Just means that the new value is used and Nothing means that the mapping is deleted.

intersectUFM :: UniqFM key elt1 -> UniqFM key elt2 -> UniqFM key elt1 #

intersectUFM_C :: (elt1 -> elt2 -> elt3) -> UniqFM key elt1 -> UniqFM key elt2 -> UniqFM key elt3 #

disjointUFM :: UniqFM key elt1 -> UniqFM key elt2 -> Bool #

foldUFM :: (elt -> a -> a) -> a -> UniqFM key elt -> a #

mapUFM :: (elt1 -> elt2) -> UniqFM key elt1 -> UniqFM key elt2 #

mapMaybeUFM :: (elt1 -> Maybe elt2) -> UniqFM key elt1 -> UniqFM key elt2 #

mapUFM_Directly :: (Unique -> elt1 -> elt2) -> UniqFM key elt1 -> UniqFM key elt2 #

filterUFM :: (elt -> Bool) -> UniqFM key elt -> UniqFM key elt #

filterUFM_Directly :: (Unique -> elt -> Bool) -> UniqFM key elt -> UniqFM key elt #

partitionUFM :: (elt -> Bool) -> UniqFM key elt -> (UniqFM key elt, UniqFM key elt) #

sizeUFM :: UniqFM key elt -> Int #

elemUFM :: Uniquable key => key -> UniqFM key elt -> Bool #

elemUFM_Directly :: Unique -> UniqFM key elt -> Bool #

lookupUFM :: Uniquable key => UniqFM key elt -> key -> Maybe elt #

lookupUFM_Directly :: UniqFM key elt -> Unique -> Maybe elt #

lookupWithDefaultUFM :: Uniquable key => UniqFM key elt -> elt -> key -> elt #

lookupWithDefaultUFM_Directly :: UniqFM key elt -> elt -> Unique -> elt #

ufmToSet_Directly :: UniqFM key elt -> IntSet #

anyUFM :: (elt -> Bool) -> UniqFM key elt -> Bool #

allUFM :: (elt -> Bool) -> UniqFM key elt -> Bool #

seqEltsUFM :: (elt -> ()) -> UniqFM key elt -> () #

nonDetEltsUFM :: UniqFM key elt -> [elt] #

nonDetKeysUFM :: UniqFM key elt -> [Unique] #

nonDetStrictFoldUFM :: (elt -> a -> a) -> a -> UniqFM key elt -> a #

nonDetStrictFoldUFM_DirectlyM :: Monad m => (Unique -> b -> elt -> m b) -> b -> UniqFM key elt -> m b #

In essence foldM See Note [Deterministic UniqFM] to learn about nondeterminism. If you use this please provide a justification why it doesn't introduce nondeterminism.

nonDetStrictFoldUFM_Directly :: (Unique -> elt -> a -> a) -> a -> UniqFM key elt -> a #

nonDetUFMToList :: UniqFM key elt -> [(Unique, elt)] #

ufmToIntMap :: UniqFM key elt -> IntMap elt #

unsafeIntMapToUFM :: IntMap elt -> UniqFM key elt #

unsafeCastUFMKey :: UniqFM key1 elt -> UniqFM key2 elt #

Cast the key domain of a UniqFM.

As long as the domains don't overlap in their uniques this is safe.

equalKeysUFM :: UniqFM key a -> UniqFM key b -> Bool #

pprUniqFM :: (a -> SDoc) -> UniqFM key a -> SDoc #

pprUFM #

Arguments

:: UniqFM key a	The things to be pretty printed
-> ([a] -> SDoc)	The pretty printing function to use on the elements
-> SDoc	`SDoc` where the things have been pretty printed

Pretty-print a non-deterministic set. The order of variables is non-deterministic and for pretty-printing that shouldn't be a problem. Having this function helps contain the non-determinism created with nonDetEltsUFM.

pprUFMWithKeys #

Arguments

:: UniqFM key a	The things to be pretty printed
-> ([(Unique, a)] -> SDoc)	The pretty printing function to use on the elements
-> SDoc	`SDoc` where the things have been pretty printed

Pretty-print a non-deterministic set. The order of variables is non-deterministic and for pretty-printing that shouldn't be a problem. Having this function helps contain the non-determinism created with nonDetUFMToList.

pluralUFM :: UniqFM key a -> SDoc #

Determines the pluralisation suffix appropriate for the length of a set in the same way that plural from Outputable does for lists.

insertList :: Ord key => [(key, elt)] -> Map key elt -> Map key elt #

insertListWith :: Ord key => (elt -> elt -> elt) -> [(key, elt)] -> Map key elt -> Map key elt #

deleteList :: Ord key => [key] -> Map key elt -> Map key elt #

foldRight :: (elt -> a -> a) -> a -> Map key elt -> a #

foldRightWithKey :: (key -> elt -> a -> a) -> a -> Map key elt -> a #

mkSplitUniqSupply :: Char -> IO UniqSupply #

Create a unique supply out of thin air. The "mask" (Char) supplied is purely cosmetic, making it easier to figure out where a Unique was born. See Note [Uniques and masks].

The payload part of the Uniques allocated from this UniqSupply are guaranteed distinct wrt all other supplies, regardless of their "mask". This is achieved by allocating the payload part from a single source of Uniques, namely genSym, shared across all UniqSupply's.

initUniqSupply :: Word -> Int -> IO () #

uniqFromMask :: Char -> IO Unique #

splitUniqSupply :: UniqSupply -> (UniqSupply, UniqSupply) #

Build two UniqSupply from a single one, each of which can supply its own Unique.

listSplitUniqSupply :: UniqSupply -> [UniqSupply] #

Create an infinite list of UniqSupply from a single one

uniqFromSupply :: UniqSupply -> Unique #

Obtain the Unique from this particular UniqSupply

uniqsFromSupply :: UniqSupply -> [Unique] #

Obtain an infinite list of Unique that can be generated by constant splitting of the supply

takeUniqFromSupply :: UniqSupply -> (Unique, UniqSupply) #

Obtain the Unique from this particular UniqSupply, and a new supply

initUs :: UniqSupply -> UniqSM a -> (a, UniqSupply) #

Run the UniqSM action, returning the final UniqSupply

initUs_ :: UniqSupply -> UniqSM a -> a #

Run the UniqSM action, discarding the final UniqSupply

showOpt :: Option -> String #

mkSrcLoc :: FastString -> Int -> Int -> SrcLoc #

mkRealSrcLoc :: FastString -> Int -> Int -> RealSrcLoc #

leftmostColumn :: Int #

Indentation level is 1-indexed, so the leftmost column is 1.

getBufPos :: SrcLoc -> Maybe BufPos #

noSrcLoc :: SrcLoc #

Built-in "bad" RealSrcLoc values for particular locations

generatedSrcLoc :: SrcLoc #

Built-in "bad" RealSrcLoc values for particular locations

interactiveSrcLoc :: SrcLoc #

Built-in "bad" RealSrcLoc values for particular locations

mkGeneralSrcLoc :: FastString -> SrcLoc #

Creates a "bad" RealSrcLoc that has no detailed information about its location

srcLocLine :: RealSrcLoc -> Int #

Raises an error when used on a "bad" RealSrcLoc

srcLocCol :: RealSrcLoc -> Int #

Raises an error when used on a "bad" RealSrcLoc

advanceSrcLoc :: RealSrcLoc -> Char -> RealSrcLoc #

Move the RealSrcLoc down by one line if the character is a newline, to the next 8-char tabstop if it is a tab, and across by one character in any other case

advanceBufPos :: BufPos -> BufPos #

sortLocated :: [Located a] -> [Located a] #

sortRealLocated :: [RealLocated a] -> [RealLocated a] #

lookupSrcLoc :: SrcLoc -> Map RealSrcLoc a -> Maybe a #

lookupSrcSpan :: SrcSpan -> Map RealSrcSpan a -> Maybe a #

removeBufSpan :: SrcSpan -> SrcSpan #

getBufSpan :: SrcSpan -> Maybe BufSpan #

noSrcSpan :: SrcSpan #

Built-in "bad" SrcSpans for common sources of location uncertainty

wiredInSrcSpan :: SrcSpan #

Built-in "bad" SrcSpans for common sources of location uncertainty

interactiveSrcSpan :: SrcSpan #

Built-in "bad" SrcSpans for common sources of location uncertainty

generatedSrcSpan :: SrcSpan #

Built-in "bad" SrcSpans for common sources of location uncertainty

isGeneratedSrcSpan :: SrcSpan -> Bool #

isNoSrcSpan :: SrcSpan -> Bool #

mkGeneralSrcSpan :: FastString -> SrcSpan #

Create a "bad" SrcSpan that has not location information

srcLocSpan :: SrcLoc -> SrcSpan #

Create a SrcSpan corresponding to a single point

realSrcLocSpan :: RealSrcLoc -> RealSrcSpan #

mkRealSrcSpan :: RealSrcLoc -> RealSrcLoc -> RealSrcSpan #

Create a SrcSpan between two points in a file

mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan #

Create a SrcSpan between two points in a file

combineSrcSpans :: SrcSpan -> SrcSpan -> SrcSpan #

Combines two SrcSpan into one that spans at least all the characters within both spans. Returns UnhelpfulSpan if the files differ.

combineRealSrcSpans :: RealSrcSpan -> RealSrcSpan -> RealSrcSpan #

Combines two SrcSpan into one that spans at least all the characters within both spans. Assumes the "file" part is the same in both inputs

combineBufSpans :: BufSpan -> BufSpan -> BufSpan #

srcSpanFirstCharacter :: SrcSpan -> SrcSpan #

Convert a SrcSpan into one that represents only its first character

isGoodSrcSpan :: SrcSpan -> Bool #

Test if a SrcSpan is "good", i.e. has precise location information

isOneLineSpan :: SrcSpan -> Bool #

True if the span is known to straddle only one line. For "bad" SrcSpan, it returns False

isZeroWidthSpan :: SrcSpan -> Bool #

True if the span has a width of zero, as returned for "virtual" semicolons in the lexer. For "bad" SrcSpan, it returns False

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.

srcSpanStartLine :: RealSrcSpan -> Int #

srcSpanEndLine :: RealSrcSpan -> Int #

srcSpanStartCol :: RealSrcSpan -> Int #

srcSpanEndCol :: RealSrcSpan -> Int #

srcSpanStart :: SrcSpan -> SrcLoc #

Returns the location at the start of the SrcSpan or a "bad" SrcSpan if that is unavailable

srcSpanEnd :: SrcSpan -> SrcLoc #

Returns the location at the end of the SrcSpan or a "bad" SrcSpan if that is unavailable

realSrcSpanStart :: RealSrcSpan -> RealSrcLoc #

realSrcSpanEnd :: RealSrcSpan -> RealSrcLoc #

srcSpanFileName_maybe :: SrcSpan -> Maybe FastString #

Obtains the filename for a SrcSpan if it is "good"

srcSpanToRealSrcSpan :: SrcSpan -> Maybe RealSrcSpan #

unhelpfulSpanFS :: UnhelpfulSpanReason -> FastString #

pprUnhelpfulSpanReason :: UnhelpfulSpanReason -> SDoc #

pprUserSpan :: Bool -> SrcSpan -> SDoc #

pprUserRealSpan :: Bool -> RealSrcSpan -> SDoc #

unLoc :: GenLocated l e -> e #

getLoc :: GenLocated l e -> l #

noLoc :: e -> Located e #

mkGeneralLocated :: String -> e -> Located e #

combineLocs :: Located a -> Located b -> SrcSpan #

addCLoc :: Located a -> Located b -> c -> Located c #

Combine locations from two Located things and add them to a third thing

eqLocated :: Eq a => GenLocated l a -> GenLocated l a -> Bool #

Tests whether the two located things are equal

cmpLocated :: Ord a => GenLocated l a -> GenLocated l a -> Ordering #

Tests the ordering of the two located things

cmpBufSpan :: HasDebugCallStack => Located a -> Located a -> Ordering #

Compare the BufSpan of two located things.

Precondition: both operands have an associated BufSpan.

pprLocated :: (Outputable l, Outputable e) => GenLocated l e -> SDoc #

pprLocatedAlways :: (Outputable l, Outputable e) => GenLocated l e -> SDoc #

Always prints the location, even without -dppr-debug

rightmost_smallest :: SrcSpan -> SrcSpan -> Ordering #

Strategies for ordering SrcSpans

leftmost_smallest :: SrcSpan -> SrcSpan -> Ordering #

Strategies for ordering SrcSpans

leftmost_largest :: SrcSpan -> SrcSpan -> Ordering #

Strategies for ordering SrcSpans

spans :: SrcSpan -> (Int, Int) -> Bool #

Determines whether a span encloses a given line and column index

isSubspanOf #

Arguments

:: SrcSpan	The span that may be enclosed by the other
-> SrcSpan	The span it may be enclosed by
-> Bool

Determines whether a span is enclosed by another one

isRealSubspanOf #

Arguments

:: RealSrcSpan	The span that may be enclosed by the other
-> RealSrcSpan	The span it may be enclosed by
-> Bool

Determines whether a span is enclosed by another one

getRealSrcSpan :: RealLocated a -> RealSrcSpan #

unRealSrcSpan :: RealLocated a -> a #

psLocatedToLocated :: PsLocated a -> Located a #

advancePsLoc :: PsLoc -> Char -> PsLoc #

mkPsSpan :: PsLoc -> PsLoc -> PsSpan #

psSpanStart :: PsSpan -> PsLoc #

psSpanEnd :: PsSpan -> PsLoc #

mkSrcSpanPs :: PsSpan -> SrcSpan #

emptyFsEnv :: FastStringEnv a #

extendFsEnv :: FastStringEnv a -> FastString -> a -> FastStringEnv a #

lookupFsEnv :: FastStringEnv a -> FastString -> Maybe a #

mkFsEnv :: [(FastString, a)] -> FastStringEnv a #

emptyUniqSet :: UniqSet a #

unitUniqSet :: Uniquable a => a -> UniqSet a #

mkUniqSet :: Uniquable a => [a] -> UniqSet a #

addOneToUniqSet :: Uniquable a => UniqSet a -> a -> UniqSet a #

addListToUniqSet :: Uniquable a => UniqSet a -> [a] -> UniqSet a #

delOneFromUniqSet :: Uniquable a => UniqSet a -> a -> UniqSet a #

delOneFromUniqSet_Directly :: UniqSet a -> Unique -> UniqSet a #

delListFromUniqSet :: Uniquable a => UniqSet a -> [a] -> UniqSet a #

delListFromUniqSet_Directly :: UniqSet a -> [Unique] -> UniqSet a #

unionUniqSets :: UniqSet a -> UniqSet a -> UniqSet a #

unionManyUniqSets :: [UniqSet a] -> UniqSet a #

minusUniqSet :: UniqSet a -> UniqSet a -> UniqSet a #

intersectUniqSets :: UniqSet a -> UniqSet a -> UniqSet a #

disjointUniqSets :: UniqSet a -> UniqSet a -> Bool #

restrictUniqSetToUFM :: UniqSet key -> UniqFM key b -> UniqSet key #

uniqSetMinusUFM :: UniqSet key -> UniqFM key b -> UniqSet key #

uniqSetMinusUDFM :: UniqSet key -> UniqDFM key b -> UniqSet key #

elementOfUniqSet :: Uniquable a => a -> UniqSet a -> Bool #

elemUniqSet_Directly :: Unique -> UniqSet a -> Bool #

filterUniqSet :: (a -> Bool) -> UniqSet a -> UniqSet a #

filterUniqSet_Directly :: (Unique -> elt -> Bool) -> UniqSet elt -> UniqSet elt #

partitionUniqSet :: (a -> Bool) -> UniqSet a -> (UniqSet a, UniqSet a) #

uniqSetAny :: (a -> Bool) -> UniqSet a -> Bool #

uniqSetAll :: (a -> Bool) -> UniqSet a -> Bool #

sizeUniqSet :: UniqSet a -> Int #

isEmptyUniqSet :: UniqSet a -> Bool #

lookupUniqSet :: Uniquable key => UniqSet key -> key -> Maybe key #

What's the point you might ask? We might have changed an object without it's key changing. In which case this lookup makes sense.

lookupUniqSet_Directly :: UniqSet a -> Unique -> Maybe a #

nonDetEltsUniqSet :: UniqSet elt -> [elt] #

nonDetKeysUniqSet :: UniqSet elt -> [Unique] #

nonDetStrictFoldUniqSet :: (elt -> a -> a) -> a -> UniqSet elt -> a #

mapUniqSet :: Uniquable b => (a -> b) -> UniqSet a -> UniqSet b #

getUniqSet :: UniqSet a -> UniqFM a a #

unsafeUFMToUniqSet :: UniqFM a a -> UniqSet a #

unsafeUFMToUniqSet converts a UniqFM a into a UniqSet a assuming, without checking, that it maps each Unique to a value that has that Unique. See Note [UniqSet invariant].

pprUniqSet :: (a -> SDoc) -> UniqSet a -> SDoc #

pprWithSourceText :: SourceText -> SDoc -> SDoc #

Special combinator for showing string literals.

mkIntegralLit :: Integral a => a -> IntegralLit #

negateIntegralLit :: IntegralLit -> IntegralLit #

mkFractionalLit :: SourceText -> Bool -> Rational -> Integer -> FractionalExponentBase -> FractionalLit #

fractionalLitFromRational :: Rational -> FractionalLit #

rationalFromFractionalLit :: FractionalLit -> Rational #

mkTHFractionalLit :: Rational -> FractionalLit #

negateFractionalLit :: FractionalLit -> FractionalLit #

integralFractionalLit :: Bool -> Integer -> FractionalLit #

The integer should already be negated if it's negative.

mkSourceFractionalLit :: String -> Bool -> Integer -> Integer -> FractionalExponentBase -> FractionalLit #

The arguments should already be negated if they are negative.

optimisationFlags :: EnumSet GeneralFlag #

The set of flags which affect optimisation for the purposes of recompilation avoidance. Specifically, these include flags which affect code generation but not the semantics of the program.

See Note [Ignoring some flag changes] in GHC.Iface.Recomp.Flags)

codeGenFlags :: EnumSet GeneralFlag #

The set of flags which affect code generation and can change a program's runtime behavior (other than performance). These include flags which affect:

user visible debugging information (e.g. info table provenance)
the ability to catch runtime errors (e.g. -fignore-asserts)
the runtime result of the program (e.g. -fomit-yields)
which code or interface file declarations are emitted

We also considered placing flags which affect asympototic space behavior (e.g. -ffull-laziness) however this would mean that changing optimisation levels would trigger recompilation even with -fignore-optim-changes, regressing #13604.

Also, arguably Opt_IgnoreAsserts should be here as well; however, we place it instead in optimisationFlags since it is implied by -O[12] and therefore would also break #13604.

See #23369.

moduleUnitId :: Module -> UnitId #

mkModule :: u -> ModuleName -> GenModule u #

pprModule :: IsLine doc => Module -> doc #

pprInstantiatedModule :: InstantiatedModule -> SDoc #

isHoleUnit :: GenUnit u -> Bool #

stableUnitCmp :: Unit -> Unit -> Ordering #

Compares unit ids lexically, rather than by their Uniques

pprUnit :: IsLine doc => Unit -> doc #

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 #

mapGenUnit :: IsUnitId v => (u -> v) -> GenUnit u -> GenUnit v #

Map over the unit type of a GenUnit

mapInstantiations :: IsUnitId v => (u -> v) -> GenInstantiations u -> GenInstantiations v #

Map over the unit identifier of unit instantiations.

toUnitId :: Unit -> UnitId #

Return the UnitId of the Unit. For on-the-fly instantiated units, return the UnitId of the indefinite unit this unit is an instance of.

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 #

rtsUnitId :: UnitId #

thisGhcUnitId :: UnitId #

interactiveUnitId :: UnitId #

thUnitId :: UnitId #

thUnit :: Unit #

primUnit :: Unit #

bignumUnit :: Unit #

baseUnit :: Unit #

rtsUnit :: 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.

mainUnit :: Unit #

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_maybe :: IsBootInterface -> ModLocation -> ModLocation #

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

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 #

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

homeUnitId :: GenHomeUnit u -> UnitId #

Return home unit id

homeUnitInstantiations :: GenHomeUnit u -> GenInstantiations u #

Return home unit instantiations

homeUnitInstanceOf :: HomeUnit -> UnitId #

Return the unit id of the unit that is instantiated by the home unit.

E.g. if home unit = q[A=p:B,...] we return q.

If the home unit is not an instance of another unit, we return its own unit id (it is an instance of itself if you will).

homeUnitInstanceOfMaybe :: GenHomeUnit u -> Maybe u #

Return the unit id of the unit that is instantiated by the home unit.

E.g. if home unit = q[A=p:B,...] we return (Just q).

If the home unit is not an instance of another unit, we return Nothing.

homeUnitAsUnit :: HomeUnit -> Unit #

Return the home unit as a normal unit.

We infer from the home unit itself the kind of unit we create: 1. If the home unit is definite, we must be compiling so we return a real unit. The definite home unit may be the result of a unit instantiation, say `p = q[A=r:X]`. In this case we could have returned a virtual unit `q[A=r:X]` but it's not what the clients of this function expect, especially because p is lost when we do this. The unit id of a virtual unit is made up internally so `unitId(q[A=r:X])` is not equal to p.

If the home unit is indefinite we can only create a virtual unit from it. It's ok because we must be only typechecking the home unit so we won't produce any code object that rely on the unit id of this virtual unit.

homeUnitMap :: IsUnitId v => (u -> v) -> GenHomeUnit u -> GenHomeUnit v #

Map over the unit identifier for instantiating units

isHomeUnitIndefinite :: GenHomeUnit u -> Bool #

Test if we are type-checking an indefinite unit

(if it is not, we should never use on-the-fly renaming)

isHomeUnitDefinite :: GenHomeUnit u -> Bool #

Test if we are compiling a definite unit

(if it is, we should never use on-the-fly renaming)

isHomeUnitInstantiating :: GenHomeUnit u -> Bool #

Test if we are compiling by instantiating a definite unit

isHomeUnit :: HomeUnit -> Unit -> Bool #

Test if the unit is the home unit

isHomeUnitId :: GenHomeUnit u -> UnitId -> Bool #

Test if the unit-id is the home unit-id

notHomeUnitId :: Maybe (GenHomeUnit u) -> UnitId -> Bool #

Test if the unit-id is not the home unit-id

isHomeUnitInstanceOf :: HomeUnit -> UnitId -> Bool #

Test if the home unit is an instance of the given unit-id

isHomeModule :: HomeUnit -> Module -> Bool #

Test if the module comes from the home unit

isHomeInstalledModule :: GenHomeUnit u -> InstalledModule -> Bool #

Test if the module comes from the home unit

notHomeInstalledModule :: GenHomeUnit u -> InstalledModule -> Bool #

Test if a module doesn't come from the given home unit

notHomeInstalledModuleMaybe :: Maybe (GenHomeUnit u) -> InstalledModule -> Bool #

Test if a module doesn't come from the given home unit

notHomeModule :: HomeUnit -> Module -> Bool #

Test if a module doesn't come from the given home unit

notHomeModuleMaybe :: Maybe HomeUnit -> Module -> Bool #

Test if a module doesn't come from the given home unit

mkHomeModule :: HomeUnit -> ModuleName -> Module #

Make a module in home unit

mkHomeInstalledModule :: GenHomeUnit u -> ModuleName -> InstalledModule #

Make a module in home unit

homeModuleNameInstantiation :: HomeUnit -> ModuleName -> Module #

Return the module that is used to instantiate the given home module name. If the ModuleName doesn't refer to a signature, return the actual home module.

E.g., the instantiating module of A in p[A=q[]:B] is q[]:B. the instantiating module of A in p is p:A.

homeModuleInstantiation :: Maybe HomeUnit -> Module -> Module #

Return the module that is used to instantiate the given home module.

If the given module isn't a module hole, return the actual home module.

E.g., the instantiating module of p:A in p[A=q[]:B] is q[]:B. the instantiating module of r:A in p[A=q[]:B] is r:A. the instantiating module of p:A in p is p:A. the instantiating module of r:A in p is r:A.

isPromoted :: PromotionFlag -> Bool #

pickLR :: LeftOrRight -> (a, a) -> a #

fIRST_TAG :: ConTag #

Tags are allocated from here for real constructors or for superclass selectors

mkAlignment :: Int -> Alignment #

alignmentOf :: Int -> Alignment #

noOneShotInfo :: OneShotInfo #

It is always safe to assume that an Id has no lambda-bound variable information

isOneShotInfo :: OneShotInfo -> Bool #

hasNoOneShotInfo :: OneShotInfo -> Bool #

worstOneShot :: OneShotInfo -> OneShotInfo -> OneShotInfo #

bestOneShot :: OneShotInfo -> OneShotInfo -> OneShotInfo #

flipSwap :: SwapFlag -> SwapFlag #

isSwapped :: SwapFlag -> Bool #

unSwap :: SwapFlag -> (a -> a -> b) -> a -> a -> b #

pprRuleName :: RuleName -> SDoc #

isNotTopLevel :: TopLevelFlag -> Bool #

isTopLevel :: TopLevelFlag -> Bool #

isMarkedCbv :: CbvMark -> Bool #

isRec :: RecFlag -> Bool #

isNonRec :: RecFlag -> Bool #

boolToRecFlag :: Bool -> RecFlag #

isGenerated :: Origin -> Bool #

setOverlapModeMaybe :: OverlapFlag -> Maybe OverlapMode -> OverlapFlag #

hasIncoherentFlag :: OverlapMode -> Bool #

hasOverlappableFlag :: OverlapMode -> Bool #

hasOverlappingFlag :: OverlapMode -> Bool #

topPrec :: PprPrec #

sigPrec :: PprPrec #

funPrec :: PprPrec #

opPrec :: PprPrec #

starPrec :: PprPrec #

maxPrec :: PprPrec #

maybeParen :: PprPrec -> PprPrec -> SDoc -> SDoc #

tupleSortBoxity :: TupleSort -> Boxity #

boxityTupleSort :: Boxity -> TupleSort #

tupleParens :: TupleSort -> SDoc -> SDoc #

sumParens :: SDoc -> SDoc #

pprAlternative #

Arguments

:: (a -> SDoc)	The pretty printing function to use
-> a	The things to be pretty printed
-> ConTag	Alternative (one-based)
-> Arity	Arity
-> SDoc	`SDoc` where the alternative havs been pretty printed and finally packed into a paragraph.

Pretty print an alternative in an unboxed sum e.g. "| a | |".

unboxedTupleOrSumExtension :: UnboxedTupleOrSum -> Extension #

oneBranch :: BranchCount #

noOccInfo :: OccInfo #

isNoOccInfo :: OccInfo -> Bool #

isManyOccs :: OccInfo -> Bool #

seqOccInfo :: OccInfo -> () #

tailCallInfo :: OccInfo -> TailCallInfo #

zapOccTailCallInfo :: OccInfo -> OccInfo #

isAlwaysTailCalled :: OccInfo -> Bool #

strongLoopBreaker :: OccInfo #

weakLoopBreaker :: OccInfo #

isWeakLoopBreaker :: OccInfo -> Bool #

isStrongLoopBreaker :: OccInfo -> Bool #

isDeadOcc :: OccInfo -> Bool #

isOneOcc :: OccInfo -> Bool #

zapFragileOcc :: OccInfo -> OccInfo #

successIf :: Bool -> SuccessFlag #

succeeded :: SuccessFlag -> Bool #

failed :: SuccessFlag -> Bool #

beginPhase :: Activation -> CompilerPhase #

activeAfter :: CompilerPhase -> Activation #

nextPhase :: CompilerPhase -> CompilerPhase #

laterPhase :: CompilerPhase -> CompilerPhase -> CompilerPhase #

activateAfterInitial :: Activation #

activateDuringFinal :: Activation #

isActive :: CompilerPhase -> Activation -> Bool #

activeInFinalPhase :: Activation -> Bool #

isNeverActive :: Activation -> Bool #

isAlwaysActive :: Activation -> Bool #

competesWith :: Activation -> Activation -> Bool #

isConLike :: RuleMatchInfo -> Bool #

isFunLike :: RuleMatchInfo -> Bool #

noUserInlineSpec :: InlineSpec -> Bool #

defaultInlinePragma :: InlinePragma #

alwaysInlinePragma :: InlinePragma #

neverInlinePragma :: InlinePragma #

alwaysInlineConLikePragma :: InlinePragma #

inlinePragmaSpec :: InlinePragma -> InlineSpec #

inlinePragmaSource :: InlinePragma -> SourceText #

inlineSpecSource :: InlineSpec -> SourceText #

dfunInlinePragma :: InlinePragma #

isDefaultInlinePragma :: InlinePragma -> Bool #

isInlinePragma :: InlinePragma -> Bool #

isInlinablePragma :: InlinePragma -> Bool #

isNoInlinePragma :: InlinePragma -> Bool #

isAnyInlinePragma :: InlinePragma -> Bool #

isOpaquePragma :: InlinePragma -> Bool #

inlinePragmaSat :: InlinePragma -> Maybe Arity #

inlinePragmaActivation :: InlinePragma -> Activation #

inlinePragmaRuleMatchInfo :: InlinePragma -> RuleMatchInfo #

setInlinePragmaActivation :: InlinePragma -> Activation -> InlinePragma #

setInlinePragmaRuleMatchInfo :: InlinePragma -> RuleMatchInfo -> InlinePragma #

inlinePragmaName :: InlineSpec -> SDoc #

Outputs string for pragma name for any of INLINEINLINABLENOINLINE. This differs from the Outputable instance for the InlineSpec type where the pragma name string as well as the accompanying SourceText (if any) is printed.

pprInline :: InlinePragma -> SDoc #

Pretty-print without displaying the user-specified InlineSpec.

pprInlineDebug :: InlinePragma -> SDoc #

Pretty-print including the user-specified InlineSpec.

isStableUserSource :: UnfoldingSource -> Bool #

isStableSystemSource :: UnfoldingSource -> Bool #

isCompulsorySource :: UnfoldingSource -> Bool #

isStableSource :: UnfoldingSource -> Bool #

intGtLimit :: Int -> IntWithInf -> Bool #

subWithInf :: IntWithInf -> Int -> IntWithInf #

Subtract an IntWithInf from an IntWithInf

treatZeroAsInf :: Int -> IntWithInf #

Turn a positive number into an IntWithInf, where 0 represents infinity

mkIntWithInf :: Int -> IntWithInf #

Inject any integer into an IntWithInf

isTypeLevel :: TypeOrKind -> Bool #

isKindLevel :: TypeOrKind -> Bool #

mightBeLifted :: Maybe Levity -> Bool #

mightBeUnlifted :: Maybe Levity -> Bool #

defaultNonStandardTyVars :: DefaultingStrategy -> Bool #

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

dataConExTyCoVars :: DataCon -> [TyCoVar] #

The existentially-quantified type/coercion variables of the constructor including dependent (kind-) GADT equalities

dataConTyCon :: DataCon -> TyCon #

The type constructor that we are building via this data constructor

dataConWorkId :: DataCon -> Id #

Get the Id of the DataCon worker: a function that is the "actual" constructor and has no top level binding in the program. The type may be different from the obvious one written in the source program. Panics if there is no such Id for this DataCon

dataConName :: DataCon -> Name #

The Name of the DataCon, giving it a unique, rooted identification

sumTyCon :: Arity -> TyCon #

Type constructor for n-ary unboxed sum.

sumDataCon :: ConTag -> Arity -> DataCon #

Data constructor for i-th alternative of a n-ary unboxed sum.

cTupleSelIdName :: ConTag -> Arity -> Name #

cTupleTyConName :: Arity -> Name #

cTupleDataConName :: Arity -> Name #

cTupleDataCon :: Arity -> DataCon #

tupleTyCon :: Boxity -> Arity -> TyCon #

tupleDataCon :: Boxity -> Arity -> DataCon #

promotedTupleDataCon :: Boxity -> Arity -> TyCon #

integerTy :: Type #

naturalTy :: Type #

tupleDataConName :: Boxity -> Arity -> Name #

tupleTyConName :: TupleSort -> Arity -> Name #

multMulTyCon :: TyCon #

unrestrictedFunTyCon :: TyCon #

manyDataConTyCon :: TyCon #

manyDataConTy :: Type #

oneDataConTyCon :: TyCon #

oneDataConTy :: Type #

multiplicityTy :: Type #

multiplicityTyCon :: TyCon #

unboxedTupleKind :: [Type] -> Kind #

Specialization of unboxedTupleSumKind for tuples

anyTypeOfKind :: Kind -> Type #

int8ElemRepDataConTy :: Type #

int16ElemRepDataConTy :: Type #

int32ElemRepDataConTy :: Type #

int64ElemRepDataConTy :: Type #

word8ElemRepDataConTy :: Type #

word16ElemRepDataConTy :: Type #

word32ElemRepDataConTy :: Type #

word64ElemRepDataConTy :: Type #

floatElemRepDataConTy :: Type #

doubleElemRepDataConTy :: Type #

vec2DataConTy :: Type #

vec4DataConTy :: Type #

vec8DataConTy :: Type #

vec16DataConTy :: Type #

vec32DataConTy :: Type #

vec64DataConTy :: Type #

intRepDataConTy :: RuntimeRepType #

int8RepDataConTy :: RuntimeRepType #

int16RepDataConTy :: RuntimeRepType #

int32RepDataConTy :: RuntimeRepType #

int64RepDataConTy :: RuntimeRepType #

wordRepDataConTy :: RuntimeRepType #

word8RepDataConTy :: RuntimeRepType #

word16RepDataConTy :: RuntimeRepType #

word32RepDataConTy :: RuntimeRepType #

word64RepDataConTy :: RuntimeRepType #

addrRepDataConTy :: RuntimeRepType #

floatRepDataConTy :: RuntimeRepType #

doubleRepDataConTy :: RuntimeRepType #

liftedDataConTy :: Type #

unliftedDataConTy :: Type #

liftedRepTy :: RuntimeRepType #

unliftedRepTy :: RuntimeRepType #

zeroBitRepTy :: RuntimeRepType #

vecRepDataConTyCon :: TyCon #

tupleRepDataConTyCon :: TyCon #

boxedRepDataConTyCon :: TyCon #

liftedDataConTyCon :: TyCon #

runtimeRepTy :: Type #

levityTy :: Type #

runtimeRepTyCon :: TyCon #

levityTyCon :: TyCon #

vecCountTyCon :: TyCon #

vecElemTyCon :: TyCon #

constraintKind :: Kind #

liftedRepTyCon :: TyCon #

type LiftedRep = 'BoxedRep 'Lifted

unliftedRepTyCon :: TyCon #

type UnliftedRep = 'BoxedRep 'Unlifted

liftedTypeKindTyCon :: TyCon #

unliftedTypeKindTyCon :: TyCon #

liftedTypeKind :: Type #

unliftedTypeKind :: Type #

zeroBitTypeKind :: Type #

constraintKindTyConName :: Name #

liftedTypeKindTyConName :: Name #

unitTy :: Type #

coercibleTyCon :: TyCon #

heqTyCon :: TyCon #

mkBoxedTupleTy :: [Type] -> Type #

Build the type of a small tuple that holds the specified type of thing Flattens 1-tuples. See Note [One-tuples].

charTy :: Type #

typeSymbolKind :: Kind #

listTyCon :: TyCon #

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 #

Alters (replaces or removes) those elements of the map that are mentioned in the second map

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 #

Converts an OccSet to an OccEnv (operationally the identity)

occNameString :: OccName -> String #

setOccNameSpace :: NameSpace -> OccName -> OccName #

isVarOcc :: OccName -> Bool #

isTvOcc :: OccName -> Bool #

isTcOcc :: OccName -> Bool #

isValOcc :: OccName -> Bool #

Value OccNamess are those that are either in the variable or data constructor namespaces

isDataOcc :: OccName -> Bool #

isDataSymOcc :: OccName -> Bool #

Test if the OccName is a data constructor that starts with a symbol (e.g. :, or [])

isSymOcc :: OccName -> Bool #

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 #

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 #

Arguments

:: Int	Index of superclass, e.g. 3
-> OccName	Class, e.g. `Ord`
-> OccName	Derived `Occname`, e.g. `$p3Ord`

mkLocalOcc #

Arguments

:: Unique	Unique to combine with the `OccName`
-> OccName	Local name, e.g. `sat`
-> OccName	Nice unique version, e.g. `$L23sat`

mkInstTyTcOcc #

Arguments

:: String	Family name, e.g. `Map`
-> OccSet	avoid these Occs
-> OccName	R:Map

Derive a name for the representation type constructor of a data/newtype instance.

mkDFunOcc #

Arguments

:: String	Typically the class and type glommed together e.g. `OrdMaybe`. Only used in debug mode, for extra clarity
-> Bool	Is this a hs-boot instance DFun?
-> OccSet	avoid these Occs
-> OccName	E.g. `$f3OrdMaybe`

mkMethodOcc :: OccName -> OccName #

emptyTidyOccEnv :: TidyOccEnv #

initTidyOccEnv :: [OccName] -> TidyOccEnv #

delTidyOccEnvList :: TidyOccEnv -> [FastString] -> TidyOccEnv #

avoidClashesOccEnv :: TidyOccEnv -> [OccName] -> TidyOccEnv #

tidyOccName :: TidyOccEnv -> OccName -> (TidyOccEnv, OccName) #

wordAlignment :: Platform -> Alignment #

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 #

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 #

isValName :: Name -> Bool #

isVarName :: Name -> Bool #

isSystemName :: Name -> Bool #

mkInternalName :: Unique -> OccName -> SrcSpan -> Name #

Create a name which is (for now at least) local to the current module and hence does not need a GenModule to disambiguate it from other Names

mkClonedInternalName :: Unique -> Name -> Name #

mkDerivedInternalName :: (OccName -> OccName) -> 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

mkSystemNameAt :: Unique -> OccName -> SrcSpan -> Name #

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.

pprName :: IsLine doc => Name -> doc #

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.

pprModulePrefix :: IsLine doc => PprStyle -> Module -> OccName -> doc #

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 #

nonDetCmpVar :: Var -> Var -> Ordering #

Compare Vars by their Uniques. This is what Ord Var does, provided here to make it explicit at the call-site that it can introduce non-determinism. See Note [Unique Determinism]

varUnique :: Var -> Unique #

varMultMaybe :: Id -> Maybe Mult #

setVarUnique :: Var -> Unique -> Var #

setVarName :: Var -> Name -> Var #

setVarType :: Var -> Type -> Var #

updateVarType :: (Type -> Type) -> Var -> Var #

Update a Vars type. Does not update the multiplicity stored in an Var, if any. Because of the possibility for abuse, ASSERTs that there is no multiplicity to update.

updateVarTypeM :: Monad m => (Type -> m Type) -> Var -> m Var #

Update a Vars type monadically. Does not update the multiplicity stored in an Var, if any. Because of the possibility for abuse, ASSERTs that there is no multiplicity to update.

isVisibleForAllTyFlag :: ForAllTyFlag -> Bool #

Does this ForAllTyFlag classify an argument that is written in Haskell?

isInvisibleForAllTyFlag :: ForAllTyFlag -> Bool #

Does this ForAllTyFlag classify an argument that is not written in Haskell?

isInferredForAllTyFlag :: ForAllTyFlag -> Bool #

mkFunTyFlag :: TypeOrConstraint -> TypeOrConstraint -> FunTyFlag #

visArg :: TypeOrConstraint -> FunTyFlag #

visArgTypeLike :: FunTyFlag #

visArgConstraintLike :: FunTyFlag #

invisArg :: TypeOrConstraint -> FunTyFlag #

invisArgTypeLike :: FunTyFlag #

invisArgConstraintLike :: FunTyFlag #

isInvisibleFunArg :: FunTyFlag -> Bool #

isVisibleFunArg :: FunTyFlag -> Bool #

isFUNArg :: FunTyFlag -> Bool #

funTyFlagResultTypeOrConstraint :: FunTyFlag -> TypeOrConstraint #

tyVarSpecToBinders :: [VarBndr a Specificity] -> [VarBndr a ForAllTyFlag] #

tyVarSpecToBinder :: VarBndr a Specificity -> VarBndr a ForAllTyFlag #

tyVarReqToBinders :: [VarBndr a ()] -> [VarBndr a ForAllTyFlag] #

tyVarReqToBinder :: VarBndr a () -> VarBndr a ForAllTyFlag #

binderVar :: VarBndr tv argf -> tv #

binderVars :: [VarBndr tv argf] -> [tv] #

binderFlag :: VarBndr tv argf -> argf #

binderFlags :: [VarBndr tv argf] -> [argf] #

binderType :: VarBndr TyCoVar argf -> Type #

isTyVarBinder :: VarBndr TyCoVar vis -> Bool #

mkForAllTyBinder :: vis -> TyCoVar -> VarBndr TyCoVar vis #

Make a named binder

mkTyVarBinder :: vis -> TyVar -> VarBndr TyVar vis #

Make a named binder var should be a type variable

mkForAllTyBinders :: vis -> [TyCoVar] -> [VarBndr TyCoVar vis] #

Make many named binders

mkTyVarBinders :: vis -> [TyVar] -> [VarBndr TyVar vis] #

Make many named binders Input vars should be type variables

mapVarBndr :: (var -> var') -> VarBndr var flag -> VarBndr var' flag #

mapVarBndrs :: (var -> var') -> [VarBndr var flag] -> [VarBndr var' flag] #

isInvisiblePiTyBinder :: PiTyBinder -> Bool #

Does this binder bind an invisible argument?

isVisiblePiTyBinder :: PiTyBinder -> Bool #

Does this binder bind a visible argument?

isNamedPiTyBinder :: PiTyBinder -> Bool #

namedPiTyBinder_maybe :: PiTyBinder -> Maybe TyCoVar #

isAnonPiTyBinder :: PiTyBinder -> Bool #

Does this binder bind a variable that is not erased? Returns True for anonymous binders.

anonPiTyBinderType_maybe :: PiTyBinder -> Maybe Type #

Extract a relevant type, if there is one.

isTyBinder :: PiTyBinder -> Bool #

If its a named binder, is the binder a tyvar? Returns True for nondependent binder. This check that we're really returning a *Ty*Binder (as opposed to a coercion binder). That way, if/when we allow coercion quantification in more places, we'll know we missed updating some function.

piTyBinderType :: PiTyBinder -> Type #

tyVarName :: TyVar -> Name #

tyVarKind :: TyVar -> Kind #

setTyVarUnique :: TyVar -> Unique -> TyVar #

setTyVarName :: TyVar -> Name -> TyVar #

setTyVarKind :: TyVar -> Kind -> TyVar #

updateTyVarKind :: (Kind -> Kind) -> TyVar -> TyVar #

updateTyVarKindM :: Monad m => (Kind -> m Kind) -> TyVar -> m TyVar #

mkTyVar :: Name -> Kind -> TyVar #

mkTcTyVar :: Name -> Kind -> TcTyVarDetails -> TyVar #

tcTyVarDetails :: TyVar -> TcTyVarDetails #

setTcTyVarDetails :: TyVar -> TcTyVarDetails -> TyVar #

idInfo :: HasDebugCallStack => Id -> IdInfo #

idDetails :: Id -> IdDetails #

mkGlobalVar :: IdDetails -> Name -> Type -> IdInfo -> Id #

mkLocalVar :: IdDetails -> Name -> Mult -> Type -> IdInfo -> Id #

mkCoVar :: Name -> Type -> CoVar #

mkExportedLocalVar :: IdDetails -> Name -> Type -> IdInfo -> Id #

Exported Vars will not be removed as dead code

lazySetIdInfo :: Id -> IdInfo -> Var #

setIdDetails :: Id -> IdDetails -> Id #

globaliseId :: Id -> Id #

If it's a local, make it global

setIdExported :: Id -> Id #

Exports the given local Var. Can also be called on global Vars, such as data constructors and class operations, which are born as global Vars and automatically exported

setIdNotExported :: Id -> Id #

We can only do this to LocalIds

updateIdTypeButNotMult :: (Type -> Type) -> Id -> Id #

updateIdTypeAndMult :: (Type -> Type) -> Id -> Id #

updateIdTypeAndMultM :: Monad m => (Type -> m Type) -> Id -> m Id #

setIdMult :: Id -> Mult -> Id #

isTyVar :: Var -> Bool #

Is this a type-level (i.e., computationally irrelevant, thus erasable) variable? Satisfies isTyVar = not . isId.

isTcTyVar :: Var -> Bool #

isTyCoVar :: Var -> Bool #

isId :: Var -> Bool #

Is this a value-level (i.e., computationally relevant) Varentifier? Satisfies isId = not . isTyVar.

isCoVar :: Var -> Bool #

Is this a coercion variable? Satisfies isId v ==> isCoVar v == not (isNonCoVarId v).

isNonCoVarId :: Var -> Bool #

Is this a term variable (Var) that is not a coercion variable? Satisfies isId v ==> isCoVar v == not (isNonCoVarId v).

isLocalId :: Var -> Bool #

isLocalVar :: Var -> Bool #

isLocalVar returns True for type variables as well as local Vars These are the variables that we need to pay attention to when finding free variables, or doing dependency analysis.

isGlobalId :: Var -> Bool #

mustHaveLocalBinding :: Var -> Bool #

mustHaveLocalBinding returns True of Vars and Vars that must have a binding in this module. The converse is not quite right: there are some global Vars that must have bindings, such as record selectors. But that doesn't matter, because it's only used for assertions

isExportedId :: Var -> Bool #

isExportedIdVar means "don't throw this away"

chooseFunTyFlag :: HasDebugCallStack => Type -> Type -> FunTyFlag #

See GHC.Types.Var Note [FunTyFlag]

partitionInvisibleTypes :: TyCon -> [Type] -> ([Type], [Type]) #

Given a TyCon and a list of argument types, partition the arguments into:

Inferred or Specified (i.e., invisible) arguments and
Required (i.e., visible) arguments

getLevity :: HasDebugCallStack => Type -> Type #

Extract the PromDataConInfo of a type. For example, getLevity Int = Lifted, or getLevity (Array# Int) = Unlifted.

Panics if this is not possible. Does not look through type family applications.

getTyVar_maybe :: Type -> Maybe TyVar #

Attempts to obtain the type variable underlying a Type

tyConAppTyCon_maybe :: Type -> Maybe TyCon #

The same as fst . splitTyConApp We can short-cut the FunTy case

splitTyConApp_maybe :: HasDebugCallStack => Type -> Maybe (TyCon, [Type]) #

Attempts to tease a type apart into a type constructor and the application of a number of arguments to that constructor

isLiftedTypeKind :: Kind -> Bool #

Returns True if the argument is (lifted) Type or Constraint See Note [TYPE and CONSTRAINT] in GHC.Builtin.Types.Prim

isMultiplicityTy :: Type -> Bool #

Is this the type Multiplicity?

isLevityTy :: Type -> Bool #

Is this the type PromDataConInfo?

isRuntimeRepTy :: Type -> Bool #

Is this the type RuntimeRep?

coreView :: Type -> Maybe Type #

This function strips off the top layer only of a type synonym application (if any) its underlying representation type. Returns Nothing if there is nothing to look through.

This function does not look through type family applications.

By being non-recursive and inlined, this case analysis gets efficiently joined onto the case analysis that the caller is already doing

typeTypeOrConstraint :: HasDebugCallStack => Type -> TypeOrConstraint #

typeKind :: HasDebugCallStack => Type -> Kind #

piResultTy :: HasDebugCallStack => Type -> Type -> Type #

mkCoercionTy :: Coercion -> Type #

mkTyConApp :: TyCon -> [Type] -> Type #

A key function: builds a TyConApp or FunTy as appropriate to its arguments. Applies its arguments to the constructor from left to right.

mkCastTy :: Type -> Coercion -> Type #

Make a CastTy. The Coercion must be nominal. Checks the Coercion for reflexivity, dropping it if it's reflexive. See Note [Respecting definitional equality] in GHC.Core.TyCo.Rep

mkAppTy :: Type -> Type -> Type #

Applies a type to another, as in e.g. k a

isCoercionTy :: Type -> Bool #

isPredTy :: HasDebugCallStack => Type -> Bool #

emptyVarSet :: VarSet #

unitVarSet :: Var -> VarSet #

extendVarSet :: VarSet -> Var -> VarSet #

extendVarSetList :: VarSet -> [Var] -> VarSet #

intersectVarSet :: VarSet -> VarSet -> VarSet #

unionVarSet :: VarSet -> VarSet -> VarSet #

unionVarSets :: [VarSet] -> VarSet #

elemVarSet :: Var -> VarSet -> Bool #

minusVarSet :: VarSet -> VarSet -> VarSet #

delVarSet :: VarSet -> Var -> VarSet #

delVarSetList :: VarSet -> [Var] -> VarSet #

isEmptyVarSet :: VarSet -> Bool #

mkVarSet :: [Var] -> VarSet #

lookupVarSet_Directly :: VarSet -> Unique -> Maybe Var #

lookupVarSet :: VarSet -> Var -> Maybe Var #

lookupVarSetByName :: VarSet -> Name -> Maybe Var #

sizeVarSet :: VarSet -> Int #

filterVarSet :: (Var -> Bool) -> VarSet -> VarSet #

delVarSetByKey :: VarSet -> Unique -> VarSet #

elemVarSetByKey :: Unique -> VarSet -> Bool #

partitionVarSet :: (Var -> Bool) -> VarSet -> (VarSet, VarSet) #

mapUnionVarSet :: (a -> VarSet) -> [a] -> VarSet #

map the function over the list, and union the results

intersectsVarSet :: VarSet -> VarSet -> Bool #

disjointVarSet :: VarSet -> VarSet -> Bool #

subVarSet :: VarSet -> VarSet -> Bool #

anyVarSet :: (Var -> Bool) -> VarSet -> Bool #

allVarSet :: (Var -> Bool) -> VarSet -> Bool #

mapVarSet :: Uniquable b => (a -> b) -> UniqSet a -> UniqSet b #

nonDetStrictFoldVarSet :: (Var -> a -> a) -> a -> VarSet -> a #

fixVarSet :: (VarSet -> VarSet) -> VarSet -> VarSet #

transCloVarSet :: (VarSet -> VarSet) -> VarSet -> VarSet #

seqVarSet :: VarSet -> () #

pluralVarSet :: VarSet -> SDoc #

Determines the pluralisation suffix appropriate for the length of a set in the same way that plural from Outputable does for lists.

pprVarSet #

Arguments

:: VarSet	The things to be pretty printed
-> ([Var] -> SDoc)	The pretty printing function to use on the elements
-> SDoc	`SDoc` where the things have been pretty printed

Pretty-print a non-deterministic set. The order of variables is non-deterministic and for pretty-printing that shouldn't be a problem. Having this function helps contain the non-determinism created with nonDetEltsUFM. Passing a list to the pretty-printing function allows the caller to decide on the order of Vars (eg. toposort them) without them having to use nonDetEltsUFM at the call site. This prevents from let-binding non-deterministically ordered lists and reusing them where determinism matters.

emptyDVarSet :: DVarSet #

unitDVarSet :: Var -> DVarSet #

mkDVarSet :: [Var] -> DVarSet #

extendDVarSet :: DVarSet -> Var -> DVarSet #

elemDVarSet :: Var -> DVarSet -> Bool #

dVarSetElems :: DVarSet -> [Var] #

subDVarSet :: DVarSet -> DVarSet -> Bool #

unionDVarSet :: DVarSet -> DVarSet -> DVarSet #

unionDVarSets :: [DVarSet] -> DVarSet #

mapUnionDVarSet :: (a -> DVarSet) -> [a] -> DVarSet #

Map the function over the list, and union the results

intersectDVarSet :: DVarSet -> DVarSet -> DVarSet #

dVarSetIntersectVarSet :: DVarSet -> VarSet -> DVarSet #

disjointDVarSet :: DVarSet -> DVarSet -> Bool #

True if empty intersection

intersectsDVarSet :: DVarSet -> DVarSet -> Bool #

True if non-empty intersection

isEmptyDVarSet :: DVarSet -> Bool #

delDVarSet :: DVarSet -> Var -> DVarSet #

minusDVarSet :: DVarSet -> DVarSet -> DVarSet #

dVarSetMinusVarSet :: DVarSet -> VarSet -> DVarSet #

nonDetStrictFoldDVarSet :: (Var -> a -> a) -> a -> DVarSet -> a #

anyDVarSet :: (Var -> Bool) -> DVarSet -> Bool #

allDVarSet :: (Var -> Bool) -> DVarSet -> Bool #

mapDVarSet :: Uniquable b => (a -> b) -> UniqDSet a -> UniqDSet b #

filterDVarSet :: (Var -> Bool) -> DVarSet -> DVarSet #

sizeDVarSet :: DVarSet -> Int #

partitionDVarSet :: (Var -> Bool) -> DVarSet -> (DVarSet, DVarSet) #

Partition DVarSet according to the predicate given

delDVarSetList :: DVarSet -> [Var] -> DVarSet #

Delete a list of variables from DVarSet

seqDVarSet :: DVarSet -> () #

extendDVarSetList :: DVarSet -> [Var] -> DVarSet #

Add a list of variables to DVarSet

dVarSetToVarSet :: DVarSet -> VarSet #

Convert a DVarSet to a VarSet by forgetting the order of insertion

transCloDVarSet :: (DVarSet -> DVarSet) -> DVarSet -> DVarSet #

transCloVarSet for DVarSet

unitFV :: Name -> FreeVars #

delFV :: Name -> FreeVars -> FreeVars #

delFVs :: [Name] -> FreeVars -> FreeVars #

mkFVs :: [Name] -> FreeVars #

emptyInScopeSet :: InScopeSet #

getInScopeVars :: InScopeSet -> VarSet #

mkInScopeSet :: VarSet -> InScopeSet #

mkInScopeSetList :: [Var] -> InScopeSet #

extendInScopeSet :: InScopeSet -> Var -> InScopeSet #

extendInScopeSetList :: InScopeSet -> [Var] -> InScopeSet #

extendInScopeSetSet :: InScopeSet -> VarSet -> InScopeSet #

delInScopeSet :: InScopeSet -> Var -> InScopeSet #

elemInScopeSet :: Var -> InScopeSet -> Bool #

lookupInScope :: InScopeSet -> Var -> Maybe Var #

Look up a variable the InScopeSet. This lets you map from the variable's identity (unique) to its full value.

lookupInScope_Directly :: InScopeSet -> Unique -> Maybe Var #

unionInScope :: InScopeSet -> InScopeSet -> InScopeSet #

varSetInScope :: VarSet -> InScopeSet -> Bool #

uniqAway :: InScopeSet -> Var -> Var #

uniqAway in_scope v finds a unique that is not used in the in-scope set, and gives that to v. See Note [Local uniques] and Note [The InScopeSet invariant].

unsafeGetFreshLocalUnique :: InScopeSet -> Unique #

unsafeGetFreshUnique in_scope finds a unique that is not in-scope in the given InScopeSet. This must be used very carefully since one can very easily introduce non-unique Uniques this way. See Note [Local uniques].

mkRnEnv2 :: InScopeSet -> RnEnv2 #

extendRnInScopeSetList :: RnEnv2 -> [Var] -> RnEnv2 #

rnInScope :: Var -> RnEnv2 -> Bool #

rnInScopeSet :: RnEnv2 -> InScopeSet #

rnEnvL :: RnEnv2 -> VarEnv Var #

Retrieve the left mapping

rnEnvR :: RnEnv2 -> VarEnv Var #

Retrieve the right mapping

rnBndrs2 :: RnEnv2 -> [Var] -> [Var] -> RnEnv2 #

Applies rnBndr2 to several variables: the two variable lists must be of equal length

rnBndr2 :: RnEnv2 -> Var -> Var -> RnEnv2 #

rnBndr2 env bL bR goes under a binder bL in the Left term, and binder bR in the Right term. It finds a new binder, new_b, and returns an environment mapping bL -> new_b and bR -> new_b

rnBndr2_var :: RnEnv2 -> Var -> Var -> (RnEnv2, Var) #

Similar to rnBndr2 but returns the new variable as well as the new environment

rnBndrL :: RnEnv2 -> Var -> (RnEnv2, Var) #

Similar to rnBndr2 but used when there's a binder on the left side only.

rnBndrR :: RnEnv2 -> Var -> (RnEnv2, Var) #

Similar to rnBndr2 but used when there's a binder on the right side only.

rnEtaL :: RnEnv2 -> Var -> (RnEnv2, Var) #

Similar to rnBndrL but used for eta expansion See Note [Eta expansion]

rnEtaR :: RnEnv2 -> Var -> (RnEnv2, Var) #

Similar to rnBndr2 but used for eta expansion See Note [Eta expansion]

delBndrL :: RnEnv2 -> Var -> RnEnv2 #

delBndrR :: RnEnv2 -> Var -> RnEnv2 #

delBndrsL :: RnEnv2 -> [Var] -> RnEnv2 #

delBndrsR :: RnEnv2 -> [Var] -> RnEnv2 #

rnOccL :: RnEnv2 -> Var -> Var #

Look up the renaming of an occurrence in the left or right term

rnOccR :: RnEnv2 -> Var -> Var #

Look up the renaming of an occurrence in the left or right term

rnOccL_maybe :: RnEnv2 -> Var -> Maybe Var #

Look up the renaming of an occurrence in the left or right term

rnOccR_maybe :: RnEnv2 -> Var -> Maybe Var #

Look up the renaming of an occurrence in the left or right term

inRnEnvL :: RnEnv2 -> Var -> Bool #

Tells whether a variable is locally bound

inRnEnvR :: RnEnv2 -> Var -> Bool #

Tells whether a variable is locally bound

anyInRnEnvR :: RnEnv2 -> VarSet -> Bool #

`anyInRnEnvR env set` == `any (inRnEnvR rn_env) (toList set)` but lazy in the second argument if the right side of the env is empty.

lookupRnInScope :: RnEnv2 -> Var -> Var #

nukeRnEnvL :: RnEnv2 -> RnEnv2 #

Wipe the left or right side renaming

nukeRnEnvR :: RnEnv2 -> RnEnv2 #

Wipe the left or right side renaming

rnSwap :: RnEnv2 -> RnEnv2 #

swap the meaning of left and right

emptyTidyEnv :: TidyEnv #

mkEmptyTidyEnv :: TidyOccEnv -> TidyEnv #

delTidyEnvList :: TidyEnv -> [Var] -> TidyEnv #

elemVarEnv :: Var -> VarEnv a -> Bool #

elemVarEnvByKey :: Unique -> VarEnv a -> Bool #

disjointVarEnv :: VarEnv a -> VarEnv a -> Bool #

alterVarEnv :: (Maybe a -> Maybe a) -> VarEnv a -> Var -> VarEnv a #

extendVarEnv :: VarEnv a -> Var -> a -> VarEnv a #

extendVarEnv_C :: (a -> a -> a) -> VarEnv a -> Var -> a -> VarEnv a #

extendVarEnv_Acc :: (a -> b -> b) -> (a -> b) -> VarEnv b -> Var -> a -> VarEnv b #

extendVarEnvList :: VarEnv a -> [(Var, a)] -> VarEnv a #

plusVarEnv_C :: (a -> a -> a) -> VarEnv a -> VarEnv a -> VarEnv a #

plusVarEnv_CD :: (a -> a -> a) -> VarEnv a -> a -> VarEnv a -> a -> VarEnv a #

plusMaybeVarEnv_C :: (a -> a -> Maybe a) -> VarEnv a -> VarEnv a -> VarEnv a #

delVarEnvList :: VarEnv a -> [Var] -> VarEnv a #

delVarEnv :: VarEnv a -> Var -> VarEnv a #

minusVarEnv :: VarEnv a -> VarEnv b -> VarEnv a #

plusVarEnv :: VarEnv a -> VarEnv a -> VarEnv a #

plusVarEnvList :: [VarEnv a] -> VarEnv a #

lookupVarEnv :: VarEnv a -> Var -> Maybe a #

lookupVarEnv_Directly :: VarEnv a -> Unique -> Maybe a #

filterVarEnv :: (a -> Bool) -> VarEnv a -> VarEnv a #

anyVarEnv :: (elt -> Bool) -> UniqFM key elt -> Bool #

lookupWithDefaultVarEnv :: VarEnv a -> a -> Var -> a #

mapVarEnv :: (a -> b) -> VarEnv a -> VarEnv b #

mkVarEnv :: [(Var, a)] -> VarEnv a #

mkVarEnv_Directly :: [(Unique, a)] -> VarEnv a #

emptyVarEnv :: VarEnv a #

unitVarEnv :: Var -> a -> VarEnv a #

isEmptyVarEnv :: VarEnv a -> Bool #

partitionVarEnv :: (a -> Bool) -> VarEnv a -> (VarEnv a, VarEnv a) #

varEnvDomain :: VarEnv elt -> UnVarSet #

restrictVarEnv :: VarEnv a -> VarSet -> VarEnv a #

Only keep variables contained in the VarSet

zipVarEnv :: [Var] -> [a] -> VarEnv a #

lookupVarEnv_NF :: VarEnv a -> Var -> a #

modifyVarEnv :: (a -> a) -> VarEnv a -> Var -> VarEnv a #

modifyVarEnv_Directly :: (a -> a) -> UniqFM key a -> Unique -> UniqFM key a #

emptyDVarEnv :: DVarEnv a #

dVarEnvElts :: DVarEnv a -> [a] #

mkDVarEnv :: [(Var, a)] -> DVarEnv a #

extendDVarEnv :: DVarEnv a -> Var -> a -> DVarEnv a #

minusDVarEnv :: DVarEnv a -> DVarEnv a' -> DVarEnv a #

lookupDVarEnv :: DVarEnv a -> Var -> Maybe a #

foldDVarEnv :: (a -> b -> b) -> b -> DVarEnv a -> b #

nonDetStrictFoldDVarEnv :: (a -> b -> b) -> b -> DVarEnv a -> b #

mapDVarEnv :: (a -> b) -> DVarEnv a -> DVarEnv b #

filterDVarEnv :: (a -> Bool) -> DVarEnv a -> DVarEnv a #

alterDVarEnv :: (Maybe a -> Maybe a) -> DVarEnv a -> Var -> DVarEnv a #

plusDVarEnv :: DVarEnv a -> DVarEnv a -> DVarEnv a #

plusDVarEnv_C :: (a -> a -> a) -> DVarEnv a -> DVarEnv a -> DVarEnv a #

unitDVarEnv :: Var -> a -> DVarEnv a #

delDVarEnv :: DVarEnv a -> Var -> DVarEnv a #

delDVarEnvList :: DVarEnv a -> [Var] -> DVarEnv a #

isEmptyDVarEnv :: DVarEnv a -> Bool #

elemDVarEnv :: Var -> DVarEnv a -> Bool #

extendDVarEnv_C :: (a -> a -> a) -> DVarEnv a -> Var -> a -> DVarEnv a #

modifyDVarEnv :: (a -> a) -> DVarEnv a -> Var -> DVarEnv a #

partitionDVarEnv :: (a -> Bool) -> DVarEnv a -> (DVarEnv a, DVarEnv a) #

extendDVarEnvList :: DVarEnv a -> [(Var, a)] -> DVarEnv a #

anyDVarEnv :: (a -> Bool) -> DVarEnv a -> Bool #

isEmptyNameSet :: NameSet -> Bool #

emptyNameSet :: NameSet #

unitNameSet :: Name -> NameSet #

mkNameSet :: [Name] -> NameSet #

extendNameSetList :: NameSet -> [Name] -> NameSet #

extendNameSet :: NameSet -> Name -> NameSet #

unionNameSet :: NameSet -> NameSet -> NameSet #

unionNameSets :: [NameSet] -> NameSet #

minusNameSet :: NameSet -> NameSet -> NameSet #

elemNameSet :: Name -> NameSet -> Bool #

delFromNameSet :: NameSet -> Name -> NameSet #

filterNameSet :: (Name -> Bool) -> NameSet -> NameSet #

intersectNameSet :: NameSet -> NameSet -> NameSet #

disjointNameSet :: NameSet -> NameSet -> Bool #

True if there is a non-empty intersection. s1 intersectsNameSet s2 doesn't compute s2 if s1 is empty

delListFromNameSet :: NameSet -> [Name] -> NameSet #

intersectsNameSet :: NameSet -> NameSet -> Bool #

nameSetAny :: (Name -> Bool) -> NameSet -> Bool #

nameSetAll :: (Name -> Bool) -> NameSet -> Bool #

nameSetElemsStable :: NameSet -> [Name] #

Get the elements of a NameSet with some stable ordering. This only works for Names that originate in the source code or have been tidied. See Note [Deterministic UniqFM] to learn about nondeterminism

isEmptyFVs :: NameSet -> Bool #

emptyFVs :: FreeVars #

plusFVs :: [FreeVars] -> FreeVars #

plusFV :: FreeVars -> FreeVars -> FreeVars #

addOneFV :: FreeVars -> Name -> FreeVars #

intersectFVs :: FreeVars -> FreeVars -> FreeVars #

emptyDUs :: DefUses #

usesOnly :: Uses -> DefUses #

mkDUs :: [(Defs, Uses)] -> DefUses #

plusDU :: DefUses -> DefUses -> DefUses #

duDefs :: DefUses -> Defs #

allUses :: DefUses -> Uses #

Just like duUses, but Defs are not eliminated from the Uses returned

duUses :: DefUses -> Uses #

Collect all Uses, regardless of whether the group is itself used, but remove Defs on the way

findUses :: DefUses -> Uses -> Uses #

Given some DefUses and some Uses, find all the uses, transitively. The result is a superset of the input Uses; and includes things defined in the input DefUses (but only if they are used)

depAnal :: (node -> [Name]) -> (node -> [Name]) -> [node] -> [SCC node] #

nonDetNameEnvElts :: NameEnv a -> [a] #

emptyNameEnv :: NameEnv a #

isEmptyNameEnv :: NameEnv a -> Bool #

unitNameEnv :: Name -> a -> NameEnv a #

extendNameEnv :: NameEnv a -> Name -> a -> NameEnv a #

extendNameEnvList :: NameEnv a -> [(Name, a)] -> NameEnv a #

lookupNameEnv :: NameEnv a -> Name -> Maybe a #

alterNameEnv :: (Maybe a -> Maybe a) -> NameEnv a -> Name -> NameEnv a #

mkNameEnv :: [(Name, a)] -> NameEnv a #

mkNameEnvWith :: (a -> Name) -> [a] -> NameEnv a #

elemNameEnv :: Name -> NameEnv a -> Bool #

plusNameEnv :: NameEnv a -> NameEnv a -> NameEnv a #

plusNameEnv_C :: (a -> a -> a) -> NameEnv a -> NameEnv a -> NameEnv a #

plusNameEnv_CD :: (a -> a -> a) -> NameEnv a -> a -> NameEnv a -> a -> NameEnv a #

plusNameEnv_CD2 :: (Maybe a -> Maybe a -> a) -> NameEnv a -> NameEnv a -> NameEnv a #

extendNameEnv_C :: (a -> a -> a) -> NameEnv a -> Name -> a -> NameEnv a #

mapNameEnv :: (elt1 -> elt2) -> NameEnv elt1 -> NameEnv elt2 #

extendNameEnv_Acc :: (a -> b -> b) -> (a -> b) -> NameEnv b -> Name -> a -> NameEnv b #

extendNameEnvList_C :: (a -> a -> a) -> NameEnv a -> [(Name, a)] -> NameEnv a #

delFromNameEnv :: NameEnv a -> Name -> NameEnv a #

delListFromNameEnv :: NameEnv a -> [Name] -> NameEnv a #

filterNameEnv :: (elt -> Bool) -> NameEnv elt -> NameEnv elt #

mapMaybeNameEnv :: (a -> Maybe b) -> NameEnv a -> NameEnv b #

anyNameEnv :: (elt -> Bool) -> NameEnv elt -> Bool #

disjointNameEnv :: NameEnv a -> NameEnv a -> Bool #

seqEltsNameEnv :: (elt -> ()) -> NameEnv elt -> () #

lookupNameEnv_NF :: NameEnv a -> Name -> a #

emptyDNameEnv :: DNameEnv a #

isEmptyDNameEnv :: DNameEnv a -> Bool #

lookupDNameEnv :: DNameEnv a -> Name -> Maybe a #

delFromDNameEnv :: DNameEnv a -> Name -> DNameEnv a #

filterDNameEnv :: (a -> Bool) -> DNameEnv a -> DNameEnv a #

mapDNameEnv :: (a -> b) -> DNameEnv a -> DNameEnv b #

adjustDNameEnv :: (a -> a) -> DNameEnv a -> Name -> DNameEnv a #

alterDNameEnv :: (Maybe a -> Maybe a) -> DNameEnv a -> Name -> DNameEnv a #

extendDNameEnv :: DNameEnv a -> Name -> a -> DNameEnv a #

extendDNameEnv_C :: (a -> a -> a) -> DNameEnv a -> Name -> a -> DNameEnv a #

eltsDNameEnv :: DNameEnv a -> [a] #

foldDNameEnv :: (a -> b -> b) -> b -> DNameEnv a -> b #

plusDNameEnv_C :: (elt -> elt -> elt) -> DNameEnv elt -> DNameEnv elt -> DNameEnv elt #

nonDetStrictFoldDNameEnv :: (a -> b -> b) -> b -> DNameEnv a -> b #

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 #

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 #

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

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.

greQualModName :: GlobalRdrElt -> ModuleName #

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 #

emptyGlobalRdrEnv :: GlobalRdrEnv #

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 #

Look for precisely this Name in the environment. This tests whether it is in scope, ignoring anything else that might be in scope with the same OccName.

lookupGRE_GreName :: GlobalRdrEnv -> GreName -> Maybe GlobalRdrElt #

Look for precisely this GreName in the environment. This tests whether it is in scope, ignoring anything else that might be in scope with the same OccName.

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

plusGlobalRdrEnv :: GlobalRdrEnv -> GlobalRdrEnv -> GlobalRdrEnv #

mkGlobalRdrEnv :: [GlobalRdrElt] -> GlobalRdrEnv #

transformGREs :: (GlobalRdrElt -> GlobalRdrElt) -> [OccName] -> GlobalRdrEnv -> GlobalRdrEnv #

Apply a transformation function to the GREs for these OccNames

extendGlobalRdrEnv :: GlobalRdrEnv -> GlobalRdrElt -> GlobalRdrEnv #

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 #

importSpecModule :: ImportSpec -> ModuleName #

isExplicitItem :: ImpItemSpec -> Bool #

pprNameProvenance :: GlobalRdrElt -> SDoc #

Print out one place where the name was define/imported (With -dppr-debug, print them all)

opIsAt :: RdrName -> Bool #

Indicate if the given name is the "@" operator

realSrcSpan :: SrcSpan -> RealSrcSpan #

noSrcSpanA :: SrcAnn ann #

noAnn :: EpAnn a #

Short form for EpAnnNotUsed

pprIfPs :: forall (p :: Pass). IsPass p => (p ~ 'Parsed => SDoc) -> SDoc #

pprIfRn :: forall (p :: Pass). IsPass p => (p ~ 'Renamed => SDoc) -> SDoc #

pprIfTc :: forall (p :: Pass). IsPass p => (p ~ 'Typechecked => SDoc) -> SDoc #

noHsTok :: forall (tok :: Symbol). GenLocated TokenLocation (HsToken tok) #

noHsUniTok :: forall (tok :: Symbol) (utok :: Symbol). GenLocated TokenLocation (HsUniToken tok utok) #

listTyConKey :: Unique #

nilDataConKey :: Unique #

emptyAnnEnv :: AnnEnv #

An empty annotation environment.

mkAnnEnv :: [Annotation] -> AnnEnv #

Construct a new annotation environment that contains the list of annotations provided.

extendAnnEnvList :: AnnEnv -> [Annotation] -> AnnEnv #

Add the given annotation to the environment.

plusAnnEnv :: AnnEnv -> AnnEnv -> AnnEnv #

Union two annotation environments.

findAnns :: Typeable a => ([Word8] -> a) -> AnnEnv -> CoreAnnTarget -> [a] #

Find the annotations attached to the given target as Typeable values of your choice. If no deserializer is specified, only transient annotations will be returned.

findAnnsByTypeRep :: AnnEnv -> CoreAnnTarget -> TypeRep -> [[Word8]] #

Find the annotations attached to the given target as Typeable values of your choice. If no deserializer is specified, only transient annotations will be returned.

deserializeAnns :: Typeable a => ([Word8] -> a) -> AnnEnv -> (ModuleEnv [a], NameEnv [a]) #

Deserialize all annotations of a given type. This happens lazily, that is no deserialization will take place until the [a] is actually demanded and the [a] can also be empty (the UniqFM is not filtered).

sProgramName :: Settings -> String #

sProjectVersion :: Settings -> String #

sGhcUsagePath :: Settings -> FilePath #

sGhciUsagePath :: Settings -> FilePath #

sToolDir :: Settings -> Maybe FilePath #

sTopDir :: Settings -> FilePath #

sGlobalPackageDatabasePath :: Settings -> FilePath #

sLdSupportsCompactUnwind :: Settings -> Bool #

sLdSupportsFilelist :: Settings -> Bool #

sLdIsGnuLd :: Settings -> Bool #

sGccSupportsNoPie :: Settings -> Bool #

sPgm_L :: Settings -> String #

sPgm_P :: Settings -> (String, [Option]) #

sPgm_F :: Settings -> String #

sPgm_c :: Settings -> String #

sPgm_cxx :: Settings -> String #

sPgm_a :: Settings -> (String, [Option]) #

sPgm_l :: Settings -> (String, [Option]) #

sPgm_lm :: Settings -> Maybe (String, [Option]) #

sPgm_dll :: Settings -> (String, [Option]) #

sPgm_T :: Settings -> String #

sPgm_windres :: Settings -> String #

sPgm_ar :: Settings -> String #

sPgm_ranlib :: Settings -> String #

sPgm_lo :: Settings -> (String, [Option]) #

sPgm_lc :: Settings -> (String, [Option]) #

sPgm_lcc :: Settings -> (String, [Option]) #

sPgm_i :: Settings -> String #

sOpt_L :: Settings -> [String] #

sOpt_P :: Settings -> [String] #

sOpt_P_fingerprint :: Settings -> Fingerprint #

sOpt_F :: Settings -> [String] #

sOpt_c :: Settings -> [String] #

sOpt_cxx :: Settings -> [String] #

sOpt_a :: Settings -> [String] #

sOpt_l :: Settings -> [String] #

sOpt_lm :: Settings -> [String] #

sOpt_windres :: Settings -> [String] #

sOpt_lo :: Settings -> [String] #

sOpt_lc :: Settings -> [String] #

sOpt_lcc :: Settings -> [String] #

sOpt_i :: Settings -> [String] #

sExtraGccViaCFlags :: Settings -> [String] #

sTargetPlatformString :: Settings -> String #

sGhcWithInterpreter :: Settings -> Bool #

sLibFFI :: Settings -> Bool #

mkUnitKeyInfo :: DbUnitInfo -> UnitKeyInfo #

Convert a DbUnitInfo (read from a package database) into UnitKeyInfo

mapUnitInfo :: IsUnitId v => (u -> v) -> GenUnitInfo u -> GenUnitInfo v #

Map over the unit parameter

unitPackageIdString :: GenUnitInfo u -> String #

unitPackageNameString :: GenUnitInfo u -> String #

pprUnitInfo :: UnitInfo -> SDoc #

mkUnit :: UnitInfo -> Unit #

Make a Unit from a UnitInfo

If the unit is definite, make a RealUnit from unitId field.

If the unit is indefinite, make a VirtUnit from unitInstanceOf and unitInstantiations fields. Note that in this case we don't keep track of unitId. It can be retrieved later with "improvement", i.e. matching on `unitInstanceOf/unitInstantiations` fields (see Note [About units] in GHC.Unit).

mkUnitPprInfo :: (u -> FastString) -> GenUnitInfo u -> UnitPprInfo #

Create a UnitPprInfo from a UnitInfo

collectIncludeDirs :: [UnitInfo] -> [FilePath] #

Find all the include directories in the given units

collectExtraCcOpts :: [UnitInfo] -> [String] #

Find all the C-compiler options in the given units

collectLibraryDirs :: Ways -> [UnitInfo] -> [FilePath] #

Find all the library directories in the given units for the given ways

collectFrameworks :: [UnitInfo] -> [String] #

Find all the frameworks in the given units

collectFrameworksDirs :: [UnitInfo] -> [String] #

Find all the package framework paths in these and the preload packages

unitHsLibs :: GhcNameVersion -> Ways -> UnitInfo -> [String] #

topNormaliseNewType_maybe :: Type -> Maybe (Coercion, Type) #

Sometimes we want to look through a newtype and get its associated coercion. This function strips off newtype layers enough to reveal something that isn't a newtype. Specifically, here's the invariant:

topNormaliseNewType_maybe rec_nts ty = Just (co, ty')

then (a) co : ty ~R ty'. (b) ty' is not a newtype.

The function returns Nothing for non-newtypes, or unsaturated applications

This function does *not* look through type families, because it has no access to the type family environment. If you do have that at hand, consider to use topNormaliseType_maybe, which should be a drop-in replacement for topNormaliseNewType_maybe If topNormliseNewType_maybe ty = Just (co, ty'), then co : ty ~R ty'

coercionType :: Coercion -> Type #

coercionRKind :: Coercion -> Type #

coercionLKind :: Coercion -> Type #

coercionKind :: Coercion -> Pair Type #

If it is the case that

c :: (t1 ~ t2)

i.e. the kind of c relates t1 and t2, then coercionKind c = Pair t1 t2.

seqCo :: Coercion -> () #

liftCoSubst :: HasDebugCallStack => Role -> LiftingContext -> Type -> Coercion #

liftCoSubst role lc ty produces a coercion (at role role) that coerces between lc_left(ty) and lc_right(ty), where lc_left is a substitution mapping type variables to the left-hand types of the mapped coercions in lc, and similar for lc_right.

mkCoercionType :: Role -> Type -> Type -> Type #

Makes a coercion type from two types: the types whose equality is proven by the relevant Coercion

coVarRole :: CoVar -> Role #

coVarKindsTypesRole :: HasDebugCallStack => CoVar -> (Kind, Kind, Type, Type, Role) #

decomposePiCos :: HasDebugCallStack => CoercionN -> Pair Type -> [Type] -> ([CoercionN], CoercionN) #

isReflexiveCo :: Coercion -> Bool #

Slowly checks if the coercion is reflexive. Don't call this in a loop, as it walks over the entire coercion.

isReflCo :: Coercion -> Bool #

Tests if this coercion is obviously reflexive. Guaranteed to work very quickly. Sometimes a coercion can be reflexive, but not obviously so. c.f. isReflexiveCo

isGReflCo :: Coercion -> Bool #

Tests if this coercion is obviously a generalized reflexive coercion. Guaranteed to work very quickly.

mkAxiomRuleCo :: CoAxiomRule -> [Coercion] -> Coercion #

mkProofIrrelCo #

Arguments

:: Role	role of the created coercion, "r"
-> CoercionN	:: phi1 ~N phi2
-> Coercion	g1 :: phi1
-> Coercion	g2 :: phi2
-> Coercion	:: g1 ~r g2

Make a "coercion between coercions".

mkSubCo :: HasDebugCallStack => Coercion -> Coercion #

mkKindCo :: Coercion -> Coercion #

Given co :: (a :: k) ~ (b :: k') produce co' :: k ~ k'.

mkNomReflCo :: Type -> Coercion #

Make a nominal reflexive coercion

mkGReflCo :: Role -> Type -> MCoercionN -> Coercion #

Make a generalized reflexive coercion

mkInstCo :: Coercion -> CoercionN -> Coercion #

Instantiates a Coercion.

mkLRCo :: LeftOrRight -> Coercion -> Coercion #

mkSelCo :: HasDebugCallStack => CoSel -> Coercion -> Coercion #

mkTransCo :: Coercion -> Coercion -> Coercion #

Create a new Coercion by composing the two given Coercions transitively. (co1 ; co2)

mkSymCo :: Coercion -> Coercion #

Create a symmetric version of the given Coercion that asserts equality between the same types but in the other "direction", so a kind of t1 ~ t2 becomes the kind t2 ~ t1.

mkUnivCo #

Arguments

:: UnivCoProvenance
-> Role	role of the built coercion, "r"
-> Type	t1 :: k1
-> Type	t2 :: k2
-> Coercion	:: t1 ~r t2

Make a universal coercion between two arbitrary types.

mkPhantomCo :: Coercion -> Type -> Type -> Coercion #

Make a phantom coercion between two types. The coercion passed in must be a nominal coercion between the kinds of the types.

mkAxiomInstCo :: CoAxiom Branched -> BranchIndex -> [Coercion] -> Coercion #

mkCoVarCo :: CoVar -> Coercion #

mkFunCo2 :: HasDebugCallStack => Role -> FunTyFlag -> FunTyFlag -> CoercionN -> Coercion -> Coercion -> Coercion #

mkNakedFunCo1 :: Role -> FunTyFlag -> CoercionN -> Coercion -> Coercion -> Coercion #

mkFunCo1 :: HasDebugCallStack => Role -> FunTyFlag -> CoercionN -> Coercion -> Coercion -> Coercion #

Build a function Coercion from two other Coercions. That is, given co1 :: a ~ b and co2 :: x ~ y produce co :: (a -> x) ~ (b -> y) or (a => x) ~ (b => y), depending on the kind of a/b. This (most common) version takes a single FunTyFlag, which is used for both fco_afl and ftf_afr of the FunCo

mkForAllCo :: TyCoVar -> CoercionN -> Coercion -> Coercion #

Make a Coercion from a tycovar, a kind coercion, and a body coercion. The kind of the tycovar should be the left-hand kind of the kind coercion. See Note [Unused coercion variable in ForAllCo]

mkAppCo #

Arguments

:: Coercion	:: t1 ~r t2
-> Coercion	:: s1 ~N s2, where s1 :: k1, s2 :: k2
-> Coercion	:: t1 s1 ~r t2 s2

Apply a Coercion to another Coercion. The second coercion must be Nominal, unless the first is Phantom. If the first is Phantom, then the second can be either Phantom or Nominal.

mkTyConAppCo :: HasDebugCallStack => Role -> TyCon -> [Coercion] -> Coercion #

Apply a type constructor to a list of coercions. It is the caller's responsibility to get the roles correct on argument coercions.

mkReflCo :: Role -> Type -> Coercion #

Make a reflexive coercion

algTcFields :: TyConDetails -> FieldLabelEnv #

Maps a label to information about the field

mkAnonTyConBinder :: TyVar -> TyConBinder #

mkAnonTyConBinders :: [TyVar] -> [TyConBinder] #

mkInvisAnonTyConBinder :: TyVar -> TyConBinder #

mkNamedTyConBinder :: ForAllTyFlag -> TyVar -> TyConBinder #

mkNamedTyConBinders :: ForAllTyFlag -> [TyVar] -> [TyConBinder] #

mkRequiredTyConBinder :: TyCoVarSet -> TyVar -> TyConBinder #

Make a Required TyConBinder. It chooses between NamedTCB and AnonTCB based on whether the tv is mentioned in the dependent set

tyConBinderForAllTyFlag :: TyConBinder -> ForAllTyFlag #

tyConBndrVisForAllTyFlag :: TyConBndrVis -> ForAllTyFlag #

isNamedTyConBinder :: TyConBinder -> Bool #

isVisibleTyConBinder :: VarBndr tv TyConBndrVis -> Bool #

isVisibleTcbVis :: TyConBndrVis -> Bool #

isInvisibleTyConBinder :: VarBndr tv TyConBndrVis -> Bool #

mkTyConKind :: [TyConBinder] -> Kind -> Kind #

tyConInvisTVBinders :: [TyConBinder] -> [InvisTVBinder] #

tyConVisibleTyVars :: TyCon -> [TyVar] #

mkLevPolyDataTyConRhs #

Arguments

:: Bool	whether the `DataCon` has a fixed levity
-> Bool	True if this is a "type data" declaration See Note [Type data declarations] in GHC.Rename.Module
-> [DataCon]
-> AlgTyConRhs

Create an AlgTyConRhs from the data constructors, for a potentially levity-polymorphic datatype (with UnliftedDatatypes).

mkDataTyConRhs :: [DataCon] -> AlgTyConRhs #

Create an AlgTyConRhs from the data constructors.

Use mkLevPolyDataConRhs if the datatype can be levity-polymorphic or if it comes from a "data type" declaration

visibleDataCons :: AlgTyConRhs -> [DataCon] #

Extract those DataCons that we are able to learn about. Note that visibility in this sense does not correspond to visibility in the context of any particular user program!

isNoParent :: AlgTyConFlav -> Bool #

tyConRepModOcc :: Module -> OccName -> (Module, OccName) #

The name (and defining module) for the Typeable representation (TyCon) of a type constructor.

See Note [Grand plan for Typeable] in GHC.Tc.Instance.Typeable.

isVoidRep :: PrimRep -> Bool #

isGcPtrRep :: PrimRep -> Bool #

primRepCompatible :: Platform -> PrimRep -> PrimRep -> Bool #

primRepsCompatible :: Platform -> [PrimRep] -> [PrimRep] -> Bool #

primRepSizeB :: Platform -> PrimRep -> Int #

The size of a PrimRep in bytes.

This applies also when used in a constructor, where we allow packing the fields. For instance, in data Foo = Foo Float# Float# the two fields will take only 8 bytes, which for 64-bit arch will be equal to 1 word. See also mkVirtHeapOffsetsWithPadding for details of how data fields are laid out.

primElemRepSizeB :: Platform -> PrimElemRep -> Int #

primElemRepToPrimRep :: PrimElemRep -> PrimRep #

primRepIsFloat :: PrimRep -> Maybe Bool #

Return if Rep stands for floating type, returns Nothing for vector types.

primRepIsWord :: PrimRep -> Bool #

primRepIsInt :: PrimRep -> Bool #

tyConFieldLabels :: TyCon -> [FieldLabel] #

The labels for the fields of this particular TyCon

lookupTyConFieldLabel :: FieldLabelString -> TyCon -> Maybe FieldLabel #

Look up a field label belonging to this TyCon

mkAlgTyCon #

Arguments

:: Name
-> [TyConBinder]	Binders of the `TyCon`
-> Kind	Result kind
-> [Role]	The roles for each TyVar
-> Maybe CType	The C type this type corresponds to when using the CAPI FFI
-> [PredType]	Stupid theta: see `algTcStupidTheta`
-> AlgTyConRhs	Information about data constructors
-> AlgTyConFlav	What flavour is it? (e.g. vanilla, type family)
-> Bool	Was the `TyCon` declared with GADT syntax?
-> TyCon

This is the making of an algebraic TyCon.

mkClassTyCon :: Name -> [TyConBinder] -> [Role] -> AlgTyConRhs -> Class -> Name -> TyCon #

Simpler specialization of mkAlgTyCon for classes

mkTupleTyCon #

Arguments

:: Name
-> [TyConBinder]
-> Kind	Result kind of the `TyCon`
-> DataCon
-> TupleSort	Whether the tuple is boxed or unboxed
-> AlgTyConFlav
-> TyCon

mkSumTyCon #

Arguments

:: Name
-> [TyConBinder]
-> Kind	Kind of the resulting `TyCon`
-> [DataCon]
-> AlgTyConFlav
-> TyCon

mkTcTyCon #

Arguments

:: Name
-> [TyConBinder]
-> Kind	result kind only
-> [(Name, TcTyVar)]	Scoped type variables; see Note [How TcTyCons work] in GHC.Tc.TyCl
-> Bool	Is this TcTyCon generalised already?
-> TyConFlavour	What sort of `TyCon` this represents
-> TyCon

Makes a tycon suitable for use during type-checking. It stores a variety of details about the definition of the TyCon, but no right-hand side. It lives only during the type-checking of a mutually-recursive group of tycons; it is then zonked to a proper TyCon in zonkTcTyCon. See also Note [Kind checking recursive type and class declarations] in GHC.Tc.TyCl.

noTcTyConScopedTyVars :: [(Name, TcTyVar)] #

No scoped type variables (to be used with mkTcTyCon).

mkPrimTyCon #

Arguments

:: Name
-> [TyConBinder]
-> Kind	result kind Must answer `True` to `isFixedRuntimeRepKind` (i.e., no representation polymorphism). (If you need a representation-polymorphic PrimTyCon, change tcHasFixedRuntimeRep, marshalablePrimTyCon, reifyTyCon for PrimTyCons.)
-> [Role]
-> TyCon

Create an primitive TyCon, such as Int#, Type or RealWorld# Primitive TyCons are marshalable iff not lifted. If you'd like to change this, modify marshalablePrimTyCon.

mkSynonymTyCon #

Arguments

:: Name
-> [TyConBinder]
-> Kind	result kind
-> [Role]
-> Type
-> Bool
-> Bool
-> Bool
-> TyCon

Create a type synonym TyCon

mkFamilyTyCon #

Arguments

:: Name
-> [TyConBinder]
-> Kind	result kind
-> Maybe Name
-> FamTyConFlav
-> Maybe Class
-> Injectivity
-> TyCon

Create a type family TyCon

mkPromotedDataCon :: DataCon -> Name -> TyConRepName -> [TyConPiTyBinder] -> Kind -> [Role] -> PromDataConInfo -> TyCon #

Create a promoted data constructor TyCon Somewhat dodgily, we give it the same Name as the data constructor itself; when we pretty-print the TyCon we add a quote; see the Outputable TyCon instance

isAbstractTyCon :: TyCon -> Bool #

Test if the TyCon is algebraic but abstract (invisible data constructors)

isPrimTyCon :: TyCon -> Bool #

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

isAlgTyCon :: TyCon -> Bool #

Returns True if the supplied TyCon resulted from either a data or newtype declaration

isVanillaAlgTyCon :: TyCon -> Bool #

Returns True for vanilla AlgTyCons -- that is, those created with a data or newtype declaration.

isDataTyCon :: TyCon -> Bool #

Returns True for data types that are definitely represented by heap-allocated constructors. These are scrutinised by Core-level case expressions, and they get info tables allocated for them.

Generally, the function will be true for all data types and false for newtypes, unboxed tuples, unboxed sums and type family TyCons. But it is not guaranteed to return True in all cases that it could.

NB: for a data type family, only the instance TyCons get an info table. The family declaration TyCon does not

isTypeDataTyCon :: TyCon -> Bool #

Was this TyCon declared as "type data"? See Note [Type data declarations] in GHC.Rename.Module.

isInjectiveTyCon :: TyCon -> Role -> Bool #

isInjectiveTyCon is true of TyCons for which this property holds (where r is the role passed in): If (T a1 b1 c1) ~r (T a2 b2 c2), then (a1 ~r1 a2), (b1 ~r2 b2), and (c1 ~r3 c2) (where r1, r2, and r3, are the roles given by tyConRolesX tc r) See also Note [Decomposing TyConApp equalities] in GHC.Tc.Solver.Canonical

isGenerativeTyCon :: TyCon -> Role -> Bool #

isGenerativeTyCon is true of TyCons for which this property holds (where r is the role passed in): If (T tys ~r t), then (t's head ~r T). See also Note [Decomposing TyConApp equalities] in GHC.Tc.Solver.Canonical

isGenInjAlgRhs :: AlgTyConRhs -> Bool #

Is this an AlgTyConRhs of a TyCon that is generative and injective with respect to representational equality?

isNewTyCon :: TyCon -> Bool #

Is this TyCon that for a newtype

unwrapNewTyCon_maybe :: TyCon -> Maybe ([TyVar], Type, CoAxiom Unbranched) #

Take a TyCon apart into the TyVars it scopes over, the Type it expands into, and (possibly) a coercion from the representation type to the newtype. Returns Nothing if this is not possible.

unwrapNewTyConEtad_maybe :: TyCon -> Maybe ([TyVar], Type, CoAxiom Unbranched) #

isTypeSynonymTyCon :: TyCon -> Bool #

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

isTauTyCon :: TyCon -> Bool #

isFamFreeTyCon :: TyCon -> Bool #

Is this tycon neither a type family nor a synonym that expands to a type family?

isForgetfulSynTyCon :: TyCon -> Bool #

Is this a forgetful type synonym? If this is a type synonym whose RHS does not mention one (or more) of its bound variables, returns True. Thus, False means that all bound variables appear on the RHS; True may not mean anything, as the test to set this flag is conservative.

tyConMustBeSaturated :: TyCon -> Bool #

True iff we can decompose (T a b c) into ((T a b) c) I.e. is it injective and generative w.r.t nominal equality? That is, if (T a b) ~N d e f, is it always the case that (T ~N d), (a ~N e) and (b ~N f)? Specifically NOT true of synonyms (open and otherwise)

It'd be unusual to call tyConMustBeSaturated on a regular H98 type synonym, because you should probably have expanded it first But regardless, it's not decomposable

isGadtSyntaxTyCon :: TyCon -> Bool #

Is this an algebraic TyCon declared with the GADT syntax?

isEnumerationTyCon :: TyCon -> Bool #

Is this an algebraic TyCon which is just an enumeration of values?

isFamilyTyCon :: TyCon -> Bool #

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

isOpenFamilyTyCon :: TyCon -> Bool #

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

isTypeFamilyTyCon :: TyCon -> Bool #

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

isDataFamilyTyCon :: TyCon -> Bool #

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

isOpenTypeFamilyTyCon :: TyCon -> Bool #

Is this an open type family TyCon?

isClosedSynFamilyTyConWithAxiom_maybe :: TyCon -> Maybe (CoAxiom Branched) #

Is this a non-empty closed type family? Returns Nothing for abstract or empty closed families.

isBuiltInSynFamTyCon_maybe :: TyCon -> Maybe BuiltInSynFamily #

tyConFamilyResVar_maybe :: TyCon -> Maybe Name #

Extract type variable naming the result of injective type family

tyConInjectivityInfo :: TyCon -> Injectivity #

tyConInjectivityInfo tc returns Injective is if tc is an injective tycon (where is states for which tyConBinders tc is injective), or NotInjective otherwise.

isTyConAssoc :: TyCon -> Bool #

Is this TyCon for an associated type?

tyConAssoc_maybe :: TyCon -> Maybe TyCon #

Get the enclosing class TyCon (if there is one) for the given TyCon.

tyConFlavourAssoc_maybe :: TyConFlavour -> Maybe TyCon #

Get the enclosing class TyCon (if there is one) for the given TyConFlavour

tyConTuple_maybe :: TyCon -> Maybe TupleSort #

isBoxedTupleTyCon :: TyCon -> Bool #

Is this the TyCon for a boxed tuple?

isUnboxedSumTyCon :: TyCon -> Bool #

Is this the TyCon for an unboxed sum?

isLiftedAlgTyCon :: TyCon -> Bool #

isPromotedDataCon_maybe :: TyCon -> Maybe DataCon #

Retrieves the promoted DataCon if this is a PromotedDataCon;

isPromotedTupleTyCon :: TyCon -> Bool #

Is this the TyCon for a promoted tuple?

isPromotedDataCon :: TyCon -> Bool #

Is this a PromotedDataCon?

isDataKindsPromotedDataCon :: TyCon -> Bool #

This function identifies PromotedDataCon's from data constructors in `data T = K1 | K2`, promoted by -XDataKinds. These type constructors are printed with a tick mark 'K1 and 'K2, and similarly have a tick mark added to their OccName's.

In contrast, constructors in `type data T = K1 | K2` are printed and represented with their original undecorated names. See Note [Type data declarations] in GHC.Rename.Module

isKindTyCon :: TyCon -> Bool #

Is this tycon really meant for use at the kind level? That is, should it be permitted without -XDataKinds?

isLiftedTypeKindTyConName :: Name -> Bool #

isImplicitTyCon :: TyCon -> Bool #

Identifies implicit tycons that, in particular, do not go into interface files (because they are implicitly reconstructed when the interface is read).

Note that:

Associated families are implicit, as they are re-constructed from the class declaration in which they reside, and
Family instances are not implicit as they represent the instance body (similar to a dfun does that for a class instance).
Tuples are implicit iff they have a wired-in name (namely: boxed and unboxed tuples are wired-in and implicit, but constraint tuples are not)

tyConCType_maybe :: TyCon -> Maybe CType #

tcHasFixedRuntimeRep :: TyCon -> Bool #

Does this TyCon have a syntactically fixed RuntimeRep when fully applied, as per Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete?

False is safe. True means we're sure. Does only a quick check, based on the TyCon's category.

See Note [Representation-polymorphic TyCons]

isConcreteTyCon :: TyCon -> Bool #

Is this TyCon concrete (i.e. not a synonym/type family)?

Used for representation polymorphism checks.

isTcTyCon :: TyCon -> Bool #

Is this a TcTyCon? (That is, one only used during type-checking?)

setTcTyConKind :: TyCon -> Kind -> TyCon #

isMonoTcTyCon :: TyCon -> Bool #

tcTyConScopedTyVars :: TyCon -> [(Name, TcTyVar)] #

expandSynTyCon_maybe #

Arguments

:: TyCon
-> [tyco]	Arguments to `TyCon`
-> ExpandSynResult tyco	Returns a `TyVar` substitution, the body type of the synonym (not yet substituted) and any arguments remaining from the application ^ Expand a type synonym application Return Nothing if the TyCon is not a synonym, or if not enough arguments are supplied

isTyConWithSrcDataCons :: TyCon -> Bool #

Check if the tycon actually refers to a proper `data` or `newtype` with user defined constructors rather than one from a class or other construction.

tyConDataCons :: TyCon -> [DataCon] #

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

tyConDataCons_maybe :: TyCon -> Maybe [DataCon] #

Determine the DataCons originating from the given TyCon, if the TyCon is the sort that can have any constructors (note: this does not include abstract algebraic types)

tyConSingleDataCon_maybe :: TyCon -> Maybe DataCon #

If the given TyCon has a single data constructor, i.e. it is a data type with one alternative, a tuple type or a newtype then that constructor is returned. If the TyCon has more than one constructor, or represents a primitive or function type constructor then Nothing is returned.

tyConSingleDataCon :: TyCon -> DataCon #

Like tyConSingleDataCon_maybe, but panics if Nothing.

tyConSingleAlgDataCon_maybe :: TyCon -> Maybe DataCon #

Like tyConSingleDataCon_maybe, but returns Nothing for newtypes.

tyConAlgDataCons_maybe :: TyCon -> Maybe [DataCon] #

Returns Just dcs if the given TyCon is a data type, a tuple type or a sum type with data constructors dcs. If the TyCon has more than one constructor, or represents a primitive or function type constructor then Nothing is returned.

Like tyConDataCons_maybe, but returns Nothing for newtypes.

tyConFamilySize :: TyCon -> Int #

Determine the number of value constructors a TyCon has. Panics if the TyCon is not algebraic or a tuple

algTyConRhs :: TyCon -> AlgTyConRhs #

Extract an AlgTyConRhs with information about data constructors from an algebraic or tuple TyCon. Panics for any other sort of TyCon

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

Extract the bound type variables and type expansion of a type synonym TyCon. Panics if the TyCon is not a synonym

newTyConEtadArity :: TyCon -> Int #

The number of type parameters that need to be passed to a newtype to resolve it. May be less than in the definition if it can be eta-contracted.

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

Extract the bound type variables and type expansion of an eta-contracted type synonym TyCon. Panics if the TyCon is not a synonym

newTyConCo_maybe :: TyCon -> Maybe (CoAxiom Unbranched) #

Extracts the newtype coercion from such a TyCon, which can be used to construct something with the newtypes type from its representation type (right hand side). If the supplied TyCon is not a newtype, returns Nothing

newTyConCo :: TyCon -> CoAxiom Unbranched #

newTyConDataCon_maybe :: TyCon -> Maybe DataCon #

tyConStupidTheta :: TyCon -> [PredType] #

Find the "stupid theta" of the TyCon. A "stupid theta" is the context to the left of an algebraic type declaration, e.g. Eq a in the declaration data Eq a => T a .... See Note [The stupid context] in GHC.Core.DataCon.

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

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

synTyConRhs_maybe :: TyCon -> Maybe Type #

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

famTyConFlav_maybe :: TyCon -> Maybe FamTyConFlav #

Extract the flavour of a type family (with all the extra information that it carries)

isClassTyCon :: TyCon -> Bool #

Is this TyCon that for a class instance?

tyConClass_maybe :: TyCon -> Maybe Class #

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

tyConATs :: TyCon -> [TyCon] #

Return the associated types of the TyCon, if any

isFamInstTyCon :: TyCon -> Bool #

Is this TyCon that for a data family instance?

tyConFamInstSig_maybe :: TyCon -> Maybe (TyCon, [Type], CoAxiom Unbranched) #

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

If this TyCon is that of a data family instance, return the family in question and the instance types. Otherwise, return Nothing

tyConFamilyCoercion_maybe :: TyCon -> Maybe (CoAxiom Unbranched) #

If this TyCon is that of a data family instance, return a TyCon which represents a coercion identifying the representation type with the type instance family. Otherwise, return Nothing

tyConPromDataConInfo :: TyCon -> PromDataConInfo #

Extract any RuntimeRepInfo from this TyCon

mkTyConTagMap :: TyCon -> NameEnv ConTag #

tyConFlavour :: TyCon -> TyConFlavour #

tcFlavourIsOpen :: TyConFlavour -> Bool #

Is this flavour of TyCon an open type family or a data family?

pprPromotionQuote :: TyCon -> SDoc #

tyConSkolem :: TyCon -> Bool #

Returns whether or not this TyCon is definite, or a hole that may be filled in at some later point. See Note [Skolem abstract data]

mkTyVarTy :: TyVar -> Type #

mkTyVarTys :: [TyVar] -> [Type] #

mkInvisFunTy :: HasDebugCallStack => Type -> Type -> Type infixr 3 #

mkInvisFunTys :: HasDebugCallStack => [Type] -> Type -> Type #

tcMkVisFunTy :: Mult -> Type -> Type -> Type #

tcMkInvisFunTy :: TypeOrConstraint -> Type -> Type -> Type #

mkVisFunTy :: HasDebugCallStack => Mult -> Type -> Type -> Type #

mkVisFunTyMany :: HasDebugCallStack => Type -> Type -> Type infixr 3 #

Make nested arrow types | Special, common, case: Arrow type with mult Many

mkVisFunTysMany :: [Type] -> Type -> Type #

mkScaledFunTys :: HasDebugCallStack => [Scaled Type] -> Type -> Type #

tcMkScaledFunTys :: [Scaled Type] -> Type -> Type #

mkForAllTys :: [ForAllTyBinder] -> Type -> Type #

Wraps foralls over the type using the provided TyCoVars from left to right

mkInvisForAllTys :: [InvisTVBinder] -> Type -> Type #

Wraps foralls over the type using the provided InvisTVBinders from left to right

mkPiTy :: PiTyBinder -> Type -> Type #

mkPiTys :: [PiTyBinder] -> Type -> Type #

coHoleCoVar :: CoercionHole -> CoVar #

setCoHoleCoVar :: CoercionHole -> CoVar -> CoercionHole #

foldTyCo :: Monoid a => TyCoFolder env a -> env -> (Type -> a, [Type] -> a, Coercion -> a, [Coercion] -> a) #

noView :: Type -> Maybe Type #

A view function that looks through nothing.

typeSize :: Type -> Int #

coercionSize :: Coercion -> Int #

funTyFlagTyCon :: FunTyFlag -> TyCon #

tYPETyCon :: TyCon #

tYPETyConName :: Name #

tYPEKind :: Type #

cONSTRAINTTyCon :: TyCon #

cONSTRAINTTyConName :: Name #

cONSTRAINTKind :: Type #

tyCoVarsOfType :: Type -> TyCoVarSet #

tyCoVarsOfTypes :: [Type] -> TyCoVarSet #

tyCoVarsOfCo :: Coercion -> TyCoVarSet #

tyCoVarsOfCos :: [Coercion] -> TyCoVarSet #

coVarsOfType :: Type -> CoVarSet #

coVarsOfTypes :: [Type] -> CoVarSet #

coVarsOfCo :: Coercion -> CoVarSet #

closeOverKinds :: TyCoVarSet -> TyCoVarSet #

closeOverKindsList :: [TyVar] -> [TyVar] #

Add the kind variables free in the kinds of the tyvars in the given set. Returns a deterministically ordered list.

closeOverKindsDSet :: DTyVarSet -> DTyVarSet #

Add the kind variables free in the kinds of the tyvars in the given set. Returns a deterministic set.

tyCoVarsOfTypeDSet :: Type -> DTyCoVarSet #

tyCoFVsOfType that returns free variables of a type in a deterministic set. For explanation of why using VarSet is not deterministic see Note [Deterministic FV] in GHC.Utils.FV.

tyCoFVsOfType :: Type -> FV #

The worker for tyCoFVsOfType and tyCoFVsOfTypeList. The previous implementation used unionVarSet which is O(n+m) and can make the function quadratic. It's exported, so that it can be composed with other functions that compute free variables. See Note [FV naming conventions] in GHC.Utils.FV.

Eta-expanded because that makes it run faster (apparently) See Note [FV eta expansion] in GHC.Utils.FV for explanation.

tyCoFVsBndr :: ForAllTyBinder -> FV -> FV #

tyCoFVsVarBndrs :: [Var] -> FV -> FV #

tyCoFVsVarBndr :: Var -> FV -> FV #

tyCoVarsOfCoDSet :: Coercion -> DTyCoVarSet #

Get a deterministic set of the vars free in a coercion

tyCoFVsOfCo :: Coercion -> FV #

tyCoFVsOfCos :: [Coercion] -> FV #

anyFreeVarsOfType :: (TyCoVar -> Bool) -> Type -> Bool #

anyFreeVarsOfTypes :: (TyCoVar -> Bool) -> [Type] -> Bool #

anyFreeVarsOfCo :: (TyCoVar -> Bool) -> Coercion -> Bool #

scopedSort :: [TyCoVar] -> [TyCoVar] #

Do a topological sort on a list of tyvars, so that binders occur before occurrences E.g. given [ a::k, k::*, b::k ] it'll return a well-scoped list [ k::*, a::k, b::k ]

This is a deterministic sorting operation (that is, doesn't depend on Uniques).

It is also meant to be stable: that is, variables should not be reordered unnecessarily. This is specified in Note [ScopedSort] See also Note [Ordering of implicit variables] in GHC.Rename.HsType

tyCoVarsOfTypeWellScoped :: Type -> [TyVar] #

Get the free vars of a type in scoped order

tyCoVarsOfTypesWellScoped :: [Type] -> [TyVar] #

Get the free vars of types in scoped order

tyConsOfType :: Type -> UniqSet TyCon #

All type constructors occurring in the type; looking through type synonyms, but not newtypes. When it finds a Class, it returns the class TyCon.

occCheckExpand :: [Var] -> Type -> Maybe Type #

emptyTvSubstEnv :: TvSubstEnv #

emptyCvSubstEnv :: CvSubstEnv #

composeTCvSubst :: Subst -> Subst -> Subst #

Composes two substitutions, applying the second one provided first, like in function composition. This function leaves IdSubstEnv untouched because IdSubstEnv is not used during substitution for types.

emptySubst :: Subst #

mkEmptySubst :: InScopeSet -> Subst #

isEmptySubst :: Subst -> Bool #

isEmptyTCvSubst :: Subst -> Bool #

Checks whether the tyvar and covar environments are empty. This function should be used over isEmptySubst when substituting for types, because types currently do not contain expressions; we can safely disregard the expression environment when deciding whether to skip a substitution. Using isEmptyTCvSubst gives us a non-trivial performance boost (up to 70% less allocation for T18223)

mkSubst :: InScopeSet -> TvSubstEnv -> CvSubstEnv -> IdSubstEnv -> Subst #

getTvSubstEnv :: Subst -> TvSubstEnv #

getCvSubstEnv :: Subst -> CvSubstEnv #

getSubstInScope :: Subst -> InScopeSet #

Find the in-scope set: see Note [The substitution invariant]

setInScope :: Subst -> InScopeSet -> Subst #

getSubstRangeTyCoFVs :: Subst -> VarSet #

Returns the free variables of the types in the range of a substitution as a non-deterministic set.

isInScope :: Var -> Subst -> Bool #

notElemSubst :: Var -> Subst -> Bool #

zapSubst :: Subst -> Subst #

Remove all substitutions that might have been built up while preserving the in-scope set originally called zapSubstEnv

extendSubstInScope :: Subst -> Var -> Subst #

Add the Var to the in-scope set

extendSubstInScopeList :: Subst -> [Var] -> Subst #

Add the Vars to the in-scope set: see also extendInScope

extendSubstInScopeSet :: Subst -> VarSet -> Subst #

Add the Vars to the in-scope set: see also extendInScope

extendTCvSubst :: Subst -> TyCoVar -> Type -> Subst #

extendTCvSubstWithClone :: Subst -> TyCoVar -> TyCoVar -> Subst #

extendTvSubst :: Subst -> TyVar -> Type -> Subst #

Add a substitution for a TyVar to the Subst The TyVar *must* be a real TyVar, and not a CoVar You must ensure that the in-scope set is such that Note [The substitution invariant] holds after extending the substitution like this.

extendTvSubstBinderAndInScope :: Subst -> PiTyBinder -> Type -> Subst #

extendTvSubstWithClone :: Subst -> TyVar -> TyVar -> Subst #

extendCvSubst :: Subst -> CoVar -> Coercion -> Subst #

Add a substitution from a CoVar to a Coercion to the Subst: you must ensure that the in-scope set satisfies Note [The substitution invariant] after extending the substitution like this

extendTvSubstAndInScope :: Subst -> TyVar -> Type -> Subst #

extendTvSubstList :: Subst -> [(TyVar, Type)] -> Subst #

Adds multiple TyVar substitutions to the Subst: see also extendTvSubst

extendTCvSubstList :: Subst -> [Var] -> [Type] -> Subst #

unionSubst :: Subst -> Subst -> Subst #

zipTvSubst :: HasDebugCallStack => [TyVar] -> [Type] -> Subst #

Generates the in-scope set for the Subst from the types in the incoming environment. No CoVars or Ids, please!

zipTCvSubst :: HasDebugCallStack => [TyCoVar] -> [Type] -> Subst #

mkTvSubstPrs :: [(TyVar, Type)] -> Subst #

Generates the in-scope set for the TCvSubst from the types in the incoming environment. No CoVars, please! The InScopeSet is just a thunk so with a bit of luck it'll never be evaluated

zipTyEnv :: HasDebugCallStack => [TyVar] -> [Type] -> TvSubstEnv #

The InScopeSet is just a thunk so with a bit of luck it'll never be evaluated

zipCoEnv :: HasDebugCallStack => [CoVar] -> [Coercion] -> CvSubstEnv #

substTyWith :: HasDebugCallStack => [TyVar] -> [Type] -> Type -> Type #

Type substitution, see zipTvSubst

substTyWithUnchecked :: [TyVar] -> [Type] -> Type -> Type #

Type substitution, see zipTvSubst. Disables sanity checks. The problems that the sanity checks in substTy catch are described in Note [The substitution invariant]. The goal of #11371 is to migrate all the calls of substTyUnchecked to substTy and remove this function. Please don't use in new code.

substCoWith :: HasDebugCallStack => [TyVar] -> [Type] -> Coercion -> Coercion #

Coercion substitution, see zipTvSubst

substCoWithUnchecked :: [TyVar] -> [Type] -> Coercion -> Coercion #

Coercion substitution, see zipTvSubst. Disables sanity checks. The problems that the sanity checks in substCo catch are described in Note [The substitution invariant]. The goal of #11371 is to migrate all the calls of substCoUnchecked to substCo and remove this function. Please don't use in new code.

substTysWith :: [TyVar] -> [Type] -> [Type] -> [Type] #

Type substitution, see zipTvSubst

substTyAddInScope :: Subst -> Type -> Type #

Substitute within a Type after adding the free variables of the type to the in-scope set. This is useful for the case when the free variables aren't already in the in-scope set or easily available. See also Note [The substitution invariant].

substTyUnchecked :: Subst -> Type -> Type #

Substitute within a Type disabling the sanity checks. The problems that the sanity checks in substTy catch are described in Note [The substitution invariant]. The goal of #11371 is to migrate all the calls of substTyUnchecked to substTy and remove this function. Please don't use in new code.

substScaledTy :: HasDebugCallStack => Subst -> Scaled Type -> Scaled Type #

substScaledTyUnchecked :: HasDebugCallStack => Subst -> Scaled Type -> Scaled Type #

substTys :: HasDebugCallStack => Subst -> [Type] -> [Type] #

Substitute within several Types The substitution has to satisfy the invariants described in Note [The substitution invariant].

substScaledTys :: HasDebugCallStack => Subst -> [Scaled Type] -> [Scaled Type] #

substTysUnchecked :: Subst -> [Type] -> [Type] #

Substitute within several Types disabling the sanity checks. The problems that the sanity checks in substTys catch are described in Note [The substitution invariant]. The goal of #11371 is to migrate all the calls of substTysUnchecked to substTys and remove this function. Please don't use in new code.

substScaledTysUnchecked :: Subst -> [Scaled Type] -> [Scaled Type] #

substTheta :: HasDebugCallStack => Subst -> ThetaType -> ThetaType #

Substitute within a ThetaType The substitution has to satisfy the invariants described in Note [The substitution invariant].

substThetaUnchecked :: Subst -> ThetaType -> ThetaType #

Substitute within a ThetaType disabling the sanity checks. The problems that the sanity checks in substTys catch are described in Note [The substitution invariant]. The goal of #11371 is to migrate all the calls of substThetaUnchecked to substTheta and remove this function. Please don't use in new code.

substTyVar :: Subst -> TyVar -> Type #

substTyVarToTyVar :: HasDebugCallStack => Subst -> TyVar -> TyVar #

substTyVars :: Subst -> [TyVar] -> [Type] #

lookupTyVar :: Subst -> TyVar -> Maybe Type #

substCo :: HasDebugCallStack => Subst -> Coercion -> Coercion #

Substitute within a Coercion The substitution has to satisfy the invariants described in Note [The substitution invariant].

substCoUnchecked :: Subst -> Coercion -> Coercion #

Substitute within a Coercion disabling sanity checks. The problems that the sanity checks in substCo catch are described in Note [The substitution invariant]. The goal of #11371 is to migrate all the calls of substCoUnchecked to substCo and remove this function. Please don't use in new code.

substCos :: HasDebugCallStack => Subst -> [Coercion] -> [Coercion] #

Substitute within several Coercions The substitution has to satisfy the invariants described in Note [The substitution invariant].

substCoVar :: Subst -> CoVar -> Coercion #

substCoVars :: Subst -> [CoVar] -> [Coercion] #

lookupCoVar :: Subst -> Var -> Maybe Coercion #

substTyVarBndr :: HasDebugCallStack => Subst -> TyVar -> (Subst, TyVar) #

substTyVarBndrs :: HasDebugCallStack => Subst -> [TyVar] -> (Subst, [TyVar]) #

substVarBndr :: HasDebugCallStack => Subst -> TyCoVar -> (Subst, TyCoVar) #

substVarBndrs :: HasDebugCallStack => Subst -> [TyCoVar] -> (Subst, [TyCoVar]) #

substCoVarBndr :: HasDebugCallStack => Subst -> CoVar -> (Subst, CoVar) #

cloneTyVarBndr :: Subst -> TyVar -> Unique -> (Subst, TyVar) #

cloneTyVarBndrs :: Subst -> [TyVar] -> UniqSupply -> (Subst, [TyVar]) #

substTyCoBndr :: Subst -> PiTyBinder -> (Subst, PiTyBinder) #

tidyVarBndrs :: TidyEnv -> [TyCoVar] -> (TidyEnv, [TyCoVar]) #

This tidies up a type for printing in an error message, or in an interface file.

It doesn't change the uniques at all, just the print names.

tidyVarBndr :: TidyEnv -> TyCoVar -> (TidyEnv, TyCoVar) #

tidyForAllTyBinder :: TidyEnv -> VarBndr TyCoVar vis -> (TidyEnv, VarBndr TyCoVar vis) #

tidyForAllTyBinders :: TidyEnv -> [VarBndr TyCoVar vis] -> (TidyEnv, [VarBndr TyCoVar vis]) #

tidyFreeTyCoVars :: TidyEnv -> [TyCoVar] -> TidyEnv #

Add the free TyVars to the env in tidy form, so that we can tidy the type they are free in

tidyOpenTyCoVars :: TidyEnv -> [TyCoVar] -> (TidyEnv, [TyCoVar]) #

tidyOpenTyCoVar :: TidyEnv -> TyCoVar -> (TidyEnv, TyCoVar) #

Treat a new TyCoVar as a binder, and give it a fresh tidy name using the environment if one has not already been allocated. See also tidyVarBndr

tidyTyCoVarOcc :: TidyEnv -> TyCoVar -> TyCoVar #

tidyTypes :: TidyEnv -> [Type] -> [Type] #

Tidy a list of Types

See Note [Strictness in tidyType and friends]

tidyType :: TidyEnv -> Type -> Type #

Tidy a Type

See Note [Strictness in tidyType and friends]

tidyOpenTypes :: TidyEnv -> [Type] -> (TidyEnv, [Type]) #

Grabs the free type variables, tidies them and then uses tidyType to work over the type itself

tidyOpenType :: TidyEnv -> Type -> (TidyEnv, Type) #

tidyTopType :: Type -> Type #

Calls tidyType on a top-level type (i.e. with an empty tidying environment)

tidyCo :: TidyEnv -> Coercion -> Coercion #

Tidy a Coercion

See Note [Strictness in tidyType and friends]

tidyCos :: TidyEnv -> [Coercion] -> [Coercion] #

kindRep :: HasDebugCallStack => Kind -> RuntimeRepType #

Extract the RuntimeRep classifier of a type from its kind. For example, kindRep * = LiftedRep; Panics if this is not possible. Treats * and Constraint as the same

kindRep_maybe :: HasDebugCallStack => Kind -> Maybe RuntimeRepType #

Given a kind (TYPE rr) or (CONSTRAINT rr), extract its RuntimeRep classifier rr. For example, kindRep_maybe * = Just LiftedRep Returns Nothing if the kind is not of form (TYPE rr)

isUnliftedTypeKind :: Kind -> Bool #

Returns True if the kind classifies unlifted types (like 'Int#') and False otherwise. Note that this returns False for representation-polymorphic kinds, which may be specialized to a kind that classifies unlifted types.

pickyIsLiftedTypeKind :: Kind -> Bool #

kindBoxedRepLevity_maybe :: Type -> Maybe Levity #

Check whether a kind is of the form `TYPE (BoxedRep Lifted)` or `TYPE (BoxedRep Unlifted)`.

Returns:

`Just Lifted` for `TYPE (BoxedRep Lifted)` and Type,
`Just Unlifted` for `TYPE (BoxedRep Unlifted)` and UnliftedType,
Nothing for anything else, e.g. `TYPE IntRep`, `TYPE (BoxedRep l)`, etc.

isLiftedRuntimeRep :: RuntimeRepType -> Bool #

Check whether a type of kind RuntimeRep is lifted.

isLiftedRuntimeRep is:

True of LiftedRep :: RuntimeRep
False of type variables, type family applications, and of other reps such as IntRep :: RuntimeRep.

isUnliftedRuntimeRep :: RuntimeRepType -> Bool #

Check whether a type of kind RuntimeRep is unlifted.

True of definitely unlifted RuntimeReps such as UnliftedRep, IntRep, FloatRep, ...
False of LiftedRep,
False for type variables and type family applications.

isLiftedLevity :: Type -> Bool #

isUnliftedLevity :: Type -> Bool #

isRuntimeRepVar :: TyVar -> Bool #

Is a tyvar of type RuntimeRep?

isLevityVar :: TyVar -> Bool #

Is a tyvar of type PromDataConInfo?

isMultiplicityVar :: TyVar -> Bool #

Is a tyvar of type Multiplicity?

splitRuntimeRep_maybe :: RuntimeRepType -> Maybe (TyCon, [Type]) #

(splitRuntimeRep_maybe rr) takes a Type rr :: RuntimeRep, and returns the (TyCon,[Type]) for the RuntimeRep, if possible, where the TyCon is one of the promoted DataCons of RuntimeRep. Remember: the unique on TyCon that is a a promoted DataCon is the same as the unique on the DataCon See Note [Promoted data constructors] in GHC.Core.TyCon May not be possible if rr is a type variable or type family application

isBoxedRuntimeRep :: RuntimeRepType -> Bool #

See isBoxedRuntimeRep_maybe.

runtimeRepLevity_maybe :: RuntimeRepType -> Maybe Levity #

Check whether a type of kind RuntimeRep is lifted, unlifted, or unknown.

`isLiftedRuntimeRep rr` returns:

`Just Lifted` if rr is `LiftedRep :: RuntimeRep`
`Just Unlifted` if rr is definitely unlifted, e.g. IntRep
Nothing if not known (e.g. it's a type variable or a type family application).

levityType_maybe :: LevityType -> Maybe Levity #

levity_maybe takes a Type of kind Levity, and returns its levity May not be possible for a type variable or type family application

mapTyCo :: Monad m => TyCoMapper () m -> (Type -> m Type, [Type] -> m [Type], Coercion -> m Coercion, [Coercion] -> m [Coercion]) #

mapTyCoX :: Monad m => TyCoMapper env m -> (env -> Type -> m Type, env -> [Type] -> m [Type], env -> Coercion -> m Coercion, env -> [Coercion] -> m [Coercion]) #

getTyVar :: HasDebugCallStack => Type -> TyVar #

Attempts to obtain the type variable underlying a Type, and panics with the given message if this is not a type variable type. See also getTyVar_maybe

repGetTyVar_maybe :: Type -> Maybe TyVar #

Attempts to obtain the type variable underlying a Type, without any expansion

isTyVarTy :: Type -> Bool #

getCastedTyVar_maybe :: Type -> Maybe (TyVar, CoercionN) #

If the type is a tyvar, possibly under a cast, returns it, along with the coercion. Thus, the co is :: kind tv ~N kind ty

mkAppTys :: Type -> [Type] -> Type #

splitAppTy_maybe :: Type -> Maybe (Type, Type) #

Attempt to take a type application apart, whether it is a function, type constructor, or plain type application. Note that type family applications are NEVER unsaturated by this!

splitAppTy :: Type -> (Type, Type) #

Attempts to take a type application apart, as in splitAppTy_maybe, and panics if this is not possible

splitAppTyNoView_maybe :: HasDebugCallStack => Type -> Maybe (Type, Type) #

Does the AppTy split as in splitAppTy_maybe, but assumes that any coreView stuff is already done

tcSplitAppTyNoView_maybe :: Type -> Maybe (Type, Type) #

Just like splitAppTyNoView_maybe, but does not split (c => t) See Note [Decomposing fat arrow c=>t]

splitAppTys :: Type -> (Type, [Type]) #

Recursively splits a type as far as is possible, leaving a residual type being applied to and the type arguments applied to it. Never fails, even if that means returning an empty list of type applications.

splitAppTysNoView :: HasDebugCallStack => Type -> (Type, [Type]) #

Like splitAppTys, but doesn't look through type synonyms

mkNumLitTy :: Integer -> Type #

isNumLitTy :: Type -> Maybe Integer #

Is this a numeric literal. We also look through type synonyms.

mkStrLitTy :: FastString -> Type #

isStrLitTy :: Type -> Maybe FastString #

Is this a symbol literal. We also look through type synonyms.

mkCharLitTy :: Char -> Type #

isCharLitTy :: Type -> Maybe Char #

Is this a char literal? We also look through type synonyms.

isLitTy :: Type -> Maybe TyLit #

Is this a type literal (symbol, numeric, or char)?

userTypeError_maybe :: Type -> Maybe Type #

Is this type a custom user error? If so, give us the kind and the error message.

pprUserTypeErrorTy :: Type -> SDoc #

Render a type corresponding to a user type error into a SDoc.

funTyConAppTy_maybe :: FunTyFlag -> Type -> Type -> Type -> Maybe (TyCon, [Type]) #

Given the components of a FunTy figure out the corresponding TyConApp.

tyConAppFunTy_maybe :: HasDebugCallStack => TyCon -> [Type] -> Maybe Type #

Return Just if this TyConApp should be represented as a FunTy

tyConAppFunCo_maybe :: HasDebugCallStack => Role -> TyCon -> [Coercion] -> Maybe Coercion #

Return Just if this TyConAppCo should be represented as a FunCo

mkFunctionType :: HasDebugCallStack => Mult -> Type -> Type -> Type #

This one works out the FunTyFlag from the argument type See GHC.Types.Var Note [FunTyFlag]

mkScaledFunctionTys :: [Scaled Type] -> Type -> Type #

Like mkFunctionType, compute the FunTyFlag from the arguments

splitFunTy :: Type -> (Mult, Type, Type) #

Attempts to extract the multiplicity, argument and result types from a type, and panics if that is not possible. See also splitFunTy_maybe

splitFunTy_maybe :: Type -> Maybe (FunTyFlag, Mult, Type, Type) #

Attempts to extract the multiplicity, argument and result types from a type

splitFunTys :: Type -> ([Scaled Type], Type) #

funArgTy :: Type -> Type #

Just like piResultTys but for a single argument Try not to iterate piResultTy, because it's inefficient to substitute one variable at a time; instead use 'piResultTys"

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

piResultTys :: HasDebugCallStack => Type -> [Type] -> Type #

(piResultTys f_ty [ty1, .., tyn]) gives the type of (f ty1 .. tyn) where f :: f_ty piResultTys is interesting because: 1. f_ty may have more for-alls than there are args 2. Less obviously, it may have fewer for-alls For case 2. think of: piResultTys (forall a.a) [forall b.b, Int] This really can happen, but only (I think) in situations involving undefined. For example: undefined :: forall a. a Term: undefined (forall b. b->b) Int This term should have type (Int -> Int), but notice that there are more type args than foralls in undefineds type.

applyTysX :: HasDebugCallStack => [TyVar] -> Type -> [Type] -> Type #

tyConAppTyConPicky_maybe :: Type -> Maybe TyCon #

Retrieve the tycon heading this type, if there is one. Does not look through synonyms.

tyConAppTyCon :: HasDebugCallStack => Type -> TyCon #

tyConAppArgs_maybe :: Type -> Maybe [Type] #

The same as snd . splitTyConApp

tyConAppArgs :: HasCallStack => Type -> [Type] #

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

tcSplitTyConApp_maybe :: HasCallStack => Type -> Maybe (TyCon, [Type]) #

tcSplitTyConApp_maybe splits a type constructor application into its type constructor and applied types.

Differs from splitTyConApp_maybe in that it does *not* split types headed with (=>), as that's not a TyCon in the type-checker.

Note that this may fail (in funTyConAppTy_maybe) in the case of a FunTy with an argument of unknown kind FunTy (e.g. `FunTy (a :: k) Int`, since the kind of a isn't of the form `TYPE rep`. This isn't usually a problem but may be temporarily the cas during canonicalization: see Note [Decomposing FunTy] in GHC.Tc.Solver.Canonical and Note [The Purely Kinded Type Invariant (PKTI)] in GHC.Tc.Gen.HsType, Wrinkle around FunTy

Consequently, you may need to zonk your type before using this function.

tcSplitTyConApp :: Type -> (TyCon, [Type]) #

newTyConInstRhs :: TyCon -> [Type] -> Type #

Unwrap one layer of newtype on a type constructor and its arguments, using an eta-reduced version of the newtype if possible. This requires tys to have at least newTyConInstArity tycon elements.

splitCastTy_maybe :: Type -> Maybe (Type, Coercion) #

isCoercionTy_maybe :: Type -> Maybe Coercion #

stripCoercionTy :: Type -> Coercion #

tyConBindersPiTyBinders :: [TyConBinder] -> [PiTyBinder] #

mkTyCoInvForAllTy :: TyCoVar -> Type -> Type #

Make a dependent forall over an Inferred variable

mkInfForAllTy :: TyVar -> Type -> Type #

Like mkTyCoInvForAllTy, but tv should be a tyvar

mkTyCoInvForAllTys :: [TyCoVar] -> Type -> Type #

Like mkForAllTys, but assumes all variables are dependent and Inferred, a common case

mkInfForAllTys :: [TyVar] -> Type -> Type #

Like mkTyCoInvForAllTys, but tvs should be a list of tyvar

mkSpecForAllTy :: TyVar -> Type -> Type #

Like mkForAllTy, but assumes the variable is dependent and Specified, a common case

mkSpecForAllTys :: [TyVar] -> Type -> Type #

Like mkForAllTys, but assumes all variables are dependent and Specified, a common case

mkVisForAllTys :: [TyVar] -> Type -> Type #

Like mkForAllTys, but assumes all variables are dependent and visible

mkTyConBindersPreferAnon #

Arguments

:: [TyVar]	binders
-> TyCoVarSet	free variables of result
-> [TyConBinder]

Given a list of type-level vars and the free vars of a result kind, makes PiTyBinders, preferring anonymous binders if the variable is, in fact, not dependent. e.g. mkTyConBindersPreferAnon (k:*),(b:k),(c:k) We want (k:*) Named, (b:k) Anon, (c:k) Anon

All non-coercion binders are visible.

splitForAllForAllTyBinders :: Type -> ([ForAllTyBinder], Type) #

Take a ForAllTy apart, returning the binders and result type

splitForAllTyCoVars :: Type -> ([TyCoVar], Type) #

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

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

Like splitForAllTyCoVars, but split only for tyvars. This always succeeds, even if it returns only an empty list. Note that the result type returned may have free variables that were bound by a forall.

splitForAllReqTyBinders :: Type -> ([ReqTyBinder], Type) #

Like splitForAllTyCoVars, but only splits ForAllTys with Required type variable binders. Furthermore, each returned tyvar is annotated with ().

splitForAllInvisTyBinders :: Type -> ([InvisTyBinder], Type) #

Like splitForAllTyCoVars, but only splits ForAllTys with Invisible type variable binders. Furthermore, each returned tyvar is annotated with its Specificity.

isForAllTy :: Type -> Bool #

Checks whether this is a proper forall (with a named binder)

isForAllTy_ty :: Type -> Bool #

Like isForAllTy, but returns True only if it is a tyvar binder

isForAllTy_co :: Type -> Bool #

Like isForAllTy, but returns True only if it is a covar binder

isPiTy :: Type -> Bool #

Is this a function or forall?

isFunTy :: Type -> Bool #

Is this a function?

splitForAllTyCoVar :: Type -> (TyCoVar, Type) #

Take a forall type apart, or panics if that is not possible.

dropForAlls :: Type -> Type #

Drops all ForAllTys

splitForAllTyCoVar_maybe :: Type -> Maybe (TyCoVar, Type) #

Attempts to take a forall type apart, but only if it's a proper forall, with a named binder

splitForAllTyVar_maybe :: Type -> Maybe (TyVar, Type) #

Like splitForAllTyCoVar_maybe, but only returns Just if it is a tyvar binder.

splitForAllCoVar_maybe :: Type -> Maybe (CoVar, Type) #

Like splitForAllTyCoVar_maybe, but only returns Just if it is a covar binder.

splitPiTy_maybe :: Type -> Maybe (PiTyBinder, Type) #

Attempts to take a forall type apart; works with proper foralls and functions

splitPiTy :: Type -> (PiTyBinder, Type) #

Takes a forall type apart, or panics

splitPiTys :: Type -> ([PiTyBinder], Type) #

Split off all PiTyBinders to a type, splitting both proper foralls and functions

getRuntimeArgTys :: Type -> [(Scaled Type, FunTyFlag)] #

Extracts a list of run-time arguments from a function type, looking through newtypes to the right of arrows.

Examples:

   newtype Identity a = I a

   getRuntimeArgTys (Int -> Bool -> Double) == [(Int, FTF_T_T), (Bool, FTF_T_T)]
   getRuntimeArgTys (Identity Int -> Bool -> Double) == [(Identity Int, FTF_T_T), (Bool, FTF_T_T)]
   getRuntimeArgTys (Int -> Identity (Bool -> Identity Double)) == [(Int, FTF_T_T), (Bool, FTF_T_T)]
   getRuntimeArgTys (forall a. Show a => Identity a -> a -> Int -> Bool)
            == [(Show a, FTF_C_T), (Identity a, FTF_T_T),(a, FTF_T_T),(Int, FTF_T_T)]

Note that, in the last case, the returned types might mention an out-of-scope type variable. This function is used only when we really care about the kinds of the returned types, so this is OK.

*Warning**: this function can return an infinite list. For example:

  newtype N a = MkN (a -> N a)
  getRuntimeArgTys (N a) == repeat (a, FTF_T_T)

invisibleTyBndrCount :: Type -> Int #

splitInvisPiTys :: Type -> ([PiTyBinder], Type) #

Like splitPiTys, but returns only *invisible* binders, including constraints. Stops at the first visible binder.

splitInvisPiTysN :: Int -> Type -> ([PiTyBinder], Type) #

Same as splitInvisPiTys, but stop when - you have found n PiTyBinders, - or you run out of invisible binders

filterOutInvisibleTypes :: TyCon -> [Type] -> [Type] #

Given a TyCon and a list of argument types, filter out any invisible (i.e., Inferred or Specified) arguments.

filterOutInferredTypes :: TyCon -> [Type] -> [Type] #

Given a TyCon and a list of argument types, filter out any Inferred arguments.

partitionInvisibles :: [(a, ForAllTyFlag)] -> ([a], [a]) #

Given a list of things paired with their visibilities, partition the things into (invisible things, visible things).

tyConForAllTyFlags :: TyCon -> [Type] -> [ForAllTyFlag] #

Given a TyCon and a list of argument types to which the TyCon is applied, determine each argument's visibility (Inferred, Specified, or Required).

Wrinkle: consider the following scenario:

T :: forall k. k -> k
tyConForAllTyFlags T [forall m. m -> m -> m, S, R, Q]

After substituting, we get

T (forall m. m -> m -> m) :: (forall m. m -> m -> m) -> forall n. n -> n -> n

Thus, the first argument is invisible, S is visible, R is invisible again, and Q is visible.

appTyForAllTyFlags :: Type -> [Type] -> [ForAllTyFlag] #

Given a Type and a list of argument types to which the Type is applied, determine each argument's visibility (Inferred, Specified, or Required).

Most of the time, the arguments will be Required, but not always. Consider f :: forall a. a -> Type. In f Type Bool, the first argument (Type) is Specified and the second argument (Bool) is Required. It is precisely this sort of higher-rank situation in which appTyForAllTyFlags comes in handy, since f Type Bool would be represented in Core using AppTys. (See also #15792).

isTauTy :: Type -> Bool #

isAtomicTy :: Type -> Bool #

mkFamilyTyConApp :: TyCon -> [Type] -> Type #

Given a family instance TyCon and its arg types, return the corresponding family type. E.g:

data family T a
data instance T (Maybe b) = MkT b

Where the instance tycon is :RTL, so:

mkFamilyTyConApp :RTL Int  =  T (Maybe Int)

coAxNthLHS :: forall (br :: BranchFlag). CoAxiom br -> Int -> Type #

Get the type on the LHS of a coercion induced by a type/data family instance.

isFamFreeTy :: Type -> Bool #

isCoVarType :: Type -> Bool #

Does this type classify a core (unlifted) Coercion? At either role nominal or representational (t1 ~# t2) or (t1 ~R# t2) See Note [Types for coercions, predicates, and evidence] in GHC.Core.TyCo.Rep

buildSynTyCon #

Arguments

:: Name
-> [KnotTied TyConBinder]
-> Kind	result kind
-> [Role]
-> KnotTied Type
-> TyCon

isUnliftedType :: HasDebugCallStack => Type -> Bool #

Is the given type definitely unlifted? See Type for what an unlifted type is.

Panics on representation-polymorphic types; See mightBeUnliftedType for a more approximate predicate that behaves better in the presence of representation polymorphism.

mightBeLiftedType :: Type -> Bool #

Returns:

False if the type is guaranteed unlifted or
True if it lifted, OR we aren't sure (e.g. in a representation-polymorphic case)

mightBeUnliftedType :: Type -> Bool #

Returns:

False if the type is guaranteed lifted or
True if it is unlifted, OR we aren't sure (e.g. in a representation-polymorphic case)

isBoxedType :: Type -> Bool #

See Type for what a boxed type is. Panics on representation-polymorphic types; See mightBeUnliftedType for a more approximate predicate that behaves better in the presence of representation polymorphism.

isRuntimeRepKindedTy :: Type -> Bool #

Is this a type of kind RuntimeRep? (e.g. LiftedRep)

dropRuntimeRepArgs :: [Type] -> [Type] #

Drops prefix of RuntimeRep constructors in TyConApps. Useful for e.g. dropping 'LiftedRep arguments of unboxed tuple TyCon applications:

dropRuntimeRepArgs [ 'LiftedRep, 'IntRep , String, Int# ] == [String, Int#]

getRuntimeRep :: HasDebugCallStack => Type -> RuntimeRepType #

Extract the RuntimeRep classifier of a type. For instance, getRuntimeRep_maybe Int = LiftedRep. Panics if this is not possible.

isUnboxedTupleType :: Type -> Bool #

isUnboxedSumType :: Type -> Bool #

isDataFamilyAppType :: Type -> Bool #

Check whether a type is a data family type

isStrictType :: HasDebugCallStack => Type -> Bool #

Computes whether an argument (or let right hand side) should be computed strictly or lazily, based only on its type. Currently, it's just isUnliftedType. Panics on representation-polymorphic types.

isPrimitiveType :: Type -> Bool #

Returns true of types that are opaque to Haskell.

isValidJoinPointType :: JoinArity -> Type -> Bool #

Determine whether a type could be the type of a join point of given total arity, according to the polymorphism rule. A join point cannot be polymorphic in its return type, since given join j a b x y z = e1 in e2, the types of e1 and e2 must be the same, and a and b are not in scope for e2. (See Note [The polymorphism rule of join points] in GHC.Core.) Returns False also if the type simply doesn't have enough arguments.

Note that we need to know how many arguments (type *and* value) the putative join point takes; for instance, if j :: forall a. a -> Int then j could be a binary join point returning an Int, but it could *not* be a unary join point returning a -> Int.

TODO: See Note [Excess polymorphism and join points]

seqType :: Type -> () #

seqTypes :: [Type] -> () #

sORTKind_maybe :: Kind -> Maybe (TypeOrConstraint, Type) #

isTYPEorCONSTRAINT :: Kind -> Bool #

Does this classify a type allowed to have values? Responds True to things like *, TYPE Lifted, TYPE IntRep, TYPE v, Constraint.

True of a kind `TYPE _` or `CONSTRAINT _`

tyConIsTYPEorCONSTRAINT :: TyCon -> Bool #

isConstraintLikeKind :: Kind -> Bool #

isConstraintKind :: Kind -> Bool #

tcIsLiftedTypeKind :: Kind -> Bool #

Is this kind equivalent to Type i.e. TYPE LiftedRep?

tcIsBoxedTypeKind :: Kind -> Bool #

Is this kind equivalent to TYPE (BoxedRep l) for some l :: Levity?

isTypeLikeKind :: Kind -> Bool #

Is this kind equivalent to TYPE r (for some unknown r)?

This considers Constraint to be distinct from *.

returnsConstraintKind :: Kind -> Bool #

typeHasFixedRuntimeRep :: HasDebugCallStack => Type -> Bool #

Returns True if a type has a syntactically fixed runtime rep, as per Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete.

This function is equivalent to `isFixedRuntimeRepKind . typeKind` but much faster.

Precondition: The type has kind (TYPE blah)

argsHaveFixedRuntimeRep :: Type -> Bool #

True if the argument types of this function type all have a fixed-runtime-rep

isFixedRuntimeRepKind :: HasDebugCallStack => Kind -> Bool #

Checks that a kind of the form Type, Constraint or 'TYPE r is concrete. See isConcrete.

Precondition: The type has kind `TYPE blah` or `CONSTRAINT blah`

isConcrete :: Type -> Bool #

Tests whether the given type is concrete, i.e. it whether it consists only of concrete type constructors, concrete type variables, and applications.

See Note [Concrete types] in GHC.Tc.Utils.Concrete.

tyConAppNeedsKindSig #

Arguments

:: Bool	Should specified binders count towards injective positions in the kind of the TyCon? (If you're using visible kind applications, then you want True here.
-> TyCon
-> Int	The number of args the `TyCon` is applied to.
-> Bool	Does `T t_1 ... t_n` need a kind signature? (Where `n` is the number of arguments)

Does a TyCon (that is applied to some number of arguments) need to be ascribed with an explicit kind signature to resolve ambiguity if rendered as a source-syntax type? (See Note [When does a tycon application need an explicit kind signature?] for a full explanation of what this function checks for.)

unrestricted :: a -> Scaled a #

Scale a payload by Many

linear :: a -> Scaled a #

Scale a payload by One

tymult :: a -> Scaled a #

Scale a payload by Many; used for type arguments in core

irrelevantMult :: Scaled a -> a #

mkScaled :: Mult -> a -> Scaled a #

scaledSet :: Scaled a -> b -> Scaled b #

isManyTy :: Mult -> Bool #

isOneTy :: Mult -> Bool #

isLinearType :: Type -> Bool #

isLinear t returns True of a if t is a type of (curried) function where at least one argument is linear (or otherwise non-unrestricted). We use this function to check whether it is safe to eta reduce an Id in CorePrep. It is always safe to return True, because True deactivates the optimisation.

mkTYPEapp :: RuntimeRepType -> Type #

mkTYPEapp_maybe :: RuntimeRepType -> Maybe Type #

Given a RuntimeRep, applies TYPE to it. On the fly it rewrites TYPE LiftedRep --> liftedTypeKind (a synonym) TYPE UnliftedRep --> unliftedTypeKind (ditto) TYPE ZeroBitRep --> zeroBitTypeKind (ditto) NB: no need to check for TYPE (BoxedRep Lifted), TYPE (BoxedRep Unlifted) because those inner types should already have been rewritten to LiftedRep and UnliftedRep respectively, by mkTyConApp

see Note [TYPE and CONSTRAINT] in GHC.Builtin.Types.Prim. See Note [Using synonyms to compress types] in GHC.Core.Type

mkCONSTRAINTapp :: RuntimeRepType -> Type #

Just like mkTYPEapp

mkCONSTRAINTapp_maybe :: RuntimeRepType -> Maybe Type #

Just like mkTYPEapp_maybe

mkBoxedRepApp_maybe :: LevityType -> Maybe Type #

Given a PromDataConInfo, apply BoxedRep to it On the fly, rewrite BoxedRep Lifted --> liftedRepTy (a synonym) BoxedRep Unlifted --> unliftedRepTy (ditto) See Note [TYPE and CONSTRAINT] in GHC.Builtin.Types.Prim. See Note [Using synonyms to compress types] in GHC.Core.Type

mkTupleRepApp_maybe :: Type -> Maybe Type #

Given a `[RuntimeRep]`, apply TupleRep to it On the fly, rewrite TupleRep [] -> zeroBitRepTy (a synonym) See Note [TYPE and CONSTRAINT] in GHC.Builtin.Types.Prim. See Note [Using synonyms to compress types] in GHC.Core.Type

typeOrConstraintKind :: TypeOrConstraint -> RuntimeRepType -> Kind #

negateOverLitVal :: OverLitVal -> OverLitVal #

litNumIsSigned :: LitNumType -> Bool #

Indicate if a numeric literal type supports negative numbers

litNumBitSize :: Platform -> LitNumType -> Maybe Word #

Number of bits

mkLitNumberWrap :: Platform -> LitNumType -> Integer -> Literal #

Make a literal number using wrapping semantics if the value is out of bound.

litNumWrap :: Platform -> Literal -> Literal #

Wrap a literal number according to its type using wrapping semantics.

litNumCoerce :: LitNumType -> Platform -> Literal -> Literal #

Coerce a literal number into another using wrapping semantics.

litNumNarrow :: LitNumType -> Platform -> Literal -> Literal #

Narrow a literal number by converting it into another number type and then converting it back to its original type.

litNumCheckRange :: Platform -> LitNumType -> Integer -> Bool #

Check that a given number is in the range of a numeric literal

litNumRange :: Platform -> LitNumType -> (Maybe Integer, Maybe Integer) #

Get the literal range

mkLitNumber :: Platform -> LitNumType -> Integer -> Literal #

Create a numeric Literal of the given type

mkLitInt :: Platform -> Integer -> Literal #

Creates a Literal of type Int#

mkLitIntWrap :: Platform -> Integer -> Literal #

Creates a Literal of type Int#. If the argument is out of the (target-dependent) range, it is wrapped. See Note [WordInt underflowoverflow]

mkLitIntUnchecked :: Integer -> Literal #

Creates a Literal of type Int# without checking its range.

mkLitIntWrapC :: Platform -> Integer -> (Literal, Bool) #

Creates a Literal of type Int#, as well as a Boolean flag indicating overflow. That is, if the argument is out of the (target-dependent) range the argument is wrapped and the overflow flag will be set. See Note [WordInt underflowoverflow]

mkLitWord :: Platform -> Integer -> Literal #

Creates a Literal of type Word#

mkLitWordWrap :: Platform -> Integer -> Literal #

Creates a Literal of type Word#. If the argument is out of the (target-dependent) range, it is wrapped. See Note [WordInt underflowoverflow]

mkLitWordUnchecked :: Integer -> Literal #

Creates a Literal of type Word# without checking its range.

mkLitWordWrapC :: Platform -> Integer -> (Literal, Bool) #

Creates a Literal of type Word#, as well as a Boolean flag indicating carry. That is, if the argument is out of the (target-dependent) range the argument is wrapped and the carry flag will be set. See Note [WordInt underflowoverflow]

mkLitInt8 :: Integer -> Literal #

Creates a Literal of type Int8#

mkLitInt8Wrap :: Integer -> Literal #

Creates a Literal of type Int8#. If the argument is out of the range, it is wrapped.

mkLitInt8Unchecked :: Integer -> Literal #

Creates a Literal of type Int8# without checking its range.

mkLitWord8 :: Integer -> Literal #

Creates a Literal of type Word8#

mkLitWord8Wrap :: Integer -> Literal #

Creates a Literal of type Word8#. If the argument is out of the range, it is wrapped.

mkLitWord8Unchecked :: Integer -> Literal #

Creates a Literal of type Word8# without checking its range.

mkLitInt16 :: Integer -> Literal #

Creates a Literal of type Int16#

mkLitInt16Wrap :: Integer -> Literal #

Creates a Literal of type Int16#. If the argument is out of the range, it is wrapped.

mkLitInt16Unchecked :: Integer -> Literal #

Creates a Literal of type Int16# without checking its range.

mkLitWord16 :: Integer -> Literal #

Creates a Literal of type Word16#

mkLitWord16Wrap :: Integer -> Literal #

Creates a Literal of type Word16#. If the argument is out of the range, it is wrapped.

mkLitWord16Unchecked :: Integer -> Literal #

Creates a Literal of type Word16# without checking its range.

mkLitInt32 :: Integer -> Literal #

Creates a Literal of type Int32#

mkLitInt32Wrap :: Integer -> Literal #

Creates a Literal of type Int32#. If the argument is out of the range, it is wrapped.

mkLitInt32Unchecked :: Integer -> Literal #

Creates a Literal of type Int32# without checking its range.

mkLitWord32 :: Integer -> Literal #

Creates a Literal of type Word32#

mkLitWord32Wrap :: Integer -> Literal #

Creates a Literal of type Word32#. If the argument is out of the range, it is wrapped.

mkLitWord32Unchecked :: Integer -> Literal #

Creates a Literal of type Word32# without checking its range.

mkLitInt64 :: Integer -> Literal #

Creates a Literal of type Int64#

mkLitInt64Wrap :: Integer -> Literal #

Creates a Literal of type Int64#. If the argument is out of the range, it is wrapped.

mkLitInt64Unchecked :: Integer -> Literal #

Creates a Literal of type Int64# without checking its range.

mkLitWord64 :: Integer -> Literal #

Creates a Literal of type Word64#

mkLitWord64Wrap :: Integer -> Literal #

Creates a Literal of type Word64#. If the argument is out of the range, it is wrapped.

mkLitWord64Unchecked :: Integer -> Literal #

Creates a Literal of type Word64# without checking its range.

mkLitFloat :: Rational -> Literal #

Creates a Literal of type Float#

mkLitDouble :: Rational -> Literal #

Creates a Literal of type Double#

mkLitChar :: Char -> Literal #

Creates a Literal of type Char#

mkLitString :: String -> Literal #

Creates a Literal of type Addr#, which is appropriate for passing to e.g. some of the "error" functions in GHC.Err such as GHC.Err.runtimeError

mkLitBigNat :: Integer -> Literal #

isLitRubbish :: Literal -> Bool #

isMinBound :: Platform -> Literal -> Bool #

isMaxBound :: Platform -> Literal -> Bool #

inCharRange :: Char -> Bool #

isZeroLit :: Literal -> Bool #

Tests whether the literal represents a zero of whatever type it is

isOneLit :: Literal -> Bool #

Tests whether the literal represents a one of whatever type it is

litValue :: Literal -> Integer #

Returns the Integer contained in the Literal, for when that makes sense, i.e. for Char and numbers.

isLitValue_maybe :: Literal -> Maybe Integer #

Returns the Integer contained in the Literal, for when that makes sense, i.e. for Char and numbers.

mapLitValue :: Platform -> (Integer -> Integer) -> Literal -> Literal #

Apply a function to the Integer contained in the Literal, for when that makes sense, e.g. for Char and numbers. For fixed-size integral literals, the result will be wrapped in accordance with the semantics of the target type. See Note [WordInt underflowoverflow]

narrowInt8Lit :: Literal -> Literal #

narrowInt16Lit :: Literal -> Literal #

narrowInt32Lit :: Literal -> Literal #

narrowInt64Lit :: Literal -> Literal #

narrowWord8Lit :: Literal -> Literal #

narrowWord16Lit :: Literal -> Literal #

narrowWord32Lit :: Literal -> Literal #

narrowWord64Lit :: Literal -> Literal #

convertToWordLit :: Platform -> Literal -> Literal #

Extend or narrow a fixed-width literal (e.g. Int16#) to a target word-sized literal (Int# or Word#). Narrowing can only happen on 32-bit architectures when we convert a 64-bit literal into a 32-bit one.

convertToIntLit :: Platform -> Literal -> Literal #

Extend or narrow a fixed-width literal (e.g. Int16#) to a target word-sized literal (Int# or Word#). Narrowing can only happen on 32-bit architectures when we convert a 64-bit literal into a 32-bit one.

charToIntLit :: Literal -> Literal #

intToCharLit :: Literal -> Literal #

floatToIntLit :: Literal -> Literal #

intToFloatLit :: Literal -> Literal #

doubleToIntLit :: Literal -> Literal #

intToDoubleLit :: Literal -> Literal #

floatToDoubleLit :: Literal -> Literal #

doubleToFloatLit :: Literal -> Literal #

nullAddrLit :: Literal #

litIsTrivial :: Literal -> Bool #

True if there is absolutely no penalty to duplicating the literal. False principally of strings.

"Why?", you say? I'm glad you asked. Well, for one duplicating strings would blow up code sizes. Not only this, it's also unsafe.

Consider a program that wants to traverse a string. One way it might do this is to first compute the Addr# pointing to the end of the string, and then, starting from the beginning, bump a pointer using eqAddr# to determine the end. For instance,

-- Given pointers to the start and end of a string, count how many zeros
-- the string contains.
countZeros :: Addr# -> Addr# -> -> Int
countZeros start end = go start 0
  where
    go off n
      | off addrEq# end = n
      | otherwise         = go (off plusAddr# 1) n'
      where n' | isTrue# (indexInt8OffAddr# off 0# ==# 0#) = n + 1
               | otherwise                                 = n

Consider what happens if we considered strings to be trivial (and therefore duplicable) and emitted a call like countZeros "hello"# ("hello"# plusAddr# 5). The beginning and end pointers do not belong to the same string, meaning that an iteration like the above would blow up terribly. This is what happened in #12757.

Ultimately the solution here is to make primitive strings a bit more structured, ensuring that the compiler can't inline in ways that will break user code. One approach to this is described in #8472.

litIsDupable :: Platform -> Literal -> Bool #

True if code space does not go bad if we duplicate this literal

litFitsInChar :: Literal -> Bool #

litIsLifted :: Literal -> Bool #

literalType :: Literal -> Type #

Find the Haskell Type the literal occupies

pprLiteral :: (SDoc -> SDoc) -> Literal -> SDoc #

pprParendCo :: Coercion -> SDoc #

coVarName :: CoVar -> Name #

setCoVarUnique :: CoVar -> Unique -> CoVar #

setCoVarName :: CoVar -> Name -> CoVar #

etaExpandCoAxBranch :: CoAxBranch -> ([TyVar], [Type], Type) #

pprCoAxiom :: forall (br :: BranchFlag). CoAxiom br -> SDoc #

pprCoAxBranchUser :: TyCon -> CoAxBranch -> SDoc #

pprCoAxBranchLHS :: TyCon -> CoAxBranch -> SDoc #

pprCoAxBranch :: TyCon -> CoAxBranch -> SDoc #

tidyCoAxBndrsForUser :: TidyEnv -> [Var] -> (TidyEnv, [Var]) #

coToMCo :: Coercion -> MCoercion #

checkReflexiveMCo :: MCoercion -> MCoercion #

isGReflMCo :: MCoercion -> Bool #

Tests if this MCoercion is obviously generalized reflexive Guaranteed to work very quickly.

mkTransMCo :: MCoercion -> MCoercion -> MCoercion #

Compose two MCoercions via transitivity

mkTransMCoL :: MCoercion -> Coercion -> MCoercion #

mkTransMCoR :: Coercion -> MCoercion -> MCoercion #

mkSymMCo :: MCoercion -> MCoercion #

Get the reverse of an MCoercion

mkCastTyMCo :: Type -> MCoercion -> Type #

Cast a type by an MCoercion

mkHomoForAllMCo :: TyCoVar -> MCoercion -> MCoercion #

mkPiMCos :: [Var] -> MCoercion -> MCoercion #

mkFunResMCo :: Id -> MCoercionR -> MCoercionR #

mkGReflLeftMCo :: Role -> Type -> MCoercionN -> Coercion #

mkGReflRightMCo :: Role -> Type -> MCoercionN -> Coercion #

mkCoherenceRightMCo :: Role -> Type -> MCoercionN -> Coercion -> Coercion #

Like mkCoherenceRightCo, but with an MCoercion

isReflMCo :: MCoercion -> Bool #

decomposeCo :: Arity -> Coercion -> Infinite Role -> [Coercion] #

This breaks a Coercion with type T A B C ~ T D E F into a list of Coercions of kinds A ~ D, B ~ E and E ~ F. Hence:

decomposeCo 3 c [r1, r2, r3] = [nth r1 0 c, nth r2 1 c, nth r3 2 c]

decomposeFunCo :: HasDebugCallStack => Coercion -> (CoercionN, Coercion, Coercion) #

getCoVar_maybe :: Coercion -> Maybe CoVar #

Extract a covar, if possible. This check is dirty. Be ashamed of yourself. (It's dirty because it cares about the structure of a coercion, which is morally reprehensible.)

multToCo :: Mult -> Coercion #

splitAppCo_maybe :: Coercion -> Maybe (Coercion, Coercion) #

Attempt to take a coercion application apart.

splitFunCo_maybe :: Coercion -> Maybe (Coercion, Coercion) #

splitForAllCo_maybe :: Coercion -> Maybe (TyCoVar, Coercion, Coercion) #

splitForAllCo_ty_maybe :: Coercion -> Maybe (TyVar, Coercion, Coercion) #

Like splitForAllCo_maybe, but only returns Just for tyvar binder

splitForAllCo_co_maybe :: Coercion -> Maybe (CoVar, Coercion, Coercion) #

Like splitForAllCo_maybe, but only returns Just for covar binder

coVarLType :: HasDebugCallStack => CoVar -> Type #

coVarRType :: HasDebugCallStack => CoVar -> Type #

coVarTypes :: HasDebugCallStack => CoVar -> Pair Type #

coVarKind :: CoVar -> Type #

mkRuntimeRepCo :: HasDebugCallStack => Coercion -> Coercion #

Given a coercion `co :: (t1 :: TYPE r1) ~ (t2 :: TYPE r2)` produce a coercion `rep_co :: r1 ~ r2` But actually it is possible that co :: (t1 :: CONSTRAINT r1) ~ (t2 :: CONSTRAINT r2) or co :: (t1 :: TYPE r1) ~ (t2 :: CONSTRAINT r2) or co :: (t1 :: CONSTRAINT r1) ~ (t2 :: TYPE r2) See Note [mkRuntimeRepCo]

isReflCoVar_maybe :: Var -> Maybe Coercion #

isGReflCo_maybe :: Coercion -> Maybe (Type, Role) #

Returns the type coerced if this coercion is a generalized reflexive coercion. Guaranteed to work very quickly.

isReflCo_maybe :: Coercion -> Maybe (Type, Role) #

Returns the type coerced if this coercion is reflexive. Guaranteed to work very quickly. Sometimes a coercion can be reflexive, but not obviously so. c.f. isReflexiveCo_maybe

isReflexiveCo_maybe :: Coercion -> Maybe (Type, Role) #

Extracts the coerced type from a reflexive coercion. This potentially walks over the entire coercion, so avoid doing this in a loop.

mkRepReflCo :: Type -> Coercion #

Make a representational reflexive coercion

mkFunCoNoFTF :: HasDebugCallStack => Role -> CoercionN -> Coercion -> Coercion -> Coercion #

mkNakedFunCo2 :: Role -> FunTyFlag -> FunTyFlag -> CoercionN -> Coercion -> Coercion -> Coercion #

mkAppCos :: Coercion -> [Coercion] -> Coercion #

Applies multiple Coercions to another Coercion, from left to right. See also mkAppCo.

mkForAllCos :: [(TyCoVar, CoercionN)] -> Coercion -> Coercion #

Make nested ForAllCos

mkHomoForAllCos :: [TyCoVar] -> Coercion -> Coercion #

Make a Coercion quantified over a type/coercion variable; the variable has the same type in both sides of the coercion

mkCoVarCos :: [CoVar] -> [Coercion] #

mkAxInstCo :: forall (br :: BranchFlag). Role -> CoAxiom br -> BranchIndex -> [Type] -> [Coercion] -> Coercion #

mkUnbranchedAxInstCo :: Role -> CoAxiom Unbranched -> [Type] -> [Coercion] -> Coercion #

mkAxInstRHS :: forall (br :: BranchFlag). CoAxiom br -> BranchIndex -> [Type] -> [Coercion] -> Type #

mkUnbranchedAxInstRHS :: CoAxiom Unbranched -> [Type] -> [Coercion] -> Type #

mkAxInstLHS :: forall (br :: BranchFlag). CoAxiom br -> BranchIndex -> [Type] -> [Coercion] -> Type #

Return the left-hand type of the axiom, when the axiom is instantiated at the types given.

mkUnbranchedAxInstLHS :: CoAxiom Unbranched -> [Type] -> [Coercion] -> Type #

Instantiate the left-hand side of an unbranched axiom

mkHoleCo :: CoercionHole -> Coercion #

Make a coercion from a coercion hole

getNthFun #

Arguments

:: FunSel
-> a	multiplicity
-> a	argument
-> a	result
-> a	One of the above three

Extract the nth field of a FunCo

mkGReflRightCo :: Role -> Type -> CoercionN -> Coercion #

Given ty :: k1, co :: k1 ~ k2, produces co' :: ty ~r (ty |> co)

mkGReflLeftCo :: Role -> Type -> CoercionN -> Coercion #

Given r, ty :: k1, and co :: k1 ~N k2, produces co' :: (ty |> co) ~r ty

mkCoherenceLeftCo :: Role -> Type -> CoercionN -> Coercion -> Coercion #

Given ty :: k1, co :: k1 ~ k2, co2:: ty ~r ty', produces @co' :: (ty |> co) ~r ty' It is not only a utility function, but it saves allocation when co is a GRefl coercion.

mkCoherenceRightCo :: Role -> Type -> CoercionN -> Coercion -> Coercion #

Given ty :: k1, co :: k1 ~ k2, co2:: ty' ~r ty, produces @co' :: ty' ~r (ty |> co) It is not only a utility function, but it saves allocation when co is a GRefl coercion.

downgradeRole :: Role -> Role -> Coercion -> Coercion #

Like downgradeRole_maybe, but panics if the change isn't a downgrade. See Note [Role twiddling functions]

setNominalRole_maybe :: Role -> Coercion -> Maybe CoercionN #

Converts a coercion to be nominal, if possible. See Note [Role twiddling functions]

tyConRolesX :: Role -> TyCon -> Infinite Role #

tyConRoleListX :: Role -> TyCon -> [Role] #

tyConRolesRepresentational :: TyCon -> Infinite Role #

tyConRoleListRepresentational :: TyCon -> [Role] #

tyConRole :: Role -> TyCon -> Int -> Role #

funRole :: Role -> FunSel -> Role #

ltRole :: Role -> Role -> Bool #

promoteCoercion :: Coercion -> CoercionN #

like mkKindCo, but aggressively & recursively optimizes to avoid using a KindCo constructor. The output role is nominal.

castCoercionKind2 :: Coercion -> Role -> Type -> Type -> CoercionN -> CoercionN -> Coercion #

Creates a new coercion with both of its types casted by different casts castCoercionKind2 g r t1 t2 h1 h2, where g :: t1 ~r t2, has type (t1 |> h1) ~r (t2 |> h2). h1 and h2 must be nominal.

castCoercionKind1 :: Coercion -> Role -> Type -> Type -> CoercionN -> Coercion #

castCoercionKind1 g r t1 t2 h = coercionKind g r t1 t2 h h That is, it's a specialised form of castCoercionKind, where the two kind coercions are identical castCoercionKind1 g r t1 t2 h, where g :: t1 ~r t2, has type (t1 |> h) ~r (t2 |> h). h must be nominal. See Note [castCoercionKind1]

castCoercionKind :: Coercion -> CoercionN -> CoercionN -> Coercion #

Creates a new coercion with both of its types casted by different casts castCoercionKind g h1 h2, where g :: t1 ~r t2, has type (t1 |> h1) ~r (t2 |> h2). h1 and h2 must be nominal. It calls coercionKindRole, so it's quite inefficient (which I stands for) Use castCoercionKind2 instead if t1, t2, and r are known beforehand.

mkPiCos :: Role -> [Var] -> Coercion -> Coercion #

mkPiCo :: Role -> Var -> Coercion -> Coercion #

Make a forall Coercion, where both types related by the coercion are quantified over the same variable.

mkFunResCo :: Role -> Id -> Coercion -> Coercion #

mkCoCast :: Coercion -> CoercionR -> Coercion #

instNewTyCon_maybe :: TyCon -> [Type] -> Maybe (Type, Coercion) #

If `instNewTyCon_maybe T ts = Just (rep_ty, co)` then `co :: T ts ~R# rep_ty`

Checks for a newtype, and for being saturated

composeSteppers :: NormaliseStepper ev -> NormaliseStepper ev -> NormaliseStepper ev #

Try one stepper and then try the next, if the first doesn't make progress. So if it returns NS_Done, it means that both steppers are satisfied

unwrapNewTypeStepper :: NormaliseStepper Coercion #

A NormaliseStepper that unwraps newtypes, careful not to fall into a loop. If it would fall into a loop, it produces NS_Abort.

topNormaliseTypeX :: NormaliseStepper ev -> (ev -> ev -> ev) -> Type -> Maybe (ev, Type) #

A general function for normalising the top-level of a type. It continues to use the provided NormaliseStepper until that function fails, and then this function returns. The roles of the coercions produced by the NormaliseStepper must all be the same, which is the role returned from the call to topNormaliseTypeX.

Typically ev is Coercion.

If topNormaliseTypeX step plus ty = Just (ev, ty') then ty ~ev1~ t1 ~ev2~ t2 ... ~evn~ ty' and ev = ev1 plus ev2 plus ... plus evn If it returns Nothing then no newtype unwrapping could happen

eqCoercion :: Coercion -> Coercion -> Bool #

Syntactic equality of coercions

eqCoercionX :: RnEnv2 -> Coercion -> Coercion -> Bool #

Compare two Coercions, with respect to an RnEnv2

liftCoSubstWithEx :: Role -> [TyVar] -> [Coercion] -> [TyCoVar] -> [Type] -> (Type -> Coercion, [Type]) #

liftCoSubstWith :: Role -> [TyCoVar] -> [Coercion] -> Type -> Coercion #

emptyLiftingContext :: InScopeSet -> LiftingContext #

mkSubstLiftingContext :: Subst -> LiftingContext #

extendLiftingContext #

Arguments

:: LiftingContext	original LC
-> TyCoVar	new variable to map...
-> Coercion	...to this lifted version
-> LiftingContext

Extend a lifting context with a new mapping.

extendLiftingContextAndInScope #

Arguments

:: LiftingContext	Original LC
-> TyCoVar	new variable to map...
-> Coercion	to this coercion
-> LiftingContext

Extend a lifting context with a new mapping, and extend the in-scope set

zapLiftingContext :: LiftingContext -> LiftingContext #

Erase the environments in a lifting context

substForAllCoBndrUsingLC :: Bool -> (Coercion -> Coercion) -> LiftingContext -> TyCoVar -> Coercion -> (LiftingContext, TyCoVar, Coercion) #

Like substForAllCoBndr, but works on a lifting context

liftCoSubstTyVar :: LiftingContext -> Role -> TyVar -> Maybe Coercion #

liftCoSubstVarBndrUsing #

Arguments

:: (r -> CoercionN)	coercion getter
-> (LiftingContext -> Type -> r)	callback
-> LiftingContext
-> TyCoVar
-> (LiftingContext, TyCoVar, r)

isMappedByLC :: TyCoVar -> LiftingContext -> Bool #

Is a var in the domain of a lifting context?

substLeftCo :: LiftingContext -> Coercion -> Coercion #

substRightCo :: LiftingContext -> Coercion -> Coercion #

swapLiftCoEnv :: LiftCoEnv -> LiftCoEnv #

Apply "sym" to all coercions in a LiftCoEnv

lcSubstLeft :: LiftingContext -> Subst #

lcSubstRight :: LiftingContext -> Subst #

liftEnvSubstLeft :: Subst -> LiftCoEnv -> Subst #

liftEnvSubstRight :: Subst -> LiftCoEnv -> Subst #

lcSubst :: LiftingContext -> Subst #

Extract the underlying substitution from the LiftingContext

lcInScopeSet :: LiftingContext -> InScopeSet #

Get the InScopeSet from a LiftingContext

coercionKinds :: [Coercion] -> Pair [Type] #

Apply coercionKind to multiple Coercions

coercionKindRole :: Coercion -> (Pair Type, Role) #

Get a coercion's kind and role.

getNthFromType :: HasDebugCallStack => CoSel -> Type -> Type #

coercionRole :: Coercion -> Role #

Retrieve the role from a coercion.

mkPrimEqPred :: Type -> Type -> Type #

Creates a primitive type equality predicate. Invariant: the types are not Coercions

mkPrimEqPredRole :: Role -> Type -> Type -> PredType #

Makes a lifted equality predicate at the given role

mkHeteroPrimEqPred :: Kind -> Kind -> Type -> Type -> Type #

Creates a primitive type equality predicate with explicit kinds

mkHeteroReprPrimEqPred :: Kind -> Kind -> Type -> Type -> Type #

Creates a primitive representational type equality predicate with explicit kinds

mkReprPrimEqPred :: Type -> Type -> Type #

buildCoercion :: Type -> Type -> CoercionN #

Assuming that two types are the same, ignoring coercions, find a nominal coercion between the types. This is useful when optimizing transitivity over coercion applications, where splitting two AppCos might yield different kinds. See Note [EtaAppCo] in GHC.Core.Coercion.Opt.

hasCoercionHoleTy :: Type -> Bool #

Is there a coercion hole in this type?

hasCoercionHoleCo :: Coercion -> Bool #

Is there a coercion hole in this coercion?

hasThisCoercionHoleTy :: Type -> CoercionHole -> Bool #

setCoHoleType :: CoercionHole -> Type -> CoercionHole #

Set the type of a CoercionHole

suggestExtension :: Extension -> GhcHint #

Suggests a single extension without extra user info.

suggestExtensionWithInfo :: SDoc -> Extension -> GhcHint #

Like suggestExtension but allows supplying extra info for the user.

suggestExtensions :: [Extension] -> GhcHint #

Suggests to enable every extension in the list.

suggestExtensionsWithInfo :: SDoc -> [Extension] -> GhcHint #

Like suggestExtensions but allows supplying extra info for the user.

suggestAnyExtension :: [Extension] -> GhcHint #

Suggests to enable any extension in the list.

suggestAnyExtensionWithInfo :: SDoc -> [Extension] -> GhcHint #

Like suggestAnyExtension but allows supplying extra info for the user.

useExtensionInOrderTo :: SDoc -> Extension -> GhcHint #

emptyMessages :: Messages e #

mkMessages :: Bag (MsgEnvelope e) -> Messages e #

isEmptyMessages :: Messages e -> Bool #

singleMessage :: MsgEnvelope e -> Messages e #

addMessage :: MsgEnvelope e -> Messages e -> Messages e #

Adds a Message to the input collection of messages. See Note [Discarding Messages].

unionMessages :: Messages e -> Messages e -> Messages e #

Joins two collections of messages together. See Note [Discarding Messages].

unionManyMessages :: Foldable f => f (Messages e) -> Messages e #

Joins many Messagess together

mkDecorated :: [SDoc] -> DecoratedSDoc #

Creates a new DecoratedSDoc out of a list of SDoc.

mkSimpleDecorated :: SDoc -> DecoratedSDoc #

Creates a new DecoratedSDoc out of a single SDoc

unionDecoratedSDoc :: DecoratedSDoc -> DecoratedSDoc -> DecoratedSDoc #

Joins two DecoratedSDoc together. The resulting DecoratedSDoc will have a number of entries which is the sum of the lengths of the input.

mapDecoratedSDoc :: (SDoc -> SDoc) -> DecoratedSDoc -> DecoratedSDoc #

Apply a transformation function to all elements of a DecoratedSDoc.

noHints :: [GhcHint] #

Helper function to use when no hints can be provided. Currently this function can be used to construct plain DiagnosticMessage and add hints to them, but once #18516 will be fully executed, the main usage of this function would be in the implementation of the diagnosticHints typeclass method, to report the fact that a particular Diagnostic has no hints.

mkPlainDiagnostic :: DiagnosticReason -> [GhcHint] -> SDoc -> DiagnosticMessage #

mkPlainError :: [GhcHint] -> SDoc -> DiagnosticMessage #

Create an error DiagnosticMessage holding just a single SDoc

mkDecoratedDiagnostic :: DiagnosticReason -> [GhcHint] -> [SDoc] -> DiagnosticMessage #

Create a DiagnosticMessage from a list of bulleted SDocs and a DiagnosticReason

mkDecoratedError :: [GhcHint] -> [SDoc] -> DiagnosticMessage #

Create an error DiagnosticMessage from a list of bulleted SDocs

pprMessageBag :: Bag SDoc -> SDoc #

mkLocMessage #

Arguments

:: MessageClass	What kind of message?
-> SrcSpan	location
-> SDoc	message
-> SDoc

mkLocMessageWarningGroups #

Arguments

:: Bool	Print warning groups (if applicable)?
-> MessageClass	What kind of message?
-> SrcSpan	location
-> SDoc	message
-> SDoc

Make an error message with location info, specifying whether to show warning groups (if applicable).

getCaretDiagnostic :: MessageClass -> SrcSpan -> IO SDoc #

isIntrinsicErrorMessage :: Diagnostic e => MsgEnvelope e -> Bool #

Returns True if this is, intrinsically, a failure. See Note [Intrinsic And Extrinsic Failures].

isWarningMessage :: Diagnostic e => MsgEnvelope e -> Bool #

errorsFound :: Diagnostic e => Messages e -> Bool #

Are there any hard errors here? -Werror warnings are not detected. If you want to check for -Werror warnings, use errorsOrFatalWarningsFound.

isExtrinsicErrorMessage :: MsgEnvelope e -> Bool #

Returns True if the envelope contains a message that will stop compilation: either an intrinsic error or a fatal (-Werror) warning

errorsOrFatalWarningsFound :: Messages e -> Bool #

Are there any errors or -Werror warnings here?

getWarningMessages :: Diagnostic e => Messages e -> Bag (MsgEnvelope e) #

getErrorMessages :: Diagnostic e => Messages e -> Bag (MsgEnvelope e) #

partitionMessages :: Diagnostic e => Messages e -> (Messages e, Messages e) #

Partitions the Messages and returns a tuple which first element are the warnings, and the second the errors.

diag_wopt :: WarningFlag -> DiagOpts -> Bool #

diag_fatal_wopt :: WarningFlag -> DiagOpts -> Bool #

diagReasonSeverity :: DiagOpts -> DiagnosticReason -> Severity #

Computes the right Severity for the input DiagnosticReason out of the 'DiagOpts. This function has to be called when a diagnostic is constructed, i.e. with a 'DiagOpts "snapshot" taken as close as possible to where a particular diagnostic message is built, otherwise the computed Severity might not be correct, due to the mutable nature of the DynFlags in GHC.

mkMCDiagnostic :: DiagOpts -> DiagnosticReason -> Maybe DiagnosticCode -> MessageClass #

Make a MessageClass for a given DiagnosticReason, consulting the 'DiagOpts.

errorDiagnostic :: MessageClass #

Varation of mkMCDiagnostic which can be used when we are sure the input DiagnosticReason is ErrorWithoutFlag and there is no diagnostic code.

mkMsgEnvelope :: Diagnostic e => DiagOpts -> SrcSpan -> NamePprCtx -> e -> MsgEnvelope e #

Wrap a Diagnostic in a MsgEnvelope, recording its location. If you know your Diagnostic is an error, consider using mkErrorMsgEnvelope, which does not require looking at the DiagOpts

mkErrorMsgEnvelope :: Diagnostic e => SrcSpan -> NamePprCtx -> e -> MsgEnvelope e #

Wrap a Diagnostic in a MsgEnvelope, recording its location. Precondition: the diagnostic is, in fact, an error. That is, diagnosticReason msg == ErrorWithoutFlag.

mkPlainMsgEnvelope :: Diagnostic e => DiagOpts -> SrcSpan -> e -> MsgEnvelope e #

Variant that doesn't care about qualified/unqualified names.

mkPlainErrorMsgEnvelope :: Diagnostic e => SrcSpan -> e -> MsgEnvelope e #

Variant of mkPlainMsgEnvelope which can be used when we are sure we are constructing a diagnostic with a ErrorWithoutFlag reason.

andValid :: Validity' a -> Validity' a -> Validity' a #

allValid :: [Validity' a] -> Validity' a #

If they aren't all valid, return the first

getInvalids :: [Validity' a] -> [a] #

formatBulleted :: SDocContext -> DecoratedSDoc -> SDoc #

Formats the input list of structured document, where each element of the list gets a bullet.

pprMessages :: Diagnostic e => DiagnosticOpts e -> Messages e -> SDoc #

pprMsgEnvelopeBagWithLoc :: Diagnostic e => DiagnosticOpts e -> Bag (MsgEnvelope e) -> [SDoc] #

pprMsgEnvelopeBagWithLocDefault :: Diagnostic e => Bag (MsgEnvelope e) -> [SDoc] #

Print the messages with the suitable default configuration, usually not what you want but sometimes you don't really care about what the configuration is (for example, if the message is in a panic).

pprLocMsgEnvelopeDefault :: Diagnostic e => MsgEnvelope e -> SDoc #

pprLocMsgEnvelope :: Diagnostic e => DiagnosticOpts e -> MsgEnvelope e -> SDoc #

sortMsgBag :: Maybe DiagOpts -> Bag (MsgEnvelope e) -> [MsgEnvelope e] #

ghcExit :: Logger -> Int -> IO () #

errorMsg :: Logger -> SDoc -> IO () #

fatalErrorMsg :: Logger -> SDoc -> IO () #

compilationProgressMsg :: Logger -> SDoc -> IO () #

showPass :: Logger -> String -> IO () #

withTiming #

Arguments

:: MonadIO m
=> Logger
-> SDoc	The name of the phase
-> (a -> ())	A function to force the result (often either `const ()` or `rnf`)
-> m a	The body of the phase to be timed
-> m a

Time a compilation phase.

When timings are enabled (e.g. with the -v2 flag), the allocations and CPU time used by the phase will be reported to stderr. Consider a typical usage: withTiming getDynFlags (text "simplify") force PrintTimings pass. When timings are enabled the following costs are included in the produced accounting,

The cost of executing pass to a result r in WHNF
The cost of evaluating force r to WHNF (e.g. ())

The choice of the force function depends upon the amount of forcing desired; the goal here is to ensure that the cost of evaluating the result is, to the greatest extent possible, included in the accounting provided by withTiming. Often the pass already sufficiently forces its result during construction; in this case const () is a reasonable choice. In other cases, it is necessary to evaluate the result to normal form, in which case something like Control.DeepSeq.rnf is appropriate.

To avoid adversely affecting compiler performance when timings are not requested, the result is only forced when timings are enabled.

See Note [withTiming] for more.

withTimingSilent #

Arguments

:: MonadIO m
=> Logger
-> SDoc	The name of the phase
-> (a -> ())	A function to force the result (often either `const ()` or `rnf`)
-> m a	The body of the phase to be timed
-> m a

Same as withTiming, but doesn't print timings in the console (when given -vN, N >= 2 or -ddump-timings).

See Note [withTiming] for more.

debugTraceMsg :: Logger -> Int -> SDoc -> IO () #

putMsg :: Logger -> SDoc -> IO () #

printInfoForUser :: Logger -> NamePprCtx -> SDoc -> IO () #

printOutputForUser :: Logger -> NamePprCtx -> SDoc -> IO () #

logInfo :: Logger -> SDoc -> IO () #

logOutput :: Logger -> SDoc -> IO () #

Like logInfo but with SevOutput rather then SevInfo

prettyPrintGhcErrors :: ExceptionMonad m => Logger -> m a -> m a #

traceCmd :: Logger -> String -> String -> IO a -> IO a #

Trace a command (when verbosity level >= 3)

traceSystoolCommand :: Logger -> String -> IO a -> IO a #

Record in the eventlog when the given tool command starts and finishes, prepending the given String with "systool:", to easily be able to collect and process all the systool events.

For those events to show up in the eventlog, you need to run GHC with -v2 or -ddump-timings.

simplCountN :: SimplCount -> Int #

zeroSimplCount #

Arguments

:: Bool	ddump-simpl-stats
-> SimplCount

isZeroSimplCount :: SimplCount -> Bool #

hasDetailedCounts :: SimplCount -> Bool #

doFreeSimplTick :: Tick -> SimplCount -> SimplCount #

doSimplTick #

Arguments

:: Int	History size of the elaborate counter
-> Tick
-> SimplCount
-> SimplCount

plusSimplCount :: SimplCount -> SimplCount -> SimplCount #

pprSimplCount :: SimplCount -> SDoc #

mkEqSpec :: TyVar -> Type -> EqSpec #

Make a non-dependent EqSpec

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 #

cbvFromStrictMark :: StrictnessMark -> CbvMark #

mkDataCon #

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 `TyVarBinder`s. These must be Inferred/Specified. See `Note [TyVarBinders in DataCons]`
-> [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 `PromDataConInfo`
-> KnotTied TyCon	Representation type constructor
-> ConTag	Constructor tag
-> ThetaType	The "stupid theta", context of the data declaration e.g. `data Eq a => T a ...`
-> 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) #

Extract the label and type for any given labelled field of the DataCon, or return Nothing if the field does not belong to it

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.

PreInlineUnconditionally Id
PostInlineUnconditionally Id
UnfoldingDone Id
RuleFired FastString
LetFloatFromLet
EtaExpansion Id
EtaReduction Id
BetaReduction Id
CaseOfCase Id
KnownBranch Id
CaseMerge Id
AltMerge Id
CaseElim Id
CaseIdentity Id
FillInCaseDefault Id
SimplifierDone

CoreDoSimplify !SimplifyOpts	The core-to-core simplifier.
CoreDoPluginPass String CorePluginPass
CoreDoFloatInwards
CoreDoFloatOutwards FloatOutSwitches
CoreLiberateCase
CoreDoPrintCore
CoreDoStaticArgs
CoreDoCallArity
CoreDoExitify
CoreDoDemand Bool
CoreDoCpr
CoreDoWorkerWrapper
CoreDoSpecialising
CoreDoSpecConstr
CoreCSE
CoreDoRuleCheck CompilerPhase String
CoreDoNothing
CoreDoPasses [CoreToDo]
CoreDesugar
CoreDesugarOpt
CoreTidy
CorePrep
CoreAddCallerCcs
CoreAddLateCcs

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

:: Type	A product type, perhaps
-> Maybe (TyCon, [Type], DataCon, [Scaled Type])

:: InterestingVarFun	Says which `Expr`s are interesting
-> CoreExpr
-> VarSet

:: AltCon	Case alternative constructor
-> [CoreBndr]	Things bound by the pattern match
-> [Type]	The type arguments to the case alternative
-> CoreExpr

:: TyCon	Type constructor of scrutinee's type (used to prune possibilities)
-> [Type]	And its type arguments
-> [AltCon]	`imposs_cons`: constructors known to be impossible due to the form of the scrutinee
-> [Alt b]	Alternatives
-> ([AltCon], [Alt b])

:: [Unique]	Uniques for constructing new binders
-> Mult	Multiplicity annotation of the case expression
-> TyCon	Type constructor of scrutinee's type
-> [Type]	Type arguments of scrutinee's type
-> [AltCon]	Constructors that cannot match the DEFAULT (if any)
-> [CoreAlt]
-> (Bool, [CoreAlt])	`True`, if a default alt was replaced with a `DataAlt`

:: CoreExpr	scrutinee
-> Scaled Type
-> Type	res_ty
-> [CoreAlt]	alts
-> CoreExpr

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

:: [Id]	The `Id`s to pattern match the tuple against
-> Id	The `Id` to select
-> Id	A variable of the same type as the scrutinee
-> CoreExpr	Scrutinee
-> CoreExpr	Selector expression

:: UniqSupply	For inventing names of intermediate variables
-> [Id]	The tuple identifiers to pattern match on; Bring these into scope in the body
-> CoreExpr	Body of the case
-> CoreExpr	Scrutinee
-> CoreExpr

:: MonadThings m
=> Type	Element type of the list
-> Type	Fold result type
-> CoreExpr	Cons function expression for the fold
-> CoreExpr	Nil expression for the fold
-> CoreExpr	List expression being folded acress
-> m CoreExpr

:: (MonadFail m, MonadThings m, MonadUnique m)
=> Type	Type of list elements to be built
-> ((Id, Type) -> (Id, Type) -> m CoreExpr)	Function that, given information about the `Id`s of the binders for the build worker function, returns the body of that worker
-> m CoreExpr

:: DynFlags	`DynFlags` to retrieve the options from
-> (DynFlags -> [a])	Relevant record accessor: one of the `opt_*` accessors
-> [a]	Correctly ordered extracted options

:: MonadIO m
=> DynFlags
-> [Located String]
-> m (DynFlags, [Located String], [Warn])	Updated `DynFlags`, left-over arguments, and list of warnings.

:: forall s m. MonadIO m
=> [Flag (CmdLineP s)]	valid flags to match against
-> s	current state
-> [Located String]	arguments to parse
-> m (([Located String], [Err], [Warn]), s)	(leftovers, errors, warnings)

:: MonadIO m
=> [Flag (CmdLineP DynFlags)]	valid flags to match against
-> Bool	are the arguments from the command line?
-> DynFlags	current dynamic flags
-> [Located String]	arguments to parse
-> m (DynFlags, [Located String], [Warn])

:: RuleOpts	Rule options
-> CompilerPhase	Rule activation test
-> String	Rule pattern
-> (Id -> [CoreRule])	Rules for an Id
-> CoreProgram	Bindings to check in
-> SDoc	Resulting check message

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

:: HscEnv
-> RuleBase
-> Char	Mask
-> Module
-> NamePprCtx
-> SrcSpan
-> CoreM a
-> IO (a, SimplCount)

:: Logger
-> DynFlags
-> Bool	Is this a simple interface generated after the core pipeline, or one with information from the backend? See: Note [Writing interface files]
-> ModIface
-> Maybe Fingerprint	The old interface hash, used to decide if we need to actually write the new interface.
-> ModLocation
-> IO ()

:: HscEnv
-> CgGuts
-> ModLocation
-> FilePath
-> IO (FilePath, Maybe FilePath, [(ForeignSrcLang, FilePath)], Maybe StgCgInfos, Maybe CmmCgInfos)	`Just f` = _stub.c is f

:: HscEnv
-> Module
-> InfoTableProvMap
-> [TyCon]
-> CollectedCCs
-> [CgStgTopBinding]	Bindings come already annotated with fvs
-> HpcInfo
-> IO (Stream IO CmmGroupSRTs CmmCgInfos)

:: HscEnv
-> String	The statement
-> String	The source
-> Int	Starting line
-> IO (Maybe ([Id], ForeignHValue, FixityEnv))

:: HscEnv
-> GhciLStmt GhcPs	The parsed statement
-> IO (Maybe ([Id], ForeignHValue, FixityEnv))

:: HscEnv
-> Bool	Normalise the type
-> String	The type as a string
-> IO (Type, Kind)	Resulting type (possibly normalised) and kind