Language.Haskell.Liquid.GHC.API

This module re-exports a bunch of the GHC API.

Documentation

parser

Arguments

:: String

Haskell module source text (full Unicode is supported)

-> DynFlags

the flags

-> FilePath

the filename (for source locations)

-> (WarningMessages, Either ErrorMessages (Located (HsModule GhcPs)))

A pure interface to the module parser.

lookupName :: GhcMonad m => Name -> m (Maybe TyThing)

Returns the TyThing for a Name. The Name may refer to any entity known to GHC, including Names defined using runStmt.

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

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

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

getGHCiMonad :: GhcMonad m => m Name

Get the monad GHCi lifts user statements into.

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

Set the monad GHCi lifts user statements into.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Return module source as token stream, including comments.

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

pprParenSymName :: NamedThing a => a -> SDoc

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

dataConType :: DataCon -> Type

getNameToInstancesIndex

Arguments

:: GhcMonad m

=> [Module]

visible modules. An orphan instance will be returned if it is visible from at least one module in the list.

-> Maybe [Module]

modules to load. If this is not specified, we load modules for everything that is in scope unqualified.

-> m (Messages, Maybe (NameEnv ([ClsInst], [FamInst])))

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

getGRE :: GhcMonad m => m GlobalRdrEnv

get the GlobalRdrEnv for a session

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

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

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

isDictonaryId :: Id -> Bool

modInfoModBreaks :: ModuleInfo -> ModBreaks

modInfoSafe :: ModuleInfo -> SafeHaskellMode

Retrieve module safe haskell mode

modInfoRdrEnv :: ModuleInfo -> Maybe GlobalRdrEnv

modInfoIface :: ModuleInfo -> Maybe ModIface

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

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

modInfoIsExportedName :: ModuleInfo -> Name -> Bool

modInfoInstances :: ModuleInfo -> [ClsInst]

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

modInfoExportsWithSelectors :: ModuleInfo -> [Name]

modInfoExports :: ModuleInfo -> [Name]

modInfoTopLevelScope :: ModuleInfo -> Maybe [Name]

modInfoTyThings :: ModuleInfo -> [TyThing]

The list of top-level entities defined in a module

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

Request information about a loaded Module

getPrintUnqual :: GhcMonad m => m PrintUnqualified

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

Return the instances for the current interactive session.

getBindings :: GhcMonad m => m [TyThing]

Return the bindings for the current interactive session.

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

Return True == module is loaded.

getModuleGraph :: GhcMonad m => m ModuleGraph

Get the module dependency graph.

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

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

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

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

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

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

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

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

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

Desugar a typechecked module.

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

Typecheck and rename a parsed module.

Throws a SourceError if either fails.

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

Parse a module.

Throws a SourceError on parse error.

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

Return the ModSummary of a module with the given name.

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

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

workingDirectoryChanged :: GhcMonad m => m ()

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

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

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

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

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

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

Remove a target

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

Add another target.

getTargets :: GhcMonad m => m [Target]

Returns the current set of targets

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

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

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

getInteractiveDynFlags :: GhcMonad m => m DynFlags

Get the DynFlags used to evaluate interactive expressions.

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

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

getProgramDynFlags :: GhcMonad m => m DynFlags

Returns the program DynFlags.

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

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

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

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

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

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

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

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

Initialise a GHC session.

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

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

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

runGhcT

Arguments

:: ExceptionMonad m

=> Maybe FilePath

See argument to initGhcMonad.

-> GhcT m a

The action to perform.

-> m a

Run function for GhcT monad transformer.

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

runGhc

Arguments

:: Maybe FilePath

See argument to initGhcMonad.

-> Ghc a

The action to perform.

-> IO a

Run function for the Ghc monad.

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

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

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

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

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

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

class ParsedMod m where

Minimal complete definition

modSummary, parsedSource

Methods

parsedSource :: m -> ParsedSource

Instances

ParsedMod ParsedModule

Defined in GHC

Methods

modSummary :: ParsedModule -> ModSummary

parsedSource :: ParsedModule -> ParsedSource

ParsedMod TypecheckedModule

Defined in GHC

Methods

modSummary :: TypecheckedModule -> ModSummary

parsedSource :: TypecheckedModule -> ParsedSource

ParsedMod DesugaredModule

Defined in GHC

Methods

modSummary :: DesugaredModule -> ModSummary

parsedSource :: DesugaredModule -> ParsedSource

class ParsedMod m => TypecheckedMod m where

Minimal complete definition

renamedSource, typecheckedSource, moduleInfo, tm_internals

Methods

renamedSource :: m -> Maybe RenamedSource

typecheckedSource :: m -> TypecheckedSource

moduleInfo :: m -> ModuleInfo

Instances

TypecheckedMod TypecheckedModule

Defined in GHC

Methods

renamedSource :: TypecheckedModule -> Maybe RenamedSource

typecheckedSource :: TypecheckedModule -> TypecheckedSource

moduleInfo :: TypecheckedModule -> ModuleInfo

tm_internals :: TypecheckedModule -> (TcGblEnv, ModDetails)

TypecheckedMod DesugaredModule

Defined in GHC

Methods

renamedSource :: DesugaredModule -> Maybe RenamedSource

typecheckedSource :: DesugaredModule -> TypecheckedSource

moduleInfo :: DesugaredModule -> ModuleInfo

tm_internals :: DesugaredModule -> (TcGblEnv, ModDetails)

data ParsedModule

The result of successful parsing.

Constructors

ParsedModule

Fields

• pm_mod_summary :: ModSummary
• pm_parsed_source :: ParsedSource
• pm_extra_src_files :: [FilePath]
• pm_annotations :: ApiAnns

Instances

ParsedMod ParsedModule

Defined in GHC

Methods

modSummary :: ParsedModule -> ModSummary

parsedSource :: ParsedModule -> ParsedSource

data TypecheckedModule

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

Constructors

TypecheckedModule

Fields

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

Instances

ParsedMod TypecheckedModule

Defined in GHC

Methods

modSummary :: TypecheckedModule -> ModSummary

parsedSource :: TypecheckedModule -> ParsedSource

TypecheckedMod TypecheckedModule

Defined in GHC

Methods

renamedSource :: TypecheckedModule -> Maybe RenamedSource

typecheckedSource :: TypecheckedModule -> TypecheckedSource

moduleInfo :: TypecheckedModule -> ModuleInfo

tm_internals :: TypecheckedModule -> (TcGblEnv, ModDetails)

data DesugaredModule

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

Constructors

DesugaredModule

Fields

• dm_typechecked_module :: TypecheckedModule
• dm_core_module :: ModGuts

Instances

ParsedMod DesugaredModule

Defined in GHC

Methods

modSummary :: DesugaredModule -> ModSummary

parsedSource :: DesugaredModule -> ParsedSource

TypecheckedMod DesugaredModule

Defined in GHC

Methods

renamedSource :: DesugaredModule -> Maybe RenamedSource

typecheckedSource :: DesugaredModule -> TypecheckedSource

moduleInfo :: DesugaredModule -> ModuleInfo

tm_internals :: DesugaredModule -> (TcGblEnv, ModDetails)

DesugaredMod DesugaredModule

Defined in GHC

Methods

coreModule :: DesugaredModule -> ModGuts

type ParsedSource = Located (HsModule GhcPs)

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

type TypecheckedSource = LHsBinds GhcTc

data CoreModule

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

Constructors

CoreModule

Fields

• cm_module :: !Module

  Module name

• cm_types :: !TypeEnv

  Type environment for types declared in this module

• cm_binds :: CoreProgram

  Declarations

• cm_safe :: SafeHaskellMode

  Safe Haskell mode

Instances

Outputable CoreModule

Defined in GHC

Methods

ppr :: CoreModule -> SDoc

pprPrec :: Rational -> CoreModule -> SDoc

data ModuleInfo

Container for information about a Module.

cyclicModuleErr :: [ModSummary] -> SDoc

topSortModuleGraph

Arguments

:: Bool

Drop hi-boot nodes? (see below)

-> ModuleGraph

-> Maybe ModuleName

Root module name. If Nothing, use the full graph.

-> [SCC ModSummary]

Topological sort of the module graph

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

Drop hi-boot nodes (first boolean arg)?

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

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

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

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

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

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

depanal

Arguments

:: GhcMonad m

=> [ModuleName]

excluded modules

-> Bool

allow duplicate roots

-> m ModuleGraph

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

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

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

data LoadHowMuch

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

Constructors

LoadAllTargets

Load all targets and its dependencies.

LoadUpTo ModuleName

Load only the given module and its dependencies.

LoadDependenciesOf ModuleName

Load only the dependencies of the given module, but not the module itself.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

parseInstanceHead :: GhcMonad m => String -> m Type

getInstancesForType :: GhcMonad m => Type -> m [ClsInst]

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

Get the kind of a type

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

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

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

isDecl :: DynFlags -> String -> Bool

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

isImport :: DynFlags -> String -> Bool

Returns True if passed string is an import declaration.

hasImport :: DynFlags -> String -> Bool

Returns True if passed string has an import declaration.

isStmt :: DynFlags -> String -> Bool

Returns True if passed string is a statement.

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

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

getRdrNamesInScope :: GhcMonad m => m [RdrName]

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

getNamesInScope :: GhcMonad m => m [Name]

Returns all names in scope in the current interactive context

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

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

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

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

getContext :: GhcMonad m => m [InteractiveImport]

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

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

Set the interactive evaluation context.

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

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

abandonAll :: GhcMonad m => m Bool

abandon :: GhcMonad m => m Bool

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

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

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

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

runParsedDecls :: GhcMonad m => [LHsDecl GhcPs] -> m [Name]

Like runDeclsWithLocation, but takes parsed declarations as argument. Useful when doing preprocessing on the AST before execution, e.g. in GHCi (see GHCi.UI.runStmt).

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

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

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

execStmt' :: GhcMonad m => GhciLStmt GhcPs -> String -> ExecOptions -> m ExecResult

Like execStmt, but takes a parsed statement as argument. Useful when doing preprocessing on the AST before execution, e.g. in GHCi (see GHCi.UI.runStmt).

execStmt

Arguments

:: GhcMonad m

=> String

a statement (bind or expression)

-> ExecOptions

-> m ExecResult

Run a statement in the current interactive context.

execOptions :: ExecOptions

default ExecOptions

getHistoryModule :: History -> Module

getResumeContext :: GhcMonad m => m [Resume]

data GetDocsFailure

Failure modes for getDocs.

Constructors

NameHasNoModule Name

nameModule_maybe returned Nothing.

NoDocsInIface Module Bool

True: The module was compiled. False: The module was :loaded.

InteractiveName

The Name was defined interactively.

Instances

Outputable GetDocsFailure

Defined in InteractiveEval

Methods

ppr :: GetDocsFailure -> SDoc

pprPrec :: Rational -> GetDocsFailure -> SDoc

showModuleIndex :: (Int, Int) -> String

dumpIfaceStats :: HscEnv -> IO ()

hscCompileCoreExpr' :: HscEnv -> SrcSpan -> CoreExpr -> IO ForeignHValue

hscCompileCoreExpr :: HscEnv -> SrcSpan -> CoreExpr -> IO ForeignHValue

hscParseIdentifier :: HscEnv -> String -> IO (Located RdrName)

hscParseType :: String -> Hsc (LHsType GhcPs)

hscParseStmtWithLocation :: String -> Int -> String -> Hsc (Maybe (GhciLStmt GhcPs))

hscParseExpr :: String -> Hsc (LHsExpr GhcPs)

hscKcType

Arguments

:: HscEnv

-> Bool

Normalise the type

-> String

The type as a string

-> IO (Type, Kind)

Resulting type (possibly normalised) and kind

Find the kind of a type, after generalisation

hscTcExpr

Arguments

:: HscEnv

-> TcRnExprMode

-> String

The expression

-> IO Type

Typecheck an expression (but don't run it)

hscImport :: HscEnv -> String -> IO (ImportDecl GhcPs)

hscAddSptEntries :: HscEnv -> [SptEntry] -> IO ()

Load the given static-pointer table entries into the interpreter. See Note [Grand plan for static forms] in StaticPtrTable.

hscParsedDecls :: HscEnv -> [LHsDecl GhcPs] -> IO ([TyThing], InteractiveContext)

hscDeclsWithLocation

Arguments

:: HscEnv

-> String

The statement

-> String

The source

-> Int

Starting line

-> IO ([TyThing], InteractiveContext)

Compile a decls

hscParseDeclsWithLocation :: HscEnv -> String -> Int -> String -> IO [LHsDecl GhcPs]

hscDecls

Arguments

:: HscEnv

-> String

The statement

-> IO ([TyThing], InteractiveContext)

Compile a decls

hscParsedStmt

Arguments

:: HscEnv

-> GhciLStmt GhcPs

The parsed statement

-> IO (Maybe ([Id], ForeignHValue, FixityEnv))

hscStmtWithLocation

Arguments

:: HscEnv

-> String

The statement

-> String

The source

-> Int

Starting line

-> IO (Maybe ([Id], ForeignHValue, FixityEnv))

Compile a stmt all the way to an HValue, but don't run it

We return Nothing to indicate an empty statement (or comment only), not a parse error.

hscStmt :: HscEnv -> String -> IO (Maybe ([Id], ForeignHValue, FixityEnv))

Compile a stmt all the way to an HValue, but don't run it

We return Nothing to indicate an empty statement (or comment only), not a parse error.

hscCompileCmmFile :: HscEnv -> FilePath -> FilePath -> IO ()

hscInteractive :: HscEnv -> CgGuts -> ModLocation -> IO (Maybe FilePath, CompiledByteCode, [SptEntry])

hscGenHardCode

Arguments

:: HscEnv

-> CgGuts

-> ModLocation

-> FilePath

-> IO (FilePath, Maybe FilePath, [(ForeignSrcLang, FilePath)])

Just f = _stub.c is f

Compile to hard-code.

hscSimpleIface' :: TcGblEnv -> Maybe Fingerprint -> Hsc (ModIface, Maybe Fingerprint, ModDetails)

hscSimplify' :: [String] -> ModGuts -> Hsc ModGuts

hscSimplify :: HscEnv -> [String] -> ModGuts -> IO ModGuts

hscGetSafe :: HscEnv -> Module -> SrcSpan -> IO (Bool, Set InstalledUnitId)

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

hscCheckSafe :: HscEnv -> Module -> SrcSpan -> IO Bool

Check that a module is safe to import.

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

hscFileFrontEnd :: ModSummary -> Hsc TcGblEnv

Given a ModSummary, parses and typechecks it, returning the TcGblEnv resulting from type-checking.

batchMsg :: Messager

oneShotMsg :: HscEnv -> RecompileRequired -> IO ()

hscMaybeWriteIface :: DynFlags -> ModIface -> Maybe Fingerprint -> ModLocation -> IO ()

hscIncrementalCompile :: Bool -> Maybe TcGblEnv -> Maybe Messager -> HscEnv -> ModSummary -> SourceModified -> Maybe ModIface -> (Int, Int) -> IO (HscStatus, ModDetails, DynFlags)

Used by both OneShot and batch mode. Runs the pipeline HsSyn and Core parts of the pipeline. We return a interface if we already had an old one around and recompilation was not needed. Otherwise it will be created during later passes when we run the compilation pipeline.

genericHscFrontend :: ModSummary -> Hsc FrontendResult

makeSimpleDetails :: HscEnv -> TcGblEnv -> IO ModDetails

Make a ModDetails from the results of typechecking. Used when typechecking only, as opposed to full compilation.

hscDesugar' :: ModLocation -> TcGblEnv -> Hsc ModGuts

hscDesugar :: HscEnv -> ModSummary -> TcGblEnv -> IO ModGuts

Convert a typechecked module to Core

tcRnModule' :: ModSummary -> Bool -> HsParsedModule -> Hsc TcGblEnv

hscTypecheckRename :: HscEnv -> ModSummary -> HsParsedModule -> IO (TcGblEnv, RenamedStuff)

Rename and typecheck a module, additionally returning the renamed syntax

hscParse' :: ModSummary -> Hsc HsParsedModule

hscParse :: HscEnv -> ModSummary -> IO HsParsedModule

parse a file, returning the abstract syntax

hscRnImportDecls :: HscEnv -> [LImportDecl GhcPs] -> IO GlobalRdrEnv

Rename some import declarations

hscGetModuleInterface :: HscEnv -> Module -> IO ModIface

hscIsGHCiMonad :: HscEnv -> String -> IO Name

hscTcRnGetInfo :: HscEnv -> Name -> IO (Maybe (TyThing, Fixity, [ClsInst], [FamInst], SDoc))

hscTcRcLookupName :: HscEnv -> Name -> IO (Maybe TyThing)

hscTcRnLookupRdrName :: HscEnv -> Located RdrName -> IO [Name]

Lookup things in the compiler's environment

ioMsgMaybe :: IO (Messages, Maybe a) -> Hsc a

Deal with errors and warnings returned by a compilation step

In order to reduce dependencies to other parts of the compiler, functions outside the "main" parts of GHC return warnings and errors as a parameter and signal success via by wrapping the result in a Maybe type. This function logs the returned warnings and propagates errors as exceptions (of type SourceError).

This function assumes the following invariants:

1. If the second result indicates success (is of the form 'Just x'), there must be no error messages in the first result.
2. If there are no error messages, but the second result indicates failure there should be warnings in the first result. That is, if the action failed, it must have been due to the warnings (i.e., -Werror).

getHscEnv :: Hsc HscEnv

newHscEnv :: DynFlags -> IO HscEnv

type Messager = HscEnv -> (Int, Int) -> RecompileRequired -> ModSummary -> IO ()

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

data TcRnExprMode

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

Constructors

TM_Inst

Instantiate the type fully (:type)

TM_NoInst

Do not instantiate the type (:type +v)

TM_Default

Default the type eagerly (:type +d)

pprFamInst :: FamInst -> SDoc

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

defaultWarnErrLogger :: WarnErrLogger

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

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

getSessionDynFlags :: GhcMonad m => m DynFlags

Grabs the DynFlags from the Session

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

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

In short, a GHC monad

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

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

Methods

getSession :: m HscEnv

setSession :: HscEnv -> m ()

Instances

GhcMonad Ghc

Defined in GhcMonad

Methods

getSession :: Ghc HscEnv

setSession :: HscEnv -> Ghc ()

ExceptionMonad m => GhcMonad (GhcT m)

Defined in GhcMonad

Methods

getSession :: GhcT m HscEnv

setSession :: HscEnv -> GhcT m ()

data Ghc a

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

Instances

Monad Ghc

Defined in GhcMonad

Methods

(>>=) :: Ghc a -> (a -> Ghc b) -> Ghc b

(>>) :: Ghc a -> Ghc b -> Ghc b

return :: a -> Ghc a

Functor Ghc

Defined in GhcMonad

Methods

fmap :: (a -> b) -> Ghc a -> Ghc b

(<$) :: a -> Ghc b -> Ghc a

MonadFix Ghc

Defined in GhcMonad

Methods

mfix :: (a -> Ghc a) -> Ghc a

Applicative Ghc

Defined in GhcMonad

Methods

pure :: a -> Ghc a

(<*>) :: Ghc (a -> b) -> Ghc a -> Ghc b

liftA2 :: (a -> b -> c) -> Ghc a -> Ghc b -> Ghc c

(*>) :: Ghc a -> Ghc b -> Ghc b

(<*) :: Ghc a -> Ghc b -> Ghc a

MonadIO Ghc

Defined in GhcMonad

Methods

liftIO :: IO a -> Ghc a

GhcMonad Ghc

Defined in GhcMonad

Methods

getSession :: Ghc HscEnv

setSession :: HscEnv -> Ghc ()

HasDynFlags Ghc

Defined in GhcMonad

Methods

getDynFlags :: Ghc DynFlags

ExceptionMonad Ghc

Defined in GhcMonad

Methods

gcatch :: Exception e => Ghc a -> (e -> Ghc a) -> Ghc a

gmask :: ((Ghc a -> Ghc a) -> Ghc b) -> Ghc b

gbracket :: Ghc a -> (a -> Ghc b) -> (a -> Ghc c) -> Ghc c

gfinally :: Ghc a -> Ghc b -> Ghc a

GhcMonadLike Ghc

Defined in Language.Haskell.Liquid.GHC.GhcMonadLike

HasHscEnv Ghc

Defined in Language.Haskell.Liquid.GHC.GhcMonadLike

Methods

askHscEnv :: Ghc HscEnv

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

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

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

Instances

Monad m => Monad (GhcT m)

Defined in GhcMonad

Methods

(>>=) :: GhcT m a -> (a -> GhcT m b) -> GhcT m b

(>>) :: GhcT m a -> GhcT m b -> GhcT m b

return :: a -> GhcT m a

Functor m => Functor (GhcT m)

Defined in GhcMonad

Methods

fmap :: (a -> b) -> GhcT m a -> GhcT m b

(<$) :: a -> GhcT m b -> GhcT m a

Applicative m => Applicative (GhcT m)

Defined in GhcMonad

Methods

pure :: a -> GhcT m a

(<*>) :: GhcT m (a -> b) -> GhcT m a -> GhcT m b

liftA2 :: (a -> b -> c) -> GhcT m a -> GhcT m b -> GhcT m c

(*>) :: GhcT m a -> GhcT m b -> GhcT m b

(<*) :: GhcT m a -> GhcT m b -> GhcT m a

MonadIO m => MonadIO (GhcT m)

Defined in GhcMonad

Methods

liftIO :: IO a -> GhcT m a

ExceptionMonad m => GhcMonad (GhcT m)

Defined in GhcMonad

Methods

getSession :: GhcT m HscEnv

setSession :: HscEnv -> GhcT m ()

MonadIO m => HasDynFlags (GhcT m)

Defined in GhcMonad

Methods

getDynFlags :: GhcT m DynFlags

ExceptionMonad m => ExceptionMonad (GhcT m)

Defined in GhcMonad

Methods

gcatch :: Exception e => GhcT m a -> (e -> GhcT m a) -> GhcT m a

gmask :: ((GhcT m a -> GhcT m a) -> GhcT m b) -> GhcT m b

gbracket :: GhcT m a -> (a -> GhcT m b) -> (a -> GhcT m c) -> GhcT m c

gfinally :: GhcT m a -> GhcT m b -> GhcT m a

(ExceptionMonad m, GhcMonadLike m) => GhcMonadLike (GhcT m)

Defined in Language.Haskell.Liquid.GHC.GhcMonadLike

(ExceptionMonad m, HasHscEnv m) => HasHscEnv (GhcT m)

Defined in Language.Haskell.Liquid.GHC.GhcMonadLike

Methods

askHscEnv :: GhcT m HscEnv

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

A function called to log warnings and errors.

phaseForeignLanguage :: Phase -> Maybe ForeignSrcLang

Foreign language of the phase if the phase deals with a foreign code

extendCompleteMatchMap :: CompleteMatchMap -> [CompleteMatch] -> CompleteMatchMap

mkCompleteMatchMap :: [CompleteMatch] -> CompleteMatchMap

byteCodeOfObject :: Unlinked -> CompiledByteCode

Retrieve the compiled byte-code if possible. Panic if it is a file-based linkable

nameOfObject :: Unlinked -> FilePath

Retrieve the filename of the linkable if possible. Panic if it is a byte-code object

isInterpretable :: Unlinked -> Bool

Is this a bytecode linkable with no file on disk?

isObject :: Unlinked -> Bool

Is this an actual file on disk we can link in somehow?

linkableObjs :: Linkable -> [FilePath]

isObjectLinkable :: Linkable -> Bool

numToTrustInfo :: Word8 -> IfaceTrustInfo

trustInfoToNum :: IfaceTrustInfo -> Word8

noIfaceTrustInfo :: IfaceTrustInfo

setSafeMode :: SafeHaskellMode -> IfaceTrustInfo

getSafeMode :: IfaceTrustInfo -> SafeHaskellMode

isHpcUsed :: HpcInfo -> AnyHpcUsage

Find out if HPC is used by this module or any of the modules it depends upon

emptyHpcInfo :: AnyHpcUsage -> HpcInfo

showModMsg :: DynFlags -> HscTarget -> Bool -> ModSummary -> String

isBootSummary :: ModSummary -> Bool

Did this ModSummary originate from a hs-boot file?

msObjFilePath :: ModSummary -> FilePath

msHiFilePath :: ModSummary -> FilePath

msHsFilePath :: ModSummary -> FilePath

ms_home_imps :: ModSummary -> [Located ModuleName]

All of the (possibly) home module imports from a ModSummary; that is to say, each of these module names could be a home import if an appropriately named file existed. (This is in contrast to package qualified imports, which are guaranteed not to be home imports.)

ms_home_srcimps :: ModSummary -> [Located ModuleName]

Like ms_home_imps, but for SOURCE imports.

ms_home_allimps :: ModSummary -> [ModuleName]

home_imps :: [(Maybe FastString, Located ModuleName)] -> [Located ModuleName]

ms_imps :: ModSummary -> [(Maybe FastString, Located ModuleName)]

ms_mod_name :: ModSummary -> ModuleName

ms_installed_mod :: ModSummary -> InstalledModule

mkModuleGraph :: [ModSummary] -> ModuleGraph

extendMG :: ModuleGraph -> ModSummary -> ModuleGraph

Add a ModSummary to ModuleGraph. Assumes that the new ModSummary is not an element of the ModuleGraph.

isTemplateHaskellOrQQNonBoot :: ModSummary -> Bool

emptyMG :: ModuleGraph

mgLookupModule :: ModuleGraph -> Module -> Maybe ModSummary

Look up a ModSummary in the ModuleGraph

mgElemModule :: ModuleGraph -> Module -> Bool

mgModSummaries :: ModuleGraph -> [ModSummary]

mgBootModules :: ModuleGraph -> ModuleSet

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

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

needsTemplateHaskellOrQQ :: ModuleGraph -> Bool

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

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

soExt :: Platform -> FilePath

mkHsSOName :: Platform -> FilePath -> FilePath

mkSOName :: Platform -> FilePath -> FilePath

updNameCache :: IORef NameCache -> (NameCache -> (NameCache, c)) -> IO c

addEpsInStats :: EpsStats -> Int -> Int -> Int -> EpsStats

Add stats for one newly-read interface

noDependencies :: Dependencies

lookupFixity :: FixityEnv -> Name -> Fixity

emptyFixityEnv :: FixityEnv

mkIfaceFixCache :: [(OccName, Fixity)] -> OccName -> Maybe Fixity

Creates cached lookup for the mi_fix_fn field of ModIface

plusWarns :: Warnings -> Warnings -> Warnings

emptyIfaceWarnCache :: OccName -> Maybe WarningTxt

mkIfaceWarnCache :: Warnings -> OccName -> Maybe WarningTxt

Constructs the cache for the mi_warn_fn field of a ModIface

tyThingId :: TyThing -> Id

Get the Id from a TyThing if it is a id *or* data constructor thing. Panics otherwise

tyThingConLike :: TyThing -> ConLike

Get the ConLike from a TyThing if it is a data constructor thing. Panics otherwise

tyThingDataCon :: TyThing -> DataCon

Get the DataCon from a TyThing if it is a data constructor thing. Panics otherwise

tyThingCoAxiom :: TyThing -> CoAxiom Branched

Get the CoAxiom from a TyThing if it is a coercion axiom thing. Panics otherwise

tyThingTyCon :: TyThing -> TyCon

Get the TyCon from a TyThing if it is a type constructor thing. Panics otherwise

lookupTypeHscEnv :: HscEnv -> Name -> IO (Maybe TyThing)

As lookupType, but with a marginally easier-to-use interface if you have a HscEnv

lookupType :: DynFlags -> HomePackageTable -> PackageTypeEnv -> Name -> Maybe TyThing

Find the TyThing for the given Name by using all the resources at our disposal: the compiled modules in the HomePackageTable and the compiled modules in other packages that live in PackageTypeEnv. Note that this does NOT look up the TyThing in the module being compiled: you have to do that yourself, if desired

plusTypeEnv :: TypeEnv -> TypeEnv -> TypeEnv

extendTypeEnvWithIds :: TypeEnv -> [Id] -> TypeEnv

extendTypeEnvList :: TypeEnv -> [TyThing] -> TypeEnv

extendTypeEnv :: TypeEnv -> TyThing -> TypeEnv

lookupTypeEnv :: TypeEnv -> Name -> Maybe TyThing

typeEnvFromEntities :: [Id] -> [TyCon] -> [FamInst] -> TypeEnv

mkTypeEnvWithImplicits :: [TyThing] -> TypeEnv

mkTypeEnv :: [TyThing] -> TypeEnv

typeEnvClasses :: TypeEnv -> [Class]

typeEnvDataCons :: TypeEnv -> [DataCon]

typeEnvPatSyns :: TypeEnv -> [PatSyn]

typeEnvIds :: TypeEnv -> [Id]

typeEnvCoAxioms :: TypeEnv -> [CoAxiom Branched]

typeEnvTyCons :: TypeEnv -> [TyCon]

typeEnvElts :: TypeEnv -> [TyThing]

emptyTypeEnv :: TypeEnv

tyThingAvailInfo :: TyThing -> [AvailInfo]

The Names that a TyThing should bring into scope. Used to build the GlobalRdrEnv for the InteractiveContext.

tyThingsTyCoVars :: [TyThing] -> TyCoVarSet

tyThingParent_maybe :: TyThing -> Maybe TyThing

tyThingParent_maybe x returns (Just p) when pprTyThingInContext should print a declaration for p (albeit with some "..." in it) when asked to show x It returns the *immediate* parent. So a datacon returns its tycon but the tycon could be the associated type of a class, so it in turn might have a parent.

isImplicitTyThing :: TyThing -> Bool

Returns True if there should be no interface-file declaration for this thing on its own: either it is built-in, or it is part of some other declaration, or it is generated implicitly by some other declaration.

implicitTyConThings :: TyCon -> [TyThing]

implicitClassThings :: Class -> [TyThing]

implicitTyThings :: TyThing -> [TyThing]

Determine the TyThings brought into scope by another TyThing other than itself. For example, Id's don't have any implicit TyThings as they just bring themselves into scope, but classes bring their dictionary datatype, type constructor and some selector functions into scope, just for a start!

pkgQual :: DynFlags -> PrintUnqualified

A function which only qualifies package names if necessary; but qualifies all other identifiers.

mkQualPackage :: DynFlags -> QueryQualifyPackage

Creates a function for formatting packages based on two heuristics: (1) don't qualify if the package in question is "main", and (2) only qualify with a unit id if the package ID would be ambiguous.

mkQualModule :: DynFlags -> QueryQualifyModule

Creates a function for formatting modules based on two heuristics: (1) if the module is the current module, don't qualify, and (2) if there is only one exposed package which exports this module, don't qualify.

mkPrintUnqualified :: DynFlags -> GlobalRdrEnv -> PrintUnqualified

Creates some functions that work out the best ways to format names for the user according to a set of heuristics.

substInteractiveContext :: InteractiveContext -> TCvSubst -> InteractiveContext

icExtendGblRdrEnv :: GlobalRdrEnv -> [TyThing] -> GlobalRdrEnv

Add TyThings to the GlobalRdrEnv, earlier ones in the list shadowing later ones, and shadowing existing entries in the GlobalRdrEnv.

setInteractivePrintName :: InteractiveContext -> Name -> InteractiveContext

setInteractivePackage :: HscEnv -> HscEnv

extendInteractiveContextWithIds :: InteractiveContext -> [Id] -> InteractiveContext

extendInteractiveContext :: InteractiveContext -> [TyThing] -> [ClsInst] -> [FamInst] -> Maybe [Type] -> FixityEnv -> InteractiveContext

extendInteractiveContext is called with new TyThings recently defined to update the InteractiveContext to include them. Ids are easily removed when shadowed, but Classes and TyCons are not. Some work could be done to determine whether they are entirely shadowed, but as you could still have references to them (e.g. instances for classes or values of the type for TyCons), it's not clear whether removing them is even the appropriate behavior.

icPrintUnqual :: DynFlags -> InteractiveContext -> PrintUnqualified

Get the PrintUnqualified function based on the flags and this InteractiveContext

icInScopeTTs :: InteractiveContext -> [TyThing]

This function returns the list of visible TyThings (useful for e.g. showBindings)

icInteractiveModule :: InteractiveContext -> Module

emptyInteractiveContext :: DynFlags -> InteractiveContext

Constructs an empty InteractiveContext.

appendStubC :: ForeignStubs -> SDoc -> ForeignStubs

importedByUser :: [ImportedBy] -> [ImportedModsVal]

emptyModDetails :: ModDetails

Constructs an empty ModDetails

mkIfaceHashCache :: [(Fingerprint, IfaceDecl)] -> OccName -> Maybe (OccName, Fingerprint)

Constructs cache for the mi_hash_fn field of a ModIface

emptyFullModIface :: Module -> ModIface

emptyPartialModIface :: Module -> PartialModIface

renameFreeHoles :: UniqDSet ModuleName -> [(ModuleName, Module)] -> UniqDSet ModuleName

Given a set of free holes, and a unit identifier, rename the free holes according to the instantiation of the unit identifier. For example, if we have A and B free, and our unit identity is p[A=C,B=impl:B], the renamed free holes are just C.

mi_free_holes :: ModIface -> UniqDSet ModuleName

The "precise" free holes, e.g., the signatures that this ModIface depends on.

mi_semantic_module :: forall (a :: ModIfacePhase). ModIface_ a -> Module

The semantic module for this interface; e.g., if it's a interface for a signature, if mi_module is p[A=A]:A, mi_semantic_module will be A.

mi_fix :: ModIface -> OccName -> Fixity

Lookups up a (possibly cached) fixity from a ModIface. If one cannot be found, defaultFixity is returned instead.

mi_boot :: ModIface -> Bool

Old-style accessor for whether or not the ModIface came from an hs-boot file.

prepareAnnotations :: HscEnv -> Maybe ModGuts -> IO AnnEnv

Deal with gathering annotations in from all possible places and combining them into a single AnnEnv

metaRequestAW :: Functor f => MetaHook f -> LHsExpr GhcTc -> f Serialized

metaRequestD :: Functor f => MetaHook f -> LHsExpr GhcTc -> f [LHsDecl GhcPs]

metaRequestT :: Functor f => MetaHook f -> LHsExpr GhcTc -> f (LHsType GhcPs)

metaRequestP :: Functor f => MetaHook f -> LHsExpr GhcTc -> f (LPat GhcPs)

metaRequestE :: Functor f => MetaHook f -> LHsExpr GhcTc -> f (LHsExpr GhcPs)

hptRules :: HscEnv -> [(ModuleName, IsBootInterface)] -> [CoreRule]

Get rules from modules "below" this one (in the dependency sense)

hptInstances :: HscEnv -> (ModuleName -> Bool) -> ([ClsInst], [FamInst])

Find all the instance declarations (of classes and families) from the Home Package Table filtered by the provided predicate function. Used in tcRnImports, to select the instances that are in the transitive closure of imports from the currently compiled module.

hptCompleteSigs :: HscEnv -> [CompleteMatch]

lookupIfaceByModule :: HomePackageTable -> PackageIfaceTable -> Module -> Maybe ModIface

Find the ModIface for a Module, searching in both the loaded home and external package module information

lookupHptByModule :: HomePackageTable -> Module -> Maybe HomeModInfo

listToHpt :: [(ModuleName, HomeModInfo)] -> HomePackageTable

addListToHpt :: HomePackageTable -> [(ModuleName, HomeModInfo)] -> HomePackageTable

addToHpt :: HomePackageTable -> ModuleName -> HomeModInfo -> HomePackageTable

delFromHpt :: HomePackageTable -> ModuleName -> HomePackageTable

mapHpt :: (HomeModInfo -> HomeModInfo) -> HomePackageTable -> HomePackageTable

allHpt :: (HomeModInfo -> Bool) -> HomePackageTable -> Bool

filterHpt :: (HomeModInfo -> Bool) -> HomePackageTable -> HomePackageTable

eltsHpt :: HomePackageTable -> [HomeModInfo]

lookupHptDirectly :: HomePackageTable -> Unique -> Maybe HomeModInfo

lookupHpt :: HomePackageTable -> ModuleName -> Maybe HomeModInfo

pprHPT :: HomePackageTable -> SDoc

emptyPackageIfaceTable :: PackageIfaceTable

Constructs an empty PackageIfaceTable

emptyHomePackageTable :: HomePackageTable

Constructs an empty HomePackageTable

pprTargetId :: TargetId -> SDoc

pprTarget :: Target -> SDoc

hscEPS :: HscEnv -> IO ExternalPackageState

Retrieve the ExternalPackageState cache.

handleFlagWarnings :: DynFlags -> [Warn] -> IO ()

printOrThrowWarnings :: DynFlags -> Bag WarnMsg -> IO ()

Given a bag of warnings, turn them into an exception if -Werror is enabled, or print them out otherwise.

handleSourceError

Arguments

:: ExceptionMonad m

=> (SourceError -> m a)

exception handler

-> m a

action to perform

-> m a

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

throwOneError :: MonadIO io => ErrMsg -> io a

throwErrors :: MonadIO io => ErrorMessages -> io a

mkApiErr :: DynFlags -> SDoc -> GhcApiError

srcErrorMessages :: SourceError -> ErrorMessages

mkSrcErr :: ErrorMessages -> SourceError

runInteractiveHsc :: HscEnv -> Hsc a -> IO a

mkInteractiveHscEnv :: HscEnv -> HscEnv

runHsc :: HscEnv -> Hsc a -> IO a

data HscStatus

Status of a compilation to hard-code

Constructors

HscNotGeneratingCode ModIface

Nothing to do.

HscUpToDate ModIface

Nothing to do because code already exists.

HscUpdateBoot ModIface

Update boot file result.

HscUpdateSig ModIface

Generate signature file (backpack)

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.

• hscs_iface_dflags :: !DynFlags

  Generate final iface using this DynFlags. FIXME (osa): I don't understand why this is necessary, but I spent almost two days trying to figure this out and I couldn't .. perhaps someone who understands this code better will remove this later.

newtype Hsc a

Constructors

Hsc (HscEnv -> WarningMessages -> IO (a, WarningMessages))

Instances

Monad Hsc

Defined in HscTypes

Methods

(>>=) :: Hsc a -> (a -> Hsc b) -> Hsc b

(>>) :: Hsc a -> Hsc b -> Hsc b

return :: a -> Hsc a

Functor Hsc

Defined in HscTypes

Methods

fmap :: (a -> b) -> Hsc a -> Hsc b

(<$) :: a -> Hsc b -> Hsc a

Applicative Hsc

Defined in HscTypes

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

MonadIO Hsc

Defined in HscTypes

Methods

liftIO :: IO a -> Hsc a

HasDynFlags Hsc

Defined in HscTypes

Methods

getDynFlags :: Hsc DynFlags

GhcMonadLike Hsc

Defined in Language.Haskell.Liquid.GHC.GhcMonadLike

HasHscEnv Hsc

Defined in Language.Haskell.Liquid.GHC.GhcMonadLike

Methods

askHscEnv :: Hsc HscEnv

data 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.

Instances

Show SourceError

Defined in HscTypes

Methods

showsPrec :: Int -> SourceError -> ShowS

show :: SourceError -> String

showList :: [SourceError] -> ShowS

Exception SourceError

Defined in HscTypes

Methods

toException :: SourceError -> SomeException

fromException :: SomeException -> Maybe SourceError

displayException :: SourceError -> String

PPrint SourceError

Defined in Language.Haskell.Liquid.Types.PrettyPrint

Methods

pprintTidy :: Tidy -> SourceError -> Doc

pprintPrec :: Int -> Tidy -> SourceError -> Doc

Result SourceError

Defined in Language.Haskell.Liquid.GHC.Interface

Methods

result :: SourceError -> FixResult UserError

data GhcApiError

An error thrown if the GHC API is used in an incorrect fashion.

Instances

Show GhcApiError

Defined in HscTypes

Methods

showsPrec :: Int -> GhcApiError -> ShowS

show :: GhcApiError -> String

showList :: [GhcApiError] -> ShowS

Exception GhcApiError

Defined in HscTypes

Methods

toException :: GhcApiError -> SomeException

fromException :: SomeException -> Maybe GhcApiError

displayException :: GhcApiError -> String

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_HPT :: HomePackageTable

  The home package table describes already-compiled home-package modules, excluding the module we are compiling right now. (In one-shot mode the current module is the only home-package module, so hsc_HPT is empty. All other modules count as "external-package" modules. However, even in GHCi mode, hi-boot interfaces are demand-loaded into the external-package table.)

  hsc_HPT is not mutable because we only demand-load external packages; the home package is eagerly loaded, module by module, by the compilation manager.

  The HPT may contain modules compiled earlier by --make but not actually below the current module in the dependency graph.

  (This changes a previous invariant: changed Jan 05.)

• hsc_EPS :: !(IORef ExternalPackageState)

  Information about the currently loaded external packages. This is mutable because packages will be demand-loaded during a compilation run as required.

• hsc_NC :: !(IORef NameCache)

  As with hsc_EPS, this is side-effected by compiling to reflect sucking in interface files. They cache the state of external interface files, in effect.

• hsc_FC :: !(IORef FinderCache)

  The cached result of performing finding in the file system

• hsc_type_env_var :: Maybe (Module, 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_iserv :: MVar (Maybe IServ)

  interactive server process. Created the first time it is needed.

• hsc_dynLinker :: DynLinker

  dynamic linker.

data IServ

Constructors

IServ

Fields

• iservPipe :: Pipe
• iservProcess :: ProcessHandle
• iservLookupSymbolCache :: IORef (UniqFM (Ptr ()))
• iservPendingFrees :: [HValueRef]

data Target

A compilation target.

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

Constructors

Target

Fields

• targetId :: TargetId

  module or filename

• targetAllowObjCode :: Bool

  object code allowed?

• targetContents :: Maybe (InputFileBuffer, UTCTime)

  Optional in-memory buffer containing the source code GHC should use for this target instead of reading it from disk.

  Since GHC version 8.10 modules which require preprocessors such as Literate Haskell or CPP to run are also supported.

  If a corresponding source file does not exist on disk this will result in a SourceError exception if targetId = TargetModule _ is used. However together with targetId = TargetFile _ GHC will not complain about the file missing.

Instances

Outputable Target

Defined in HscTypes

Methods

ppr :: Target -> SDoc

pprPrec :: Rational -> Target -> SDoc

data TargetId

Constructors

TargetModule ModuleName

A module name: search for the file

TargetFile FilePath (Maybe Phase)

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

Instances

Eq TargetId

Defined in HscTypes

Methods

(==) :: TargetId -> TargetId -> Bool

(/=) :: TargetId -> TargetId -> Bool

Outputable TargetId

Defined in HscTypes

Methods

ppr :: TargetId -> SDoc

pprPrec :: Rational -> TargetId -> SDoc

type InputFileBuffer = StringBuffer

type HomePackageTable = DModuleNameEnv HomeModInfo

Helps us find information about modules in the home package

type PackageIfaceTable = ModuleEnv ModIface

Helps us find information about modules in the imported packages

data HomeModInfo

Information about modules in the package being compiled

Constructors

HomeModInfo

Fields

• hm_iface :: !ModIface

  The basic loaded interface file: every loaded module has one of these, even if it is imported from another package

• hm_details :: !ModDetails

  Extra information that has been created from the ModIface for the module, typically during typechecking

• hm_linkable :: !(Maybe Linkable)

  The actual artifact we would like to link to access things in this module.

  hm_linkable might be Nothing:

  1. If this is an .hs-boot module
  2. Temporarily during compilation if we pruned away the old linkable because it was out of date.

  After a complete compilation (load), all hm_linkable fields in the HomePackageTable will be Just.

  When re-linking a module (HscNoRecomp), we construct the HomeModInfo by building a new ModDetails from the old ModIface (only).

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 MetaResult

data constructors not exported to ensure correct result type

type MetaHook (f :: Type -> Type) = MetaRequest -> LHsExpr GhcTc -> f MetaResult

type FinderCache = InstalledModuleEnv InstalledFindResult

The FinderCache maps modules to the result of searching for that module. It records the results of searching for modules along the search path. On :load, we flush the entire contents of this cache.

data InstalledFindResult

Constructors

InstalledFound ModLocation InstalledModule

InstalledNoPackage InstalledUnitId

InstalledNotFound [FilePath] (Maybe InstalledUnitId)

data FindResult

The result of searching for an imported module.

NB: FindResult manages both user source-import lookups (which can result in Module) as well as direct imports for interfaces (which always result in InstalledModule).

Constructors

Found ModLocation Module

The module was found

NoPackage UnitId

The requested package was not found

FoundMultiple [(Module, ModuleOrigin)]

_Error_: both in multiple packages

NotFound

Not found

Fields

• fr_paths :: [FilePath]
• fr_pkg :: Maybe UnitId
• fr_mods_hidden :: [UnitId]
• fr_pkgs_hidden :: [UnitId]
• fr_unusables :: [(UnitId, UnusablePackageReason)]
• fr_suggestions :: [ModuleSuggestion]

type PartialModIface = ModIface_ 'ModIfaceCore

type ModIface = ModIface_ 'ModIfaceFinal

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)

  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.

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.

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

  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_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 [RnNames . Trust Own Package]

• mi_complete_sigs :: [IfaceCompleteMatch]
• mi_doc_hdr :: Maybe HsDocString

  Module header.

• mi_decl_docs :: DeclDocMap

  Docs on declarations.

• mi_arg_docs :: ArgDocMap

  Docs on arguments.

• mi_final_exts :: !(IfaceBackendExts phase)

  Either () or ModIfaceBackend for a fully instantiated interface.

Instances

Binary ModIface

Defined in HscTypes

Methods

put_ :: BinHandle -> ModIface -> IO ()

put :: BinHandle -> ModIface -> IO (Bin ModIface)

get :: BinHandle -> IO ModIface

(NFData (IfaceBackendExts phase), NFData (IfaceDeclExts phase)) => NFData (ModIface_ phase)

Defined in HscTypes

Methods

rnf :: ModIface_ phase -> ()

type IfaceExport = AvailInfo

The original names declared of a certain module that are exported

data ModDetails

The ModDetails is essentially a cache for information in the ModIface for home modules only. Information relating to packages will be loaded into global environments in ExternalPackageState.

Constructors

ModDetails

Fields

• md_exports :: [AvailInfo]
• md_types :: !TypeEnv

  Local type environment for this particular module Includes Ids, TyCons, PatSyns

• md_insts :: ![ClsInst]

  DFunIds for the instances in this module

• md_fam_insts :: ![FamInst]
• md_rules :: ![CoreRule]

  Domain may include Ids from other modules

• md_anns :: ![Annotation]

  Annotations present in this module: currently they only annotate things also declared in this module

• md_complete_sigs :: [CompleteMatch]

  Complete match pragmas for this module

type ImportedMods = ModuleEnv [ImportedBy]

Records the modules directly imported by a module for extracting e.g. usage information, and also to give better error message

data ImportedBy

If a module was "imported" by the user, we associate it with more detailed usage information ImportedModsVal; a module imported by the system only gets used for usage information.

Constructors

ImportedByUser ImportedModsVal

ImportedBySystem

data ImportedModsVal

Constructors

ImportedModsVal

Fields

• imv_name :: ModuleName

  The name the module is imported with

• imv_span :: SrcSpan

  the source span of the whole import

• imv_is_safe :: IsSafeImport

  whether this is a safe import

• imv_is_hiding :: Bool

  whether this is an "hiding" import

• imv_all_exports :: !GlobalRdrEnv

  all the things the module could provide NB. BangPattern here: otherwise this leaks. (#15111)

• imv_qualified :: Bool

  whether this is a qualified import

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 Rules.hs

• 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

  Warnings declared in the module

• mg_anns :: [Annotation]

  Annotations declared in this module

• mg_complete_sigs :: [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_safe_haskell :: SafeHaskellMode

  Safe Haskell mode

• mg_trust_pkg :: Bool

  Do we need to trust our own package for Safe Haskell? See Note [RnNames . Trust Own Package]

• mg_doc_hdr :: !(Maybe HsDocString)

  Module header.

• mg_decl_docs :: !DeclDocMap

  Docs on declarations.

• mg_arg_docs :: !ArgDocMap

  Docs on arguments.

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_foreign :: !ForeignStubs

  Foreign export stubs

• cg_foreign_files :: ![(ForeignSrcLang, FilePath)]
• cg_dep_pkgs :: ![InstalledUnitId]

  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 StaticPtrTable

data ForeignStubs

Foreign export stubs

Constructors

NoStubs

We don't have any stubs

ForeignStubs SDoc SDoc

There are some stubs. Parameters:

1) Header file prototypes for "foreign exported" functions

2) C stubs to use when calling "foreign exported" functions

data InteractiveContext

Interactive context, recording information about the state of the context in which statements are executed in a GHCi session.

Constructors

InteractiveContext

Fields

• ic_dflags :: DynFlags

  The DynFlags used to evaluate interative expressions and statements.

• ic_mod_index :: Int

  Each GHCi stmt or declaration brings some new things into scope. We give them names like interactive:Ghci9.T, where the ic_index is the '9'. The ic_mod_index is incremented whenever we add something to ic_tythings See Note [The interactive package]

• ic_imports :: [InteractiveImport]

  The GHCi top-level scope (ic_rn_gbl_env) is extended with these imports

  This field is only stored here so that the client can retrieve it with GHC.getContext. GHC itself doesn't use it, but does reset it to empty sometimes (such as before a GHC.load). The context is set with GHC.setContext.

• ic_tythings :: [TyThing]

  TyThings defined by the user, in reverse order of definition (ie most recent at the front) See Note [ic_tythings]

• ic_rn_gbl_env :: GlobalRdrEnv

  The cached GlobalRdrEnv, built by setContext and updated regularly It contains everything in scope at the command line, including everything in ic_tythings

• ic_instances :: ([ClsInst], [FamInst])

  All instances and family instances created during this session. These are grabbed en masse after each update to be sure that proper overlapping is retained. That is, rather than re-check the overlapping each time we update the context, we just take the results from the instance code that already does that.

• ic_fix_env :: FixityEnv

  Fixities declared in let statements

• ic_default :: Maybe [Type]

  The current default types, set by a 'default' declaration

• ic_resume :: [Resume]

  The stack of breakpoint contexts

• ic_monad :: Name

  The monad that GHCi is executing in

• ic_int_print :: Name

  The function that is used for printing results of expressions in ghci and -e mode.

• ic_cwd :: Maybe FilePath

data InteractiveImport

Constructors

IIDecl (ImportDecl GhcPs)

Bring the exports of a particular module (filtered by an import decl) into scope

IIModule ModuleName

Bring into scope the entire top-level envt of of this module, including the things imported into it.

Instances

Outputable InteractiveImport

Defined in HscTypes

Methods

ppr :: InteractiveImport -> SDoc

pprPrec :: Rational -> InteractiveImport -> SDoc

type TypeEnv = NameEnv TyThing

A map from Names to TyThings, constructed by typechecking local declarations or interface files

class Monad m => MonadThings (m :: Type -> Type) where

Class that abstracts out the common ability of the monads in GHC to lookup a TyThing in the monadic environment by Name. Provides a number of related convenience functions for accessing particular kinds of TyThing

Minimal complete definition

lookupThing

Methods

lookupThing :: Name -> m TyThing

lookupId :: Name -> m Id

lookupDataCon :: Name -> m DataCon

lookupTyCon :: Name -> m TyCon

data Warnings

Warning information for a module

Constructors

NoWarnings

Nothing deprecated

WarnAll WarningTxt

Whole module deprecated

WarnSome [(OccName, WarningTxt)]

Some specific things deprecated

Instances

Eq Warnings

Defined in HscTypes

Methods

(==) :: Warnings -> Warnings -> Bool

(/=) :: Warnings -> Warnings -> Bool

Binary Warnings

Defined in HscTypes

Methods

put_ :: BinHandle -> Warnings -> IO ()

put :: BinHandle -> Warnings -> IO (Bin Warnings)

get :: BinHandle -> IO Warnings

type FixityEnv = NameEnv FixItem

Fixity environment mapping names to their fixities

data FixItem

Fixity information for an Name. We keep the OccName in the range so that we can generate an interface from it

Constructors

FixItem OccName Fixity

Instances

Outputable FixItem

Defined in HscTypes

Methods

ppr :: FixItem -> SDoc

pprPrec :: Rational -> FixItem -> SDoc

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 transformation rule in a module other than the one defining the function in the head of the rule

type IsBootInterface = Bool

Did this module originate from a *-boot file?

data Dependencies

Dependency information about ALL modules and packages below this one in the import hierarchy.

Invariant: the dependencies of a module M never includes M.

Invariant: none of the lists contain duplicates.

Constructors

Deps

Fields

• dep_mods :: [(ModuleName, IsBootInterface)]

  All home-package modules transitively below this one I.e. modules that this one imports, or that are in the dep_mods of those directly-imported modules

• dep_pkgs :: [(InstalledUnitId, Bool)]

  All packages transitively below this module I.e. packages to which this module's direct imports belong, or that are in the dep_pkgs of those modules The bool indicates if the package is required to be trusted when the module is imported as a safe import (Safe Haskell). See Note [RnNames . Tracking Trust Transitively]

• dep_orphs :: [Module]

  Transitive closure of orphan modules (whether home or external pkg).

  (Possible optimization: don't include family instance orphans as they are anyway included in dep_finsts. But then be careful about code which relies on dep_orphs having the complete list!) This does NOT include us, unlike imp_orphs.

• dep_finsts :: [Module]

  Transitive closure of depended upon modules which contain family instances (whether home or external). This is used by checkFamInstConsistency. This does NOT include us, unlike imp_finsts. See Note [The type family instance consistency story].

• dep_plgins :: [ModuleName]

  All the plugins used while compiling this module.

Instances

Eq Dependencies

Defined in HscTypes

Methods

(==) :: Dependencies -> Dependencies -> Bool

(/=) :: Dependencies -> Dependencies -> Bool

Binary Dependencies

Defined in HscTypes

Methods

put_ :: BinHandle -> Dependencies -> IO ()

put :: BinHandle -> Dependencies -> IO (Bin Dependencies)

get :: BinHandle -> IO Dependencies

data Usage

Records modules for which changes may force recompilation of this module See wiki: https://gitlab.haskell.org/ghc/ghc/wikis/commentary/compiler/recompilation-avoidance

This differs from Dependencies. A module X may be in the dep_mods of this module (via an import chain) but if we don't use anything from X it won't appear in our Usage

Constructors

UsagePackageModule

Module from another package

Fields

• usg_mod :: Module

  External package module depended on

• usg_mod_hash :: Fingerprint

  Cached module fingerprint

• usg_safe :: IsSafeImport

  Was this module imported as a safe import

UsageHomeModule

Module from the current package | A file upon which the module depends, e.g. a CPP #include, or using TH's addDependentFile

Fields

• usg_mod_name :: ModuleName

  Name of the module

• usg_mod_hash :: Fingerprint

  Cached module fingerprint

• usg_entities :: [(OccName, Fingerprint)]

  Entities we depend on, sorted by occurrence name and fingerprinted. NB: usages are for parent names only, e.g. type constructors but not the associated data constructors.

• usg_exports :: Maybe Fingerprint

  Fingerprint for the export list of this module, if we directly imported it (and hence we depend on its export list)

• usg_safe :: IsSafeImport

  Was this module imported as a safe import

UsageFile

Fields

• usg_file_path :: FilePath

  External file dependency. From a CPP #include or TH addDependentFile. Should be absolute.

• usg_file_hash :: Fingerprint

  Fingerprint of the file contents.

UsageMergedRequirement

A requirement which was merged into this one.

Fields

• usg_mod :: Module

  External package module depended on

• usg_mod_hash :: Fingerprint

  Cached module fingerprint

Instances

Eq Usage

Defined in HscTypes

Methods

(==) :: Usage -> Usage -> Bool

(/=) :: Usage -> Usage -> Bool

Binary Usage

Defined in HscTypes

Methods

put_ :: BinHandle -> Usage -> IO ()

put :: BinHandle -> Usage -> IO (Bin Usage)

get :: BinHandle -> IO Usage

type PackageTypeEnv = TypeEnv

type PackageRuleBase = RuleBase

type PackageInstEnv = InstEnv

type PackageFamInstEnv = FamInstEnv

type PackageCompleteMatchMap = CompleteMatchMap

data ExternalPackageState

Information about other packages that we have slurped in by reading their interface files

Constructors

EPS

Fields

• eps_is_boot :: !(ModuleNameEnv (ModuleName, IsBootInterface))

  In OneShot mode (only), home-package modules accumulate in the external package state, and are sucked in lazily. For these home-pkg modules (only) we need to record which are boot modules. We set this field after loading all the explicitly-imported interfaces, but before doing anything else

  The ModuleName part is not necessary, but it's useful for debug prints, and it's convenient because this field comes direct from imp_dep_mods

• eps_PIT :: !PackageIfaceTable

  The ModIfaces for modules in external packages whose interfaces we have opened. The declarations in these interface files are held in the eps_decls, eps_inst_env, eps_fam_inst_env and eps_rules fields of this record, not in the mi_decls fields of the interface we have sucked in.

  What is in the PIT is:

  • The Module
  • Fingerprint info
  • Its exports
  • Fixities
  • Deprecations and warnings
• eps_free_holes :: InstalledModuleEnv (UniqDSet ModuleName)

  Cache for mi_free_holes. Ordinarily, we can rely on the eps_PIT for this information, EXCEPT that when we do dependency analysis, we need to look at the Dependencies of our imports to determine what their precise free holes are (moduleFreeHolesPrecise). We don't want to repeatedly reread in the interface for every import, so cache it here. When the PIT gets filled in we can drop these entries.

• eps_PTE :: !PackageTypeEnv

  Result of typechecking all the external package interface files we have sucked in. The domain of the mapping is external-package modules

• eps_inst_env :: !PackageInstEnv

  The total InstEnv accumulated from all the external-package modules

• eps_fam_inst_env :: !PackageFamInstEnv

  The total FamInstEnv accumulated from all the external-package modules

• eps_rule_base :: !PackageRuleBase

  The total RuleEnv accumulated from all the external-package modules

• eps_ann_env :: !PackageAnnEnv

  The total AnnEnv accumulated from all the external-package modules

• eps_complete_matches :: !PackageCompleteMatchMap

  The total CompleteMatchMap accumulated from all the external-package modules

• eps_mod_fam_inst_env :: !(ModuleEnv FamInstEnv)

  The family instances accumulated from external packages, keyed off the module that declared them

• eps_stats :: !EpsStats

  Stastics about what was loaded from external packages

data EpsStats

Accumulated statistics about what we are putting into the ExternalPackageState. "In" means stuff that is just read from interface files, "Out" means actually sucked in and type-checked

Constructors

EpsStats

Fields

• n_ifaces_in :: !Int
• n_decls_in :: !Int
• n_decls_out :: !Int
• n_rules_in :: !Int
• n_rules_out :: !Int
• n_insts_in :: !Int
• n_insts_out :: !Int

data ModuleGraph

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

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

data ModSummary

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

• A regular Haskell source module
• A hi-boot source module

Constructors

ModSummary

Fields

• ms_mod :: Module

  Identity of the module

• ms_hsc_src :: HscSource

  The module source either plain Haskell or hs-boot

• ms_location :: ModLocation

  Location of the various files belonging to the module

• ms_hs_date :: UTCTime

  Timestamp of source file

• ms_obj_date :: Maybe UTCTime

  Timestamp of object, if we have one

• ms_iface_date :: Maybe UTCTime

  Timestamp of hi file, if we *only* are typechecking (it is Nothing otherwise. See Note [Recompilation checking in -fno-code mode] and #9243

• ms_hie_date :: Maybe UTCTime

  Timestamp of hie file, if we have one

• ms_srcimps :: [(Maybe FastString, Located ModuleName)]

  Source imports of the module

• ms_textual_imps :: [(Maybe FastString, Located ModuleName)]

  Non-source imports of the module from the module *text*

• ms_parsed_mod :: Maybe HsParsedModule

  The parsed, nonrenamed source, if we have it. This is also used to support "inline module syntax" in Backpack files.

• ms_hspp_file :: FilePath

  Filename of preprocessed source file

• ms_hspp_opts :: DynFlags

  Cached flags from OPTIONS, INCLUDE and LANGUAGE pragmas in the modules source code

• ms_hspp_buf :: Maybe StringBuffer

  The actual preprocessed source, if we have it

Instances

Outputable ModSummary

Defined in HscTypes

Methods

ppr :: ModSummary -> SDoc

pprPrec :: Rational -> ModSummary -> SDoc

data SourceModified

Indicates whether a given module's source has been modified since it was last compiled.

Constructors

SourceModified

the source has been modified

SourceUnmodified

the source has not been modified. Compilation may or may not be necessary, depending on whether any dependencies have changed since we last compiled.

SourceUnmodifiedAndStable

the source has not been modified, and furthermore all of its (transitive) dependencies are up to date; it definitely does not need to be recompiled. This is important for two reasons: (a) we can omit the version check in checkOldIface, and (b) if the module used TH splices we don't need to force recompilation.

data HpcInfo

Information about a modules use of Haskell Program Coverage

Constructors

HpcInfo

Fields

• hpcInfoTickCount :: Int
• hpcInfoHash :: Int

NoHpcInfo

Fields

• hpcUsed :: AnyHpcUsage

  Is hpc used anywhere on the module *tree*?

type AnyHpcUsage = Bool

This is used to signal if one of my imports used HPC instrumentation even if there is no module-local HPC usage

type IsSafeImport = Bool

Is an import a safe import?

data IfaceTrustInfo

Safe Haskell information for ModIface Simply a wrapper around SafeHaskellMode to sepperate iface and flags

Instances

Binary IfaceTrustInfo

Defined in HscTypes

Methods

put_ :: BinHandle -> IfaceTrustInfo -> IO ()

put :: BinHandle -> IfaceTrustInfo -> IO (Bin IfaceTrustInfo)

get :: BinHandle -> IO IfaceTrustInfo

Outputable IfaceTrustInfo

Defined in HscTypes

Methods

ppr :: IfaceTrustInfo -> SDoc

pprPrec :: Rational -> IfaceTrustInfo -> SDoc

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)

• hpm_annotations :: ApiAnns

data CompleteMatch

A list of conlikes which represents a complete pattern match. These arise from COMPLETE signatures.

Constructors

CompleteMatch

Fields

• completeMatchConLikes :: [Name]

  The ConLikes that form a covering family (e.g. Nothing, Just)

• completeMatchTyCon :: Name

  The TyCon that they cover (e.g. Maybe)

Instances

Outputable CompleteMatch

Defined in HscTypes

Methods

ppr :: CompleteMatch -> SDoc

pprPrec :: Rational -> CompleteMatch -> SDoc

type CompleteMatchMap = UniqFM [CompleteMatch]

A map keyed by the completeMatchTyCon.

data HsModule pass

Haskell Module

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

Constructors

HsModule

AnnKeywordIds

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

Fields

• hsmodName :: Maybe (Located ModuleName)

  Nothing: "module X where" is omitted (in which case the next field is Nothing too)

• hsmodExports :: Maybe (Located [LIE pass])

  Export list

  • Nothing: export list omitted, so export everything
  • Just []: export nothing
  • Just [...]: as you would expect...
  • AnnKeywordIds : AnnOpen ,AnnClose
• hsmodImports :: [LImportDecl pass]

  We snaffle interesting stuff out of the imported interfaces early on, adding that info to TyDecls/etc; so this list is often empty, downstream.

• hsmodDecls :: [LHsDecl pass]

  Type, class, value, and interface signature decls

• hsmodDeprecMessage :: Maybe (Located WarningTxt)

  reason/explanation for warning/deprecation of this module

  • AnnKeywordIds : AnnOpen ,AnnClose
• hsmodHaddockModHeader :: Maybe LHsDocString

  Haddock module info and description, unparsed

  • AnnKeywordIds : AnnOpen ,AnnClose

Instances

Data (HsModule GhcPs)

Defined in GHC.Hs

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsModule GhcPs -> c (HsModule GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsModule GhcPs)

toConstr :: HsModule GhcPs -> Constr

dataTypeOf :: HsModule GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsModule GhcPs))

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

gmapT :: (forall b. Data b => b -> b) -> HsModule GhcPs -> HsModule GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsModule GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsModule GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> HsModule GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsModule GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsModule GhcPs -> m (HsModule GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsModule GhcPs -> m (HsModule GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsModule GhcPs -> m (HsModule GhcPs)

Data (HsModule GhcRn)

Defined in GHC.Hs

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsModule GhcRn -> c (HsModule GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsModule GhcRn)

toConstr :: HsModule GhcRn -> Constr

dataTypeOf :: HsModule GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsModule GhcRn))

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

gmapT :: (forall b. Data b => b -> b) -> HsModule GhcRn -> HsModule GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsModule GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsModule GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> HsModule GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsModule GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsModule GhcRn -> m (HsModule GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsModule GhcRn -> m (HsModule GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsModule GhcRn -> m (HsModule GhcRn)

Data (HsModule GhcTc)

Defined in GHC.Hs

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsModule GhcTc -> c (HsModule GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsModule GhcTc)

toConstr :: HsModule GhcTc -> Constr

dataTypeOf :: HsModule GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsModule GhcTc))

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

gmapT :: (forall b. Data b => b -> b) -> HsModule GhcTc -> HsModule GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsModule GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsModule GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> HsModule GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsModule GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsModule GhcTc -> m (HsModule GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsModule GhcTc -> m (HsModule GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsModule GhcTc -> m (HsModule GhcTc)

OutputableBndrId p => Outputable (HsModule (GhcPass p))

Defined in GHC.Hs

Methods

ppr :: HsModule (GhcPass p) -> SDoc

pprPrec :: Rational -> HsModule (GhcPass p) -> SDoc

lPatImplicits :: LPat GhcRn -> [(SrcSpan, [Name])]

hsValBindsImplicits :: forall (idR :: Pass). HsValBindsLR GhcRn (GhcPass idR) -> [(SrcSpan, [Name])]

lStmtsImplicits :: forall (idR :: Pass) body. [LStmtLR GhcRn (GhcPass idR) (Located (body (GhcPass idR)))] -> [(SrcSpan, [Name])]

hsDataFamInstBinders :: forall (p :: Pass). DataFamInstDecl (GhcPass p) -> ([Located (IdP (GhcPass p))], [LFieldOcc (GhcPass p)])

the SrcLoc returned are for the whole declarations, not just the names

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

hsPatSynSelectors :: forall (p :: Pass). HsValBinds (GhcPass p) -> [IdP (GhcPass p)]

Collects record pattern-synonym selectors only; the pattern synonym names are collected by collectHsValBinders.

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

See Note [SrcSpan for binders]

hsLTyClDeclBinders :: forall (p :: Pass). Located (TyClDecl (GhcPass p)) -> ([Located (IdP (GhcPass p))], [LFieldOcc (GhcPass p)])

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

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

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

hsGroupBinders :: HsGroup GhcRn -> [Name]

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

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

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

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

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

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

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

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

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

Same as collectHsBindsBinders, but works over a list of bindings

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

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

Collect both Ids and pattern-synonym binders

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

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

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

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

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

isBangedHsBind :: HsBind GhcTc -> Bool

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

isUnliftedHsBind :: HsBind GhcTc -> Bool

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

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

mkPrefixFunRhs :: Located id -> HsMatchContext id

Make a prefix, non-strict function HsMatchContext

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

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

isInfixFunBind :: HsBindLR id1 id2 -> Bool

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

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

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

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

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

In Name-land, with empty bind_fvs

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

Not infix, with place holders for coercion and free vars

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

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

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

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

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

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

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

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

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

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

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

typeToLHsType :: Type -> LHsType GhcPs

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

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

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

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

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

mkLHsSigWcType :: LHsType GhcPs -> LHsSigWcType GhcPs

mkLHsSigType :: LHsType GhcPs -> LHsSigType GhcPs

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

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

mkChunkified

Arguments

:: ([a] -> a)

"Small" constructor function, of maximum input arity mAX_TUPLE_SIZE

-> [a]

Possible "big" list of things to construct from

-> a

Constructed thing made possible by recursive decomposition

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

mkBigLHsPatTup :: [LPat GhcRn] -> LPat GhcRn

mkBigLHsVarPatTup :: [IdP GhcRn] -> LPat GhcRn

The Big equivalents for the source tuple patterns

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

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

The Big equivalents for the source tuple expressions

missingTupArg :: HsTupArg GhcPs

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

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

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

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

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

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

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

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

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

nlList :: [LHsExpr GhcPs] -> LHsExpr GhcPs

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

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

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

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

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

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

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

nlWildPatName :: LPat GhcRn

Wildcard pattern - after renaming

nlWildPat :: LPat GhcPs

Wildcard pattern - after parsing

nlWildConPat :: DataCon -> LPat GhcPs

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

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

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

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

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

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

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

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

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

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

nlLitPat :: HsLit GhcPs -> LPat GhcPs

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

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

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

nlHsDataCon :: DataCon -> LHsExpr GhcTc

NB: Only for LHsExpr **Id**

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

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

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

unqualQuasiQuote :: RdrName

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

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

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

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

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

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

emptyRecStmtId :: StmtLR GhcTc GhcTc bodyR

emptyRecStmtName :: StmtLR GhcRn GhcRn bodyR

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

unitRecStmtTc :: RecStmtTc

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

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

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

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

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

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

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

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

emptyTransStmt :: StmtLR GhcPs GhcPs (LHsExpr GhcPs)

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

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

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

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

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

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

mkHsIsString :: SourceText -> FastString -> HsOverLit GhcPs

mkHsFractional :: FractionalLit -> HsOverLit GhcPs

mkHsIntegral :: IntegralLit -> HsOverLit GhcPs

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

e => (e)

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

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

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

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

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

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

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

matchSeparator :: HsMatchContext id -> SDoc

isMonadCompContext :: HsStmtContext id -> Bool

isMonadFailStmtContext :: HsStmtContext id -> Bool

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

isComprehensionContext :: HsStmtContext id -> Bool

isPatSynCtxt :: HsMatchContext id -> Bool

pp_dotdot :: SDoc

thTyBrackets :: SDoc -> SDoc

thBrackets :: SDoc -> SDoc -> SDoc

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

isTypedBracket :: HsBracket id -> Bool

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

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

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

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

isTypedSplice :: HsSplice id -> Bool

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

isSingletonMatchGroup :: [LMatch id body] -> Bool

Is there only one RHS in this list of matches?

isEmptyMatchGroup :: MatchGroup id body -> Bool

isInfixMatch :: Match id body -> Bool

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

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

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

isQuietHsCmd :: HsCmd id -> Bool

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

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

isAtomicHsExpr :: HsExpr id -> Bool

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

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

hsExprNeedsParens :: PprPrec -> HsExpr p -> Bool

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

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

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

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

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

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

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

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

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

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

isQuietHsExpr :: HsExpr id -> Bool

tupArgPresent :: LHsTupArg id -> Bool

unboundVarOcc :: UnboundVar -> OccName

mkRnSyntaxExpr :: Name -> SyntaxExpr GhcRn

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

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

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

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

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

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

type PostTcExpr = HsExpr GhcTc

Post-Type checking Expression

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

type PostTcTable = [(Name, PostTcExpr)]

Post-Type checking Table

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

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

Command Syntax Table (for Arrow syntax)

data UnboundVar

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

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

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

Constructors

OutOfScope OccName GlobalRdrEnv

An (unqualified) out-of-scope variable, together with the GlobalRdrEnv with respect to which it is unbound

TrueExprHole OccName

A "true" expression hole (_ or _x)

Instances

Data UnboundVar

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: UnboundVar -> Constr

dataTypeOf :: UnboundVar -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> UnboundVar -> UnboundVar

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

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

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

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

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

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

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

Outputable UnboundVar

Defined in GHC.Hs.Expr

Methods

ppr :: UnboundVar -> SDoc

pprPrec :: Rational -> UnboundVar -> SDoc

data RecordConTc

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

Constructors

RecordConTc

Fields

• rcon_con_like :: ConLike
• rcon_con_expr :: PostTcExpr

data RecordUpdTc

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

Constructors

RecordUpdTc

Fields

• rupd_cons :: [ConLike]
• rupd_in_tys :: [Type]
• rupd_out_tys :: [Type]
• rupd_wrap :: HsWrapper

Instances

Data RecordUpdTc

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: RecordUpdTc -> Constr

dataTypeOf :: RecordUpdTc -> DataType

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

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

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

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

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

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

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

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

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

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

type LHsTupArg id = Located (HsTupArg id)

Located Haskell Tuple Argument

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

data HsTupArg id

• AnnKeywordId : AnnComma

Haskell Tuple Argument

Constructors

Present (XPresent id) (LHsExpr id)

The argument

Missing (XMissing id)

The argument is missing, but this is its type

XTupArg (XXTupArg id)

Note [Trees that Grow] extension point

type LHsCmd id = Located (HsCmd id)

Located Haskell Command (for arrow syntax)

data HsArrAppType

Haskell Array Application Type

Constructors

HsHigherOrderApp

HsFirstOrderApp

Instances

Data HsArrAppType

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: HsArrAppType -> Constr

dataTypeOf :: HsArrAppType -> DataType

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

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

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

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

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

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

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

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

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

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

type LHsCmdTop p = Located (HsCmdTop p)

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

Located Haskell Top-level Command

data HsCmdTop p

Haskell Top-level Command

Constructors

HsCmdTop (XCmdTop p) (LHsCmd p)

XCmdTop (XXCmdTop p)

Instances

OutputableBndrId p => Outputable (HsCmdTop (GhcPass p))

Defined in GHC.Hs.Expr

Methods

ppr :: HsCmdTop (GhcPass p) -> SDoc

pprPrec :: Rational -> HsCmdTop (GhcPass p) -> SDoc

data CmdTopTc

Constructors

CmdTopTc Type Type (CmdSyntaxTable GhcTc)

type HsRecordBinds p = HsRecFields p (LHsExpr p)

Haskell Record Bindings

data MatchGroupTc

Constructors

MatchGroupTc

Fields

• mg_arg_tys :: [Type]
• mg_res_ty :: Type

Instances

Data MatchGroupTc

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: MatchGroupTc -> Constr

dataTypeOf :: MatchGroupTc -> DataType

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

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

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

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

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

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

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

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

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

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

type LMatch id body = Located (Match id body)

Located Match

May have AnnKeywordId : AnnSemi when in a list

data Match p body

Constructors

Match

Fields

• m_ext :: XCMatch p body
• m_ctxt :: HsMatchContext (NameOrRdrName (IdP p))
• m_pats :: [LPat p]
• m_grhss :: GRHSs p body

XMatch (XXMatch p body)

Instances

(OutputableBndrId pr, Outputable body) => Outputable (Match (GhcPass pr) body)

Defined in GHC.Hs.Expr

Methods

ppr :: Match (GhcPass pr) body -> SDoc

pprPrec :: Rational -> Match (GhcPass pr) body -> SDoc

type LGRHS id body = Located (GRHS id body)

Located Guarded Right-Hand Side

data GRHS p body

Guarded Right Hand Side.

Constructors

GRHS (XCGRHS p body) [GuardLStmt p] body

XGRHS (XXGRHS p body)

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

Located do block Statement

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

Located Statement with separate Left and Right id's

type Stmt id body = StmtLR id id body

do block Statement

type CmdLStmt id = LStmt id (LHsCmd id)

Command Located Statement

type CmdStmt id = Stmt id (LHsCmd id)

Command Statement

type ExprLStmt id = LStmt id (LHsExpr id)

Expression Located Statement

type ExprStmt id = Stmt id (LHsExpr id)

Expression Statement

type GuardLStmt id = LStmt id (LHsExpr id)

Guard Located Statement

type GuardStmt id = Stmt id (LHsExpr id)

Guard Statement

type GhciLStmt id = LStmt id (LHsExpr id)

Ghci Located Statement

type GhciStmt id = Stmt id (LHsExpr id)

Ghci Statement

data StmtLR idL idR body

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

Constructors

LastStmt (XLastStmt idL idR body) body Bool (SyntaxExpr idR)

BindStmt (XBindStmt idL idR body) (LPat idL) body (SyntaxExpr idR) (SyntaxExpr idR)

ApplicativeStmt (XApplicativeStmt idL idR body) [(SyntaxExpr idR, ApplicativeArg idL)] (Maybe (SyntaxExpr idR))

ApplicativeStmt represents an applicative expression built with <$> and <*>. It is generated by the renamer, and is desugared into the appropriate applicative expression by the desugarer, but it is intended to be invisible in error messages.

For full details, see Note [ApplicativeDo] in RnExpr

BodyStmt (XBodyStmt idL idR body) body (SyntaxExpr idR) (SyntaxExpr idR)

LetStmt (XLetStmt idL idR body) (LHsLocalBindsLR idL idR)

• AnnKeywordId : AnnLet AnnOpen '{',AnnClose '}',

ParStmt (XParStmt idL idR body) [ParStmtBlock idL idR] (HsExpr idR) (SyntaxExpr idR)

TransStmt

Fields

• trS_ext :: XTransStmt idL idR body
• trS_form :: TransForm
• trS_stmts :: [ExprLStmt idL]
• trS_bndrs :: [(IdP idR, IdP idR)]
• trS_using :: LHsExpr idR
• trS_by :: Maybe (LHsExpr idR)
• trS_ret :: SyntaxExpr idR
• trS_bind :: SyntaxExpr idR
• trS_fmap :: HsExpr idR

RecStmt

• AnnKeywordId : AnnRec

Fields

• recS_ext :: XRecStmt idL idR body
• recS_stmts :: [LStmtLR idL idR body]
• recS_later_ids :: [IdP idR]
• recS_rec_ids :: [IdP idR]
• recS_bind_fn :: SyntaxExpr idR
• recS_ret_fn :: SyntaxExpr idR
• recS_mfix_fn :: SyntaxExpr idR

XStmtLR (XXStmtLR idL idR body)

Instances

(OutputableBndrId pl, OutputableBndrId pr, Outputable body) => Outputable (StmtLR (GhcPass pl) (GhcPass pr) body)

Defined in GHC.Hs.Expr

Methods

ppr :: StmtLR (GhcPass pl) (GhcPass pr) body -> SDoc

pprPrec :: Rational -> StmtLR (GhcPass pl) (GhcPass pr) body -> SDoc

data RecStmtTc

Constructors

RecStmtTc

Fields

• recS_bind_ty :: Type
• recS_later_rets :: [PostTcExpr]
• recS_rec_rets :: [PostTcExpr]
• recS_ret_ty :: Type

data TransForm

Constructors

ThenForm

GroupForm

Instances

Data TransForm

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: TransForm -> Constr

dataTypeOf :: TransForm -> DataType

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

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

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

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

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

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

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

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

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

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

data ParStmtBlock idL idR

Parenthesised Statement Block

Constructors

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

XParStmtBlock (XXParStmtBlock idL idR)

Instances

(Outputable (StmtLR idL idL (LHsExpr idL)), Outputable (XXParStmtBlock idL idR)) => Outputable (ParStmtBlock idL idR)

Defined in GHC.Hs.Expr

Methods

ppr :: ParStmtBlock idL idR -> SDoc

pprPrec :: Rational -> ParStmtBlock idL idR -> SDoc

data ApplicativeArg idL

Applicative Argument

Constructors

ApplicativeArgOne

Fields

• xarg_app_arg_one :: XApplicativeArgOne idL
• app_arg_pattern :: LPat idL
• arg_expr :: LHsExpr idL
• is_body_stmt :: Bool
• fail_operator :: SyntaxExpr idL

ApplicativeArgMany

Fields

• xarg_app_arg_many :: XApplicativeArgMany idL
• app_stmts :: [ExprLStmt idL]
• final_expr :: HsExpr idL
• bv_pattern :: LPat idL

XApplicativeArg (XXApplicativeArg idL)

Instances

OutputableBndrId idL => Outputable (ApplicativeArg (GhcPass idL))

Defined in GHC.Hs.Expr

Methods

ppr :: ApplicativeArg (GhcPass idL) -> SDoc

pprPrec :: Rational -> ApplicativeArg (GhcPass idL) -> SDoc

data SpliceDecoration

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

Constructors

HasParens

$( splice ) or $$( splice )

HasDollar

$splice or $$splice

NoParens

bare splice

Instances

Eq SpliceDecoration

Defined in GHC.Hs.Expr

Methods

(==) :: SpliceDecoration -> SpliceDecoration -> Bool

(/=) :: SpliceDecoration -> SpliceDecoration -> Bool

Data SpliceDecoration

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: SpliceDecoration -> Constr

dataTypeOf :: SpliceDecoration -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> SpliceDecoration -> SpliceDecoration

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

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

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

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

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

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

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

Show SpliceDecoration

Defined in GHC.Hs.Expr

Methods

showsPrec :: Int -> SpliceDecoration -> ShowS

show :: SpliceDecoration -> String

showList :: [SpliceDecoration] -> ShowS

Outputable SpliceDecoration

Defined in GHC.Hs.Expr

Methods

ppr :: SpliceDecoration -> SDoc

pprPrec :: Rational -> SpliceDecoration -> SDoc

newtype ThModFinalizers

Finalizers produced by a splice with addModFinalizer

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

Constructors

ThModFinalizers [ForeignRef (Q ())]

Instances

Data ThModFinalizers

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: ThModFinalizers -> Constr

dataTypeOf :: ThModFinalizers -> DataType

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

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

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

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

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

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

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

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

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

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

data DelayedSplice

Constructors

DelayedSplice TcLclEnv (LHsExpr GhcRn) TcType (LHsExpr GhcTcId)

Instances

Data DelayedSplice

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: DelayedSplice -> Constr

dataTypeOf :: DelayedSplice -> DataType

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

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

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

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

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

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

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

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

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

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

data HsSplicedThing id

Haskell Spliced Thing

Values that can result from running a splice.

Constructors

HsSplicedExpr (HsExpr id)

Haskell Spliced Expression

HsSplicedTy (HsType id)

Haskell Spliced Type

HsSplicedPat (Pat id)

Haskell Spliced Pattern

Instances

OutputableBndrId p => Outputable (HsSplicedThing (GhcPass p))

Defined in GHC.Hs.Expr

Methods

ppr :: HsSplicedThing (GhcPass p) -> SDoc

pprPrec :: Rational -> HsSplicedThing (GhcPass p) -> SDoc

type SplicePointName = Name

data PendingRnSplice

Pending Renamer Splice

Constructors

PendingRnSplice UntypedSpliceFlavour SplicePointName (LHsExpr GhcRn)

Instances

Outputable PendingRnSplice

Defined in GHC.Hs.Expr

Methods

ppr :: PendingRnSplice -> SDoc

pprPrec :: Rational -> PendingRnSplice -> SDoc

data UntypedSpliceFlavour

Constructors

UntypedExpSplice

UntypedPatSplice

UntypedTypeSplice

UntypedDeclSplice

Instances

Data UntypedSpliceFlavour

Defined in GHC.Hs.Expr

Methods

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

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

toConstr :: UntypedSpliceFlavour -> Constr

dataTypeOf :: UntypedSpliceFlavour -> DataType

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

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

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

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

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

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

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

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

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

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

data PendingTcSplice

Pending Type-checker Splice

Constructors

PendingTcSplice SplicePointName (LHsExpr GhcTc)

Instances

Outputable PendingTcSplice

Defined in GHC.Hs.Expr

Methods

ppr :: PendingTcSplice -> SDoc

pprPrec :: Rational -> PendingTcSplice -> SDoc

data HsBracket p

Haskell Bracket

Constructors

ExpBr (XExpBr p) (LHsExpr p)

PatBr (XPatBr p) (LPat p)

DecBrL (XDecBrL p) [LHsDecl p]

DecBrG (XDecBrG p) (HsGroup p)

TypBr (XTypBr p) (LHsType p)

VarBr (XVarBr p) Bool (IdP p)

TExpBr (XTExpBr p) (LHsExpr p)

XBracket (XXBracket p)

Instances

OutputableBndrId p => Outputable (HsBracket (GhcPass p))

Defined in GHC.Hs.Expr

Methods

ppr :: HsBracket (GhcPass p) -> SDoc

pprPrec :: Rational -> HsBracket (GhcPass p) -> SDoc

data ArithSeqInfo id

Arithmetic Sequence Information

Constructors

From (LHsExpr id)

FromThen (LHsExpr id) (LHsExpr id)

FromTo (LHsExpr id) (LHsExpr id)

FromThenTo (LHsExpr id) (LHsExpr id) (LHsExpr id)

Instances

OutputableBndrId p => Outputable (ArithSeqInfo (GhcPass p))

Defined in GHC.Hs.Expr

Methods

ppr :: ArithSeqInfo (GhcPass p) -> SDoc

pprPrec :: Rational -> ArithSeqInfo (GhcPass p) -> SDoc

data HsMatchContext id

Haskell Match Context

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

Constructors

FunRhs

A pattern matching on an argument of a function binding

Fields

• mc_fun :: Located id

  function binder of f

• mc_fixity :: LexicalFixity

  fixing of f

• mc_strictness :: SrcStrictness

  was f banged? See Note [FunBind vs PatBind]

LambdaExpr

Patterns of a lambda

CaseAlt

Patterns and guards on a case alternative

IfAlt

Guards of a multi-way if alternative

ProcExpr

Patterns of a proc

PatBindRhs

A pattern binding eg [y] <- e = e

PatBindGuards

Guards of pattern bindings, e.g., (Just b) | Just _ <- x = e | otherwise = e'

RecUpd

Record update [used only in DsExpr to tell matchWrapper what sort of runtime error message to generate]

StmtCtxt (HsStmtContext id)

Pattern of a do-stmt, list comprehension, pattern guard, etc

ThPatSplice

A Template Haskell pattern splice

ThPatQuote

A Template Haskell pattern quotation [p| (a,b) |]

PatSyn

A pattern synonym declaration

Instances

Functor HsMatchContext

Defined in GHC.Hs.Expr

Methods

fmap :: (a -> b) -> HsMatchContext a -> HsMatchContext b

(<$) :: a -> HsMatchContext b -> HsMatchContext a

Data id => Data (HsMatchContext id)

Defined in GHC.Hs.Expr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsMatchContext id -> c (HsMatchContext id)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsMatchContext id)

toConstr :: HsMatchContext id -> Constr

dataTypeOf :: HsMatchContext id -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsMatchContext id))

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

gmapT :: (forall b. Data b => b -> b) -> HsMatchContext id -> HsMatchContext id

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsMatchContext id -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsMatchContext id -> r

gmapQ :: (forall d. Data d => d -> u) -> HsMatchContext id -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsMatchContext id -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsMatchContext id -> m (HsMatchContext id)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMatchContext id -> m (HsMatchContext id)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsMatchContext id -> m (HsMatchContext id)

OutputableBndr id => Outputable (HsMatchContext id)

Defined in GHC.Hs.Expr

Methods

ppr :: HsMatchContext id -> SDoc

pprPrec :: Rational -> HsMatchContext id -> SDoc

data HsStmtContext id

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

Constructors

ListComp

MonadComp

DoExpr

do { ... }

MDoExpr

mdo { ... } ie recursive do-expression

ArrowExpr

do-notation in an arrow-command context

GhciStmtCtxt

A command-line Stmt in GHCi pat <- rhs

PatGuard (HsMatchContext id)

Pattern guard for specified thing

ParStmtCtxt (HsStmtContext id)

A branch of a parallel stmt

TransStmtCtxt (HsStmtContext id)

A branch of a transform stmt

Instances

Functor HsStmtContext

Defined in GHC.Hs.Expr

Methods

fmap :: (a -> b) -> HsStmtContext a -> HsStmtContext b

(<$) :: a -> HsStmtContext b -> HsStmtContext a

Data id => Data (HsStmtContext id)

Defined in GHC.Hs.Expr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsStmtContext id -> c (HsStmtContext id)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsStmtContext id)

toConstr :: HsStmtContext id -> Constr

dataTypeOf :: HsStmtContext id -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsStmtContext id))

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

gmapT :: (forall b. Data b => b -> b) -> HsStmtContext id -> HsStmtContext id

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsStmtContext id -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsStmtContext id -> r

gmapQ :: (forall d. Data d => d -> u) -> HsStmtContext id -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsStmtContext id -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsStmtContext id -> m (HsStmtContext id)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsStmtContext id -> m (HsStmtContext id)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsStmtContext id -> m (HsStmtContext id)

(Outputable (GhcPass p), Outputable (NameOrRdrName (GhcPass p))) => Outputable (HsStmtContext (GhcPass p))

Defined in GHC.Hs.Expr

Methods

ppr :: HsStmtContext (GhcPass p) -> SDoc

pprPrec :: Rational -> HsStmtContext (GhcPass p) -> SDoc

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

annProvenanceName_maybe :: AnnProvenance name -> Maybe name

docDeclDoc :: DocDecl -> HsDocString

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

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

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

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

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

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

Eliminate a DerivStrategy.

derivStrategyName :: DerivStrategy a -> SDoc

A short description of a DerivStrategy'.

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

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

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

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

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

hsConDeclArgTys :: HsConDeclDetails pass -> [LBangType pass]

getConArgs :: ConDecl pass -> HsConDeclDetails pass

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

newOrDataToFlavour :: NewOrData -> TyConFlavour

Convert a NewOrData to a TyConFlavour

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

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

Maybe return name of the result type variable

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

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

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

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

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

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

hsDeclHasCusk :: TyClDecl GhcRn -> Bool

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

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

tyClDeclTyVars :: TyClDecl pass -> LHsQTyVars pass

tcdName :: TyClDecl pass -> IdP pass

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

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

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

isDataFamilyDecl :: TyClDecl pass -> Bool

data family declaration

isClosedTypeFamilyInfo :: FamilyInfo pass -> Bool

closed type family info

isOpenTypeFamilyInfo :: FamilyInfo pass -> Bool

open type family info

isTypeFamilyDecl :: TyClDecl pass -> Bool

type family declaration

isFamilyDecl :: TyClDecl pass -> Bool

type/data family declaration

isClassDecl :: TyClDecl pass -> Bool

type class

isSynDecl :: TyClDecl pass -> Bool

type or type instance declaration

isDataDecl :: TyClDecl pass -> Bool

True = argument is a data/newtype declaration.

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

hsGroupInstDecls :: HsGroup id -> [LInstDecl id]

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

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

type LHsDecl p

Arguments

 = Located (HsDecl p)

When in a list this may have

• AnnKeywordId : AnnSemi

data HsDecl p

A Haskell Declaration

Constructors

TyClD (XTyClD p) (TyClDecl p)

Type or Class Declaration

InstD (XInstD p) (InstDecl p)

Instance declaration

DerivD (XDerivD p) (DerivDecl p)

Deriving declaration

ValD (XValD p) (HsBind p)

Value declaration

SigD (XSigD p) (Sig p)

Signature declaration

KindSigD (XKindSigD p) (StandaloneKindSig p)

Standalone kind signature

DefD (XDefD p) (DefaultDecl p)

'default' declaration

ForD (XForD p) (ForeignDecl p)

Foreign declaration

WarningD (XWarningD p) (WarnDecls p)

Warning declaration

AnnD (XAnnD p) (AnnDecl p)

Annotation declaration

RuleD (XRuleD p) (RuleDecls p)

Rule declaration

SpliceD (XSpliceD p) (SpliceDecl p)

Splice declaration (Includes quasi-quotes)

DocD (XDocD p) DocDecl

Documentation comment declaration

RoleAnnotD (XRoleAnnotD p) (RoleAnnotDecl p)

Role annotation declaration

XHsDecl (XXHsDecl p)

Instances

OutputableBndrId p => Outputable (HsDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: HsDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> HsDecl (GhcPass p) -> SDoc

data HsGroup p

Haskell Group

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

Constructors

HsGroup

Fields

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

XHsGroup (XXHsGroup p)

Instances

OutputableBndrId p => Outputable (HsGroup (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: HsGroup (GhcPass p) -> SDoc

pprPrec :: Rational -> HsGroup (GhcPass p) -> SDoc

type LSpliceDecl pass = Located (SpliceDecl pass)

Located Splice Declaration

data SpliceDecl p

Splice Declaration

Constructors

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

XSpliceDecl (XXSpliceDecl p)

Instances

OutputableBndrId p => Outputable (SpliceDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: SpliceDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> SpliceDecl (GhcPass p) -> SDoc

type LTyClDecl pass = Located (TyClDecl pass)

Located Declaration of a Type or Class

data TyClDecl pass

A type or class declaration.

Constructors

FamDecl

type/data family T :: *->*

• AnnKeywordId : AnnType, AnnData, AnnFamily,AnnDcolon, AnnWhere,AnnOpenP, AnnDcolon,AnnCloseP, AnnEqual,AnnRarrow, AnnVbar

Fields

• tcdFExt :: XFamDecl pass
• tcdFam :: FamilyDecl pass

SynDecl

type declaration

• AnnKeywordId : AnnType, AnnEqual,

Fields

• tcdSExt :: XSynDecl pass

  Post renameer, FVs

• tcdLName :: Located (IdP pass)

  Type constructor

• tcdTyVars :: LHsQTyVars pass

  Type variables; for an associated type these include outer binders

• tcdFixity :: LexicalFixity

  Fixity used in the declaration

• tcdRhs :: LHsType pass

DataDecl

data declaration

• AnnKeywordId : AnnData, AnnFamily, AnnNewType, AnnNewType,AnnDcolon AnnWhere,

Fields

• tcdDExt :: XDataDecl pass

  Post renamer, CUSK flag, FVs

• tcdLName :: Located (IdP pass)

  Type constructor

• tcdTyVars :: LHsQTyVars pass

  Type variables; for an associated type these include outer binders

• tcdFixity :: LexicalFixity

  Fixity used in the declaration

• tcdDataDefn :: HsDataDefn pass

ClassDecl

• AnnKeywordId : AnnClass, AnnWhere,AnnOpen, AnnClose
• The tcdFDs will have AnnVbar, AnnComma AnnRarrow

Fields

• tcdCExt :: XClassDecl pass

  Post renamer, FVs

• tcdCtxt :: LHsContext pass

  Context...

• tcdLName :: Located (IdP pass)

  Type constructor

• tcdTyVars :: LHsQTyVars pass

  Type variables; for an associated type these include outer binders

• tcdFixity :: LexicalFixity

  Fixity used in the declaration

• tcdFDs :: [LHsFunDep pass]

  Functional deps

• tcdSigs :: [LSig pass]

  Methods' signatures

• tcdMeths :: LHsBinds pass

  Default methods

• tcdATs :: [LFamilyDecl pass]

  Associated types;

• tcdATDefs :: [LTyFamDefltDecl pass]

  Associated type defaults

• tcdDocs :: [LDocDecl]

  Haddock docs

XTyClDecl (XXTyClDecl pass)

Instances

OutputableBndrId p => Outputable (TyClDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: TyClDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> TyClDecl (GhcPass p) -> SDoc

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

data DataDeclRn

Constructors

DataDeclRn

Fields

• tcdDataCusk :: Bool

  does this have a CUSK? See Note [CUSKs: complete user-supplied kind signatures]

• tcdFVs :: NameSet

Instances

Data DataDeclRn

Defined in GHC.Hs.Decls

Methods

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

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

toConstr :: DataDeclRn -> Constr

dataTypeOf :: DataDeclRn -> DataType

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

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

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

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

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

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

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

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

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

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

data TyClGroup pass

Type or Class Group

Constructors

TyClGroup

Fields

• group_ext :: XCTyClGroup pass
• group_tyclds :: [LTyClDecl pass]
• group_roles :: [LRoleAnnotDecl pass]
• group_kisigs :: [LStandaloneKindSig pass]
• group_instds :: [LInstDecl pass]

XTyClGroup (XXTyClGroup pass)

Instances

OutputableBndrId p => Outputable (TyClGroup (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: TyClGroup (GhcPass p) -> SDoc

pprPrec :: Rational -> TyClGroup (GhcPass p) -> SDoc

type LFamilyResultSig pass = Located (FamilyResultSig pass)

Located type Family Result Signature

data FamilyResultSig pass

type Family Result Signature

Constructors

NoSig (XNoSig pass)

• AnnKeywordId :

KindSig (XCKindSig pass) (LHsKind pass)

• AnnKeywordId : AnnOpenP,AnnDcolon, AnnCloseP

TyVarSig (XTyVarSig pass) (LHsTyVarBndr pass)

• AnnKeywordId : AnnOpenP,AnnDcolon, AnnCloseP, AnnEqual

XFamilyResultSig (XXFamilyResultSig pass)

type LFamilyDecl pass = Located (FamilyDecl pass)

Located type Family Declaration

data FamilyDecl pass

type Family Declaration

Constructors

FamilyDecl

Fields

• fdExt :: XCFamilyDecl pass
• fdInfo :: FamilyInfo pass
• fdLName :: Located (IdP pass)
• fdTyVars :: LHsQTyVars pass
• fdFixity :: LexicalFixity
• fdResultSig :: LFamilyResultSig pass
• fdInjectivityAnn :: Maybe (LInjectivityAnn pass)

XFamilyDecl (XXFamilyDecl pass)

• AnnKeywordId : AnnType, AnnData, AnnFamily, AnnWhere, AnnOpenP, AnnDcolon, AnnCloseP, AnnEqual, AnnRarrow, AnnVbar

Instances

OutputableBndrId p => Outputable (FamilyDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: FamilyDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> FamilyDecl (GhcPass p) -> SDoc

type LInjectivityAnn pass = Located (InjectivityAnn pass)

Located Injectivity Annotation

data InjectivityAnn pass

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

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

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

Constructors

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

• AnnKeywordId : AnnRarrow, AnnVbar

data FamilyInfo pass

Constructors

DataFamily

OpenTypeFamily

ClosedTypeFamily (Maybe [LTyFamInstEqn pass])

Nothing if we're in an hs-boot file and the user said "type family Foo x where .."

Instances

Outputable (FamilyInfo pass)

Defined in GHC.Hs.Decls

Methods

ppr :: FamilyInfo pass -> SDoc

pprPrec :: Rational -> FamilyInfo pass -> SDoc

data HsDataDefn pass

Haskell Data type Definition

Constructors

HsDataDefn

Declares a data type or newtype, giving its constructors data/newtype T a = constrs data/newtype instance T [a] = constrs

Fields

• dd_ext :: XCHsDataDefn pass
• dd_ND :: NewOrData
• dd_ctxt :: LHsContext pass

  Context

• dd_cType :: Maybe (Located CType)
• dd_kindSig :: Maybe (LHsKind pass)

  Optional kind signature.

  (Just k) for a GADT-style data, or data instance decl, with explicit kind sig

  Always Nothing for H98-syntax decls

• dd_cons :: [LConDecl pass]

  Data constructors

  For data T a = T1 | T2 a the LConDecls all have ConDeclH98. For data T a where { T1 :: T a } the LConDecls all have ConDeclGADT.

• dd_derivs :: HsDeriving pass

  Optional 'deriving' claues

XHsDataDefn (XXHsDataDefn pass)

Instances

OutputableBndrId p => Outputable (HsDataDefn (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: HsDataDefn (GhcPass p) -> SDoc

pprPrec :: Rational -> HsDataDefn (GhcPass p) -> SDoc

type HsDeriving pass

Arguments

 = Located [LHsDerivingClause pass]

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

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

Haskell Deriving clause

type LHsDerivingClause pass = Located (HsDerivingClause pass)

data HsDerivingClause pass

A single deriving clause of a data declaration.

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

Constructors

HsDerivingClause

Fields

• deriv_clause_ext :: XCHsDerivingClause pass
• deriv_clause_strategy :: Maybe (LDerivStrategy pass)

  The user-specified strategy (if any) to use when deriving deriv_clause_tys.

• deriv_clause_tys :: Located [LHsSigType pass]

  The types to derive.

  It uses LHsSigTypes because, with -XGeneralizedNewtypeDeriving, we can mention type variables that aren't bound by the datatype, e.g.

  data T b = ... deriving (C [a])

  should produce a derived instance for C [a] (T b).

XHsDerivingClause (XXHsDerivingClause pass)

Instances

OutputableBndrId p => Outputable (HsDerivingClause (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: HsDerivingClause (GhcPass p) -> SDoc

pprPrec :: Rational -> HsDerivingClause (GhcPass p) -> SDoc

type LStandaloneKindSig pass = Located (StandaloneKindSig pass)

Located Standalone Kind Signature

data StandaloneKindSig pass

Constructors

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

XStandaloneKindSig (XXStandaloneKindSig pass)

Instances

OutputableBndrId p => Outputable (StandaloneKindSig (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: StandaloneKindSig (GhcPass p) -> SDoc

pprPrec :: Rational -> StandaloneKindSig (GhcPass p) -> SDoc

data NewOrData

Constructors

NewType

newtype Blah ...

DataType

data Blah ...

Instances

Eq NewOrData

Defined in GHC.Hs.Decls

Methods

(==) :: NewOrData -> NewOrData -> Bool

(/=) :: NewOrData -> NewOrData -> Bool

Data NewOrData

Defined in GHC.Hs.Decls

Methods

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

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

toConstr :: NewOrData -> Constr

dataTypeOf :: NewOrData -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> NewOrData -> NewOrData

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

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

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

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

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

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

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

Outputable NewOrData

Defined in GHC.Hs.Decls

Methods

ppr :: NewOrData -> SDoc

pprPrec :: Rational -> NewOrData -> SDoc

type LConDecl pass

Arguments

 = Located (ConDecl pass)

May have AnnKeywordId : AnnSemi when in a GADT constructor list

Located data Constructor Declaration

data ConDecl pass

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

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

data T = Int MkT Int
       | MkT2

data T a where
     Int MkT Int :: T Int

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

data Constructor Declaration

Constructors

ConDeclGADT

Fields

• con_g_ext :: XConDeclGADT pass
• con_names :: [Located (IdP pass)]
• con_forall :: Located Bool

  True = explicit forall False => hsq_explicit is empty

• con_qvars :: LHsQTyVars pass
• con_mb_cxt :: Maybe (LHsContext pass)

  User-written context (if any)

• con_args :: HsConDeclDetails pass

  Arguments; never InfixCon

• con_res_ty :: LHsType pass

  Result type

• con_doc :: Maybe LHsDocString

  A possible Haddock comment.

ConDeclH98

Fields

• con_ext :: XConDeclH98 pass
• con_name :: Located (IdP pass)
• con_forall :: Located Bool

  True = explicit forall False => hsq_explicit is empty

• con_ex_tvs :: [LHsTyVarBndr pass]

  Existentials only

• con_mb_cxt :: Maybe (LHsContext pass)

  User-written context (if any)

• con_args :: HsConDeclDetails pass

  Arguments; never InfixCon

• con_doc :: Maybe LHsDocString

  A possible Haddock comment.

XConDecl (XXConDecl pass)

Instances

OutputableBndrId p => Outputable (ConDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: ConDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> ConDecl (GhcPass p) -> SDoc

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

Haskell data Constructor Declaration Details

type LTyFamInstEqn pass

Arguments

 = Located (TyFamInstEqn pass)

May have AnnKeywordId : AnnSemi when in a list

Located Type Family Instance Equation

type HsTyPats pass = [LHsTypeArg pass]

Haskell Type Patterns

type TyFamInstEqn pass = FamInstEqn pass (LHsType pass)

Type Family Instance Equation

type TyFamDefltDecl = TyFamInstDecl

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

type LTyFamDefltDecl pass = Located (TyFamDefltDecl pass)

Located type family default declarations.

type LTyFamInstDecl pass = Located (TyFamInstDecl pass)

Located Type Family Instance Declaration

newtype TyFamInstDecl pass

Type Family Instance Declaration

Constructors

TyFamInstDecl

• AnnKeywordId : AnnType, AnnInstance,

Fields

• tfid_eqn :: TyFamInstEqn pass

Instances

OutputableBndrId p => Outputable (TyFamInstDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: TyFamInstDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> TyFamInstDecl (GhcPass p) -> SDoc

type LDataFamInstDecl pass = Located (DataFamInstDecl pass)

Located Data Family Instance Declaration

newtype DataFamInstDecl pass

Data Family Instance Declaration

Constructors

DataFamInstDecl

• AnnKeywordId : AnnData, AnnNewType,AnnInstance, AnnDcolon AnnWhere,AnnOpen, AnnClose

Fields

• dfid_eqn :: FamInstEqn pass (HsDataDefn pass)

Instances

OutputableBndrId p => Outputable (DataFamInstDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: DataFamInstDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> DataFamInstDecl (GhcPass p) -> SDoc

type LFamInstEqn pass rhs = Located (FamInstEqn pass rhs)

Located Family Instance Equation

type FamInstEqn pass rhs

Arguments

 = HsImplicitBndrs pass (FamEqn pass rhs)

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

Family Instance Equation

data FamEqn pass rhs

Family Equation

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

Constructors

FamEqn

• AnnKeywordId : AnnEqual

Fields

• feqn_ext :: XCFamEqn pass rhs
• feqn_tycon :: Located (IdP pass)
• feqn_bndrs :: Maybe [LHsTyVarBndr pass]

  Optional quantified type vars

• feqn_pats :: HsTyPats pass
• feqn_fixity :: LexicalFixity

  Fixity used in the declaration

• feqn_rhs :: rhs

XFamEqn (XXFamEqn pass rhs)

type LClsInstDecl pass = Located (ClsInstDecl pass)

Located Class Instance Declaration

data ClsInstDecl pass

Class Instance Declaration

Constructors

ClsInstDecl

• AnnKeywordId : AnnInstance, AnnWhere, AnnOpen,AnnClose,

Fields

• cid_ext :: XCClsInstDecl pass
• cid_poly_ty :: LHsSigType pass
• cid_binds :: LHsBinds pass
• cid_sigs :: [LSig pass]
• cid_tyfam_insts :: [LTyFamInstDecl pass]
• cid_datafam_insts :: [LDataFamInstDecl pass]
• cid_overlap_mode :: Maybe (Located OverlapMode)
  • AnnKeywordId : AnnOpen, AnnClose,

XClsInstDecl (XXClsInstDecl pass)

Instances

OutputableBndrId p => Outputable (ClsInstDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: ClsInstDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> ClsInstDecl (GhcPass p) -> SDoc

type LInstDecl pass = Located (InstDecl pass)

Located Instance Declaration

data InstDecl pass

Instance Declaration

Constructors

ClsInstD

Fields

• cid_d_ext :: XClsInstD pass
• cid_inst :: ClsInstDecl pass

DataFamInstD

Fields

• dfid_ext :: XDataFamInstD pass
• dfid_inst :: DataFamInstDecl pass

TyFamInstD

Fields

• tfid_ext :: XTyFamInstD pass
• tfid_inst :: TyFamInstDecl pass

XInstDecl (XXInstDecl pass)

Instances

OutputableBndrId p => Outputable (InstDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: InstDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> InstDecl (GhcPass p) -> SDoc

type LDerivDecl pass = Located (DerivDecl pass)

Located stand-alone 'deriving instance' declaration

data DerivDecl pass

Stand-alone 'deriving instance' declaration

Constructors

DerivDecl

Fields

• deriv_ext :: XCDerivDecl pass
• deriv_type :: LHsSigWcType pass

  The instance type to derive.

  It uses an LHsSigWcType because the context is allowed to be a single wildcard:

  deriving instance _ => Eq (Foo a)

  Which signifies that the context should be inferred.

• deriv_strategy :: Maybe (LDerivStrategy pass)
• deriv_overlap_mode :: Maybe (Located OverlapMode)
  • AnnKeywordId : AnnDeriving, AnnInstance, AnnStock, AnnAnyClass, AnnNewtype, AnnOpen,AnnClose

XDerivDecl (XXDerivDecl pass)

Instances

OutputableBndrId p => Outputable (DerivDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: DerivDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> DerivDecl (GhcPass p) -> SDoc

type LDerivStrategy pass = Located (DerivStrategy pass)

A Located DerivStrategy.

data DerivStrategy pass

Which technique the user explicitly requested when deriving an instance.

Constructors

StockStrategy

GHC's "standard" strategy, which is to implement a custom instance for the data type. This only works for certain types that GHC knows about (e.g., Eq, Show, Functor when -XDeriveFunctor is enabled, etc.)

AnyclassStrategy

-XDeriveAnyClass

NewtypeStrategy

-XGeneralizedNewtypeDeriving

ViaStrategy (XViaStrategy pass)

-XDerivingVia

Instances

OutputableBndrId p => Outputable (DerivStrategy (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: DerivStrategy (GhcPass p) -> SDoc

pprPrec :: Rational -> DerivStrategy (GhcPass p) -> SDoc

type LDefaultDecl pass = Located (DefaultDecl pass)

Located Default Declaration

data DefaultDecl pass

Default Declaration

Constructors

DefaultDecl (XCDefaultDecl pass) [LHsType pass]

• AnnKeywordIds : AnnDefault, AnnOpen,AnnClose

XDefaultDecl (XXDefaultDecl pass)

Instances

OutputableBndrId p => Outputable (DefaultDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: DefaultDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> DefaultDecl (GhcPass p) -> SDoc

type LForeignDecl pass = Located (ForeignDecl pass)

Located Foreign Declaration

data ForeignDecl pass

Foreign Declaration

Constructors

ForeignImport

Fields

• fd_i_ext :: XForeignImport pass
• fd_name :: Located (IdP pass)
• fd_sig_ty :: LHsSigType pass
• fd_fi :: ForeignImport

ForeignExport

• AnnKeywordId : AnnForeign, AnnImport,AnnExport, AnnDcolon

Fields

• fd_e_ext :: XForeignExport pass
• fd_name :: Located (IdP pass)
• fd_sig_ty :: LHsSigType pass
• fd_fe :: ForeignExport

XForeignDecl (XXForeignDecl pass)

Instances

OutputableBndrId p => Outputable (ForeignDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: ForeignDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> ForeignDecl (GhcPass p) -> SDoc

data ForeignImport

Constructors

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

Instances

Data ForeignImport

Defined in GHC.Hs.Decls

Methods

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

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

toConstr :: ForeignImport -> Constr

dataTypeOf :: ForeignImport -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> ForeignImport -> ForeignImport

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

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

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

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

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

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

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

Outputable ForeignImport

Defined in GHC.Hs.Decls

Methods

ppr :: ForeignImport -> SDoc

pprPrec :: Rational -> ForeignImport -> SDoc

data CImportSpec

Constructors

CLabel CLabelString

CFunction CCallTarget

CWrapper

Instances

Data CImportSpec

Defined in GHC.Hs.Decls

Methods

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

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

toConstr :: CImportSpec -> Constr

dataTypeOf :: CImportSpec -> DataType

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

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

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

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

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

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

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

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

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

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

data ForeignExport

Constructors

CExport (Located CExportSpec) (Located SourceText)

Instances

Data ForeignExport

Defined in GHC.Hs.Decls

Methods

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

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

toConstr :: ForeignExport -> Constr

dataTypeOf :: ForeignExport -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> ForeignExport -> ForeignExport

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

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

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

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

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

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

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

Outputable ForeignExport

Defined in GHC.Hs.Decls

Methods

ppr :: ForeignExport -> SDoc

pprPrec :: Rational -> ForeignExport -> SDoc

type LRuleDecls pass = Located (RuleDecls pass)

Located Rule Declarations

data RuleDecls pass

Rule Declarations

Constructors

HsRules

Fields

• rds_ext :: XCRuleDecls pass
• rds_src :: SourceText
• rds_rules :: [LRuleDecl pass]

XRuleDecls (XXRuleDecls pass)

Instances

OutputableBndrId p => Outputable (RuleDecls (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: RuleDecls (GhcPass p) -> SDoc

pprPrec :: Rational -> RuleDecls (GhcPass p) -> SDoc

type LRuleDecl pass = Located (RuleDecl pass)

Located Rule Declaration

data RuleDecl pass

Rule Declaration

Constructors

HsRule

• AnnKeywordId : AnnOpen,AnnTilde, AnnVal, AnnClose, AnnForall,AnnDot, AnnEqual,

Fields

• rd_ext :: XHsRule pass

  After renamer, free-vars from the LHS and RHS

• rd_name :: Located (SourceText, RuleName)

  Note [Pragma source text] in BasicTypes

• rd_act :: Activation
• rd_tyvs :: Maybe [LHsTyVarBndr (NoGhcTc pass)]

  Forall'd type vars

• rd_tmvs :: [LRuleBndr pass]

  Forall'd term vars, before typechecking; after typechecking this includes all forall'd vars

• rd_lhs :: Located (HsExpr pass)
• rd_rhs :: Located (HsExpr pass)

XRuleDecl (XXRuleDecl pass)

Instances

OutputableBndrId p => Outputable (RuleDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: RuleDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> RuleDecl (GhcPass p) -> SDoc

data HsRuleRn

Constructors

HsRuleRn NameSet NameSet

Instances

Data HsRuleRn

Defined in GHC.Hs.Decls

Methods

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

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

toConstr :: HsRuleRn -> Constr

dataTypeOf :: HsRuleRn -> DataType

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

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

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

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

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

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

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

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

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

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

type LRuleBndr pass = Located (RuleBndr pass)

Located Rule Binder

data RuleBndr pass

Rule Binder

Constructors

RuleBndr (XCRuleBndr pass) (Located (IdP pass))

RuleBndrSig (XRuleBndrSig pass) (Located (IdP pass)) (LHsSigWcType pass)

XRuleBndr (XXRuleBndr pass)

• AnnKeywordId : AnnOpen, AnnDcolon,AnnClose

Instances

OutputableBndrId p => Outputable (RuleBndr (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: RuleBndr (GhcPass p) -> SDoc

pprPrec :: Rational -> RuleBndr (GhcPass p) -> SDoc

type LDocDecl = Located DocDecl

Located Documentation comment Declaration

data DocDecl

Documentation comment Declaration

Constructors

DocCommentNext HsDocString

DocCommentPrev HsDocString

DocCommentNamed String HsDocString

DocGroup Int HsDocString

Instances

Data DocDecl

Defined in GHC.Hs.Decls

Methods

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

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

toConstr :: DocDecl -> Constr

dataTypeOf :: DocDecl -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> DocDecl -> DocDecl

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

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

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

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

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

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

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

Outputable DocDecl

Defined in GHC.Hs.Decls

Methods

ppr :: DocDecl -> SDoc

pprPrec :: Rational -> DocDecl -> SDoc

type LWarnDecls pass = Located (WarnDecls pass)

Located Warning Declarations

data WarnDecls pass

Warning pragma Declarations

Constructors

Warnings

Fields

• wd_ext :: XWarnings pass
• wd_src :: SourceText
• wd_warnings :: [LWarnDecl pass]

XWarnDecls (XXWarnDecls pass)

Instances

OutputableBndr (IdP (GhcPass p)) => Outputable (WarnDecls (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: WarnDecls (GhcPass p) -> SDoc

pprPrec :: Rational -> WarnDecls (GhcPass p) -> SDoc

type LWarnDecl pass = Located (WarnDecl pass)

Located Warning pragma Declaration

data WarnDecl pass

Warning pragma Declaration

Constructors

XWarnDecl (XXWarnDecl pass)

Instances

OutputableBndr (IdP (GhcPass p)) => Outputable (WarnDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: WarnDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> WarnDecl (GhcPass p) -> SDoc

type LAnnDecl pass = Located (AnnDecl pass)

Located Annotation Declaration

data AnnDecl pass

Annotation Declaration

Constructors

HsAnnotation (XHsAnnotation pass) SourceText (AnnProvenance (IdP pass)) (Located (HsExpr pass))

• AnnKeywordId : AnnOpen, AnnType AnnModule AnnClose

XAnnDecl (XXAnnDecl pass)

Instances

OutputableBndrId p => Outputable (AnnDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: AnnDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> AnnDecl (GhcPass p) -> SDoc

data AnnProvenance name

Annotation Provenance

Constructors

ValueAnnProvenance (Located name)

TypeAnnProvenance (Located name)

ModuleAnnProvenance

Instances

Functor AnnProvenance

Defined in GHC.Hs.Decls

Methods

fmap :: (a -> b) -> AnnProvenance a -> AnnProvenance b

(<$) :: a -> AnnProvenance b -> AnnProvenance a

Foldable AnnProvenance

Defined in GHC.Hs.Decls

Methods

fold :: Monoid m => AnnProvenance m -> m

foldMap :: Monoid m => (a -> m) -> AnnProvenance a -> m

foldMap' :: Monoid m => (a -> m) -> AnnProvenance a -> m

foldr :: (a -> b -> b) -> b -> AnnProvenance a -> b

foldr' :: (a -> b -> b) -> b -> AnnProvenance a -> b

foldl :: (b -> a -> b) -> b -> AnnProvenance a -> b

foldl' :: (b -> a -> b) -> b -> AnnProvenance a -> b

foldr1 :: (a -> a -> a) -> AnnProvenance a -> a

foldl1 :: (a -> a -> a) -> AnnProvenance a -> a

toList :: AnnProvenance a -> [a]

null :: AnnProvenance a -> Bool

length :: AnnProvenance a -> Int

elem :: Eq a => a -> AnnProvenance a -> Bool

maximum :: Ord a => AnnProvenance a -> a

minimum :: Ord a => AnnProvenance a -> a

sum :: Num a => AnnProvenance a -> a

product :: Num a => AnnProvenance a -> a

Traversable AnnProvenance

Defined in GHC.Hs.Decls

Methods

traverse :: Applicative f => (a -> f b) -> AnnProvenance a -> f (AnnProvenance b)

sequenceA :: Applicative f => AnnProvenance (f a) -> f (AnnProvenance a)

mapM :: Monad m => (a -> m b) -> AnnProvenance a -> m (AnnProvenance b)

sequence :: Monad m => AnnProvenance (m a) -> m (AnnProvenance a)

Data pass => Data (AnnProvenance pass)

Defined in GHC.Hs.Decls

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnProvenance pass -> c (AnnProvenance pass)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (AnnProvenance pass)

toConstr :: AnnProvenance pass -> Constr

dataTypeOf :: AnnProvenance pass -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (AnnProvenance pass))

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

gmapT :: (forall b. Data b => b -> b) -> AnnProvenance pass -> AnnProvenance pass

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnProvenance pass -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnProvenance pass -> r

gmapQ :: (forall d. Data d => d -> u) -> AnnProvenance pass -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnProvenance pass -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnProvenance pass -> m (AnnProvenance pass)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnProvenance pass -> m (AnnProvenance pass)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnProvenance pass -> m (AnnProvenance pass)

type LRoleAnnotDecl pass = Located (RoleAnnotDecl pass)

Located Role Annotation Declaration

data RoleAnnotDecl pass

Role Annotation Declaration

Constructors

RoleAnnotDecl (XCRoleAnnotDecl pass) (Located (IdP pass)) [Located (Maybe Role)]

• AnnKeywordId : AnnType, AnnRole

XRoleAnnotDecl (XXRoleAnnotDecl pass)

Instances

OutputableBndr (IdP (GhcPass p)) => Outputable (RoleAnnotDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: RoleAnnotDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> RoleAnnotDecl (GhcPass p) -> SDoc

collectEvVarsPat :: Pat GhcTc -> Bag EvVar

collectEvVarsPats :: [Pat GhcTc] -> Bag EvVar

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

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

patNeedsParens :: PprPrec -> Pat p -> Bool

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

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

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

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

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

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

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

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

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

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

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

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

hsRecFieldId :: HsRecField GhcTc arg -> Located Id

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

hsRecFieldsArgs :: HsRecFields p arg -> [arg]

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

hsConPatArgs :: HsConPatDetails p -> [LPat p]

type InPat p = LPat p

type OutPat p = LPat p

data ListPatTc

Constructors

ListPatTc Type (Maybe (Type, SyntaxExpr GhcTc))

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

Haskell Constructor Pattern Details

data HsRecFields p arg

Haskell Record Fields

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

Constructors

HsRecFields

Fields

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

Instances

Functor (HsRecFields p)

Defined in GHC.Hs.Pat

Methods

fmap :: (a -> b) -> HsRecFields p a -> HsRecFields p b

(<$) :: a -> HsRecFields p b -> HsRecFields p a

Foldable (HsRecFields p)

Defined in GHC.Hs.Pat

Methods

fold :: Monoid m => HsRecFields p m -> m

foldMap :: Monoid m => (a -> m) -> HsRecFields p a -> m

foldMap' :: Monoid m => (a -> m) -> HsRecFields p a -> m

foldr :: (a -> b -> b) -> b -> HsRecFields p a -> b

foldr' :: (a -> b -> b) -> b -> HsRecFields p a -> b

foldl :: (b -> a -> b) -> b -> HsRecFields p a -> b

foldl' :: (b -> a -> b) -> b -> HsRecFields p a -> b

foldr1 :: (a -> a -> a) -> HsRecFields p a -> a

foldl1 :: (a -> a -> a) -> HsRecFields p a -> a

toList :: HsRecFields p a -> [a]

null :: HsRecFields p a -> Bool

length :: HsRecFields p a -> Int

elem :: Eq a => a -> HsRecFields p a -> Bool

maximum :: Ord a => HsRecFields p a -> a

minimum :: Ord a => HsRecFields p a -> a

sum :: Num a => HsRecFields p a -> a

product :: Num a => HsRecFields p a -> a

Traversable (HsRecFields p)

Defined in GHC.Hs.Pat

Methods

traverse :: Applicative f => (a -> f b) -> HsRecFields p a -> f (HsRecFields p b)

sequenceA :: Applicative f => HsRecFields p (f a) -> f (HsRecFields p a)

mapM :: Monad m => (a -> m b) -> HsRecFields p a -> m (HsRecFields p b)

sequence :: Monad m => HsRecFields p (m a) -> m (HsRecFields p a)

Outputable arg => Outputable (HsRecFields p arg)

Defined in GHC.Hs.Pat

Methods

ppr :: HsRecFields p arg -> SDoc

pprPrec :: Rational -> HsRecFields p arg -> SDoc

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

Located Haskell Record Field

type LHsRecField p arg = Located (HsRecField p arg)

Located Haskell Record Field

type LHsRecUpdField p = Located (HsRecUpdField p)

Located Haskell Record Update Field

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

Haskell Record Field

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

Haskell Record Update Field

data HsRecField' id arg

Haskell Record Field

• AnnKeywordId : AnnEqual,

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

Constructors

HsRecField

Fields

• hsRecFieldLbl :: Located id
• hsRecFieldArg :: arg

  Filled in by renamer when punning

• hsRecPun :: Bool

  Note [Punning]

Instances

Functor (HsRecField' id)

Defined in GHC.Hs.Pat

Methods

fmap :: (a -> b) -> HsRecField' id a -> HsRecField' id b

(<$) :: a -> HsRecField' id b -> HsRecField' id a

Foldable (HsRecField' id)

Defined in GHC.Hs.Pat

Methods

fold :: Monoid m => HsRecField' id m -> m

foldMap :: Monoid m => (a -> m) -> HsRecField' id a -> m

foldMap' :: Monoid m => (a -> m) -> HsRecField' id a -> m

foldr :: (a -> b -> b) -> b -> HsRecField' id a -> b

foldr' :: (a -> b -> b) -> b -> HsRecField' id a -> b

foldl :: (b -> a -> b) -> b -> HsRecField' id a -> b

foldl' :: (b -> a -> b) -> b -> HsRecField' id a -> b

foldr1 :: (a -> a -> a) -> HsRecField' id a -> a

foldl1 :: (a -> a -> a) -> HsRecField' id a -> a

toList :: HsRecField' id a -> [a]

null :: HsRecField' id a -> Bool

length :: HsRecField' id a -> Int

elem :: Eq a => a -> HsRecField' id a -> Bool

maximum :: Ord a => HsRecField' id a -> a

minimum :: Ord a => HsRecField' id a -> a

sum :: Num a => HsRecField' id a -> a

product :: Num a => HsRecField' id a -> a

Traversable (HsRecField' id)

Defined in GHC.Hs.Pat

Methods

traverse :: Applicative f => (a -> f b) -> HsRecField' id a -> f (HsRecField' id b)

sequenceA :: Applicative f => HsRecField' id (f a) -> f (HsRecField' id a)

mapM :: Monad m => (a -> m b) -> HsRecField' id a -> m (HsRecField' id b)

sequence :: Monad m => HsRecField' id (m a) -> m (HsRecField' id a)

(Data id, Data arg) => Data (HsRecField' id arg)

Defined in GHC.Hs.Pat

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsRecField' id arg -> c (HsRecField' id arg)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsRecField' id arg)

toConstr :: HsRecField' id arg -> Constr

dataTypeOf :: HsRecField' id arg -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsRecField' id arg))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsRecField' id arg))

gmapT :: (forall b. Data b => b -> b) -> HsRecField' id arg -> HsRecField' id arg

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsRecField' id arg -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsRecField' id arg -> r

gmapQ :: (forall d. Data d => d -> u) -> HsRecField' id arg -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsRecField' id arg -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsRecField' id arg -> m (HsRecField' id arg)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsRecField' id arg -> m (HsRecField' id arg)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsRecField' id arg -> m (HsRecField' id arg)

(Outputable p, Outputable arg) => Outputable (HsRecField' p arg)

Defined in GHC.Hs.Pat

Methods

ppr :: HsRecField' p arg -> SDoc

pprPrec :: Rational -> HsRecField' p arg -> SDoc

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

pprTcSpecPrags :: TcSpecPrags -> SDoc

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

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

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

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

pragBrackets :: SDoc -> SDoc

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

hsSigDoc :: Sig name -> SDoc

isCompleteMatchSig :: LSig name -> Bool

isSCCFunSig :: LSig name -> Bool

isMinimalLSig :: LSig name -> Bool

isInlineLSig :: LSig name -> Bool

isPragLSig :: LSig name -> Bool

isSpecInstLSig :: LSig name -> Bool

isSpecLSig :: LSig name -> Bool

isTypeLSig :: LSig name -> Bool

isFixityLSig :: LSig name -> Bool

isDefaultMethod :: TcSpecPrags -> Bool

hasSpecPrags :: TcSpecPrags -> Bool

noSpecPrags :: TcSpecPrags

isEmptyIPBindsTc :: HsIPBinds GhcTc -> Bool

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

pprTicks :: SDoc -> SDoc -> SDoc

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

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

isEmptyLHsBinds :: LHsBindsLR idL idR -> Bool

emptyLHsBinds :: LHsBindsLR idL idR

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

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

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

eqEmptyLocalBinds :: HsLocalBindsLR a b -> Bool

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

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

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

pprDeclList :: [SDoc] -> SDoc

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

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

type HsLocalBinds id = HsLocalBindsLR id id

Haskell Local Bindings

type LHsLocalBinds id = Located (HsLocalBinds id)

Located Haskell local bindings

data HsLocalBindsLR idL idR

Haskell Local Bindings with separate Left and Right identifier types

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

Constructors

HsValBinds (XHsValBinds idL idR) (HsValBindsLR idL idR)

Haskell Value Bindings

HsIPBinds (XHsIPBinds idL idR) (HsIPBinds idR)

Haskell Implicit Parameter Bindings

EmptyLocalBinds (XEmptyLocalBinds idL idR)

Empty Local Bindings

XHsLocalBindsLR (XXHsLocalBindsLR idL idR)

Instances

(OutputableBndrId pl, OutputableBndrId pr) => Outputable (HsLocalBindsLR (GhcPass pl) (GhcPass pr))

Defined in GHC.Hs.Binds

Methods

ppr :: HsLocalBindsLR (GhcPass pl) (GhcPass pr) -> SDoc

pprPrec :: Rational -> HsLocalBindsLR (GhcPass pl) (GhcPass pr) -> SDoc

type LHsLocalBindsLR idL idR = Located (HsLocalBindsLR idL idR)

type HsValBinds id = HsValBindsLR id id

Haskell Value Bindings

data HsValBindsLR idL idR

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

Constructors

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

Value Bindings In

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

XValBindsLR (XXValBindsLR idL idR)

Value Bindings Out

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

Instances

(OutputableBndrId pl, OutputableBndrId pr) => Outputable (HsValBindsLR (GhcPass pl) (GhcPass pr))

Defined in GHC.Hs.Binds

Methods

ppr :: HsValBindsLR (GhcPass pl) (GhcPass pr) -> SDoc

pprPrec :: Rational -> HsValBindsLR (GhcPass pl) (GhcPass pr) -> SDoc

data NHsValBindsLR idL

Constructors

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

type LHsBind id = LHsBindLR id id

Located Haskell Binding

type LHsBinds id = LHsBindsLR id id

Located Haskell Bindings

type HsBind id = HsBindLR id id

Haskell Binding

type LHsBindsLR idL idR = Bag (LHsBindLR idL idR)

Located Haskell Bindings with separate Left and Right identifier types

type LHsBindLR idL idR = Located (HsBindLR idL idR)

Located Haskell Binding with separate Left and Right identifier types

data HsBindLR idL idR

Haskell Binding with separate Left and Right id's

Constructors

FunBind

Function-like Binding

FunBind is used for both functions f x = e and variables f = x -> e and strict variables !x = x + 1

Reason 1: Special case for type inference: see tcMonoBinds.

Reason 2: Instance decls can only have FunBinds, which is convenient. If you change this, you'll need to change e.g. rnMethodBinds

But note that the form f :: a->a = ... parses as a pattern binding, just like (f :: a -> a) = ...

Strict bindings have their strictness recorded in the SrcStrictness of their MatchContext. See Note [FunBind vs PatBind] for details about the relationship between FunBind and PatBind.

AnnKeywordIds

• AnnFunId, attached to each element of fun_matches
• AnnEqual,AnnWhere, AnnOpen,AnnClose,

Fields

• fun_ext :: XFunBind idL idR

  After the renamer, this contains the locally-bound free variables of this defn. See Note [Bind free vars]

• fun_id :: Located (IdP idL)
• fun_matches :: MatchGroup idR (LHsExpr idR)

  The payload

• fun_co_fn :: HsWrapper

  Coercion from the type of the MatchGroup to the type of the Id. Example:

       f :: Int -> forall a. a -> a
       f x y = y
  

  Then the MatchGroup will have type (Int -> a' -> a') (with a free type variable a'). The coercion will take a CoreExpr of this type and convert it to a CoreExpr of type Int -> forall a'. a' -> a' Notice that the coercion captures the free a'.

• fun_tick :: [Tickish Id]

  Ticks to put on the rhs, if any

PatBind

Pattern Binding

The pattern is never a simple variable; That case is done by FunBind. See Note [FunBind vs PatBind] for details about the relationship between FunBind and PatBind.

Fields

• pat_ext :: XPatBind idL idR

  See Note [Bind free vars]

• pat_lhs :: LPat idL
• pat_rhs :: GRHSs idR (LHsExpr idR)
• pat_ticks :: ([Tickish Id], [[Tickish Id]])

  Ticks to put on the rhs, if any, and ticks to put on the bound variables.

VarBind

Variable Binding

Dictionary binding and suchlike. All VarBinds are introduced by the type checker

Fields

• var_ext :: XVarBind idL idR
• var_id :: IdP idL
• var_rhs :: LHsExpr idR

  Located only for consistency

• var_inline :: Bool

  True = inline this binding regardless (used for implication constraints only)

AbsBinds

Abstraction Bindings

Fields

• abs_ext :: XAbsBinds idL idR
• abs_tvs :: [TyVar]
• abs_ev_vars :: [EvVar]

  Includes equality constraints

• abs_exports :: [ABExport idL]

  AbsBinds only gets used when idL = idR after renaming, but these need to be idL's for the collect... code in HsUtil to have the right type

• abs_ev_binds :: [TcEvBinds]

  Evidence bindings Why a list? See TcInstDcls Note [Typechecking plan for instance declarations]

• abs_binds :: LHsBinds idL

  Typechecked user bindings

• abs_sig :: Bool

PatSynBind (XPatSynBind idL idR) (PatSynBind idL idR)

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

XHsBindsLR (XXHsBindsLR idL idR)

Instances

(OutputableBndrId pl, OutputableBndrId pr) => Outputable (HsBindLR (GhcPass pl) (GhcPass pr))

Defined in GHC.Hs.Binds

Methods

ppr :: HsBindLR (GhcPass pl) (GhcPass pr) -> SDoc

pprPrec :: Rational -> HsBindLR (GhcPass pl) (GhcPass pr) -> SDoc

data NPatBindTc

Constructors

NPatBindTc

Fields

• pat_fvs :: NameSet

  Free variables

• pat_rhs_ty :: Type

  Type of the GRHSs

Instances

Data NPatBindTc

Defined in GHC.Hs.Binds

Methods

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

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

toConstr :: NPatBindTc -> Constr

dataTypeOf :: NPatBindTc -> DataType

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

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

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

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

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

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

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

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

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

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

data ABExport p

Abtraction Bindings Export

Constructors

ABE

Fields

• abe_ext :: XABE p
• abe_poly :: IdP p

  Any INLINE pragma is attached to this Id

• abe_mono :: IdP p
• abe_wrap :: HsWrapper

  See Note [ABExport wrapper] Shape: (forall abs_tvs. abs_ev_vars => abe_mono) ~ abe_poly

• abe_prags :: TcSpecPrags

  SPECIALISE pragmas

XABExport (XXABExport p)

Instances

OutputableBndrId p => Outputable (ABExport (GhcPass p))

Defined in GHC.Hs.Binds

Methods

ppr :: ABExport (GhcPass p) -> SDoc

pprPrec :: Rational -> ABExport (GhcPass p) -> SDoc

data PatSynBind idL idR

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

Pattern Synonym binding

Constructors

PSB

Fields

• psb_ext :: XPSB idL idR

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

• psb_id :: Located (IdP idL)

  Name of the pattern synonym

• psb_args :: HsPatSynDetails (Located (IdP idR))

  Formal parameter names

• psb_def :: LPat idR

  Right-hand side

• psb_dir :: HsPatSynDir idR

  Directionality

XPatSynBind (XXPatSynBind idL idR)

Instances

(OutputableBndrId l, OutputableBndrId r, Outputable (XXPatSynBind (GhcPass l) (GhcPass r))) => Outputable (PatSynBind (GhcPass l) (GhcPass r))

Defined in GHC.Hs.Binds

Methods

ppr :: PatSynBind (GhcPass l) (GhcPass r) -> SDoc

pprPrec :: Rational -> PatSynBind (GhcPass l) (GhcPass r) -> SDoc

data HsIPBinds id

Haskell Implicit Parameter Bindings

Constructors

IPBinds (XIPBinds id) [LIPBind id]

XHsIPBinds (XXHsIPBinds id)

Instances

OutputableBndrId p => Outputable (HsIPBinds (GhcPass p))

Defined in GHC.Hs.Binds

Methods

ppr :: HsIPBinds (GhcPass p) -> SDoc

pprPrec :: Rational -> HsIPBinds (GhcPass p) -> SDoc

type LIPBind id = Located (IPBind id)

Located Implicit Parameter Binding

May have AnnKeywordId : AnnSemi when in a list

data IPBind id

Implicit parameter bindings.

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

• AnnKeywordId : AnnEqual

Constructors

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

XIPBind (XXIPBind id)

Instances

OutputableBndrId p => Outputable (IPBind (GhcPass p))

Defined in GHC.Hs.Binds

Methods

ppr :: IPBind (GhcPass p) -> SDoc

pprPrec :: Rational -> IPBind (GhcPass p) -> SDoc

type LSig pass = Located (Sig pass)

Located Signature

data Sig pass

Signatures and pragmas

Constructors

TypeSig (XTypeSig pass) [Located (IdP pass)] (LHsSigWcType pass)

An ordinary type signature

f :: Num a => a -> a

After renaming, this list of Names contains the named wildcards brought into scope by this signature. For a signature _ -> _a -> Bool, the renamer will leave the unnamed wildcard _ untouched, and the named wildcard _a is then replaced with fresh meta vars in the type. Their names are stored in the type signature that brought them into scope, in this third field to be more specific.

• AnnKeywordId : AnnDcolon, AnnComma

PatSynSig (XPatSynSig pass) [Located (IdP pass)] (LHsSigType pass)

A pattern synonym type signature

pattern Single :: () => (Show a) => a -> [a]

• AnnKeywordId : AnnPattern, AnnDcolon,AnnForall AnnDot,AnnDarrow

ClassOpSig (XClassOpSig pass) Bool [Located (IdP pass)] (LHsSigType pass)

A signature for a class method False: ordinary class-method signature True: generic-default class method signature e.g. class C a where op :: a -> a -- Ordinary default op :: Eq a => a -> a -- Generic default No wildcards allowed here

• AnnKeywordId : AnnDefault, AnnDcolon

IdSig (XIdSig pass) Id

A type signature in generated code, notably the code generated for record selectors. We simply record the desired Id itself, replete with its name, type and IdDetails. Otherwise it's just like a type signature: there should be an accompanying binding

FixSig (XFixSig pass) (FixitySig pass)

An ordinary fixity declaration

    infixl 8 ***

• AnnKeywordId : AnnInfix, AnnVal

InlineSig (XInlineSig pass) (Located (IdP pass)) InlinePragma

An inline pragma

{#- INLINE f #-}

• AnnKeywordId : AnnOpen '{-# INLINE' and '[', AnnClose,AnnOpen, AnnVal,AnnTilde, AnnClose

SpecSig (XSpecSig pass) (Located (IdP pass)) [LHsSigType pass] InlinePragma

A specialisation pragma

{-# SPECIALISE f :: Int -> Int #-}

• AnnKeywordId : AnnOpen, AnnOpen '{-# SPECIALISE' and '[', AnnTilde, AnnVal, AnnClose ']' and '#-}', AnnDcolon

SpecInstSig (XSpecInstSig pass) SourceText (LHsSigType pass)

A specialisation pragma for instance declarations only

{-# SPECIALISE instance Eq [Int] #-}

(Class tys); should be a specialisation of the current instance declaration

• AnnKeywordId : AnnOpen, AnnInstance,AnnClose

MinimalSig (XMinimalSig pass) SourceText (LBooleanFormula (Located (IdP pass)))

A minimal complete definition pragma

{-# MINIMAL a | (b, c | (d | e)) #-}

• AnnKeywordId : AnnOpen, AnnVbar,AnnComma, AnnClose

SCCFunSig (XSCCFunSig pass) SourceText (Located (IdP pass)) (Maybe (Located StringLiteral))

A "set cost centre" pragma for declarations

{-# SCC funName #-}

or

{-# SCC funName "cost_centre_name" #-}

CompleteMatchSig (XCompleteMatchSig pass) SourceText (Located [Located (IdP pass)]) (Maybe (Located (IdP pass)))

A complete match pragma

{-# COMPLETE C, D [:: T] #-}

Used to inform the pattern match checker about additional complete matchings which, for example, arise from pattern synonym definitions.

XSig (XXSig pass)

Instances

OutputableBndrId p => Outputable (Sig (GhcPass p))

Defined in GHC.Hs.Binds

Methods

ppr :: Sig (GhcPass p) -> SDoc

pprPrec :: Rational -> Sig (GhcPass p) -> SDoc

type LFixitySig pass = Located (FixitySig pass)

Located Fixity Signature

data FixitySig pass

Fixity Signature

Constructors

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

XFixitySig (XXFixitySig pass)

Instances

OutputableBndrId p => Outputable (FixitySig (GhcPass p))

Defined in GHC.Hs.Binds

Methods

ppr :: FixitySig (GhcPass p) -> SDoc

pprPrec :: Rational -> FixitySig (GhcPass p) -> SDoc

data TcSpecPrags

Type checker Specialisation Pragmas

TcSpecPrags conveys SPECIALISE pragmas from the type checker to the desugarer

Constructors

IsDefaultMethod

Super-specialised: a default method should be macro-expanded at every call site

SpecPrags [LTcSpecPrag]

Instances

Data TcSpecPrags

Defined in GHC.Hs.Binds

Methods

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

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

toConstr :: TcSpecPrags -> Constr

dataTypeOf :: TcSpecPrags -> DataType

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

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

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

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

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

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

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

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

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

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

type LTcSpecPrag = Located TcSpecPrag

Located Type checker Specification Pragmas

data TcSpecPrag

Type checker Specification Pragma

Constructors

SpecPrag Id HsWrapper InlinePragma

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

Instances

Data TcSpecPrag

Defined in GHC.Hs.Binds

Methods

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

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

toConstr :: TcSpecPrag -> Constr

dataTypeOf :: TcSpecPrag -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> TcSpecPrag -> TcSpecPrag

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

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

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

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

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

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

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

Outputable TcSpecPrag

Defined in GHC.Hs.Binds

Methods

ppr :: TcSpecPrag -> SDoc

pprPrec :: Rational -> TcSpecPrag -> SDoc

type HsPatSynDetails arg = HsConDetails arg [RecordPatSynField arg]

Haskell Pattern Synonym Details

data RecordPatSynField a

Record Pattern Synonym Field

Constructors

RecordPatSynField

Fields

• recordPatSynSelectorId :: a
• recordPatSynPatVar :: a

Instances

Functor RecordPatSynField

Defined in GHC.Hs.Binds

Methods

fmap :: (a -> b) -> RecordPatSynField a -> RecordPatSynField b

(<$) :: a -> RecordPatSynField b -> RecordPatSynField a

Foldable RecordPatSynField

Defined in GHC.Hs.Binds

Methods

fold :: Monoid m => RecordPatSynField m -> m

foldMap :: Monoid m => (a -> m) -> RecordPatSynField a -> m

foldMap' :: Monoid m => (a -> m) -> RecordPatSynField a -> m

foldr :: (a -> b -> b) -> b -> RecordPatSynField a -> b

foldr' :: (a -> b -> b) -> b -> RecordPatSynField a -> b

foldl :: (b -> a -> b) -> b -> RecordPatSynField a -> b

foldl' :: (b -> a -> b) -> b -> RecordPatSynField a -> b

foldr1 :: (a -> a -> a) -> RecordPatSynField a -> a

foldl1 :: (a -> a -> a) -> RecordPatSynField a -> a

toList :: RecordPatSynField a -> [a]

null :: RecordPatSynField a -> Bool

length :: RecordPatSynField a -> Int

elem :: Eq a => a -> RecordPatSynField a -> Bool

maximum :: Ord a => RecordPatSynField a -> a

minimum :: Ord a => RecordPatSynField a -> a

sum :: Num a => RecordPatSynField a -> a

product :: Num a => RecordPatSynField a -> a

Traversable RecordPatSynField

Defined in GHC.Hs.Binds

Methods

traverse :: Applicative f => (a -> f b) -> RecordPatSynField a -> f (RecordPatSynField b)

sequenceA :: Applicative f => RecordPatSynField (f a) -> f (RecordPatSynField a)

mapM :: Monad m => (a -> m b) -> RecordPatSynField a -> m (RecordPatSynField b)

sequence :: Monad m => RecordPatSynField (m a) -> m (RecordPatSynField a)

Data a => Data (RecordPatSynField a)

Defined in GHC.Hs.Binds

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RecordPatSynField a -> c (RecordPatSynField a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RecordPatSynField a)

toConstr :: RecordPatSynField a -> Constr

dataTypeOf :: RecordPatSynField a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RecordPatSynField a))

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

gmapT :: (forall b. Data b => b -> b) -> RecordPatSynField a -> RecordPatSynField a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RecordPatSynField a -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RecordPatSynField a -> r

gmapQ :: (forall d. Data d => d -> u) -> RecordPatSynField a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> RecordPatSynField a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RecordPatSynField a -> m (RecordPatSynField a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RecordPatSynField a -> m (RecordPatSynField a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RecordPatSynField a -> m (RecordPatSynField a)

Outputable a => Outputable (RecordPatSynField a)

Defined in GHC.Hs.Binds

Methods

ppr :: RecordPatSynField a -> SDoc

pprPrec :: Rational -> RecordPatSynField a -> SDoc

data HsPatSynDir id

Haskell Pattern Synonym Direction

Constructors

Unidirectional

ImplicitBidirectional

ExplicitBidirectional (MatchGroup id (LHsExpr id))

instanceBindFun :: TyCoVar -> BindFlag

lookupInstEnv :: Bool -> InstEnvs -> Class -> [Type] -> ClsInstLookupResult

See Note [Rules for instance lookup] ^ See Note [Safe Haskell Overlapping Instances] in TcSimplify ^ See Note [Safe Haskell Overlapping Instances Implementation] in TcSimplify

lookupUniqueInstEnv :: InstEnvs -> Class -> [Type] -> Either MsgDoc (ClsInst, [Type])

Look up an instance in the given instance environment. The given class application must match exactly one instance and the match may not contain any flexi type variables. If the lookup is unsuccessful, yield 'Left errorMessage'.

identicalClsInstHead :: ClsInst -> ClsInst -> Bool

True when when the instance heads are the same e.g. both are Eq [(a,b)] Used for overriding in GHCi Obviously should be insenstive to alpha-renaming

deleteDFunFromInstEnv :: InstEnv -> DFunId -> InstEnv

deleteFromInstEnv :: InstEnv -> ClsInst -> InstEnv

extendInstEnv :: InstEnv -> ClsInst -> InstEnv

extendInstEnvList :: InstEnv -> [ClsInst] -> InstEnv

memberInstEnv :: InstEnv -> ClsInst -> Bool

Checks for an exact match of ClsInst in the instance environment. We use this when we do signature checking in TcRnDriver

classInstances :: InstEnvs -> Class -> [ClsInst]

instIsVisible :: VisibleOrphanModules -> ClsInst -> Bool

Test if an instance is visible, by checking that its origin module is in VisibleOrphanModules. See Note [Instance lookup and orphan instances]

instEnvClasses :: InstEnv -> [Class]

instEnvElts :: InstEnv -> [ClsInst]

emptyInstEnv :: InstEnv

mkImportedInstance

Arguments

:: Name

the name of the class

-> [Maybe Name]

the types which the class was applied to

-> Name

the Name of the dictionary binding

-> DFunId

the Id of the dictionary.

-> OverlapFlag

may this instance overlap?

-> IsOrphan

is this instance an orphan?

-> ClsInst

mkLocalInstance :: DFunId -> OverlapFlag -> [TyVar] -> Class -> [Type] -> ClsInst

instanceSig :: ClsInst -> ([TyVar], [Type], Class, [Type])

orphNamesOfClsInst :: ClsInst -> NameSet

Collects the names of concrete types and type constructors that make up the head of a class instance. For instance, given `class Foo a b`:

`instance Foo (Either (Maybe Int) a) Bool` would yield [Either, Maybe, Int, Bool]

Used in the implementation of ":info" in GHCi.

The tcSplitSigmaTy is because of instance Foo a => Baz T where ... The decl is an orphan if Baz and T are both not locally defined, even if Foo *is* locally defined

instanceHead :: ClsInst -> ([TyVar], Class, [Type])

pprInstances :: [ClsInst] -> SDoc

pprInstanceHdr :: ClsInst -> SDoc

pprInstance :: ClsInst -> SDoc

instanceRoughTcs :: ClsInst -> [Maybe Name]

updateClsInstDFun :: (DFunId -> DFunId) -> ClsInst -> ClsInst

instanceDFunId :: ClsInst -> DFunId

isIncoherent :: ClsInst -> Bool

isOverlapping :: ClsInst -> Bool

isOverlappable :: ClsInst -> Bool

fuzzyClsInstCmp :: ClsInst -> ClsInst -> Ordering

A fuzzy comparison function for class instances, intended for sorting instances before displaying them to the user.

data ClsInst

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

Constructors

ClsInst

Fields

• is_cls_nm :: Name

  Class name

• is_tcs :: [Maybe Name]

  Top of type args

• is_dfun_name :: Name

  is_dfun_name = idName . is_dfun.

  We use is_dfun_name for the visibility check, instIsVisible, which needs to know the Module which the dictionary is defined in. However, we cannot use the Module attached to is_dfun since doing so would mean we would potentially pull in an entire interface file unnecessarily. This was the cause of #12367.

• is_tvs :: [TyVar]
• is_cls :: Class
• is_tys :: [Type]
• is_dfun :: DFunId
• is_flag :: OverlapFlag
• is_orphan :: IsOrphan

Instances

Data ClsInst

Defined in InstEnv

Methods

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

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

toConstr :: ClsInst -> Constr

dataTypeOf :: ClsInst -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> ClsInst -> ClsInst

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

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

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

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

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

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

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

NamedThing ClsInst

Defined in InstEnv

Methods

getOccName :: ClsInst -> OccName

getName :: ClsInst -> Name

Outputable ClsInst

Defined in InstEnv

Methods

ppr :: ClsInst -> SDoc

pprPrec :: Rational -> ClsInst -> SDoc

type InstEnv = UniqDFM ClsInstEnv

data InstEnvs

InstEnvs represents the combination of the global type class instance environment, the local type class instance environment, and the set of transitively reachable orphan modules (according to what modules have been directly imported) used to test orphan instance visibility.

Constructors

InstEnvs

Fields

• ie_global :: InstEnv
• ie_local :: InstEnv
• ie_visible :: VisibleOrphanModules

type VisibleOrphanModules = ModuleSet

Set of visible orphan modules, according to what modules have been directly imported. This is based off of the dep_orphs field, which records transitively reachable orphan modules (modules that define orphan instances).

type DFunInstType = Maybe Type

type InstMatch = (ClsInst, [DFunInstType])

type ClsInstLookupResult = ([InstMatch], [ClsInst], [InstMatch])

data FamInst

Instances

NamedThing FamInst

Defined in FamInstEnv

Methods

getOccName :: FamInst -> OccName

getName :: FamInst -> Name

Outputable FamInst

Defined in FamInstEnv

Methods

ppr :: FamInst -> SDoc

pprPrec :: Rational -> FamInst -> SDoc

data Linkable

Information we can use to dynamically link modules into the compiler

Constructors

LM

Fields

• linkableTime :: UTCTime

  Time at which this linkable was built (i.e. when the bytecodes were produced, or the mod date on the files)

• linkableModule :: Module

  The linkable module itself

• linkableUnlinked :: [Unlinked]

  Those files and chunks of code we have yet to link.

  INVARIANT: A valid linkable always has at least one Unlinked item. If this list is empty, the Linkable represents a fake linkable, which is generated in HscNothing mode to avoid recompiling modules.

  ToDo: Do items get removed from this list when they get linked?

Instances

Outputable Linkable

Defined in LinkerTypes

Methods

ppr :: Linkable -> SDoc

pprPrec :: Rational -> Linkable -> SDoc

data Unlinked

Objects which have yet to be linked by the compiler

Constructors

DotO FilePath

An object file (.o)

DotA FilePath

Static archive file (.a)

DotDLL FilePath

Dynamically linked library file (.so, .dll, .dylib)

BCOs CompiledByteCode [SptEntry]

A byte-code object, lives only in memory. Also carries some static pointer table entries which should be loaded along with the BCOs. See Note [Grant plan for static forms] in StaticPtrTable.

Instances

Outputable Unlinked

Defined in LinkerTypes

Methods

ppr :: Unlinked -> SDoc

pprPrec :: Rational -> Unlinked -> SDoc

data SptEntry

An entry to be inserted into a module's static pointer table. See Note [Grand plan for static forms] in StaticPtrTable.

Constructors

SptEntry Id Fingerprint

Instances

Outputable SptEntry

Defined in LinkerTypes

Methods

ppr :: SptEntry -> SDoc

pprPrec :: Rational -> SptEntry -> SDoc

emptyModBreaks :: ModBreaks

Construct an empty ModBreaks

data CompiledByteCode

Instances

Outputable CompiledByteCode

Defined in ByteCodeTypes

Methods

ppr :: CompiledByteCode -> SDoc

pprPrec :: Rational -> CompiledByteCode -> SDoc

type BreakIndex = Int

Breakpoint index

data ModBreaks

All the information about the breakpoints for a module

Constructors

ModBreaks

Fields

• modBreaks_flags :: ForeignRef BreakArray

  The array of flags, one per breakpoint, indicating which breakpoints are enabled.

• modBreaks_locs :: !(Array BreakIndex SrcSpan)

  An array giving the source span of each breakpoint.

• modBreaks_vars :: !(Array BreakIndex [OccName])

  An array giving the names of the free variables at each breakpoint.

• modBreaks_decls :: !(Array BreakIndex [String])

  An array giving the names of the declarations enclosing each breakpoint.

• modBreaks_ccs :: !(Array BreakIndex (RemotePtr CostCentre))

  Array pointing to cost centre for each breakpoint

• modBreaks_breakInfo :: IntMap CgBreakInfo

  info about each breakpoint from the bytecode generator

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

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

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

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

hsTypeNeedsParens :: PprPrec -> HsType pass -> Bool

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

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

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

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

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

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

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

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

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

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

pprAnonWildCard :: SDoc

ambiguousFieldOcc :: FieldOcc GhcTc -> AmbiguousFieldOcc GhcTc

unambiguousFieldOcc :: AmbiguousFieldOcc GhcTc -> FieldOcc GhcTc

selectorAmbiguousFieldOcc :: AmbiguousFieldOcc GhcTc -> Id

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

mkAmbiguousFieldOcc :: Located RdrName -> AmbiguousFieldOcc GhcPs

mkFieldOcc :: Located RdrName -> FieldOcc GhcPs

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Decompose a pattern synonym type signature into its constituent parts.

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

numVisibleArgs :: [HsArg tm ty] -> Arity

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

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

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

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

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

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

mkAnonWildCardTy :: HsType GhcPs

isLHsForAllTy :: LHsType p -> Bool

ignoreParens :: LHsType pass -> LHsType pass

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

Get the kind signature of a type, ignoring parentheses:

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

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

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

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

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

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

Convert a LHsTyVarBndr to an equivalent LHsType.

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

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

hsAllLTyVarNames :: LHsQTyVars GhcRn -> [Name]

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

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

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

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

hsScopedTvs :: LHsSigType GhcRn -> [Name]

hsWcScopedTvs :: LHsSigWcType GhcRn -> [Name]

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

hsTvbAllKinded :: LHsQTyVars pass -> Bool

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

isHsKindedTyVar :: HsTyVarBndr pass -> Bool

Does this HsTyVarBndr come with an explicit kind annotation?

hsIPNameFS :: HsIPName -> FastString

mkEmptyWildCardBndrs :: thing -> HsWildCardBndrs GhcRn thing

mkEmptyImplicitBndrs :: thing -> HsImplicitBndrs GhcRn thing

mkHsWildCardBndrs :: thing -> HsWildCardBndrs GhcPs thing

mkHsImplicitBndrs :: thing -> HsImplicitBndrs GhcPs thing

dropWildCards :: LHsSigWcType pass -> LHsSigType pass

hsSigWcType :: LHsSigWcType pass -> LHsType pass

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

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

isEmptyLHsQTvs :: LHsQTyVars GhcRn -> Bool

emptyLHsQTvs :: LHsQTyVars GhcRn

hsQTvExplicit :: LHsQTyVars pass -> [LHsTyVarBndr pass]

mkHsQTvs :: [LHsTyVarBndr GhcPs] -> LHsQTyVars GhcPs

noLHsContext :: LHsContext pass

getBangStrictness :: LHsType a -> HsSrcBang

getBangType :: LHsType a -> LHsType a

type LBangType pass = Located (BangType pass)

Located Bang Type

type BangType pass = HsType pass

Bang Type

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

type LHsContext pass

Arguments

 = Located (HsContext pass)

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

Located Haskell Context

type HsContext pass = [LHsType pass]

Haskell Context

type LHsType pass

Arguments

 = Located (HsType pass)

May have AnnKeywordId : AnnComma when in a list

Located Haskell Type

type HsKind pass = HsType pass

Haskell Kind

type LHsKind pass

Arguments

 = Located (HsKind pass)

AnnKeywordId : AnnDcolon

Located Haskell Kind

type LHsTyVarBndr pass = Located (HsTyVarBndr pass)

Located Haskell Type Variable Binder

data LHsQTyVars pass

Located Haskell Quantified Type Variables

Constructors

HsQTvs

Fields

• hsq_ext :: XHsQTvs pass
• hsq_explicit :: [LHsTyVarBndr pass]

XLHsQTyVars (XXLHsQTyVars pass)

Instances

OutputableBndrId p => Outputable (LHsQTyVars (GhcPass p))

Defined in GHC.Hs.Types

Methods

ppr :: LHsQTyVars (GhcPass p) -> SDoc

pprPrec :: Rational -> LHsQTyVars (GhcPass p) -> SDoc

data HsImplicitBndrs pass thing

Haskell Implicit Binders

Constructors

HsIB

Fields

• hsib_ext :: XHsIB pass thing
• hsib_body :: thing

XHsImplicitBndrs (XXHsImplicitBndrs pass thing)

Instances

Outputable thing => Outputable (HsImplicitBndrs (GhcPass p) thing)

Defined in GHC.Hs.Types

Methods

ppr :: HsImplicitBndrs (GhcPass p) thing -> SDoc

pprPrec :: Rational -> HsImplicitBndrs (GhcPass p) thing -> SDoc

data HsWildCardBndrs pass thing

Haskell Wildcard Binders

Constructors

HsWC

Fields

• hswc_ext :: XHsWC pass thing
• hswc_body :: thing

XHsWildCardBndrs (XXHsWildCardBndrs pass thing)

Instances

Outputable thing => Outputable (HsWildCardBndrs (GhcPass p) thing)

Defined in GHC.Hs.Types

Methods

ppr :: HsWildCardBndrs (GhcPass p) thing -> SDoc

pprPrec :: Rational -> HsWildCardBndrs (GhcPass p) thing -> SDoc

type LHsSigType pass = HsImplicitBndrs pass (LHsType pass)

Located Haskell Signature Type

type LHsWcType pass = HsWildCardBndrs pass (LHsType pass)

Located Haskell Wildcard Type

type LHsSigWcType pass = HsWildCardBndrs pass (LHsSigType pass)

Located Haskell Signature Wildcard Type

newtype HsIPName

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

Constructors

HsIPName FastString

Instances

Eq HsIPName

Defined in GHC.Hs.Types

Methods

(==) :: HsIPName -> HsIPName -> Bool

(/=) :: HsIPName -> HsIPName -> Bool

Data HsIPName

Defined in GHC.Hs.Types

Methods

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

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

toConstr :: HsIPName -> Constr

dataTypeOf :: HsIPName -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> HsIPName -> HsIPName

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

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

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

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

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

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

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

Outputable HsIPName

Defined in GHC.Hs.Types

Methods

ppr :: HsIPName -> SDoc

pprPrec :: Rational -> HsIPName -> SDoc

OutputableBndr HsIPName

Defined in GHC.Hs.Types

Methods

pprBndr :: BindingSite -> HsIPName -> SDoc

pprPrefixOcc :: HsIPName -> SDoc

pprInfixOcc :: HsIPName -> SDoc

bndrIsJoin_maybe :: HsIPName -> Maybe Int

data HsTyVarBndr pass

Haskell Type Variable Binder

Constructors

UserTyVar (XUserTyVar pass) (Located (IdP pass))

KindedTyVar (XKindedTyVar pass) (Located (IdP pass)) (LHsKind pass)

• AnnKeywordId : AnnOpen, AnnDcolon, AnnClose

XTyVarBndr (XXTyVarBndr pass)

Instances

NamedThing (HsTyVarBndr GhcRn)

Defined in GHC.Hs.Types

Methods

getOccName :: HsTyVarBndr GhcRn -> OccName

getName :: HsTyVarBndr GhcRn -> Name

OutputableBndrId p => Outputable (HsTyVarBndr (GhcPass p))

Defined in GHC.Hs.Types

Methods

ppr :: HsTyVarBndr (GhcPass p) -> SDoc

pprPrec :: Rational -> HsTyVarBndr (GhcPass p) -> SDoc

data HsType pass

Haskell Type

Constructors

HsForAllTy

• AnnKeywordId : AnnForall, AnnDot,AnnDarrow For details on above see note [Api annotations] in ApiAnnotation

Fields

• hst_xforall :: XForAllTy pass
• hst_fvf :: ForallVisFlag
• hst_bndrs :: [LHsTyVarBndr pass]
• hst_body :: LHsType pass

HsQualTy

Fields

• hst_xqual :: XQualTy pass
• hst_ctxt :: LHsContext pass
• hst_body :: LHsType pass

HsTyVar (XTyVar pass) PromotionFlag (Located (IdP pass))

• AnnKeywordId : None

HsAppTy (XAppTy pass) (LHsType pass) (LHsType pass)

• AnnKeywordId : None

HsAppKindTy (XAppKindTy pass) (LHsType pass) (LHsKind pass)

HsFunTy (XFunTy pass) (LHsType pass) (LHsType pass)

• AnnKeywordId : AnnRarrow,

HsListTy (XListTy pass) (LHsType pass)

• AnnKeywordId : AnnOpen '[', AnnClose ']'

HsTupleTy (XTupleTy pass) HsTupleSort [LHsType pass]

• AnnKeywordId : AnnOpen '(' or '(#', AnnClose ')' or '#)'

HsSumTy (XSumTy pass) [LHsType pass]

• AnnKeywordId : AnnOpen '(#', AnnClose '#)'@

HsOpTy (XOpTy pass) (LHsType pass) (Located (IdP pass)) (LHsType pass)

• AnnKeywordId : None

HsParTy (XParTy pass) (LHsType pass)

• AnnKeywordId : AnnOpen '(', AnnClose ')'

HsIParamTy (XIParamTy pass) (Located HsIPName) (LHsType pass)

(?x :: ty)

• AnnKeywordId : AnnDcolon

HsStarTy (XStarTy pass) Bool

• AnnKeywordId : None

HsKindSig (XKindSig pass) (LHsType pass) (LHsKind pass)

(ty :: kind)

• AnnKeywordId : AnnOpen '(', AnnDcolon,AnnClose ')'

HsSpliceTy (XSpliceTy pass) (HsSplice pass)

• AnnKeywordId : AnnOpen '$(', AnnClose ')'

HsDocTy (XDocTy pass) (LHsType pass) LHsDocString

• AnnKeywordId : None

HsBangTy (XBangTy pass) HsSrcBang (LHsType pass)

• AnnKeywordId : AnnOpen '{-# UNPACK' or '{-# NOUNPACK', AnnClose '#-}' AnnBang '!'

HsRecTy (XRecTy pass) [LConDeclField pass]

• AnnKeywordId : AnnOpen '{', AnnClose '}'

HsExplicitListTy (XExplicitListTy pass) PromotionFlag [LHsType pass]

• AnnKeywordId : AnnOpen "'[", AnnClose ']'

HsExplicitTupleTy (XExplicitTupleTy pass) [LHsType pass]

• AnnKeywordId : AnnOpen "'(", AnnClose ')'

HsTyLit (XTyLit pass) HsTyLit

• AnnKeywordId : None

HsWildCardTy (XWildCardTy pass)

• AnnKeywordId : None

XHsType (XXType pass)

Instances

OutputableBndrId p => Outputable (HsType (GhcPass p))

Defined in GHC.Hs.Types

Methods

ppr :: HsType (GhcPass p) -> SDoc

pprPrec :: Rational -> HsType (GhcPass p) -> SDoc

data NewHsTypeX

Constructors

NHsCoreTy Type

Instances

Data NewHsTypeX

• AnnKeywordId : None

Defined in GHC.Hs.Types

Methods

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

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

toConstr :: NewHsTypeX -> Constr

dataTypeOf :: NewHsTypeX -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> NewHsTypeX -> NewHsTypeX

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

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

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

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

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

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

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

Outputable NewHsTypeX

Defined in GHC.Hs.Types

Methods

ppr :: NewHsTypeX -> SDoc

pprPrec :: Rational -> NewHsTypeX -> SDoc

data HsTyLit

Haskell Type Literal

Constructors

HsNumTy SourceText Integer

HsStrTy SourceText FastString

Instances

Data HsTyLit

Defined in GHC.Hs.Types

Methods

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

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

toConstr :: HsTyLit -> Constr

dataTypeOf :: HsTyLit -> DataType

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

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

gmapT :: (forall b. Data b => b -> b) -> HsTyLit -> HsTyLit

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

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

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

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

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

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

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

Outputable HsTyLit

Defined in GHC.Hs.Types

Methods

ppr :: HsTyLit -> SDoc

pprPrec :: Rational -> HsTyLit -> SDoc

data HsTupleSort

Haskell Tuple Sort

Constructors

HsUnboxedTuple

HsBoxedTuple

HsConstraintTuple

HsBoxedOrConstraintTuple

Instances

Data HsTupleSort

Defined in GHC.Hs.Types

Methods

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

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

toConstr :: HsTupleSort -> Constr

dataTypeOf :: HsTupleSort -> DataType

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

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

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

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

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

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

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

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

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

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

type LConDeclField pass

Arguments

 = Located (ConDeclField pass)

May have AnnKeywordId : AnnComma when in a list

Located Constructor Declaration Field

data ConDeclField pass

Constructor Declaration Field

Constructors

ConDeclField

• AnnKeywordId : AnnDcolon

Fields

• cd_fld_ext :: XConDeclField pass
• cd_fld_names :: [LFieldOcc pass]

  See Note [ConDeclField passs]

• cd_fld_type :: LBangType pass
• cd_fld_doc :: Maybe LHsDocString

XConDeclField (XXConDeclField pass)

Instances

OutputableBndrId p => Outputable (ConDeclField (GhcPass p))

Defined in GHC.Hs.Types

Methods

ppr :: ConDeclField (GhcPass p) -> SDoc

pprPrec :: Rational -> ConDeclField (GhcPass p) -> SDoc

data HsConDetails arg rec

Haskell Constructor Details

Constructors

PrefixCon [arg]

RecCon rec

InfixCon arg arg

Instances

(Data arg, Data rec) => Data (HsConDetails arg rec)

Defined in GHC.Hs.Types

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsConDetails arg rec -> c (HsConDetails arg rec)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsConDetails arg rec)

toConstr :: HsConDetails arg rec -> Constr

dataTypeOf :: HsConDetails arg rec -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsConDetails arg rec))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsConDetails arg rec))

gmapT :: (forall b. Data b => b -> b) -> HsConDetails arg rec -> HsConDetails arg rec

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsConDetails arg rec -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsConDetails arg rec -> r

gmapQ :: (forall d. Data d => d -> u) -> HsConDetails arg rec -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsConDetails arg rec -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsConDetails arg rec -> m (HsConDetails arg rec)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDetails arg rec -> m (HsConDetails arg rec)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDetails arg rec -> m (HsConDetails arg rec)

(Outputable arg, Outputable rec) => Outputable (HsConDetails arg rec)

Defined in GHC.Hs.Types

Methods

ppr :: HsConDetails arg rec -> SDoc

pprPrec :: Rational -> HsConDetails arg rec -> SDoc

data HsArg tm ty

Constructors

HsValArg tm

HsTypeArg SrcSpan ty

HsArgPar SrcSpan

Instances

(Outputable tm, Outputable ty) => Outputable (HsArg tm ty)

Defined in GHC.Hs.Types

Methods

ppr :: HsArg tm ty -> SDoc

pprPrec :: Rational -> HsArg tm ty -> SDoc

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

type LFieldOcc pass = Located (FieldOcc pass)

Located Field Occurrence

data FieldOcc pass

Field Occurrence

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

Constructors

FieldOcc

Fields

• extFieldOcc :: XCFieldOcc pass
• rdrNameFieldOcc :: Located RdrName

  See Note [Located RdrNames] in GHC.Hs.Expr

XFieldOcc (XXFieldOcc pass)

Instances

Eq (XCFieldOcc (GhcPass p)) => Eq (FieldOcc (GhcPass p))

Defined in GHC.Hs.Types

Methods

(==) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool

(/=) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool

Ord (XCFieldOcc (GhcPass p)) => Ord (FieldOcc (GhcPass p))

Defined in GHC.Hs.Types

Methods

compare :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Ordering

(<) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool

(<=) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool

(>) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool

(>=) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool

max :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> FieldOcc (GhcPass p)

min :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> FieldOcc (GhcPass p)

Outputable (FieldOcc pass)

Defined in GHC.Hs.Types

Methods

ppr :: FieldOcc pass -> SDoc

pprPrec :: Rational -> FieldOcc pass -> SDoc

data AmbiguousFieldOcc pass

Ambiguous Field Occurrence

Represents an *occurrence* of a field that is potentially ambiguous after the renamer, with the ambiguity resolved by the typechecker. We always store the RdrName that the user originally wrote, and store the selector function after the renamer (for unambiguous occurrences) or the typechecker (for ambiguous occurrences).

See Note [HsRecField and HsRecUpdField] in GHC.Hs.Pat and Note [Disambiguating record fields] in TcExpr. See Note [Located RdrNames] in GHC.Hs.Expr

Constructors

Unambiguous (XUnambiguous pass) (Located RdrName)

Ambiguous (XAmbiguous pass) (Located RdrName)

XAmbiguousFieldOcc (XXAmbiguousFieldOcc pass)

Instances

Outputable (AmbiguousFieldOcc (GhcPass p))

Defined in GHC.Hs.Types

Methods

ppr :: AmbiguousFieldOcc (GhcPass p) -> SDoc

pprPrec :: Rational -> AmbiguousFieldOcc (GhcPass p) -> SDoc

OutputableBndr (AmbiguousFieldOcc (GhcPass p))

Defined in GHC.Hs.Types

Methods

pprBndr :: BindingSite -> AmbiguousFieldOcc (GhcPass p) -> SDoc

pprPrefixOcc :: AmbiguousFieldOcc (GhcPass p) -> SDoc

pprInfixOcc :: AmbiguousFieldOcc (GhcPass p) -> SDoc

bndrIsJoin_maybe :: AmbiguousFieldOcc (GhcPass p) -> Maybe Int

data ExecOptions

Constructors

ExecOptions

Fields

• execSingleStep :: SingleStep

  stepping mode

• execSourceFile :: String

  filename (for errors)

• execLineNumber :: Int

  line number (for errors)

• execWrap :: ForeignHValue -> EvalExpr ForeignHValue

data SingleStep

Constructors

RunToCompletion

SingleStep

RunAndLogSteps

data ExecResult

Constructors

ExecComplete

Fields

• execResult :: Either SomeException [Name]
• execAllocation :: Word64

ExecBreak

Fields

• breakNames :: [Name]
• breakInfo :: Maybe BreakInfo

data BreakInfo

data Resume

Constructors

Resume

Fields

• resumeStmt :: String
• resumeContext :: ForeignRef (ResumeContext [HValueRef])
• resumeBindings :: ([TyThing], GlobalRdrEnv)
• resumeFinalIds :: [Id]
• resumeApStack :: ForeignHValue
• resumeBreakInfo :: Maybe BreakInfo
• resumeSpan :: SrcSpan
• resumeDecl :: String
• resumeCCS :: RemotePtr CostCentreStack
• resumeHistory :: [History]
• resumeHistoryIx :: Int

data History

promotedNilDataCon :: TyCon

promotedConsDataCon :: TyCon

promotedGTDataCon :: TyCon

promotedEQDataCon :: TyCon

promotedLTDataCon :: TyCon

promotedJustDataCon :: TyCon

promotedNothingDataCon :: TyCon

promotedFalseDataCon :: TyCon

promotedTrueDataCon :: TyCon

mkSumTy :: [Type] -> Type

mkTupleTy1 :: Boxity -> [Type] -> Type

Make a tuple type. The list of types should not include any RuntimeRep specifications. Boxed 1-tuples are *not* flattened. See Note [One-tuples] and Note [Don't flatten tuples from HsSyn] in MkCore

mkTupleTy :: Boxity -> [Type] -> Type

Make a tuple type. The list of types should not include any RuntimeRep specifications. Boxed 1-tuples are flattened. See Note [One-tuples]

justDataCon :: DataCon

nothingDataCon :: DataCon

maybeTyCon :: TyCon

consDataCon :: DataCon

nilDataCon :: DataCon

mkListTy :: Type -> Type

ordGTDataConId :: Id

ordEQDataConId :: Id

ordLTDataConId :: Id

ordGTDataCon :: DataCon

ordEQDataCon :: DataCon

ordLTDataCon :: DataCon

orderingTyCon :: TyCon

trueDataConId :: Id

falseDataConId :: Id

trueDataCon :: DataCon

falseDataCon :: DataCon

boolTyCon :: TyCon

boolTy :: Type

doubleDataCon :: DataCon

doubleTyCon :: TyCon

doubleTy :: Type

floatDataCon :: DataCon

floatTyCon :: TyCon

floatTy :: Type

word8DataCon :: DataCon

word8TyCon :: TyCon

word8Ty :: Type

wordDataCon :: DataCon

wordTyCon :: TyCon

wordTy :: Type

intDataCon :: DataCon

intTyCon :: TyCon

intTy :: Type

stringTy :: Type

charDataCon :: DataCon

charTyCon :: TyCon

charTy :: Type

boxingDataCon_maybe :: TyCon -> Maybe DataCon

liftedRepTy :: Type

liftedRepDataCon :: DataCon

sumRepDataConTyCon :: TyCon

liftedTypeKindTyCon :: TyCon

coercibleDataCon :: DataCon

coercibleClass :: Class

heqDataCon :: DataCon

heqClass :: Class

eqDataCon :: DataCon

eqClass :: Class

eqTyCon :: TyCon

unboxedSumKind :: [Type] -> Kind

Specialization of unboxedTupleSumKind for sums

sumDataCon :: ConTag -> Arity -> DataCon

Data constructor for i-th alternative of a n-ary unboxed sum.

sumTyCon :: Arity -> TyCon

Type constructor for n-ary unboxed sum.

unboxedUnitDataCon :: DataCon

unboxedUnitTyCon :: TyCon

pairTyCon :: TyCon

unitDataConId :: Id

unitDataCon :: DataCon

unitTyConKey :: Unique

unitTyCon :: TyCon

tupleDataCon :: Boxity -> Arity -> DataCon

promotedTupleDataCon :: Boxity -> Arity -> TyCon

tupleTyCon :: Boxity -> Arity -> TyCon

cTupleDataConNames :: [Name]

cTupleDataConName :: Arity -> Name

cTupleTyConNameArity_maybe :: Name -> Maybe Arity

If the given name is that of a constraint tuple, return its arity. Note that this is inefficient.

isCTupleTyConName :: Name -> Bool

cTupleTyConNames :: [Name]

cTupleTyConName :: Arity -> Name

mkTupleStr :: Boxity -> Arity -> String

isBuiltInOcc_maybe :: OccName -> Maybe Name

Built-in syntax isn't "in scope" so these OccNames map to wired-in Names with BuiltInSyntax. However, this should only be necessary while resolving names produced by Template Haskell splices since we take care to encode built-in syntax names specially in interface files. See Note [Symbol table representation of names].

Moreover, there is no need to include names of things that the user can't write (e.g. type representation bindings like $tc(,,,)).

typeToTypeKind :: Kind

constraintKindTyCon :: TyCon

typeSymbolKindCon :: TyCon

typeNatKindCon :: TyCon

consDataCon_RDR :: RdrName

listTyCon_RDR :: RdrName

intDataCon_RDR :: RdrName

charTyCon_RDR :: RdrName

intTyCon_RDR :: RdrName

true_RDR :: RdrName

false_RDR :: RdrName

boolTyCon_RDR :: RdrName

liftedTypeKindTyConName :: Name

constraintKindTyConName :: Name

makeRecoveryTyCon :: TyCon -> TyCon

Make a fake, recovery TyCon from an existing one. Used when recovering from errors in type declarations

anyTy :: Type

anyTyCon :: TyCon

doubleTyConName :: Name

floatTyConName :: Name

word8TyConName :: Name

wordTyConName :: Name

justDataConName :: Name

nothingDataConName :: Name

maybeTyConName :: Name

consDataConName :: Name

nilDataConName :: Name

listTyConName :: Name

boolTyConName :: Name

intTyConName :: Name

charTyConName :: Name

coercibleTyConName :: Name

heqTyConName :: Name

eqTyCon_RDR :: RdrName

eqTyConName :: Name

mkWiredInIdName :: Module -> FastString -> Unique -> Id -> Name

mkWiredInTyConName :: BuiltInSyntax -> Module -> FastString -> Unique -> TyCon -> Name

wiredInTyCons :: [TyCon]

isNeverLevPolyId :: Id -> Bool

transferPolyIdInfo :: Id -> [Var] -> Id -> Id

zapStableUnfolding :: Id -> Id

zapIdTailCallInfo :: Id -> Id

zapIdUsedOnceInfo :: Id -> Id

zapIdUsageEnvInfo :: Id -> Id

zapIdUsageInfo :: Id -> Id

zapIdDemandInfo :: Id -> Id

zapFragileIdInfo :: Id -> Id

zapLamIdInfo :: Id -> Id

updOneShotInfo :: Id -> OneShotInfo -> Id

setIdOneShotInfo :: Id -> OneShotInfo -> Id infixl 1

clearOneShotLambda :: Id -> Id

setOneShotLambda :: Id -> Id

isProbablyOneShotLambda :: Id -> Bool

isStateHackType :: Type -> Bool

typeOneShot :: Type -> OneShotInfo

stateHackOneShot :: OneShotInfo

Should we apply the state hack to values of this Type?

isOneShotBndr :: Var -> Bool

Returns whether the lambda associated with the Id is certainly applied at most once This one is the "business end", called externally. It works on type variables as well as Ids, returning True Its main purpose is to encapsulate the Horrible State Hack See Note [The state-transformer hack] in CoreArity

idStateHackOneShotInfo :: Id -> OneShotInfo

Like idOneShotInfo, but taking the Horrible State Hack in to account See Note [The state-transformer hack] in CoreArity

idOneShotInfo :: Id -> OneShotInfo

isConLikeId :: Id -> Bool

idRuleMatchInfo :: Id -> RuleMatchInfo

setInlineActivation :: Id -> Activation -> Id infixl 1

idInlineActivation :: Id -> Activation

modifyInlinePragma :: Id -> (InlinePragma -> InlinePragma) -> Id

setInlinePragma :: Id -> InlinePragma -> Id infixl 1

idInlinePragma :: Id -> InlinePragma

zapIdOccInfo :: Id -> Id

setIdOccInfo :: Id -> OccInfo -> Id infixl 1

idOccInfo :: Id -> OccInfo

setIdCafInfo :: Id -> CafInfo -> Id

idCafInfo :: Id -> CafInfo infixl 1

setIdSpecialisation :: Id -> RuleInfo -> Id infixl 1

idHasRules :: Id -> Bool

idCoreRules :: Id -> [CoreRule]

idSpecialisation :: Id -> RuleInfo

setCaseBndrEvald :: StrictnessMark -> Id -> Id

setIdDemandInfo :: Id -> Demand -> Id infixl 1

idDemandInfo :: Id -> Demand

setIdUnfolding :: Id -> Unfolding -> Id infixl 1

realIdUnfolding :: Id -> Unfolding

idUnfolding :: Id -> Unfolding

isStrictId :: Id -> Bool

This predicate says whether the Id has a strict demand placed on it or has a type such that it can always be evaluated strictly (i.e an unlifted type, as of GHC 7.6). We need to check separately whether the Id has a so-called "strict type" because if the demand for the given id hasn't been computed yet but id has a strict type, we still want isStrictId id to be True.

zapIdStrictness :: Id -> Id

setIdStrictness :: Id -> StrictSig -> Id infixl 1

idStrictness :: Id -> StrictSig

Accesses the Id's strictnessInfo.

isBottomingId :: Var -> Bool

Returns true if an application to n args would diverge

idFunRepArity :: Id -> RepArity

setIdCallArity :: Id -> Arity -> Id infixl 1

idCallArity :: Id -> Arity

setIdArity :: Id -> Arity -> Id infixl 1

idArity :: Id -> Arity

asJoinId_maybe :: Id -> Maybe JoinArity -> Id infixl 1

zapJoinId :: Id -> Id

asJoinId :: Id -> JoinArity -> JoinId infixl 1

idJoinArity :: JoinId -> JoinArity

isDeadBinder :: Id -> Bool

idIsFrom :: Module -> Id -> Bool

isImplicitId :: Id -> Bool

isImplicitId tells whether an Ids info is implied by other declarations, so we don't need to put its signature in an interface file, even if it's mentioned in some other interface unfolding.

hasNoBinding :: Id -> Bool

Returns True of an Id which may not have a binding, even though it is defined in this module.

idDataCon :: Id -> DataCon

Get from either the worker or the wrapper Id to the DataCon. Currently used only in the desugarer.

INVARIANT: idDataCon (dataConWrapId d) = d: remember, dataConWrapId can return either the wrapper or the worker

isJoinId_maybe :: Var -> Maybe JoinArity

isJoinId :: Var -> Bool

isDataConId_maybe :: Id -> Maybe DataCon

isDataConWrapId_maybe :: Id -> Maybe DataCon

isDataConWrapId :: Id -> Bool

isDataConWorkId_maybe :: Id -> Maybe DataCon

isDataConWorkId :: Id -> Bool

isFCallId_maybe :: Id -> Maybe ForeignCall

isFCallId :: Id -> Bool

isPrimOpId_maybe :: Id -> Maybe PrimOp

isDFunId :: Id -> Bool

isPrimOpId :: Id -> Bool

isClassOpId_maybe :: Id -> Maybe Class

isNaughtyRecordSelector :: Id -> Bool

isPatSynRecordSelector :: Id -> Bool

isDataConRecordSelector :: Id -> Bool

isRecordSelector :: Id -> Bool

recordSelectorTyCon :: Id -> RecSelParent

If the Id is that for a record selector, extract the sel_tycon. Panic otherwise.

mkTemplateLocalsNum :: Int -> [Type] -> [Id]

Create a template local for a series of type, but start from a specified template local

mkTemplateLocals :: [Type] -> [Id]

Create a template local for a series of types

mkTemplateLocal :: Int -> Type -> Id

Create a template local: a family of system local Ids in bijection with Ints, typically used in unfoldings

mkWorkerId :: Unique -> Id -> Type -> Id

Workers get local names. CoreTidy will externalise these if necessary

mkUserLocalOrCoVar :: OccName -> Unique -> Type -> SrcSpan -> Id

Like mkUserLocal, but checks if we have a coercion type

mkUserLocal :: OccName -> Unique -> Type -> SrcSpan -> Id

Create a user local Id. These are local Ids (see Var) with a name and location that the user might recognize

mkSysLocalOrCoVarM :: MonadUnique m => FastString -> Type -> m Id

mkSysLocalM :: MonadUnique m => FastString -> Type -> m Id

mkSysLocalOrCoVar :: FastString -> Unique -> Type -> Id

Like mkSysLocal, but checks to see if we have a covar type

mkSysLocal :: FastString -> Unique -> Type -> Id

Create a system local Id. These are local Ids (see Var) that are created by the compiler out of thin air

mkExportedVanillaId :: Name -> Type -> Id

mkExportedLocalId :: IdDetails -> Name -> Type -> Id

Create a local Id that is marked as exported. This prevents things attached to it from being removed as dead code. See Note [Exported LocalIds]

mkLocalIdWithInfo :: Name -> Type -> IdInfo -> Id

mkLocalIdOrCoVarWithInfo :: Name -> Type -> IdInfo -> Id

Make a local id, with the IdDetails set to CoVarId if the type indicates so.

mkLocalIdOrCoVar :: Name -> Type -> Id

Like mkLocalId, but checks the type to see if it should make a covar

mkLocalCoVar :: Name -> Type -> CoVar

Make a local CoVar

mkLocalId :: Name -> Type -> Id

For an explanation of global vs. local Ids, see Var

mkVanillaGlobalWithInfo :: Name -> Type -> IdInfo -> Id

Make a global Id with no global information but some generic IdInfo

mkVanillaGlobal :: Name -> Type -> Id

Make a global Id without any extra information at all

mkGlobalId :: IdDetails -> Name -> Type -> IdInfo -> Id

For an explanation of global vs. local Ids, see Var

maybeModifyIdInfo :: Maybe IdInfo -> Id -> Id

modifyIdInfo :: HasDebugCallStack => (IdInfo -> IdInfo) -> Id -> Id

setIdInfo :: Id -> IdInfo -> Id

localiseId :: Id -> Id

setIdType :: Id -> Type -> Id

Not only does this set the Id Type, it also evaluates the type to try and reduce space usage

setIdUnique :: Id -> Unique -> Id

setIdName :: Id -> Name -> Id

idType :: Id -> Kind

idUnique :: Id -> Unique

idName :: Id -> Name

collectNAnnBndrs :: Int -> AnnExpr bndr annot -> ([bndr], AnnExpr bndr annot)

As collectNBinders but for AnnExpr rather than Expr

collectAnnBndrs :: AnnExpr bndr annot -> ([bndr], AnnExpr bndr annot)

As collectBinders but for AnnExpr rather than Expr

deAnnBind :: AnnBind b annot -> Bind b

deAnnAlt :: AnnAlt bndr annot -> Alt bndr

deAnnotate' :: AnnExpr' bndr annot -> Expr bndr

deAnnotate :: AnnExpr bndr annot -> Expr bndr

collectAnnArgsTicks :: (Tickish Var -> Bool) -> AnnExpr b a -> (AnnExpr b a, [AnnExpr b a], [Tickish Var])

collectAnnArgs :: AnnExpr b a -> (AnnExpr b a, [AnnExpr b a])

Takes a nested application expression and returns the function being applied and the arguments to which it is applied

valArgCount :: [Arg b] -> Int

The number of argument expressions that are values rather than types at their top level

valBndrCount :: [CoreBndr] -> Int

The number of binders that bind values rather than types

isTypeArg :: Expr b -> Bool

Returns True iff the expression is a Type expression at its top level. Note this does NOT include Coercions.

isCoArg :: Expr b -> Bool

Returns True iff the expression is a Coercion expression at its top level

isTyCoArg :: Expr b -> Bool

Returns True iff the expression is a Type or Coercion expression at its top level

isValArg :: Expr b -> Bool

Returns True for value arguments, false for type args NB: coercions are value arguments (zero width, to be sure, like State#, but still value args).

isRuntimeArg :: CoreExpr -> Bool

Will this argument expression exist at runtime?

isRuntimeVar :: Var -> Bool

Will this variable exist at runtime?

collectArgsTicks :: (Tickish Id -> Bool) -> Expr b -> (Expr b, [Arg b], [Tickish Id])

Like collectArgs, but also collects looks through floatable ticks if it means that we can find more arguments.

stripNArgs :: Word -> Expr a -> Maybe (Expr a)

Attempt to remove the last N arguments of a function call. Strip off any ticks or coercions encountered along the way and any at the end.

collectArgs :: Expr b -> (Expr b, [Arg b])

Takes a nested application expression and returns the function being applied and the arguments to which it is applied

collectNBinders :: Int -> Expr b -> ([b], Expr b)

Strip off exactly N leading lambdas (type or value). Good for use with join points.

collectTyAndValBinders :: CoreExpr -> ([TyVar], [Id], CoreExpr)

collectTyBinders :: CoreExpr -> ([TyVar], CoreExpr)

collectBinders :: Expr b -> ([b], Expr b)

We often want to strip off leading lambdas before getting down to business. Variants are collectTyBinders, collectValBinders, and collectTyAndValBinders

flattenBinds :: [Bind b] -> [(b, Expr b)]

Collapse all the bindings in the supplied groups into a single list of lhs/rhs pairs suitable for binding in a Rec binding group

rhssOfAlts :: [Alt b] -> [Expr b]

rhssOfBind :: Bind b -> [Expr b]

bindersOfBinds :: [Bind b] -> [b]

bindersOf applied to a list of binding groups

bindersOf :: Bind b -> [b]

Extract every variable by this group

exprToCoercion_maybe :: CoreExpr -> Maybe Coercion

If the expression is a Coercion, converts.

exprToType :: CoreExpr -> Type

If the expression is a Type, converts. Otherwise, panics. NB: This does not convert Coercion to CoercionTy.

applyTypeToArg :: Type -> CoreExpr -> Type

Determines the type resulting from applying an expression with given type to a given argument expression

varsToCoreExprs :: [CoreBndr] -> [Expr b]

varToCoreExpr :: CoreBndr -> Expr b

Convert a binder into either a Var or Type Expr appropriately

mkCoBind :: CoVar -> Coercion -> CoreBind

Create a binding group where a type variable is bound to a type. Per CoreSyn, this can only be used to bind something in a non-recursive let expression

mkTyBind :: TyVar -> Type -> CoreBind

Create a binding group where a type variable is bound to a type. Per CoreSyn, this can only be used to bind something in a non-recursive let expression

mkLetRec :: [(b, Expr b)] -> Expr b -> Expr b

mkLetRec binds body wraps body in a let rec with the given set of binds if binds is non-empty.

mkLetNonRec :: b -> Expr b -> Expr b -> Expr b

mkLetNonRec bndr rhs body wraps body in a let binding bndr.

mkLet :: Bind b -> Expr b -> Expr b

mkLets :: [Bind b] -> Expr b -> Expr b

Bind all supplied binding groups over an expression in a nested let expression. Assumes that the rhs satisfies the let/app invariant. Prefer to use mkCoreLets if possible, which does guarantee the invariant

mkLams :: [b] -> Expr b -> Expr b

Bind all supplied binders over an expression in a nested lambda expression. Prefer to use mkCoreLams if possible

mkDoubleLitDouble :: Double -> Expr b

Create a machine double precision literal expression of type Double# from a Double. If you want an expression of type Double use mkDoubleExpr

mkDoubleLit :: Rational -> Expr b

Create a machine double precision literal expression of type Double# from a Rational. If you want an expression of type Double use mkDoubleExpr

mkFloatLitFloat :: Float -> Expr b

Create a machine single precision literal expression of type Float# from a Float. If you want an expression of type Float use mkFloatExpr

mkFloatLit :: Rational -> Expr b

Create a machine single precision literal expression of type Float# from a Rational. If you want an expression of type Float use mkFloatExpr

mkStringLit :: String -> Expr b

Create a machine string literal expression of type Addr#. If you want an expression of type String use mkStringExpr

mkCharLit :: Char -> Expr b

Create a machine character literal expression of type Char#. If you want an expression of type Char use mkCharExpr

mkInt64LitInt64 :: Int64 -> Expr b

mkWord64LitWord64 :: Word64 -> Expr b

mkWordLitWord :: DynFlags -> Word -> Expr b

Create a machine word literal expression of type Word# from a Word. If you want an expression of type Word use mkWordExpr

mkWordLit :: DynFlags -> Integer -> Expr b

Create a machine word literal expression of type Word# from an Integer. If you want an expression of type Word use mkWordExpr

mkIntLitInt :: DynFlags -> Int -> Expr b

Create a machine integer literal expression of type Int# from an Int. If you want an expression of type Int use mkIntExpr

mkIntLit :: DynFlags -> Integer -> Expr b

Create a machine integer literal expression of type Int# from an Integer. If you want an expression of type Int use mkIntExpr

mkTyArg :: Type -> Expr b

mkConApp2 :: DataCon -> [Type] -> [Var] -> Expr b

mkTyApps :: Expr b -> [Type] -> Expr b infixl 4

Apply a list of type argument expressions to a function expression in a nested fashion

mkConApp :: DataCon -> [Arg b] -> Expr b

Apply a list of argument expressions to a data constructor in a nested fashion. Prefer to use mkCoreConApps if possible

mkVarApps :: Expr b -> [Var] -> Expr b infixl 4

Apply a list of type or value variables to a function expression in a nested fashion

mkCoApps :: Expr b -> [Coercion] -> Expr b infixl 4

Apply a list of coercion argument expressions to a function expression in a nested fashion

mkApps :: Expr b -> [Arg b] -> Expr b infixl 4

Apply a list of argument expressions to a function expression in a nested fashion. Prefer to use mkCoreApps if possible

deTagExpr :: TaggedExpr t -> CoreExpr

cmpAltCon :: AltCon -> AltCon -> Ordering

Compares AltCons within a single list of alternatives DEFAULT comes out smallest, so that sorting by AltCon puts alternatives in the order required: see Note [Case expression invariants]

ltAlt :: (AltCon, a, b) -> (AltCon, a, b) -> Bool

cmpAlt :: (AltCon, a, b) -> (AltCon, a, b) -> Ordering

canUnfold :: Unfolding -> Bool

isFragileUnfolding :: Unfolding -> Bool

neverUnfoldGuidance :: UnfoldingGuidance -> Bool

isBootUnfolding :: Unfolding -> Bool

hasSomeUnfolding :: Unfolding -> Bool

Only returns False if there is no unfolding information available at all

isStableUnfolding :: Unfolding -> Bool

isCompulsoryUnfolding :: Unfolding -> Bool

expandUnfolding_maybe :: Unfolding -> Maybe CoreExpr

isExpandableUnfolding :: Unfolding -> Bool

isCheapUnfolding :: Unfolding -> Bool

Is the thing we will unfold into certainly cheap?

isConLikeUnfolding :: Unfolding -> Bool

True if the unfolding is a constructor application, the application of a CONLIKE function or OtherCon

isEvaldUnfolding :: Unfolding -> Bool

Determines if it possibly the case that the unfolding will yield a value. Unlike isValueUnfolding it returns True for OtherCon

isValueUnfolding :: Unfolding -> Bool

Determines if it is certainly the case that the unfolding will yield a value (something in HNF): returns False if unsure

otherCons :: Unfolding -> [AltCon]

The constructors that the unfolding could never be: returns [] if no information is available

maybeUnfoldingTemplate :: Unfolding -> Maybe CoreExpr

Retrieves the template of an unfolding if possible maybeUnfoldingTemplate is used mainly wnen specialising, and we do want to specialise DFuns, so it's important to return a template for DFunUnfoldings

unfoldingTemplate :: Unfolding -> CoreExpr

Retrieves the template of an unfolding: panics if none is known

isStableSource :: UnfoldingSource -> Bool

mkOtherCon :: [AltCon] -> Unfolding

bootUnfolding :: Unfolding

There is no known Unfolding, because this came from an hi-boot file.

evaldUnfolding :: Unfolding

This unfolding marks the associated thing as being evaluated

noUnfolding :: Unfolding

There is no known Unfolding

boringCxtNotOk :: Bool

boringCxtOk :: Bool

unSaturatedOk :: Bool

needSaturated :: Bool

setRuleIdName :: Name -> CoreRule -> CoreRule

Set the Name of the Id at the head of the rule left hand side

isLocalRule :: CoreRule -> Bool

ruleIdName :: CoreRule -> Name

The Name of the Id at the head of the rule left hand side

ruleActivation :: CoreRule -> Activation

ruleModule :: CoreRule -> Maybe Module

ruleName :: CoreRule -> RuleName

ruleArity :: CoreRule -> Int

The number of arguments the ru_fn must be applied to before the rule can match on it

isAutoRule :: CoreRule -> Bool

isBuiltinRule :: CoreRule -> Bool

emptyRuleEnv :: RuleEnv

mkRuleEnv :: RuleBase -> [Module] -> RuleEnv

chooseOrphanAnchor :: NameSet -> IsOrphan

notOrphan :: IsOrphan -> Bool

Returns true if IsOrphan is not an orphan.

isOrphan :: IsOrphan -> Bool

Returns true if IsOrphan is orphan.

tickishContains :: Eq b => Tickish b -> Tickish b -> Bool

Returns whether one tick "contains" the other one, therefore making the second tick redundant.

tickishPlace :: Tickish id -> TickishPlacement

Placement behaviour we want for the ticks

tickishIsCode :: Tickish id -> Bool

Return True if this source annotation compiles to some backend code. Without this flag, the tickish is seen as a simple annotation that does not have any associated evaluation code.

What this means that we are allowed to disregard the tick if doing so means that we can skip generating any code in the first place. A typical example is top-level bindings:

foo = tick... y -> ... ==> foo = y -> tick... ...

Here there is just no operational difference between the first and the second version. Therefore code generation should simply translate the code as if it found the latter.

mkNoScope :: Tickish id -> Tickish id

mkNoCount :: Tickish id -> Tickish id

tickishCanSplit :: Tickish id -> Bool

Returns True for a tick that is both counting and scoping and can be split into its (tick, scope) parts using mkNoScope and mkNoTick respectively.

tickishFloatable :: Tickish id -> Bool

Returns True for ticks that can be floated upwards easily even where it might change execution counts, such as:

Just (tick... foo) ==> tick... (Just foo)

This is a combination of tickishSoftScope and tickishCounts. Note that in principle splittable ticks can become floatable using mkNoTick -- even though there's currently no tickish for which that is the case.

tickishScopesLike :: Tickish id -> TickishScoping -> Bool

Returns whether the tick scoping rule is at least as permissive as the given scoping rule.

tickishScoped :: Tickish id -> TickishScoping

Returns the intended scoping rule for a Tickish

tickishCounts :: Tickish id -> Bool

A "counting tick" (where tickishCounts is True) is one that counts evaluations in some way. We cannot discard a counting tick, and the compiler should preserve the number of counting ticks as far as possible.

However, we still allow the simplifier to increase or decrease sharing, so in practice the actual number of ticks may vary, except that we never change the value from zero to non-zero or vice versa.

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:

1. The source code is parsed into an abstract syntax tree, which is represented by the data type HsExpr with the names being RdrNames
2. 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.

1. 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.
2. 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 [CoreSyn let/app invariant] See Note [Levity polymorphism invariants]
• Lambda abstraction See Note [Levity 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 [CoreSyn letrec invariant] See Note [CoreSyn let/app invariant] See Note [Levity polymorphism invariants] See Note [CoreSyn 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.
• Notes. These allow general information to be added to expressions in the syntax tree
• 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) Coercion

Tick (Tickish Id) (Expr b)

Type Type

Coercion Coercion

Instances

Show CoreExpr

Defined in Language.Haskell.Liquid.Transforms.CoreToLogic

Methods

showsPrec :: Int -> CoreExpr -> ShowS

show :: CoreExpr -> String

showList :: [CoreExpr] -> ShowS

Subable CoreExpr

Defined in Language.Haskell.Liquid.GHC.Play

Methods

sub :: HashMap CoreBndr CoreExpr -> CoreExpr -> CoreExpr

subTy :: HashMap TyVar Type -> CoreExpr -> CoreExpr

Eq (DeBruijn CoreExpr)

Defined in CoreMap

Methods

(==) :: DeBruijn CoreExpr -> DeBruijn CoreExpr -> Bool

(/=) :: DeBruijn CoreExpr -> DeBruijn CoreExpr -> Bool

Eq (DeBruijn CoreAlt)

Defined in CoreMap

Methods

(==) :: DeBruijn CoreAlt -> DeBruijn CoreAlt -> Bool

(/=) :: DeBruijn CoreAlt -> DeBruijn CoreAlt -> Bool

Data b => Data (Expr b)

Defined in CoreSyn

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)

PPrint (Expr Var)

Defined in Language.Haskell.Liquid.Types.PrettyPrint

Methods

pprintTidy :: Tidy -> Expr Var -> Doc

pprintPrec :: Int -> Tidy -> Expr Var -> Doc

CBVisitable (Expr Var)

Defined in Language.Haskell.Liquid.Types.Visitors

Methods

freeVars :: HashSet Var -> Expr Var -> [Var]

readVars :: Expr Var -> [Var]

letVars :: Expr Var -> [Var]

literals :: Expr Var -> [Literal]

CBVisitable (Alt Var)

Defined in Language.Haskell.Liquid.Types.Visitors

Methods

freeVars :: HashSet Var -> Alt Var -> [Var]

readVars :: Alt Var -> [Var]

letVars :: Alt Var -> [Var]

literals :: Alt Var -> [Literal]

Subable (Alt Var)

Defined in Language.Haskell.Liquid.GHC.Play

Methods

sub :: HashMap CoreBndr CoreExpr -> Alt Var -> Alt Var

subTy :: HashMap TyVar Type -> Alt Var -> Alt Var

Show (Axiom Var Type CoreExpr)

Defined in Language.Haskell.Liquid.Types.Types

Methods

showsPrec :: Int -> Axiom Var Type CoreExpr -> ShowS

show :: Axiom Var Type CoreExpr -> String

showList :: [Axiom Var Type CoreExpr] -> ShowS

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 Alt b = (AltCon, [b], Expr 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)

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

Eq AltCon

Defined in CoreSyn

Methods

(==) :: AltCon -> AltCon -> Bool

(/=) :: AltCon -> AltCon -> Bool

Data AltCon

Defined in CoreSyn

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

Ord AltCon

Defined in CoreSyn

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

Outputable AltCon

Defined in CoreSyn

Methods

ppr :: AltCon -> SDoc

pprPrec :: Rational -> AltCon -> SDoc

PPrint AltCon

Defined in Language.Haskell.Liquid.Synthesize.Misc

Methods

pprintTidy :: Tidy -> AltCon -> Doc

pprintPrec :: Int -> Tidy -> AltCon -> Doc

CBVisitable AltCon

Defined in Language.Haskell.Liquid.Types.Visitors

Methods

freeVars :: HashSet Var -> AltCon -> [Var]

readVars :: AltCon -> [Var]

letVars :: AltCon -> [Var]

literals :: AltCon -> [Literal]

Eq (DeBruijn CoreAlt)

Defined in CoreMap

Methods

(==) :: DeBruijn CoreAlt -> DeBruijn CoreAlt -> Bool

(/=) :: DeBruijn CoreAlt -> DeBruijn CoreAlt -> Bool

CBVisitable (Alt Var)

Defined in Language.Haskell.Liquid.Types.Visitors

Methods

freeVars :: HashSet Var -> Alt Var -> [Var]

readVars :: Alt Var -> [Var]

letVars :: Alt Var -> [Var]

literals :: Alt Var -> [Literal]

Subable (Alt Var)

Defined in Language.Haskell.Liquid.GHC.Play

Methods

sub :: HashMap CoreBndr CoreExpr -> Alt Var -> Alt Var

subTy :: HashMap TyVar Type -> Alt Var -> Alt Var

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

CBVisitable CoreBind

Defined in Language.Haskell.Liquid.Types.Visitors

Methods

freeVars :: HashSet Var -> CoreBind -> [Var]

readVars :: CoreBind -> [Var]

letVars :: CoreBind -> [Var]

literals :: CoreBind -> [Literal]

Data b => Data (Bind b)

Defined in CoreSyn

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)

PPrint (Bind Var)

Defined in Language.Haskell.Liquid.Types.PrettyPrint

Methods

pprintTidy :: Tidy -> Bind Var -> Doc

pprintPrec :: Int -> Tidy -> Bind Var -> Doc

CBVisitable [CoreBind]

Defined in Language.Haskell.Liquid.Types.Visitors

Methods

freeVars :: HashSet Var -> [CoreBind] -> [Var]

readVars :: [CoreBind] -> [Var]

letVars :: [CoreBind] -> [Var]

literals :: [CoreBind] -> [Literal]

Subable (Bind Var)

Defined in Language.Haskell.Liquid.GHC.Play

Methods

sub :: HashMap CoreBndr CoreExpr -> Bind Var -> Bind Var

subTy :: HashMap TyVar Type -> Bind Var -> Bind Var

type InBndr = CoreBndr

type InType = Type

type InKind = Kind

type InBind = CoreBind

type InExpr = CoreExpr

type InAlt = CoreAlt

type InArg = CoreArg

type InCoercion = Coercion

type OutBndr = CoreBndr

type OutType = Type

type OutKind = Kind

type OutCoercion = Coercion

type OutBind = CoreBind

type OutExpr = CoreExpr

type OutAlt = CoreAlt

type OutArg = CoreArg

type MOutCoercion = MCoercion

data Tickish id

Allows attaching extra information to points in expressions

Constructors

ProfNote

An {--} profiling annotation, either automatically added by the desugarer as a result of -auto-all, or added by the user.

Fields

• profNoteCC :: CostCentre

  the cost centre

• profNoteCount :: !Bool

  bump the entry count?

• profNoteScope :: !Bool

  scopes over the enclosed expression (i.e. not just a tick)

HpcTick

A "tick" used by HPC to track the execution of each subexpression in the original source code.

Fields

• tickModule :: Module
• tickId :: !Int

Breakpoint

A breakpoint for the GHCi debugger. This behaves like an HPC tick, but has a list of free variables which will be available for inspection in GHCi when the program stops at the breakpoint.

NB. we must take account of these Ids when (a) counting free variables, and (b) substituting (don't substitute for them)

Fields

• breakpointId :: !Int
• breakpointFVs :: [id]

  the order of this list is important: it matches the order of the lists in the appropriate entry in HscTypes.ModBreaks.

  Careful about substitution! See Note [substTickish] in CoreSubst.

SourceNote

A source note.

Source notes are pure annotations: Their presence should neither influence compilation nor execution. The semantics are given by causality: The presence of a source note means that a local change in the referenced source code span will possibly provoke the generated code to change. On the flip-side, the functionality of annotated code *must* be invariant against changes to all source code *except* the spans referenced in the source notes (see "Causality of optimized Haskell" paper for details).

Therefore extending the scope of any given source note is always valid. Note that it is still undesirable though, as this reduces their usefulness for debugging and profiling. Therefore we will generally try only to make use of this property where it is necessary to enable optimizations.

Fields

• sourceSpan :: RealSrcSpan

  Source covered

• sourceName :: String

  Name for source location (uses same names as CCs)

Instances

Eq id => Eq (Tickish id)

Defined in CoreSyn

Methods

(==) :: Tickish id -> Tickish id -> Bool

(/=) :: Tickish id -> Tickish id -> Bool

Data id => Data (Tickish id)

Defined in CoreSyn

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Tickish id -> c (Tickish id)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Tickish id)

toConstr :: Tickish id -> Constr

dataTypeOf :: Tickish id -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Tickish id))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Tickish id))

gmapT :: (forall b. Data b => b -> b) -> Tickish id -> Tickish id

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tickish id -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tickish id -> r

gmapQ :: (forall d. Data d => d -> u) -> Tickish id -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Tickish id -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Tickish id -> m (Tickish id)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Tickish id -> m (Tickish id)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Tickish id -> m (Tickish id)

Ord id => Ord (Tickish id)

Defined in CoreSyn

Methods

compare :: Tickish id -> Tickish id -> Ordering

(<) :: Tickish id -> Tickish id -> Bool

(<=) :: Tickish id -> Tickish id -> Bool

(>) :: Tickish id -> Tickish id -> Bool

(>=) :: Tickish id -> Tickish id -> Bool

max :: Tickish id -> Tickish id -> Tickish id

min :: Tickish id -> Tickish id -> Tickish id

data TickishScoping

Specifies the scoping behaviour of ticks. This governs the behaviour of ticks that care about the covered code and the cost associated with it. Important for ticks relating to profiling.

Constructors

NoScope

No scoping: The tick does not care about what code it covers. Transformations can freely move code inside as well as outside without any additional annotation obligations

SoftScope

Soft scoping: We want all code that is covered to stay covered. Note that this scope type does not forbid transformations from happening, as long as all results of the transformations are still covered by this tick or a copy of it. For example

let x = tick... (let y = foo in bar) in baz ===> let x = tick... bar; y = tick... foo in baz

Is a valid transformation as far as "bar" and "foo" is concerned, because both still are scoped over by the tick.

Note though that one might object to the "let" not being covered by the tick any more. However, we are generally lax with this - constant costs don't matter too much, and given that the "let" was effectively merged we can view it as having lost its identity anyway.

Also note that this scoping behaviour allows floating a tick "upwards" in pretty much any situation. For example:

case foo of x -> tick... bar ==> tick... case foo of x -> bar

While this is always leagl, we want to make a best effort to only make us of this where it exposes transformation opportunities.

CostCentreScope

Cost centre scoping: We don't want any costs to move to other cost-centre stacks. This means we not only want no code or cost to get moved out of their cost centres, but we also object to code getting associated with new cost-centre ticks - or changing the order in which they get applied.

A rule of thumb is that we don't want any code to gain new annotations. However, there are notable exceptions, for example:

let f = y -> foo in tick... ... (f x) ... ==> tick... ... foo[x/y] ...

In-lining lambdas like this is always legal, because inlining a function does not change the cost-centre stack when the function is called.

Instances

Eq TickishScoping

Defined in CoreSyn

Methods

(==) :: TickishScoping -> TickishScoping -> Bool

(/=) :: TickishScoping -> TickishScoping -> Bool

data TickishPlacement

Governs the kind of expression that the tick gets placed on when annotating for example using mkTick. If we find that we want to put a tickish on an expression ruled out here, we try to float it inwards until we find a suitable expression.

Constructors

PlaceRuntime

Place ticks exactly on run-time expressions. We can still move the tick through pure compile-time constructs such as other ticks, casts or type lambdas. This is the most restrictive placement rule for ticks, as all tickishs have in common that they want to track runtime processes. The only legal placement rule for counting ticks.

PlaceNonLam

As PlaceRuntime, but we float the tick through all lambdas. This makes sense where there is little difference between annotating the lambda and annotating the lambda's code.

PlaceCostCentre

In addition to floating through lambdas, cost-centre style tickishs can also be moved from constructors, non-function variables and literals. For example:

let x = scc... C (scc... y) (scc... 3) in ...

Neither the constructor application, the variable or the literal are likely to have any cost worth mentioning. And even if y names a thunk, the call would not care about the evaluation context. Therefore removing all annotations in the above example is safe.

Instances

Eq TickishPlacement

Defined in CoreSyn

Methods

(==) :: TickishPlacement -> TickishPlacement -> Bool

(/=) :: TickishPlacement -> TickishPlacement -> Bool

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

Data IsOrphan

Defined in CoreSyn

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

Defined in CoreSyn

Methods

put_ :: BinHandle -> IsOrphan -> IO ()

put :: BinHandle -> IsOrphan -> IO (Bin IsOrphan)

get :: BinHandle -> IO IsOrphan

type RuleBase = NameEnv [CoreRule]

Gathers a collection of CoreRules. Maps (the name of) an Id to its rules

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...)

Constructors

RuleEnv

Fields

• re_base :: RuleBase
• re_visible_orphs :: ModuleSet

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 TidyPgm for the sole purpose of this field.

• ru_origin :: !Module

  Module 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

type RuleFun = DynFlags -> InScopeEnv -> Id -> [CoreExpr] -> Maybe CoreExpr

type InScopeEnv = (InScopeSet, IdUnfoldingFun)

type IdUnfoldingFun = Id -> Unfolding

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 CoreUnfold

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 ToIface 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_is_value :: Bool
• uf_is_conlike :: Bool
• uf_is_work_free :: Bool
• uf_expandable :: Bool
• uf_guidance :: UnfoldingGuidance

data UnfoldingSource

Constructors

InlineRhs

InlineStable

InlineCompulsory

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

Eq UnfoldingGuidance

Defined in CoreSyn

Methods

(==) :: UnfoldingGuidance -> UnfoldingGuidance -> Bool

(/=) :: UnfoldingGuidance -> UnfoldingGuidance -> Bool

type CoreProgram = [CoreBind]

type CoreBndr = Var

The common case for the type of binders and variables when we are manipulating the Core language within GHC

type CoreExpr = Expr CoreBndr

Expressions where binders are CoreBndrs

type CoreArg = Arg CoreBndr

Argument expressions where binders are CoreBndrs

type CoreBind = Bind CoreBndr

Binding groups where binders are CoreBndrs

type CoreAlt = Alt CoreBndr

Case alternatives where binders are CoreBndrs

data TaggedBndr t

Binders are tagged with a t

Constructors

TB CoreBndr t

Instances

Outputable b => Outputable (TaggedBndr b)

Defined in CoreSyn

Methods

ppr :: TaggedBndr b -> SDoc

pprPrec :: Rational -> TaggedBndr b -> SDoc

type TaggedBind t = Bind (TaggedBndr t)

type TaggedExpr t = Expr (TaggedBndr t)

type TaggedArg t = Arg (TaggedBndr t)

type TaggedAlt t = Alt (TaggedBndr t)

type AnnAlt bndr annot = (AltCon, [bndr], AnnExpr bndr annot)

A clone of the Alt type but allowing annotation at every tree node

data AnnBind bndr annot

A clone of the Bind type but allowing annotation at every tree node

Constructors

AnnNonRec bndr (AnnExpr bndr annot)

conLikeIsInfix :: ConLike -> Bool

conLikesWithFields :: [ConLike] -> [FieldLabelString] -> [ConLike]

The ConLikes that have *all* the given fields

conLikeFieldType :: ConLike -> FieldLabelString -> Type

Extract the type for any given labelled field of the ConLike

conLikeFullSig :: ConLike -> ([TyVar], [TyCoVar], [EqSpec], ThetaType, ThetaType, [Type], Type)

The "full signature" of the ConLike returns, in order:

1) The universally quantified type variables

2) The existentially quantified type/coercion variables

3) The equality specification

4) The provided theta (the constraints provided by a match)

5) The required theta (the constraints required for a match)

6) The original argument types (i.e. before any change of the representation of the type)

7) The original result type

conLikeResTy :: ConLike -> [Type] -> Type

Returns the type of the whole pattern

conLikeImplBangs :: ConLike -> [HsImplBang]

Returns the strictness information for each constructor

conLikeWrapId_maybe :: ConLike -> Maybe Id

Returns the Id of the wrapper. This is also known as the builder in some contexts. The value is Nothing only in the case of unidirectional pattern synonyms.

conLikeStupidTheta :: ConLike -> ThetaType

The "stupid theta" of the ConLike, such as data Eq a in:

data Eq a => T a = ...

It is empty for PatSynCon as they do not allow such contexts.

conLikeExTyCoVars :: ConLike -> [TyCoVar]

Existentially quantified type/coercion variables

conLikeInstOrigArgTys :: ConLike -> [Type] -> [Type]

Returns just the instantiated value argument types of a ConLike, (excluding dictionary args)

conLikeFieldLabels :: ConLike -> [FieldLabel]

Names of fields used for selectors

conLikeArity :: ConLike -> Arity

Number of arguments

buildSynTyCon

Arguments

:: Name

-> [KnotTied TyConBinder]

-> Kind

result kind

-> [Role]

-> KnotTied Type

-> TyCon

buildAlgTyCon

Arguments

:: Name

-> [TyVar]

Kind variables and type variables

-> [Role]

-> Maybe CType

-> ThetaType

Stupid theta

-> AlgTyConRhs

-> Bool

True = was declared in GADT syntax

-> AlgTyConFlav

-> TyCon

splitDataProductType_maybe

Arguments

:: Type

A product type, perhaps

-> Maybe (TyCon, [Type], DataCon, [Type])

Extract the type constructor, type argument, data constructor and it's representation argument types from a type if it is a product type.

Precisely, we return Just for any type that is all of:

• Concrete (i.e. constructors visible)
• Single-constructor
• Not existentially quantified

Whether the type is a data type or a newtype

promoteDataCon :: DataCon -> TyCon

dataConUserTyVarsArePermuted :: DataCon -> Bool

Were the type variables of the data con written in a different order than the regular order (universal tyvars followed by existential tyvars)?

This is not a cheap test, so we minimize its use in GHC as much as possible. Currently, its only call site in the GHC codebase is in mkDataConRep in MkId, and so dataConUserTyVarsArePermuted is only called at most once during a data constructor's lifetime.

dataConCannotMatch :: [Type] -> DataCon -> Bool

classDataCon :: Class -> DataCon

specialPromotedDc :: DataCon -> Bool

Should this DataCon be allowed in a type even without -XDataKinds? Currently, only Lifted & Unlifted

isVanillaDataCon :: DataCon -> Bool

Vanilla DataCons are those that are nice boring Haskell 98 constructors

isUnboxedTupleCon :: DataCon -> Bool

isTupleDataCon :: DataCon -> Bool

dataConIdentity :: DataCon -> ByteString

The string package:module.name identifying a constructor, which is attached to its info table and used by the GHCi debugger and the heap profiler

dataConRepArgTys :: DataCon -> [Type]

Returns the arg types of the worker, including *all* non-dependent evidence, after any flattening has been done and without substituting for any type variables

dataConOrigArgTys :: DataCon -> [Type]

Returns the argument types of the wrapper, excluding all dictionary arguments and without substituting for any type variables

dataConInstArgTys

Arguments

:: DataCon

A datacon with no existentials or equality constraints However, it can have a dcTheta (notably it can be a class dictionary, with superclasses)

-> [Type]

Instantiated at these types

-> [Type]

Finds the instantiated types of the arguments required to construct a DataCon representation NB: these INCLUDE any dictionary args but EXCLUDE the data-declaration context, which is discarded It's all post-flattening etc; this is a representation type

dataConUserType :: DataCon -> Type

The user-declared type of the data constructor in the nice-to-read form:

T :: forall a b. a -> b -> T [a]

rather than:

T :: forall a c. forall b. (c~[a]) => a -> b -> T c

The type variables are quantified in the order that the user wrote them. See Note [DataCon user type variable binders].

NB: If the constructor is part of a data instance, the result type mentions the family tycon, not the internal one.

dataConOrigResTy :: DataCon -> Type

dataConInstSig :: DataCon -> [Type] -> ([TyCoVar], ThetaType, [Type])

Instantiate the universal tyvars of a data con, returning ( instantiated existentials , instantiated constraints including dependent GADT equalities which are *also* listed in the instantiated existentials , instantiated args)

dataConSig :: DataCon -> ([TyCoVar], ThetaType, [Type], Type)

The "signature" of the DataCon returns, in order:

1) The result of dataConUnivAndExTyCoVars,

2) All the ThetaTypes relating to the DataCon (coercion, dictionary, implicit parameter - whatever), including dependent GADT equalities. Dependent GADT equalities are *also* listed in return value (1), so be careful!

3) The type arguments to the constructor

4) The original result type of the DataCon

dataConBoxer :: DataCon -> Maybe DataConBoxer

dataConImplBangs :: DataCon -> [HsImplBang]

dataConRepStrictness :: DataCon -> [StrictnessMark]

Give the demands on the arguments of a Core constructor application (Con dc args)

isNullaryRepDataCon :: DataCon -> Bool

Return whether there are any argument types for this DataCons runtime representation type See Note [DataCon arities]

isNullarySrcDataCon :: DataCon -> Bool

Return whether there are any argument types for this DataCons original source type See Note [DataCon arities]

dataConRepArity :: DataCon -> Arity

Gives the number of actual fields in the representation of the data constructor. This may be more than appear in the source code; the extra ones are the existentially quantified dictionaries

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

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

dataConFieldType :: DataCon -> FieldLabelString -> Type

Extract the type for any given labelled field of the DataCon

dataConImplicitTyThings :: DataCon -> [TyThing]

Find all the Ids implicitly brought into scope by the data constructor. Currently, the union of the dataConWorkId and the dataConWrapId

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)

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)

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

dataConTheta :: DataCon -> ThetaType

The *full* constraints on the constructor type, including dependent GADT equalities.

dataConEqSpec :: DataCon -> [EqSpec]

Equalities derived from the result type of the data constructor, as written by the programmer in any GADT declaration. This includes *all* GADT-like equalities, including those written in by hand by the programmer.

dataConUnivAndExTyCoVars :: DataCon -> [TyCoVar]

Both the universal and existential type/coercion variables of the constructor

dataConUnivTyVars :: DataCon -> [TyVar]

The universally-quantified type variables of the constructor

dataConIsInfix :: DataCon -> Bool

Should the DataCon be presented infix?

dataConRepType :: DataCon -> Type

The representation type of the data constructor, i.e. the sort type that will represent values of this type at runtime

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.

dataConTagZ :: DataCon -> ConTagZ

dataConTag :: DataCon -> ConTag

The tag used for ordering DataCons

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.

-> [TyVarBinder]

User-written TyVarBinders. These must be Inferred/Specified. See Note [TyVarBinders in DataCons]

-> [EqSpec]

GADT equalities

-> KnotTied ThetaType

Theta-type occurring before the arguments proper

-> [KnotTied Type]

Original argument types

-> KnotTied Type

Original result type

-> RuntimeRepInfo

See comments on RuntimeRepInfo

-> 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

isMarkedStrict :: StrictnessMark -> Bool

isSrcUnpacked :: SrcUnpackedness -> Bool

isSrcStrict :: SrcStrictness -> Bool

isBanged :: HsImplBang -> Bool

eqHsBang :: HsImplBang -> HsImplBang -> Bool

Compare strictness annotations

filterEqSpec :: [EqSpec] -> [TyVar] -> [TyVar]

Filter out any TyVars mentioned in an EqSpec.

substEqSpec :: TCvSubst -> EqSpec -> EqSpec

Substitute in an EqSpec. Precondition: if the LHS of the EqSpec is mapped in the substitution, it is mapped to a type variable, not a full type.

eqSpecPreds :: [EqSpec] -> ThetaType

eqSpecPair :: EqSpec -> (TyVar, Type)

eqSpecType :: EqSpec -> Type

eqSpecTyVar :: EqSpec -> TyVar

mkEqSpec :: TyVar -> Type -> EqSpec

Make a non-dependent EqSpec

data HsSrcBang

Haskell Source Bang

Bangs on data constructor arguments as the user wrote them in the source code.

(HsSrcBang _ SrcUnpack SrcLazy) and (HsSrcBang _ SrcUnpack NoSrcStrict) (without StrictData) makes no sense, we emit a warning (in checkValidDataCon) and treat it like (HsSrcBang _ NoSrcUnpack SrcLazy)

Constructors

HsSrcBang SourceText SrcUnpackedness SrcStrictness

Instances

Data HsSrcBang

Defined in DataCon

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsSrcBang -> c HsSrcBang

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsSrcBang

toConstr :: HsSrcBang -> Constr

dataTypeOf :: HsSrcBang -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsSrcBang)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsSrcBang)

gmapT :: (forall b. Data b => b -> b) -> HsSrcBang -> HsSrcBang

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsSrcBang -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsSrcBang -> r

gmapQ :: (forall d. Data d => d -> u) -> HsSrcBang -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsSrcBang -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsSrcBang -> m HsSrcBang

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSrcBang -> m HsSrcBang

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSrcBang -> m HsSrcBang

Outputable HsSrcBang

Defined in DataCon

Methods

ppr :: HsSrcBang -> SDoc

pprPrec :: Rational -> HsSrcBang -> SDoc

data HsImplBang

Haskell Implementation Bang

Bangs of data constructor arguments as generated by the compiler after consulting HsSrcBang, flags, etc.

Constructors

HsLazy

Lazy field, or one with an unlifted type

HsStrict

Strict but not unpacked field

HsUnpack (Maybe Coercion)

Strict and unpacked field co :: arg-ty ~ product-ty HsBang

Instances

Data HsImplBang

Defined in DataCon

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsImplBang -> c HsImplBang

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsImplBang

toConstr :: HsImplBang -> Constr

dataTypeOf :: HsImplBang -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsImplBang)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsImplBang)

gmapT :: (forall b. Data b => b -> b) -> HsImplBang -> HsImplBang

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsImplBang -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsImplBang -> r

gmapQ :: (forall d. Data d => d -> u) -> HsImplBang -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsImplBang -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsImplBang -> m HsImplBang

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImplBang -> m HsImplBang

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsImplBang -> m HsImplBang

Outputable HsImplBang

Defined in DataCon

Methods

ppr :: HsImplBang -> SDoc

pprPrec :: Rational -> HsImplBang -> SDoc

data SrcStrictness

Source Strictness

What strictness annotation the user wrote

Constructors

SrcLazy

Lazy, ie '~'

SrcStrict

Strict, ie !

NoSrcStrict

no strictness annotation

Instances

Eq SrcStrictness

Defined in DataCon

Methods

(==) :: SrcStrictness -> SrcStrictness -> Bool

(/=) :: SrcStrictness -> SrcStrictness -> Bool

Data SrcStrictness

Defined in DataCon

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcStrictness -> c SrcStrictness

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SrcStrictness

toConstr :: SrcStrictness -> Constr

dataTypeOf :: SrcStrictness -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SrcStrictness)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcStrictness)

gmapT :: (forall b. Data b => b -> b) -> SrcStrictness -> SrcStrictness

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcStrictness -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SrcStrictness -> r

gmapQ :: (forall d. Data d => d -> u) -> SrcStrictness -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcStrictness -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SrcStrictness -> m SrcStrictness

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcStrictness -> m SrcStrictness

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcStrictness -> m SrcStrictness

Binary SrcStrictness

Defined in DataCon

Methods

put_ :: BinHandle -> SrcStrictness -> IO ()

put :: BinHandle -> SrcStrictness -> IO (Bin SrcStrictness)

get :: BinHandle -> IO SrcStrictness

Outputable SrcStrictness

Defined in DataCon

Methods

ppr :: SrcStrictness -> SDoc

pprPrec :: Rational -> SrcStrictness -> SDoc

data SrcUnpackedness

Source Unpackedness

What unpackedness the user requested

Constructors

SrcUnpack

{--} specified

SrcNoUnpack

{--} specified

NoSrcUnpack

no unpack pragma

Instances

Eq SrcUnpackedness

Defined in DataCon

Methods

(==) :: SrcUnpackedness -> SrcUnpackedness -> Bool

(/=) :: SrcUnpackedness -> SrcUnpackedness -> Bool

Data SrcUnpackedness

Defined in DataCon

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcUnpackedness -> c SrcUnpackedness

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SrcUnpackedness

toConstr :: SrcUnpackedness -> Constr

dataTypeOf :: SrcUnpackedness -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SrcUnpackedness)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcUnpackedness)

gmapT :: (forall b. Data b => b -> b) -> SrcUnpackedness -> SrcUnpackedness

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcUnpackedness -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SrcUnpackedness -> r

gmapQ :: (forall d. Data d => d -> u) -> SrcUnpackedness -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcUnpackedness -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SrcUnpackedness -> m SrcUnpackedness

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcUnpackedness -> m SrcUnpackedness

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcUnpackedness -> m SrcUnpackedness

Binary SrcUnpackedness

Defined in DataCon

Methods

put_ :: BinHandle -> SrcUnpackedness -> IO ()

put :: BinHandle -> SrcUnpackedness -> IO (Bin SrcUnpackedness)

get :: BinHandle -> IO SrcUnpackedness

Outputable SrcUnpackedness

Defined in DataCon

Methods

ppr :: SrcUnpackedness -> SDoc

pprPrec :: Rational -> SrcUnpackedness -> SDoc

data StrictnessMark

Constructors

MarkedStrict

NotMarkedStrict

Instances

Outputable StrictnessMark

Defined in DataCon

Methods

ppr :: StrictnessMark -> SDoc

pprPrec :: Rational -> StrictnessMark -> SDoc

isEqPrimPred :: PredType -> Bool

isEqPred :: PredType -> Bool

isClassPred :: PredType -> Bool

isEvVarType :: Type -> Bool

getClassPredTys_maybe :: PredType -> Maybe (Class, [Type])

instanceCantMatch :: [Maybe Name] -> [Maybe Name] -> Bool

roughMatchTcs :: [Type] -> [Maybe Name]

hsOverLitNeedsParens :: PprPrec -> HsOverLit x -> Bool

hsOverLitNeedsParens p ol returns True if an overloaded literal ol needs to be parenthesized under precedence p.

hsLitNeedsParens :: PprPrec -> HsLit x -> Bool

hsLitNeedsParens p l returns True if a literal l needs to be parenthesized under precedence p.

pmPprHsLit :: forall (x :: Pass). HsLit (GhcPass x) -> SDoc

pmPprHsLit pretty prints literals and is used when pretty printing pattern match warnings. All are printed the same (i.e., without hashes if they are primitive and not wrapped in constructors if they are boxed). This happens mainly for too reasons: * We do not want to expose their internal representation * The warnings become too messy

pp_st_suffix :: SourceText -> SDoc -> SDoc -> SDoc

convertLit :: ConvertIdX a b => HsLit a -> HsLit b

Convert a literal from one index type to another, updating the annotations according to the relevant Convertable instance

overLitType :: HsOverLit GhcTc -> Type

negateOverLitVal :: OverLitVal -> OverLitVal

data HsLit x

Haskell Literal

Constructors

HsChar (XHsChar x) Char

Character

HsCharPrim (XHsCharPrim x) Char

Unboxed character

HsString (XHsString x) FastString

String

HsStringPrim (XHsStringPrim x) ByteString

Packed bytes

HsInt (XHsInt x) IntegralLit

Genuinely an Int; arises from TcGenDeriv, and from TRANSLATION

HsIntPrim (XHsIntPrim x) Integer

literal Int#

HsWordPrim (XHsWordPrim x) Integer

literal Word#

HsInt64Prim (XHsInt64Prim x) Integer

literal Int64#

HsWord64Prim (XHsWord64Prim x) Integer

literal Word64#

HsInteger (XHsInteger x) Integer Type

Genuinely an integer; arises only from TRANSLATION (overloaded literals are done with HsOverLit)

HsRat (XHsRat x) FractionalLit Type

Genuinely a rational; arises only from TRANSLATION (overloaded literals are done with HsOverLit)

HsFloatPrim (XHsFloatPrim x) FractionalLit

Unboxed Float

HsDoublePrim (XHsDoublePrim x) FractionalLit

Unboxed Double

XLit (XXLit x)

Instances

Eq (HsLit x)

Defined in GHC.Hs.Lit

Methods

(==) :: HsLit x -> HsLit x -> Bool

(/=) :: HsLit x -> HsLit x -> Bool

Outputable (HsLit (GhcPass p))

Defined in GHC.Hs.Lit

Methods

ppr :: HsLit (GhcPass p) -> SDoc

pprPrec :: Rational -> HsLit (GhcPass p) -> SDoc

data HsOverLit p

Haskell Overloaded Literal

Constructors

OverLit

Fields

• ol_ext :: XOverLit p
• ol_val :: OverLitVal
• ol_witness :: HsExpr p

XOverLit (XXOverLit p)

Instances

Eq (XXOverLit p) => Eq (HsOverLit p)

Defined in GHC.Hs.Lit

Methods

(==) :: HsOverLit p -> HsOverLit p -> Bool

(/=) :: HsOverLit p -> HsOverLit p -> Bool

Ord (XXOverLit p) => Ord (HsOverLit p)

Defined in GHC.Hs.Lit

Methods

compare :: HsOverLit p -> HsOverLit p -> Ordering

(<) :: HsOverLit p -> HsOverLit p -> Bool

(<=) :: HsOverLit p -> HsOverLit p -> Bool

(>) :: HsOverLit p -> HsOverLit p -> Bool

(>=) :: HsOverLit p -> HsOverLit p -> Bool

max :: HsOverLit p -> HsOverLit p -> HsOverLit p

min :: HsOverLit p -> HsOverLit p -> HsOverLit p

OutputableBndrId p => Outputable (HsOverLit (GhcPass p))

Defined in GHC.Hs.Lit

Methods

ppr :: HsOverLit (GhcPass p) -> SDoc

pprPrec :: Rational -> HsOverLit (GhcPass p) -> SDoc

data OverLitTc

Constructors

OverLitTc

Fields

• ol_rebindable :: Bool
• ol_type :: Type

Instances

Data OverLitTc

Defined in GHC.Hs.Lit

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OverLitTc -> c OverLitTc

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OverLitTc

toConstr :: OverLitTc -> Constr

dataTypeOf :: OverLitTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OverLitTc)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OverLitTc)

gmapT :: (forall b. Data b => b -> b) -> OverLitTc -> OverLitTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OverLitTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OverLitTc -> r

gmapQ :: (forall d. Data d => d -> u) -> OverLitTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> OverLitTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> OverLitTc -> m OverLitTc

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OverLitTc -> m OverLitTc

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OverLitTc -> m OverLitTc

data OverLitVal

Overloaded Literal Value

Constructors

HsIntegral !IntegralLit

Integer-looking literals;

HsFractional !FractionalLit

Frac-looking literals

HsIsString !SourceText !FastString

String-looking literals

Instances

Eq OverLitVal

Defined in GHC.Hs.Lit

Methods

(==) :: OverLitVal -> OverLitVal -> Bool

(/=) :: OverLitVal -> OverLitVal -> Bool

Data OverLitVal

Defined in GHC.Hs.Lit

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OverLitVal -> c OverLitVal

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OverLitVal

toConstr :: OverLitVal -> Constr

dataTypeOf :: OverLitVal -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OverLitVal)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OverLitVal)

gmapT :: (forall b. Data b => b -> b) -> OverLitVal -> OverLitVal

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OverLitVal -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OverLitVal -> r

gmapQ :: (forall d. Data d => d -> u) -> OverLitVal -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> OverLitVal -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> OverLitVal -> m OverLitVal

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OverLitVal -> m OverLitVal

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OverLitVal -> m OverLitVal

Ord OverLitVal

Defined in GHC.Hs.Lit

Methods

compare :: OverLitVal -> OverLitVal -> Ordering

(<) :: OverLitVal -> OverLitVal -> Bool

(<=) :: OverLitVal -> OverLitVal -> Bool

(>) :: OverLitVal -> OverLitVal -> Bool

(>=) :: OverLitVal -> OverLitVal -> Bool

max :: OverLitVal -> OverLitVal -> OverLitVal

min :: OverLitVal -> OverLitVal -> OverLitVal

Outputable OverLitVal

Defined in GHC.Hs.Lit

Methods

ppr :: OverLitVal -> SDoc

pprPrec :: Rational -> OverLitVal -> SDoc

pprLiteral :: (SDoc -> SDoc) -> Literal -> SDoc

absentLiteralOf :: TyCon -> Maybe Literal

literalType :: Literal -> Type

Find the Haskell Type the literal occupies

litIsLifted :: Literal -> Bool

litFitsInChar :: Literal -> Bool

litIsDupable :: DynFlags -> Literal -> Bool

True if code space does not go bad if we duplicate this 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 -> -> Int
countZeros start end = go start 0
  where
    go off n
      | off `addrEq#` end = n
      | otherwise         = go (off `plusAddr#` 1) n'
      where n' | isTrue 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" 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.

rubbishLit :: Literal

A nonsense literal of type forall (a :: TYPE UnliftedRep). a.

nullAddrLit :: Literal

double2FloatLit :: Literal -> Literal

float2DoubleLit :: Literal -> Literal

int2DoubleLit :: Literal -> Literal

double2IntLit :: Literal -> Literal

int2FloatLit :: Literal -> Literal

float2IntLit :: Literal -> Literal

int2CharLit :: Literal -> Literal

char2IntLit :: Literal -> Literal

narrow32WordLit :: Literal -> Literal

narrow16WordLit :: Literal -> Literal

narrow8WordLit :: Literal -> Literal

narrow32IntLit :: Literal -> Literal

narrow16IntLit :: Literal -> Literal

narrow8IntLit :: Literal -> Literal

narrowLit :: Integral a => Proxy a -> Literal -> Literal

Narrow a literal number (unchecked result range)

int2WordLit :: DynFlags -> Literal -> Literal

word2IntLit :: DynFlags -> Literal -> Literal

isLitValue :: Literal -> Bool

Indicate if the Literal contains an Integer value, e.g. Char, Int, Word, LitInteger and LitNatural.

mapLitValue :: DynFlags -> (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]

isLitValue_maybe :: Literal -> Maybe Integer

Returns the Integer contained in the Literal, for when that makes sense, i.e. for Char and numbers.

litValue :: Literal -> Integer

Returns the Integer contained in the Literal, for when that makes sense, i.e. for Char, Int, Word, LitInteger and LitNatural.

isZeroLit :: Literal -> Bool

Tests whether the literal represents a zero of whatever type it is

inCharRange :: Char -> Bool

inWordRange :: DynFlags -> Integer -> Bool

inIntRange :: DynFlags -> Integer -> Bool

mkLitNatural :: Integer -> Type -> Literal

mkLitInteger :: Integer -> Type -> Literal

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

mkLitChar :: Char -> Literal

Creates a Literal of type Char#

mkLitDouble :: Rational -> Literal

Creates a Literal of type Double#

mkLitFloat :: Rational -> Literal

Creates a Literal of type Float#

mkLitWord64Wrap :: DynFlags -> Integer -> Literal

Creates a Literal of type Word64#. If the argument is out of the range, it is wrapped.

mkLitWord64 :: Integer -> Literal

Creates a Literal of type Word64#

mkLitInt64Wrap :: DynFlags -> Integer -> Literal

Creates a Literal of type Int64#. If the argument is out of the range, it is wrapped.

mkLitInt64 :: Integer -> Literal

Creates a Literal of type Int64#

mkLitWordWrapC :: DynFlags -> 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]

mkLitWordWrap :: DynFlags -> 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]

mkLitWord :: DynFlags -> Integer -> Literal

Creates a Literal of type Word#

mkLitIntWrapC :: DynFlags -> 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]

mkLitIntWrap :: DynFlags -> 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]

mkLitInt :: DynFlags -> Integer -> Literal

Creates a Literal of type Int#

mkLitNumber :: DynFlags -> LitNumType -> Integer -> Type -> Literal

Create a numeric Literal of the given type

litNumCheckRange :: DynFlags -> LitNumType -> Integer -> Bool

Check that a given number is in the range of a numeric literal

mkLitNumberWrap :: DynFlags -> LitNumType -> Integer -> Type -> Literal

Create a numeric Literal of the given type

litNumIsSigned :: LitNumType -> Bool

Indicate if a numeric literal type supports negative numbers

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 of UnliftedRep (i.e. 'MutVar#') when the the value is never used.
• A character
• A string
• The NULL pointer

Constructors

LitChar Char

Char# - at least 31 bits. Create with mkLitChar

LitNumber !LitNumType !Integer Type

Any numeric literal that can be internally represented with an Integer. See Note [Types of LitNumbers] below for the Type field.

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

A nonsense value, used when an unlifted binding is absent and has type forall (a :: TYPE UnliftedRep). a. May be lowered by code-gen to any possible value. Also 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

Eq Literal

Defined in Literal

Methods

(==) :: Literal -> Literal -> Bool

(/=) :: Literal -> Literal -> Bool

Data Literal

Defined in 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

Ord Literal

Needed for the Ord instance of AltCon, which in turn is needed in CoreMap.

Defined in 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

Binary Literal

Defined in Literal

Methods

put_ :: BinHandle -> Literal -> IO ()

put :: BinHandle -> Literal -> IO (Bin Literal)

get :: BinHandle -> IO Literal

Outputable Literal

Defined in Literal

Methods

ppr :: Literal -> SDoc

pprPrec :: Rational -> Literal -> SDoc

data LitNumType

Numeric literal type

Constructors

LitNumInteger

Integer (see Note [Integer literals])

LitNumNatural

Natural (see Note [Natural literals])

LitNumInt

Int# - according to target machine

LitNumInt64

Int64# - exactly 64 bits

LitNumWord

Word# - according to target machine

LitNumWord64

Word64# - exactly 64 bits

Instances

Enum LitNumType

Defined in 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]

Eq LitNumType

Defined in Literal

Methods

(==) :: LitNumType -> LitNumType -> Bool

(/=) :: LitNumType -> LitNumType -> Bool

Data LitNumType

Defined in 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

Ord LitNumType

Defined in 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

Binary LitNumType

Defined in Literal

Methods

put_ :: BinHandle -> LitNumType -> IO ()

put :: BinHandle -> LitNumType -> IO (Bin LitNumType)

get :: BinHandle -> IO LitNumType

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.)

classifiesTypeWithValues :: Kind -> Bool

Does this classify a type allowed to have values? Responds True to things like *, #, TYPE Lifted, TYPE v, Constraint.

True of any sub-kind of OpenTypeKind

isKindLevPoly :: Kind -> Bool

Tests whether the given kind (which should look like TYPE x) is something other than a constructor tree (that is, constructors at every node). E.g. True of TYPE k, TYPE (F Int) False of TYPE 'LiftedRep

isConstraintKindCon :: TyCon -> Bool

setJoinResTy :: Int -> Type -> Type -> Type

modifyJoinResTy :: Int -> (Type -> Type) -> Type -> Type

splitVisVarsOfTypes :: [Type] -> Pair TyCoVarSet

splitVisVarsOfType :: Type -> Pair TyCoVarSet

Retrieve the free variables in this type, splitting them based on whether they are used visibly or invisibly. Invisible ones come first.

synTyConResKind :: TyCon -> Kind

Find the result Kind of a type synonym, after applying it to its arity number of type variables Actually this function works fine on data types too, but they'd always return *, so we never need to ask

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

resultIsLevPoly :: Type -> Bool

Looking past all pi-types, is the end result potentially levity polymorphic? Example: True for (forall r (a :: TYPE r). String -> a) Example: False for (forall r1 r2 (a :: TYPE r1) (b :: TYPE r2). a -> b -> Type)

isTypeLevPoly :: Type -> Bool

Returns True if a type is levity polymorphic. Should be the same as (isKindLevPoly . typeKind) but much faster. Precondition: The type has kind (TYPE blah)

tcReturnsConstraintKind :: Kind -> Bool

tcIsRuntimeTypeKind :: Kind -> Bool

Is this kind equivalent to TYPE r (for some unknown r)?

This considers Constraint to be distinct from *.

tcIsLiftedTypeKind :: Kind -> Bool

Is this kind equivalent to *?

This considers Constraint to be distinct from *. For a version that treats them as the same type, see isLiftedTypeKind.

tcIsConstraintKind :: Kind -> Bool

tcTypeKind :: HasDebugCallStack => Type -> Kind

nonDetCmpTc :: TyCon -> TyCon -> Ordering

Compare two TyCons. NB: This should never see Constraint (as recognized by Kind.isConstraintKindCon) which is considered a synonym for Type in Core. See Note [Kind Constraint and kind Type] in Kind. See Note [nonDetCmpType nondeterminism]

nonDetCmpTypesX :: RnEnv2 -> [Type] -> [Type] -> Ordering

nonDetCmpTypeX :: RnEnv2 -> Type -> Type -> Ordering

nonDetCmpTypes :: [Type] -> [Type] -> Ordering

nonDetCmpType :: Type -> Type -> Ordering

eqVarBndrs :: RnEnv2 -> [Var] -> [Var] -> Maybe RnEnv2

eqTypes :: [Type] -> [Type] -> Bool

Type equality on lists of types, looking through type synonyms but not newtypes.

eqTypeX :: RnEnv2 -> Type -> Type -> Bool

Compare types with respect to a (presumably) non-empty RnEnv2.

seqTypes :: [Type] -> ()

seqType :: Type -> ()

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 CoreSyn.) 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]

isPrimitiveType :: Type -> Bool

Returns true of types that are opaque to Haskell.

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 levity-polymorphic types.

isDataFamilyAppType :: Type -> Bool

Check whether a type is a data family type

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

isUnboxedSumType :: Type -> Bool

isUnboxedTupleType :: Type -> Bool

getRuntimeRep :: HasDebugCallStack => Type -> Type

Extract the RuntimeRep classifier of a type. For instance, getRuntimeRep_maybe Int = LiftedRep. Panics if this is not possible.

getRuntimeRep_maybe :: HasDebugCallStack => Type -> Maybe Type

Extract the RuntimeRep classifier of a type. For instance, getRuntimeRep_maybe Int = LiftedRep. Returns Nothing if this is not possible.

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]

isRuntimeRepKindedTy :: Type -> Bool

Is this a type of kind RuntimeRep? (e.g. LiftedRep)

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 levity-polymorphic case)

isUnliftedType :: HasDebugCallStack => Type -> Bool

See Type for what an unlifted type is. Panics on levity polymorphic types; See mightBeUnliftedType for a more approximate predicate that behaves better in the presence of levity polymorphism.

isLiftedType_maybe :: HasDebugCallStack => Type -> Maybe Bool

Returns Just True if this type is surely lifted, Just False if it is surely unlifted, Nothing if we can't be sure (i.e., it is levity polymorphic), and panics if the kind does not have the shape TYPE r.

isCoVarType :: Type -> Bool

Does this type classify a core (unlifted) Coercion? At either role nominal or representational (t1 ~ t2) See Note [Types for coercions, predicates, and evidence] in TyCoRep

isFamFreeTy :: Type -> Bool

coAxNthLHS :: forall (br :: BranchFlag). CoAxiom br -> Int -> Type

Get the type on the LHS of a coercion induced by a type/data family instance.

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)

closeOverKindsDSet :: DTyVarSet -> DTyVarSet

Add the kind variables free in the kinds of the tyvars in the given set. Returns a deterministic set.

closeOverKindsList :: [TyVar] -> [TyVar]

Add the kind variables free in the kinds of the tyvars in the given set. Returns a deterministically ordered list.

closeOverKindsFV :: [TyVar] -> FV

Given a list of tyvars returns a deterministic FV computation that returns the given tyvars with the kind variables free in the kinds of the given tyvars.

closeOverKinds :: TyVarSet -> TyVarSet

Add the kind variables free in the kinds of the tyvars in the given set. Returns a non-deterministic set.

binderRelevantType_maybe :: TyCoBinder -> Maybe Type

Extract a relevant type, if there is one.

tyBinderType :: TyBinder -> Type

tyCoBinderType :: TyCoBinder -> Type

tyCoBinderVar_maybe :: TyCoBinder -> Maybe TyCoVar

isAnonTyCoBinder :: TyCoBinder -> Bool

Does this binder bind a variable that is not erased? Returns True for anonymous binders.

mkAnonBinder :: AnonArgFlag -> Type -> TyCoBinder

Make an anonymous binder

isTauTy :: Type -> Bool

appTyArgFlags :: Type -> [Type] -> [ArgFlag]

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 appTyArgFlags comes in handy, since f Type Bool would be represented in Core using AppTys. (See also #15792).

tyConArgFlags :: TyCon -> [Type] -> [ArgFlag]

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
tyConArgFlags 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.

partitionInvisibles :: [(a, ArgFlag)] -> ([a], [a])

Given a list of things paired with their visibilities, partition the things into (invisible things, visible things).

filterOutInferredTypes :: TyCon -> [Type] -> [Type]

Given a TyCon and a list of argument types, filter out any Inferred arguments.

filterOutInvisibleTypes :: TyCon -> [Type] -> [Type]

Given a TyCon and a list of argument types, filter out any invisible (i.e., Inferred or Specified) arguments.

splitPiTysInvisibleN :: Int -> Type -> ([TyCoBinder], Type)

splitPiTysInvisible :: Type -> ([TyCoBinder], Type)

invisibleTyBndrCount :: Type -> Int

splitForAllVarBndrs :: Type -> ([TyCoVarBinder], Type)

Like splitPiTys but split off only named binders and returns TyCoVarBinders rather than TyCoBinders

splitPiTys :: Type -> ([TyCoBinder], Type)

Split off all TyCoBinders to a type, splitting both proper foralls and functions

splitPiTy :: Type -> (TyCoBinder, Type)

Takes a forall type apart, or panics

splitPiTy_maybe :: Type -> Maybe (TyCoBinder, Type)

Attempts to take a forall type apart; works with proper foralls and functions

splitForAllTy_co_maybe :: Type -> Maybe (TyCoVar, Type)

Like splitForAllTy_maybe, but only returns Just if it is a covar binder.

splitForAllTy_ty_maybe :: Type -> Maybe (TyCoVar, Type)

Like splitForAllTy_maybe, but only returns Just if it is a tyvar binder.

splitForAllTy_maybe :: Type -> Maybe (TyCoVar, Type)

Attempts to take a forall type apart, but only if it's a proper forall, with a named binder

dropForAlls :: Type -> Type

Drops all ForAllTys

splitForAllTy :: Type -> (TyCoVar, Type)

Take a forall type apart, or panics if that is not possible.

isFunTy :: Type -> Bool

Is this a function?

isPiTy :: Type -> Bool

Is this a function or forall?

isForAllTy_co :: Type -> Bool

Like isForAllTy, but returns True only if it is a covar binder

isForAllTy_ty :: Type -> Bool

Like isForAllTy, but returns True only if it is a tyvar binder

isForAllTy :: Type -> Bool

Checks whether this is a proper forall (with a named binder)

splitForAllTysSameVis :: ArgFlag -> Type -> ([TyCoVar], Type)

Like splitForAllTys, but only splits a ForAllTy if sameVis argf supplied_argf is True, where argf is the visibility of the ForAllTy's binder and supplied_argf is the visibility provided as an argument to this function.

splitForAllTys :: 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.

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 TyCoBinders, 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.

mkLamTypes :: [Var] -> Type -> Type

mkLamType for multiple type or value arguments

mkLamType :: Var -> Type -> Type

Makes a (->) type or an implicit forall type, depending on whether it is given a type variable or a term variable. This is used, for example, when producing the type of a lambda. Always uses Inferred binders.

mkVisForAllTys :: [TyVar] -> Type -> Type

Like mkForAllTys, but assumes all variables are dependent and visible

mkSpecForAllTys :: [TyVar] -> Type -> Type

Like mkForAllTys, but assumes all variables are dependent and Specified, a common case

mkSpecForAllTy :: TyVar -> Type -> Type

Like mkForAllTy, but assumes the variable is dependent and Specified, a common case

mkInvForAllTys :: [TyVar] -> Type -> Type

Like mkTyCoInvForAllTys, but tvs should be a list of tyvar

mkTyCoInvForAllTys :: [TyCoVar] -> Type -> Type

Like mkForAllTys, but assumes all variables are dependent and Inferred, a common case

mkInvForAllTy :: TyVar -> Type -> Type

Like mkTyCoInvForAllTy, but tv should be a tyvar

mkTyCoInvForAllTy :: TyCoVar -> Type -> Type

Make a dependent forall over an Inferred variable

stripCoercionTy :: Type -> Coercion

isCoercionTy_maybe :: Type -> Maybe Coercion

mkCoercionTy :: Coercion -> Type

discardCast :: Type -> Type

Drop the cast on a type, if any. If there is no cast, just return the original type. This is rarely what you want. The CastTy data constructor (in TyCoRep) has the invariant that another CastTy is not inside. See the data constructor for a full description of this invariant. Since CastTy cannot be nested, the result of discardCast cannot be a CastTy.

tyConBindersTyCoBinders :: [TyConBinder] -> [TyCoBinder]

splitCastTy_maybe :: Type -> Maybe (Type, Coercion)

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.

nextRole :: Type -> Role

splitListTyConApp_maybe :: Type -> Maybe Type

Attempts to tease a list type apart and gives the type of the elements if successful (looks through type synonyms)

repSplitTyConApp_maybe :: HasDebugCallStack => Type -> Maybe (TyCon, [Type])

Like splitTyConApp_maybe, but doesn't look through synonyms. This assumes the synonyms have already been dealt with.

Moreover, for a FunTy, it only succeeds if the argument types have enough info to extract the runtime-rep arguments that the funTyCon requires. This will usually be true; but may be temporarily false during canonicalization: see Note [FunTy and decomposing tycon applications] in TcCanonical

tcSplitTyConApp_maybe :: HasCallStack => Type -> Maybe (TyCon, [Type])

Split a type constructor application into its type constructor and applied types. Note that this may fail 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). Consequently, you may need to zonk your type before using this function.

If you only need the TyCon, consider using tcTyConAppTyCon_maybe.

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

tyConAppArgN :: Int -> Type -> Type

tyConAppArgs :: Type -> [Type]

tyConAppArgs_maybe :: Type -> Maybe [Type]

The same as snd . splitTyConApp

tyConAppTyCon :: Type -> TyCon

tyConAppTyCon_maybe :: Type -> Maybe TyCon

The same as fst . splitTyConApp

tyConAppTyConPicky_maybe :: Type -> Maybe TyCon

Retrieve the tycon heading this type, if there is one. Does not look through synonyms.

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.

applyTysX :: [TyVar] -> Type -> [Type] -> Type

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.

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

funResultTy :: Type -> Type

Extract the function result type and panic if that is not possible

splitFunTys :: Type -> ([Type], Type)

splitFunTy_maybe :: Type -> Maybe (Type, Type)

Attempts to extract the argument and result types from a type

splitFunTy :: Type -> (Type, Type)

Attempts to extract the argument and result types from a type, and panics if that is not possible. See also splitFunTy_maybe

pprUserTypeErrorTy :: Type -> SDoc

Render a type corresponding to a user type error into a SDoc.

userTypeError_maybe :: Type -> Maybe Type

Is this type a custom user error? If so, give us the kind and the error message.

isLitTy :: Type -> Maybe TyLit

Is this a type literal (symbol or numeric).

isStrLitTy :: Type -> Maybe FastString

Is this a symbol literal. We also look through type synonyms.

mkStrLitTy :: FastString -> Type

isNumLitTy :: Type -> Maybe Integer

Is this a numeric literal. We also look through type synonyms.

mkNumLitTy :: Integer -> Type

repSplitAppTys :: HasDebugCallStack => Type -> (Type, [Type])

Like splitAppTys, but doesn't look through type synonyms

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.

splitAppTy :: Type -> (Type, Type)

Attempts to take a type application apart, as in splitAppTy_maybe, and panics if this is not possible

tcRepSplitAppTy_maybe :: Type -> Maybe (Type, Type)

Does the AppTy split as in tcSplitAppTy_maybe, but assumes that any coreView stuff is already done. Refuses to look through (c => t)

repSplitAppTy_maybe :: HasDebugCallStack => Type -> Maybe (Type, Type)

Does the AppTy split as in splitAppTy_maybe, but assumes that any Core view stuff is already done

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!

mkAppTys :: Type -> [Type] -> Type

repGetTyVar_maybe :: Type -> Maybe TyVar

Attempts to obtain the type variable underlying a Type, without any expansion

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

getTyVar_maybe :: Type -> Maybe TyVar

Attempts to obtain the type variable underlying a Type

isTyVarTy :: Type -> Bool

getTyVar :: String -> 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

mapCoercion :: Monad m => TyCoMapper env m -> env -> Coercion -> m Coercion

mapType :: Monad m => TyCoMapper env m -> env -> Type -> m Type

isRuntimeRepVar :: TyVar -> Bool

Is a tyvar of type RuntimeRep?

isUnliftedRuntimeRep :: Type -> Bool

isUnliftedTypeKind :: Kind -> Bool

Returns True if the kind classifies unlifted types and False otherwise. Note that this returns False for levity-polymorphic kinds, which may be specialized to a kind that classifies unlifted types.

isLiftedRuntimeRep :: Type -> Bool

kindRep_maybe :: HasDebugCallStack => Kind -> Maybe Type

Given a kind (TYPE rr), extract its RuntimeRep classifier rr. For example, kindRep_maybe * = Just LiftedRep Returns Nothing if the kind is not of form (TYPE rr) Treats * and Constraint as the same

kindRep :: HasDebugCallStack => Kind -> Type

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

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

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 TyCoRep.

• tcm_tycobinder :: env -> TyCoVar -> ArgFlag -> 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 TcTyClsDecls

cloneTyVarBndrs :: TCvSubst -> [TyVar] -> UniqSupply -> (TCvSubst, [TyVar])

cloneTyVarBndr :: TCvSubst -> TyVar -> Unique -> (TCvSubst, TyVar)

substVarBndrs :: HasCallStack => TCvSubst -> [TyCoVar] -> (TCvSubst, [TyCoVar])

substVarBndr :: HasCallStack => TCvSubst -> TyCoVar -> (TCvSubst, TyCoVar)

substTyVarBndrs :: HasCallStack => TCvSubst -> [TyVar] -> (TCvSubst, [TyVar])

substTyVarBndr :: HasCallStack => TCvSubst -> TyVar -> (TCvSubst, TyVar)

substCoUnchecked :: TCvSubst -> 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.

lookupTyVar :: TCvSubst -> TyVar -> Maybe Type

substTyVars :: TCvSubst -> [TyVar] -> [Type]

substTyVar :: TCvSubst -> TyVar -> Type

substThetaUnchecked :: TCvSubst -> 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.

substTheta :: HasCallStack => TCvSubst -> ThetaType -> ThetaType

Substitute within a ThetaType The substitution has to satisfy the invariants described in Note [The substitution invariant].

substTysUnchecked :: TCvSubst -> [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.

substTys :: HasCallStack => TCvSubst -> [Type] -> [Type]

Substitute within several Types The substitution has to satisfy the invariants described in Note [The substitution invariant].

substTyUnchecked :: TCvSubst -> 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.

substTy :: HasCallStack => TCvSubst -> Type -> Type

Substitute within a Type The substitution has to satisfy the invariants described in Note [The substitution invariant].

substTyAddInScope :: TCvSubst -> 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].

substTysWith :: [TyVar] -> [Type] -> [Type] -> [Type]

Type 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.

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.

substTyWith :: HasCallStack => [TyVar] -> [Type] -> Type -> Type

Type substitution, see zipTvSubst

zipCoEnv :: HasDebugCallStack => [CoVar] -> [Coercion] -> CvSubstEnv

zipTyEnv :: HasDebugCallStack => [TyVar] -> [Type] -> TvSubstEnv

mkTvSubstPrs :: [(TyVar, Type)] -> TCvSubst

Generates the in-scope set for the TCvSubst from the types in the incoming environment. No CoVars, please!

zipTCvSubst :: HasDebugCallStack => [TyCoVar] -> [Type] -> TCvSubst

zipTvSubst :: HasDebugCallStack => [TyVar] -> [Type] -> TCvSubst

Generates the in-scope set for the TCvSubst from the types in the incoming environment. No CoVars, please!

unionTCvSubst :: TCvSubst -> TCvSubst -> TCvSubst

extendTCvSubstList :: TCvSubst -> [Var] -> [Type] -> TCvSubst

extendTvSubstList :: TCvSubst -> [Var] -> [Type] -> TCvSubst

extendTvSubstAndInScope :: TCvSubst -> TyVar -> Type -> TCvSubst

extendCvSubst :: TCvSubst -> CoVar -> Coercion -> TCvSubst

extendTvSubstWithClone :: TCvSubst -> TyVar -> TyVar -> TCvSubst

extendTvSubstBinderAndInScope :: TCvSubst -> TyCoBinder -> Type -> TCvSubst

extendTvSubst :: TCvSubst -> TyVar -> Type -> TCvSubst

extendTCvSubstWithClone :: TCvSubst -> TyCoVar -> TyCoVar -> TCvSubst

extendTCvSubst :: TCvSubst -> TyCoVar -> Type -> TCvSubst

extendTCvInScopeSet :: TCvSubst -> VarSet -> TCvSubst

extendTCvInScopeList :: TCvSubst -> [Var] -> TCvSubst

extendTCvInScope :: TCvSubst -> Var -> TCvSubst

zapTCvSubst :: TCvSubst -> TCvSubst

setTvSubstEnv :: TCvSubst -> TvSubstEnv -> TCvSubst

notElemTCvSubst :: Var -> TCvSubst -> Bool

isInScope :: Var -> TCvSubst -> Bool

getTCvSubstRangeFVs :: TCvSubst -> VarSet

Returns the free variables of the types in the range of a substitution as a non-deterministic set.

getTCvInScope :: TCvSubst -> InScopeSet

getTvSubstEnv :: TCvSubst -> TvSubstEnv

mkTCvSubst :: InScopeSet -> (TvSubstEnv, CvSubstEnv) -> TCvSubst

isEmptyTCvSubst :: TCvSubst -> Bool

mkEmptyTCvSubst :: InScopeSet -> TCvSubst

emptyTCvSubst :: TCvSubst

composeTCvSubst :: TCvSubst -> TCvSubst -> TCvSubst

Composes two substitutions, applying the second one provided first, like in function composition.

composeTCvSubstEnv :: InScopeSet -> (TvSubstEnv, CvSubstEnv) -> (TvSubstEnv, CvSubstEnv) -> (TvSubstEnv, CvSubstEnv)

(compose env1 env2)(x) is env1(env2(x)); i.e. apply env2 then env1. It assumes that both are idempotent. Typically, env1 is the refinement to a base substitution env2

emptyTvSubstEnv :: TvSubstEnv

data TCvSubst

Type & coercion substitution

The following invariants must hold of a TCvSubst:

1. The in-scope set is needed only to guide the generation of fresh uniques
2. In particular, the kind of the type variables in the in-scope set is not relevant
3. The substitution is only applied ONCE! This is because in general such application will not reach a fixed point.

Constructors

TCvSubst InScopeSet TvSubstEnv CvSubstEnv

Instances

Outputable TCvSubst

Defined in TyCoSubst

Methods

ppr :: TCvSubst -> SDoc

pprPrec :: Rational -> TCvSubst -> SDoc

type TvSubstEnv = TyVarEnv Type

A substitution of Types for TyVars and Kinds for KindVars

pprTypeApp :: TyCon -> [Type] -> SDoc

pprForAll :: [TyCoVarBinder] -> SDoc

pprThetaArrowTy :: ThetaType -> SDoc

pprParendType :: Type -> SDoc

tidyKind :: TidyEnv -> Kind -> Kind

tidyOpenKind :: TidyEnv -> Kind -> (TidyEnv, Kind)

tidyTopType :: Type -> Type

Calls tidyType on a top-level type (i.e. with an empty tidying environment)

tidyOpenType :: TidyEnv -> Type -> (TidyEnv, Type)

tidyOpenTypes :: TidyEnv -> [Type] -> (TidyEnv, [Type])

Grabs the free type variables, tidies them and then uses tidyType to work over the type itself

tidyType :: TidyEnv -> Type -> Type

tidyTypes :: TidyEnv -> [Type] -> [Type]

tidyTyCoVarOcc :: TidyEnv -> TyCoVar -> 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

tidyOpenTyCoVars :: TidyEnv -> [TyCoVar] -> (TidyEnv, [TyCoVar])

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

tidyTyCoVarBinders :: TidyEnv -> [VarBndr TyCoVar vis] -> (TidyEnv, [VarBndr TyCoVar vis])

tidyTyCoVarBinder :: TidyEnv -> VarBndr TyCoVar vis -> (TidyEnv, VarBndr TyCoVar vis)

tidyVarBndr :: TidyEnv -> TyCoVar -> (TidyEnv, TyCoVar)

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.

tyCoVarsOfTypesWellScoped :: [Type] -> [TyVar]

Get the free vars of types in scoped order

tyCoVarsOfTypeWellScoped :: Type -> [TyVar]

Get the free vars of a type in scoped order

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 RnTypes

noFreeVarsOfType :: Type -> Bool

Returns True if this type has no free variables. Should be the same as isEmptyVarSet . tyCoVarsOfType, but faster in the non-forall case.

coVarsOfTypes :: [Type] -> TyCoVarSet

coVarsOfType :: Type -> CoVarSet

tyCoFVsVarBndr :: Var -> FV -> FV

tyCoFVsVarBndrs :: [Var] -> FV -> FV

tyCoFVsBndr :: TyCoVarBinder -> FV -> 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 FV.

Eta-expanded because that makes it run faster (apparently) See Note [FV eta expansion] in FV for explanation.

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 FV.

tyCoVarsOfTypes :: [Type] -> TyCoVarSet

tyCoVarsOfType :: Type -> TyCoVarSet

doubleX8PrimTyCon :: TyCon

doubleX8PrimTy :: Type

floatX16PrimTyCon :: TyCon

floatX16PrimTy :: Type

doubleX4PrimTyCon :: TyCon

doubleX4PrimTy :: Type

floatX8PrimTyCon :: TyCon

floatX8PrimTy :: Type

doubleX2PrimTyCon :: TyCon

doubleX2PrimTy :: Type

floatX4PrimTyCon :: TyCon

floatX4PrimTy :: Type

word64X8PrimTyCon :: TyCon

word64X8PrimTy :: Type

word32X16PrimTyCon :: TyCon

word32X16PrimTy :: Type

word16X32PrimTyCon :: TyCon

word16X32PrimTy :: Type

word8X64PrimTyCon :: TyCon

word8X64PrimTy :: Type

word64X4PrimTyCon :: TyCon

word64X4PrimTy :: Type

word32X8PrimTyCon :: TyCon

word32X8PrimTy :: Type

word16X16PrimTyCon :: TyCon

word16X16PrimTy :: Type

word8X32PrimTyCon :: TyCon

word8X32PrimTy :: Type

word64X2PrimTyCon :: TyCon

word64X2PrimTy :: Type

word32X4PrimTyCon :: TyCon

word32X4PrimTy :: Type

word16X8PrimTyCon :: TyCon

word16X8PrimTy :: Type

word8X16PrimTyCon :: TyCon

word8X16PrimTy :: Type

int64X8PrimTyCon :: TyCon

int64X8PrimTy :: Type

int32X16PrimTyCon :: TyCon

int32X16PrimTy :: Type

int16X32PrimTyCon :: TyCon

int16X32PrimTy :: Type

int8X64PrimTyCon :: TyCon

int8X64PrimTy :: Type

int64X4PrimTyCon :: TyCon

int64X4PrimTy :: Type

int32X8PrimTyCon :: TyCon

int32X8PrimTy :: Type

int16X16PrimTyCon :: TyCon

int16X16PrimTy :: Type

int8X32PrimTyCon :: TyCon

int8X32PrimTy :: Type

int64X2PrimTyCon :: TyCon

int64X2PrimTy :: Type

int32X4PrimTyCon :: TyCon

int32X4PrimTy :: Type

int16X8PrimTyCon :: TyCon

int16X8PrimTy :: Type

int8X16PrimTyCon :: TyCon

int8X16PrimTy :: Type

threadIdPrimTyCon :: TyCon

threadIdPrimTy :: Type

mkWeakPrimTy :: Type -> Type

weakPrimTyCon :: TyCon

bcoPrimTyCon :: TyCon

bcoPrimTy :: Type

compactPrimTy :: Type

compactPrimTyCon :: TyCon

mkStableNamePrimTy :: Type -> Type

stableNamePrimTyCon :: TyCon

mkStablePtrPrimTy :: Type -> Type

stablePtrPrimTyCon :: TyCon

mkTVarPrimTy :: Type -> Type -> Type

tVarPrimTyCon :: TyCon

mkMVarPrimTy :: Type -> Type -> Type

mVarPrimTyCon :: TyCon

mkMutVarPrimTy :: Type -> Type -> Type

mutVarPrimTyCon :: TyCon

mkSmallMutableArrayPrimTy :: Type -> Type -> Type

mkMutableArrayArrayPrimTy :: Type -> Type

mkMutableByteArrayPrimTy :: Type -> Type

mkMutableArrayPrimTy :: Type -> Type -> Type

mkSmallArrayPrimTy :: Type -> Type

mkArrayArrayPrimTy :: Type

byteArrayPrimTy :: Type

mkArrayPrimTy :: Type -> Type

smallMutableArrayPrimTyCon :: TyCon

smallArrayPrimTyCon :: TyCon

mutableArrayArrayPrimTyCon :: TyCon

arrayArrayPrimTyCon :: TyCon

byteArrayPrimTyCon :: TyCon

mutableByteArrayPrimTyCon :: TyCon

mutableArrayPrimTyCon :: TyCon

arrayPrimTyCon :: TyCon

equalityTyCon :: Role -> TyCon

Given a Role, what TyCon is the type of equality predicates at that role?

eqPhantPrimTyCon :: TyCon

eqReprPrimTyCon :: TyCon

eqPrimTyCon :: TyCon

proxyPrimTyCon :: TyCon

mkProxyPrimTy :: Type -> Type -> Type

voidPrimTyCon :: TyCon

voidPrimTy :: Type

realWorldStatePrimTy :: Type

realWorldTy :: Type

realWorldTyCon :: TyCon

statePrimTyCon :: TyCon

mkStatePrimTy :: Type -> Type

doublePrimTyCon :: TyCon

doublePrimTy :: Type

floatPrimTyCon :: TyCon

floatPrimTy :: Type

addrPrimTyCon :: TyCon

addrPrimTy :: Type

word64PrimTyCon :: TyCon

word64PrimTy :: Type

word32PrimTyCon :: TyCon

word32PrimTy :: Type

word16PrimTyCon :: TyCon

word16PrimTy :: Type

word8PrimTyCon :: TyCon

word8PrimTy :: Type

wordPrimTyCon :: TyCon

wordPrimTy :: Type

int64PrimTyCon :: TyCon

int64PrimTy :: Type

int32PrimTyCon :: TyCon

int32PrimTy :: Type

int16PrimTyCon :: TyCon

int16PrimTy :: Type

int8PrimTyCon :: TyCon

int8PrimTy :: Type

intPrimTyCon :: TyCon

intPrimTy :: Type

charPrimTyCon :: TyCon

charPrimTy :: Type

primRepToRuntimeRep :: PrimRep -> Type

Convert a PrimRep to a Type of kind RuntimeRep Defined here to avoid (more) module loops

tYPE :: Type -> Type

Given a RuntimeRep, applies TYPE to it. see Note [TYPE and RuntimeRep]

mkPrimTyConName :: FastString -> Unique -> TyCon -> Name

tYPETyConName :: Name

tYPETyCon :: TyCon

funTyCon :: TyCon

The (->) type constructor.

(->) :: forall (rep1 :: RuntimeRep) (rep2 :: RuntimeRep).
        TYPE rep1 -> TYPE rep2 -> *

funTyConName :: Name

openBetaTy :: Type

openAlphaTy :: Type

openBetaTyVar :: TyVar

openAlphaTyVar :: TyVar

runtimeRep2Ty :: Type

runtimeRep1Ty :: Type

runtimeRep2TyVar :: TyVar

runtimeRep1TyVar :: TyVar

alphaTyUnliftedRep :: Type

alphaTysUnliftedRep :: [Type]

alphaTyVarUnliftedRep :: TyVar

alphaTyVarsUnliftedRep :: [TyVar]

deltaTy :: Type

gammaTy :: Type

betaTy :: Type

alphaTy :: Type

alphaTys :: [Type]

deltaTyVar :: TyVar

gammaTyVar :: TyVar

betaTyVar :: TyVar

alphaTyVar :: TyVar

alphaTyVars :: [TyVar]

mkTemplateAnonTyConBinders :: [Kind] -> [TyConBinder]

mkTemplateKindTyConBinders :: [Kind] -> [TyConBinder]

mkTemplateKiTyVar :: Kind -> (Kind -> [Kind]) -> [TyVar]

mkTemplateKiTyVars :: [Kind] -> ([Kind] -> [Kind]) -> [TyVar]

mkTemplateTyConBinders :: [Kind] -> ([Kind] -> [Kind]) -> [TyConBinder]

mkTemplateTyVars :: [Kind] -> [TyVar]

mkTemplateTyVarsFrom :: Int -> [Kind] -> [TyVar]

mkTemplateKindVars :: [Kind] -> [TyVar]

doublePrimTyConName :: Name

floatPrimTyConName :: Name

addrPrimTyConName :: Name

word64PrimTyConName :: Name

word32PrimTyConName :: Name

word16PrimTyConName :: Name

word8PrimTyConName :: Name

wordPrimTyConName :: Name

int64PrimTyConName :: Name

int32PrimTyConName :: Name

int16PrimTyConName :: Name

int8PrimTyConName :: Name

intPrimTyConName :: Name

charPrimTyConName :: Name

exposedPrimTyCons :: [TyCon]

Primitive TyCons that are defined in, and exported from, GHC.Prim.

unexposedPrimTyCons :: [TyCon]

Primitive TyCons that are defined in GHC.Prim but not exposed. It's important to keep these separate as we don't want users to be able to write them (see #15209) or see them in GHCi's :browse output (see #12023).

primTyCons :: [TyCon]

provSize :: UnivCoProvenance -> Int

coercionSize :: Coercion -> Int

typeSize :: Type -> Int

setCoHoleCoVar :: CoercionHole -> CoVar -> CoercionHole

coHoleCoVar :: CoercionHole -> CoVar

mkTyConTy :: TyCon -> Type

Create the plain type constructor type which has been applied to no type arguments at all.

mkPiTys :: [TyCoBinder] -> Type -> Type

mkPiTy :: TyCoBinder -> Type -> Type

mkForAllTys :: [TyCoVarBinder] -> Type -> Type

Wraps foralls over the type using the provided TyCoVars from left to right

mkInvisFunTys :: [Type] -> Type -> Type

Make nested arrow types

mkVisFunTys :: [Type] -> Type -> Type

Make nested arrow types

mkInvisFunTy :: Type -> Type -> Type infixr 3

mkVisFunTy :: Type -> Type -> Type infixr 3

mkTyCoVarTys :: [TyCoVar] -> [Type]

mkTyCoVarTy :: TyCoVar -> Type

mkTyVarTys :: [TyVar] -> [Type]

mkTyVarTy :: TyVar -> Type

isTyBinder :: TyCoBinder -> 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.

isNamedBinder :: TyCoBinder -> Bool

isVisibleBinder :: TyCoBinder -> Bool

Does this binder bind a visible argument?

isInvisibleBinder :: TyCoBinder -> Bool

Does this binder bind an invisible argument?

delBinderVar :: VarSet -> TyCoVarBinder -> VarSet

Remove the binder's variable from the set, if the binder has a variable.

tyThingCategory :: TyThing -> String

pprTyThingCategory :: TyThing -> SDoc

pprShortTyThing :: TyThing -> SDoc

type KindOrType = Type

The key representation of types within the compiler

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 TcTyClsDecls

type TyBinder = TyCoBinder

TyBinder is like TyCoBinder, but there can only be TyVarBinder in the Named field.

type CoercionR = Coercion

type CoercionP = Coercion

type KindCoercion = CoercionN

type MCoercionR = MCoercion

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

Data CoercionHole

Defined in TyCoRep

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

Outputable CoercionHole

Defined in TyCoRep

Methods

ppr :: CoercionHole -> SDoc

pprPrec :: Rational -> CoercionHole -> SDoc

isCoercionTy :: Type -> Bool

mkAppTy :: Type -> Type -> Type

Applies a type to another, as in e.g. k a

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 TyCoRep

piResultTy :: HasDebugCallStack => Type -> Type -> Type

eqType :: Type -> Type -> Bool

Type equality on source types. Does not look through newtypes or PredTypes, but it does look through type synonyms. This first checks that the kinds of the types are equal and then checks whether the types are equal, ignoring casts and coercions. (The kind check is a recursive call, but since all kinds have type Type, there is no need to check the types of kinds.) See also Note [Non-trivial definitional equality] in TyCoRep.

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 considers Constraint to be a synonym of TYPE LiftedRep.

By being non-recursive and inlined, this case analysis gets efficiently joined onto the case analysis that the caller is already doing

tcView :: Type -> Maybe Type

Gives the typechecker view of a type. This unwraps synonyms but leaves Constraint alone. c.f. coreView, which turns Constraint into TYPE LiftedRep. Returns Nothing if no unwrapping happens. See also Note [coreView vs tcView]

isRuntimeRepTy :: Type -> Bool

Is this the type RuntimeRep?

isLiftedTypeKind :: Kind -> Bool

This version considers Constraint to be the same as *. Returns True if the argument is equivalent to Type/Constraint and False otherwise. See Note [Kind Constraint and kind Type]

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

partitionInvisibleTypes :: TyCon -> [Type] -> ([Type], [Type])

Given a TyCon and a list of argument types, partition the arguments into:

1. Inferred or Specified (i.e., invisible) arguments and
2. Required (i.e., visible) arguments

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]

checkRecTc :: RecTcChecker -> TyCon -> Maybe RecTcChecker

setRecTcMaxBound :: Int -> RecTcChecker -> RecTcChecker

Change the upper bound for the number of times a RecTcChecker is allowed to encounter each TyCon.

defaultRecTcMaxBound :: Int

The default upper bound (100) for the number of times a RecTcChecker is allowed to encounter each TyCon.

initRecTc :: RecTcChecker

Initialise a RecTcChecker with defaultRecTcMaxBound.

pprPromotionQuote :: TyCon -> SDoc

tcFlavourIsOpen :: TyConFlavour -> Bool

Is this flavour of TyCon an open type family or a data family?

tyConFlavour :: TyCon -> TyConFlavour

mkTyConTagMap :: TyCon -> NameEnv ConTag

tyConRuntimeRepInfo :: TyCon -> RuntimeRepInfo

Extract any RuntimeRepInfo from this TyCon

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

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

tyConFamInstSig_maybe :: TyCon -> Maybe (TyCon, [Type], CoAxiom Unbranched)

isFamInstTyCon :: TyCon -> Bool

Is this TyCon that for a data family instance?

tyConATs :: TyCon -> [TyCon]

Return the associated types of the TyCon, if any

tyConClass_maybe :: TyCon -> Maybe Class

If this TyCon is that for a class instance, return the class it is for. Otherwise returns Nothing

isClassTyCon :: TyCon -> Bool

Is this TyCon that for a class instance?

famTyConFlav_maybe :: TyCon -> Maybe FamTyConFlav

Extract the flavour of a type family (with all the extra information that it carries)

synTyConRhs_maybe :: TyCon -> Maybe Type

Extract the information pertaining to the right hand side of a type synonym (type) declaration.

synTyConDefn_maybe :: TyCon -> Maybe ([TyVar], Type)

Extract the TyVars bound by a vanilla type synonym and the corresponding (unsubstituted) right hand side.

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 ...

newTyConDataCon_maybe :: TyCon -> Maybe DataCon

newTyConCo :: TyCon -> CoAxiom Unbranched

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

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

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.

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

tyConRoles :: TyCon -> [Role]

Get the list of roles for the type parameters of a TyCon

tyConFamilyResVar_maybe :: TyCon -> Maybe Name

Extract type variable naming the result of injective type family

algTyConRhs :: TyCon -> AlgTyConRhs

Extract an AlgTyConRhs with information about data constructors from an algebraic or tuple TyCon. Panics for any other sort of TyCon

tyConFamilySize :: TyCon -> Int

Determine the number of value constructors a TyCon has. Panics if the TyCon is not algebraic or a tuple

tyConSingleAlgDataCon_maybe :: TyCon -> Maybe DataCon

tyConSingleDataCon :: TyCon -> DataCon

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. In any other case, the function panics

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)

tyConDataCons :: TyCon -> [DataCon]

As tyConDataCons_maybe, but returns the empty list of constructors if no constructors could be found

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.

expandSynTyCon_maybe

Arguments

:: TyCon

-> [tyco]

Arguments to TyCon

-> Maybe ([(TyVar, tyco)], Type, [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, if any

isTcLevPoly :: TyCon -> Bool

Could this TyCon ever be levity-polymorphic when fully applied? True is safe. False means we're sure. Does only a quick check based on the TyCon's category. Precondition: The fully-applied TyCon has kind (TYPE blah)

setTcTyConKind :: TyCon -> Kind -> TyCon

isTcTyCon :: TyCon -> Bool

Is this a TcTyCon? (That is, one only used during type-checking?)

tyConCType_maybe :: TyCon -> Maybe CType

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)

isLiftedTypeKindTyConName :: Name -> Bool

isKindTyCon :: TyCon -> Bool

Is this tycon really meant for use at the kind level? That is, should it be permitted without -XDataKinds?

isPromotedDataCon_maybe :: TyCon -> Maybe DataCon

Retrieves the promoted DataCon if this is a PromotedDataCon;

isPromotedDataCon :: TyCon -> Bool

Is this a PromotedDataCon?

isPromotedTupleTyCon :: TyCon -> Bool

Is this the TyCon for a promoted tuple?

isUnboxedSumTyCon :: TyCon -> Bool

Is this the TyCon for an unboxed sum?

isBoxedTupleTyCon :: TyCon -> Bool

Is this the TyCon for a boxed tuple?

tyConTuple_maybe :: TyCon -> Maybe TupleSort

tyConFlavourAssoc_maybe :: TyConFlavour -> Maybe TyCon

Get the enclosing class TyCon (if there is one) for the given TyConFlavour

tyConAssoc_maybe :: TyCon -> Maybe TyCon

Get the enclosing class TyCon (if there is one) for the given TyCon.

isTyConAssoc :: TyCon -> Bool

Is this TyCon for an associated type?

isBuiltInSynFamTyCon_maybe :: TyCon -> Maybe BuiltInSynFamily

tyConInjectivityInfo :: TyCon -> Injectivity

tyConInjectivityInfo tc returns Injective is is tc is an injective tycon (where is states for which tyConBinders tc is injective), or NotInjective otherwise.

isClosedSynFamilyTyConWithAxiom_maybe :: TyCon -> Maybe (CoAxiom Branched)

Is this a non-empty closed type family? Returns Nothing for abstract or empty closed families.

isOpenTypeFamilyTyCon :: TyCon -> Bool

Is this an open type family TyCon?

isDataFamilyTyCon :: TyCon -> Bool

Is this a synonym TyCon that can have may have further instances appear?

isTypeFamilyTyCon :: TyCon -> Bool

Is this a synonym TyCon that can have may have further instances appear?

isOpenFamilyTyCon :: TyCon -> Bool

Is this a TyCon, synonym or otherwise, that defines a family with instances?

isFamilyTyCon :: TyCon -> Bool

Is this a TyCon, synonym or otherwise, that defines a family?

isEnumerationTyCon :: TyCon -> Bool

Is this an algebraic TyCon which is just an enumeration of values?

isGadtSyntaxTyCon :: TyCon -> Bool

Is this an algebraic TyCon declared with the GADT syntax?

mustBeSaturated :: 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 mustBeSaturated on a regular H98 type synonym, because you should probably have expanded it first But regardless, it's not decomposable

isFamFreeTyCon :: TyCon -> Bool

isTauTyCon :: TyCon -> Bool

isTypeSynonymTyCon :: TyCon -> Bool

Is this a TyCon representing a regular H98 type synonym (type)?

isDataSumTyCon_maybe :: TyCon -> Maybe [DataCon]

isDataProductTyCon_maybe :: TyCon -> Maybe DataCon

isProductTyCon :: TyCon -> Bool

unwrapNewTyConEtad_maybe :: TyCon -> Maybe ([TyVar], Type, CoAxiom Unbranched)

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.

isNewTyCon :: TyCon -> Bool

Is this TyCon that for a newtype

isGenInjAlgRhs :: AlgTyConRhs -> Bool

Is this an AlgTyConRhs of a TyCon that is generative and injective with respect to representational equality?

isGenerativeTyCon :: TyCon -> Role -> Bool

isGenerativeTyCon is true of TyCons for which this property holds (where X is the role passed in): If (T tys ~X t), then (t's head ~X T). See also Note [Decomposing equality] in TcCanonical

isInjectiveTyCon :: TyCon -> Role -> Bool

isInjectiveTyCon is true of TyCons for which this property holds (where X is the role passed in): If (T a1 b1 c1) ~X (T a2 b2 c2), then (a1 ~X1 a2), (b1 ~X2 b2), and (c1 ~X3 c2) (where X1, X2, and X3, are the roles given by tyConRolesX tc X) See also Note [Decomposing equality] in TcCanonical

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

isVanillaAlgTyCon :: TyCon -> Bool

Returns True for vanilla AlgTyCons -- that is, those created with a data or newtype declaration.

isAlgTyCon :: TyCon -> Bool

Returns True if the supplied TyCon resulted from either a data or newtype declaration

isUnliftedTyCon :: TyCon -> Bool

Is this TyCon unlifted (i.e. cannot contain bottom)? Note that this can only be true for primitive and unboxed-tuple TyCons

isPrimTyCon :: TyCon -> Bool

Does this TyCon represent something that cannot be defined in Haskell?

isAbstractTyCon :: TyCon -> Bool

Test if the TyCon is algebraic but abstract (invisible data constructors)

mkPromotedDataCon :: DataCon -> Name -> TyConRepName -> [TyConTyCoBinder] -> Kind -> [Role] -> RuntimeRepInfo -> 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

mkFamilyTyCon

Arguments

:: Name

-> [TyConBinder]

-> Kind

result kind

-> Maybe Name

-> FamTyConFlav

-> Maybe Class

-> Injectivity

-> TyCon

Create a type family TyCon

mkSynonymTyCon

Arguments

:: Name

-> [TyConBinder]

-> Kind

result kind

-> [Role]

-> Type

-> Bool

-> Bool

-> TyCon

Create a type synonym TyCon

mkLiftedPrimTyCon

Arguments

:: Name

-> [TyConBinder]

-> Kind

result kind

-> [Role]

-> TyCon

Create a lifted primitive TyCon such as RealWorld

mkKindTyCon

Arguments

:: Name

-> [TyConBinder]

-> Kind

result kind

-> [Role]

-> Name

-> TyCon

Kind constructors

mkPrimTyCon

Arguments

:: Name

-> [TyConBinder]

-> Kind

result kind, never levity-polymorphic

-> [Role]

-> TyCon

Create an unlifted primitive TyCon, such as Int#.

noTcTyConScopedTyVars :: [(Name, TcTyVar)]

No scoped type variables (to be used with mkTcTyCon).

mkTcTyCon

Arguments

:: Name

-> [TyConBinder]

-> Kind

result kind only

-> [(Name, TcTyVar)]

Scoped type variables; see Note [How TcTyCons work] in TcTyClsDecls

-> 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 TcTyClsDecls.

mkSumTyCon

Arguments

:: Name

-> [TyConBinder]

-> Kind

Kind of the resulting TyCon

-> Arity

Arity of the sum

-> [TyVar]

TyVars scoped over: see tyConTyVars

-> [DataCon]

-> AlgTyConFlav

-> TyCon

mkTupleTyCon

Arguments

:: Name

-> [TyConBinder]

-> Kind

Result kind of the TyCon

-> Arity

Arity of the tuple TyCon

-> DataCon

-> TupleSort

Whether the tuple is boxed or unboxed

-> AlgTyConFlav

-> TyCon

mkClassTyCon :: Name -> [TyConBinder] -> [Role] -> AlgTyConRhs -> Class -> Name -> TyCon

Simpler specialization of mkAlgTyCon for classes

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. Notably, you have to pass in the generic (in the -XGenerics sense) information about the type constructor - you can get hold of it easily (see Generics module)

mkFunTyCon :: Name -> [TyConBinder] -> Name -> TyCon

Given the name of the function type constructor and it's kind, create the corresponding TyCon. It is recommended to use funTyCon if you want this functionality

lookupTyConFieldLabel :: FieldLabelString -> TyCon -> Maybe FieldLabel

Look up a field label belonging to this TyCon

tyConFieldLabels :: TyCon -> [FieldLabel]

The labels for the fields of this particular TyCon

primRepIsFloat :: PrimRep -> Maybe Bool

Return if Rep stands for floating type, returns Nothing for vector types.

primElemRepSizeB :: PrimElemRep -> Int

primRepSizeB :: DynFlags -> 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 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 layed out.

primRepsCompatible :: DynFlags -> [PrimRep] -> [PrimRep] -> Bool

primRepCompatible :: DynFlags -> PrimRep -> PrimRep -> Bool

isGcPtrRep :: PrimRep -> Bool

isVoidRep :: PrimRep -> 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 TcTypeable in TcTypeable.

mkPrelTyConRepName :: Name -> TyConRepName

Make a Name for the Typeable representation of the given wired-in type

tyConRepName_maybe :: TyCon -> Maybe TyConRepName

isNoParent :: AlgTyConFlav -> Bool

visibleDataCons :: AlgTyConRhs -> [DataCon]

Both type classes as well as family instances imply implicit type constructors. These implicit type constructors refer to their parent structure (ie, the class or family from which they derive) using a type of the following form.

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!

mkDataTyConRhs :: [DataCon] -> AlgTyConRhs

tyConVisibleTyVars :: TyCon -> [TyVar]

tyConTyVarBinders :: [TyConBinder] -> [TyVarBinder]

mkTyConKind :: [TyConBinder] -> Kind -> Kind

isInvisibleTyConBinder :: VarBndr tv TyConBndrVis -> Bool

isVisibleTyConBinder :: VarBndr tv TyConBndrVis -> Bool

isNamedTyConBinder :: TyConBinder -> Bool

tyConBndrVisArgFlag :: TyConBndrVis -> ArgFlag

tyConBinderArgFlag :: TyConBinder -> ArgFlag

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

mkNamedTyConBinders :: ArgFlag -> [TyVar] -> [TyConBinder]

mkNamedTyConBinder :: ArgFlag -> TyVar -> TyConBinder

mkAnonTyConBinders :: AnonArgFlag -> [TyVar] -> [TyConBinder]

mkAnonTyConBinder :: AnonArgFlag -> TyVar -> TyConBinder

type TyConBinder = VarBndr TyVar TyConBndrVis

type TyConTyCoBinder = VarBndr TyCoVar TyConBndrVis

data TyConBndrVis

Constructors

NamedTCB ArgFlag

AnonTCB AnonArgFlag

Instances

Binary TyConBndrVis

Defined in TyCon

Methods

put_ :: BinHandle -> TyConBndrVis -> IO ()

put :: BinHandle -> TyConBndrVis -> IO (Bin TyConBndrVis)

get :: BinHandle -> IO TyConBndrVis

Outputable TyConBndrVis

Defined in TyCon

Methods

ppr :: TyConBndrVis -> SDoc

pprPrec :: Rational -> TyConBndrVis -> SDoc

Outputable tv => Outputable (VarBndr tv TyConBndrVis)

Defined in TyCon

Methods

ppr :: VarBndr tv TyConBndrVis -> SDoc

pprPrec :: Rational -> VarBndr tv TyConBndrVis -> SDoc

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 TyCons 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]

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 TyCons 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 newtypes do not exist at runtime so need a different representation type).

  The free TyVars 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 TyVars in this field may be shorter than the declared arity of the TyCon.

• nt_co :: CoAxiom Unbranched
• nt_lev_poly :: Bool

data RuntimeRepInfo

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 RepType

Constructors

NoRRI

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

data AlgTyConFlav

Constructors

VanillaAlgTyCon TyConRepName

An ordinary type constructor has no parent.

UnboxedAlgTyCon (Maybe TyConRepName)

An unboxed type constructor. The TyConRepName is a Maybe since 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 TyCoRep

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

Outputable AlgTyConFlav

Defined in TyCon

Methods

ppr :: AlgTyConFlav -> SDoc

pprPrec :: Rational -> AlgTyConFlav -> SDoc

data Injectivity

Constructors

NotInjective

Injective [Bool]

Instances

Eq Injectivity

Defined in TyCon

Methods

(==) :: Injectivity -> Injectivity -> Bool

(/=) :: Injectivity -> Injectivity -> Bool

Binary Injectivity

Defined in TyCon

Methods

put_ :: BinHandle -> Injectivity -> IO ()

put :: BinHandle -> Injectivity -> IO (Bin Injectivity)

get :: BinHandle -> IO Injectivity

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

Outputable FamTyConFlav

Defined in TyCon

Methods

ppr :: FamTyConFlav -> SDoc

pprPrec :: Rational -> FamTyConFlav -> SDoc

type TyConRepName = Name

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 RepType and Note [VoidRep] in 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 (with 32-bit words only)

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 (with 32-bit words only)

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

Show PrimRep

Defined in TyCon

Methods

showsPrec :: Int -> PrimRep -> ShowS

show :: PrimRep -> String

showList :: [PrimRep] -> ShowS

Outputable PrimRep

Defined in TyCon

Methods

ppr :: PrimRep -> SDoc

pprPrec :: Rational -> PrimRep -> SDoc

data PrimElemRep

Constructors

Int8ElemRep

Int16ElemRep

Int32ElemRep

Int64ElemRep

Word8ElemRep

Word16ElemRep

Word32ElemRep

Word64ElemRep

FloatElemRep

DoubleElemRep

Instances

Eq PrimElemRep

Defined in TyCon

Methods

(==) :: PrimElemRep -> PrimElemRep -> Bool

(/=) :: PrimElemRep -> PrimElemRep -> Bool

Show PrimElemRep

Defined in TyCon

Methods

showsPrec :: Int -> PrimElemRep -> ShowS

show :: PrimElemRep -> String

showList :: [PrimElemRep] -> ShowS

Outputable PrimElemRep

Defined in TyCon

Methods

ppr :: PrimElemRep -> SDoc

pprPrec :: Rational -> PrimElemRep -> SDoc

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

Eq TyConFlavour

Defined in TyCon

Methods

(==) :: TyConFlavour -> TyConFlavour -> Bool

(/=) :: TyConFlavour -> TyConFlavour -> Bool

Outputable TyConFlavour

Defined in TyCon

Methods

ppr :: TyConFlavour -> SDoc

pprPrec :: Rational -> TyConFlavour -> SDoc

data RecTcChecker

pprFunDep :: Outputable a => FunDep a -> SDoc

pprFundeps :: Outputable a => [FunDep a] -> SDoc

pprDefMethInfo :: DefMethInfo -> SDoc

isAbstractClass :: Class -> Bool

classExtraBigSig :: Class -> ([TyVar], [FunDep TyVar], [PredType], [Id], [ClassATItem], [ClassOpItem])

classBigSig :: Class -> ([TyVar], [PredType], [Id], [ClassOpItem])

classHasFds :: Class -> Bool

classTvsFds :: Class -> ([TyVar], [FunDep TyVar])

classSCTheta :: Class -> [PredType]

classATItems :: Class -> [ClassATItem]

classATs :: Class -> [TyCon]

classOpItems :: Class -> [ClassOpItem]

classMethods :: Class -> [Id]

classSCSelId :: Class -> Int -> Id

classSCSelIds :: Class -> [Id]

classAllSelIds :: Class -> [Id]

classArity :: Class -> Arity

mkAbstractClass :: Name -> [TyVar] -> [FunDep TyVar] -> TyCon -> Class

mkClass :: Name -> [TyVar] -> [FunDep TyVar] -> [PredType] -> [Id] -> [ClassATItem] -> [ClassOpItem] -> ClassMinimalDef -> TyCon -> Class

classMinimalDef :: Class -> ClassMinimalDef

data Class

Instances

Eq Class

Defined in Class

Methods

(==) :: Class -> Class -> Bool

(/=) :: Class -> Class -> Bool

Data Class

Defined in Class

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Class -> c Class

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Class

toConstr :: Class -> Constr

dataTypeOf :: Class -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Class)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Class)

gmapT :: (forall b. Data b => b -> b) -> Class -> Class

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Class -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Class -> r

gmapQ :: (forall d. Data d => d -> u) -> Class -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Class -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Class -> m Class

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Class -> m Class

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Class -> m Class

Show Class

Defined in Language.Haskell.Liquid.GHC.Misc

Methods

showsPrec :: Int -> Class -> ShowS

show :: Class -> String

showList :: [Class] -> ShowS

NFData Class

Defined in Language.Haskell.Liquid.GHC.Misc

Methods

rnf :: Class -> ()

NamedThing Class

Defined in Class

Methods

getOccName :: Class -> OccName

getName :: Class -> Name

Uniquable Class

Defined in Class

Methods

getUnique :: Class -> Unique

Outputable Class

Defined in Class

Methods

ppr :: Class -> SDoc

pprPrec :: Rational -> Class -> SDoc

Symbolic Class

Defined in Language.Haskell.Liquid.GHC.Misc

Methods

symbol :: Class -> Symbol

Fixpoint Class

Defined in Language.Haskell.Liquid.Types.RefType

Methods

toFix :: Class -> Doc

simplify :: Class -> Class

PPrint Class

Defined in Language.Haskell.Liquid.Types.PrettyPrint

Methods

pprintTidy :: Tidy -> Class -> Doc

pprintPrec :: Int -> Tidy -> Class -> Doc

type FunDep a = ([a], [a])

type ClassOpItem = (Id, DefMethInfo)

type DefMethInfo = Maybe (Name, DefMethSpec Type)

data ClassATItem

Constructors

ATI TyCon (Maybe (Type, SrcSpan))

type ClassMinimalDef = BooleanFormula Name

data Role

Constructors

Nominal

Representational

Phantom

Instances

Eq Role

Defined in CoAxiom

Methods

(==) :: Role -> Role -> Bool

(/=) :: Role -> Role -> Bool

Data Role

Defined in CoAxiom

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

Ord Role

Defined in CoAxiom

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

Binary Role

Defined in CoAxiom

Methods

put_ :: BinHandle -> Role -> IO ()

put :: BinHandle -> Role -> IO (Bin Role)

get :: BinHandle -> IO Role

Outputable Role

Defined in CoAxiom

Methods

ppr :: Role -> SDoc

pprPrec :: Rational -> Role -> SDoc

conLikeName :: ConLike -> Name

data ConLike

A constructor-like thing

Constructors

RealDataCon DataCon

PatSynCon PatSyn

Instances

Eq ConLike

Defined in ConLike

Methods

(==) :: ConLike -> ConLike -> Bool

(/=) :: ConLike -> ConLike -> Bool

Data ConLike

Defined in ConLike

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConLike -> c ConLike

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ConLike

toConstr :: ConLike -> Constr

dataTypeOf :: ConLike -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ConLike)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConLike)

gmapT :: (forall b. Data b => b -> b) -> ConLike -> ConLike

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConLike -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConLike -> r

gmapQ :: (forall d. Data d => d -> u) -> ConLike -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ConLike -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConLike -> m ConLike

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConLike -> m ConLike

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConLike -> m ConLike

NamedThing ConLike

Defined in ConLike

Methods

getOccName :: ConLike -> OccName

getName :: ConLike -> Name

Uniquable ConLike

Defined in ConLike

Methods

getUnique :: ConLike -> Unique

Outputable ConLike

Defined in ConLike

Methods

ppr :: ConLike -> SDoc

pprPrec :: Rational -> ConLike -> SDoc

OutputableBndr ConLike

Defined in ConLike

Methods

pprBndr :: BindingSite -> ConLike -> SDoc

pprPrefixOcc :: ConLike -> SDoc

pprInfixOcc :: ConLike -> SDoc

bndrIsJoin_maybe :: ConLike -> Maybe Int

dataConName :: DataCon -> Name

The Name of the DataCon, giving it a unique, rooted identification

dataConTyCon :: DataCon -> TyCon

The type constructor that we are building via this data constructor

dataConExTyCoVars :: DataCon -> [TyCoVar]

The existentially-quantified type/coercion variables of the constructor including dependent (kind-) GADT equalities

dataConUserTyVars :: DataCon -> [TyVar]

The type variables of the constructor, in the order the user wrote them

dataConUserTyVarBinders :: DataCon -> [TyVarBinder]

TyCoVarBinders for the type variables of the constructor, in the order the user wrote them

dataConSourceArity :: DataCon -> Arity

Source-level arity of the data constructor

dataConFieldLabels :: DataCon -> [FieldLabel]

The labels for the fields of this particular DataCon

dataConInstOrigArgTys :: DataCon -> [Type] -> [Type]

Returns just the instantiated value argument types of a DataCon, (excluding dictionary args)

dataConStupidTheta :: DataCon -> ThetaType

The "stupid theta" of the DataCon, such as data Eq a in:

data Eq a => T a = ...

dataConFullSig :: DataCon -> ([TyVar], [TyCoVar], [EqSpec], ThetaType, [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)

6) The original result type of the DataCon

isUnboxedSumCon :: DataCon -> Bool

data DataCon

A data constructor

• AnnKeywordId : AnnOpen, AnnClose,AnnComma

Instances

Eq DataCon

Defined in DataCon

Methods

(==) :: DataCon -> DataCon -> Bool

(/=) :: DataCon -> DataCon -> Bool

Data DataCon

Defined in DataCon

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DataCon -> c DataCon

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DataCon

toConstr :: DataCon -> Constr

dataTypeOf :: DataCon -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DataCon)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataCon)

gmapT :: (forall b. Data b => b -> b) -> DataCon -> DataCon

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DataCon -> r

gmapQr :: 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

Ord DataCon

Defined in Language.Haskell.Liquid.Types.Types

Methods

compare :: DataCon -> DataCon -> Ordering

(<) :: DataCon -> DataCon -> Bool

(<=) :: DataCon -> DataCon -> Bool

(>) :: DataCon -> DataCon -> Bool

(>=) :: DataCon -> DataCon -> Bool

max :: DataCon -> DataCon -> DataCon

min :: DataCon -> DataCon -> DataCon

Show DataCon

Defined in Language.Haskell.Liquid.Types.Types

Methods

showsPrec :: Int -> DataCon -> ShowS

show :: DataCon -> String

showList :: [DataCon] -> ShowS

NamedThing DataCon

Defined in DataCon

Methods

getOccName :: DataCon -> OccName

getName :: DataCon -> Name

Uniquable DataCon

Defined in DataCon

Methods

getUnique :: DataCon -> Unique

Outputable DataCon

Defined in DataCon

Methods

ppr :: DataCon -> SDoc

pprPrec :: Rational -> DataCon -> SDoc

OutputableBndr DataCon

Defined in DataCon

Methods

pprBndr :: BindingSite -> DataCon -> SDoc

pprPrefixOcc :: DataCon -> SDoc

pprInfixOcc :: DataCon -> SDoc

bndrIsJoin_maybe :: DataCon -> Maybe Int

Symbolic DataCon

Defined in Language.Haskell.Liquid.Types.Types

Methods

symbol :: DataCon -> Symbol

PPrint DataCon

Defined in Language.Haskell.Liquid.Types.Types

Methods

pprintTidy :: Tidy -> DataCon -> Doc

pprintPrec :: Int -> Tidy -> DataCon -> Doc

Hashable DataCon

Defined in Language.Haskell.Liquid.GHC.Misc

Methods

hashWithSalt :: Int -> DataCon -> Int

hash :: DataCon -> Int

ResolveSym DataCon

Defined in Language.Haskell.Liquid.Bare.Resolve

Methods

resolveLocSym :: Env -> ModName -> String -> LocSymbol -> Either UserError DataCon

Qualify (Measure SpecType DataCon)

Defined in Language.Haskell.Liquid.Bare.Resolve

Methods

qualify :: Env -> ModName -> SourcePos -> [Symbol] -> Measure SpecType DataCon -> Measure SpecType DataCon

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 :: [Type]
• dcr_stricts :: [StrictnessMark]
• dcr_bangs :: [HsImplBang]

data EqSpec

An EqSpec is a tyvar/type pair representing an equality made in rejigging a GADT constructor

Instances

Outputable EqSpec

Defined in DataCon

Methods

ppr :: EqSpec -> SDoc

pprPrec :: Rational -> EqSpec -> SDoc

pprLExpr :: forall (p :: Pass). OutputableBndrId p => LHsExpr (GhcPass p) -> SDoc

pprExpr :: forall (p :: Pass). OutputableBndrId p => HsExpr (GhcPass p) -> SDoc

pprSplice :: forall (p :: Pass). OutputableBndrId p => HsSplice (GhcPass p) -> SDoc

pprSpliceDecl :: forall (p :: Pass). OutputableBndrId p => HsSplice (GhcPass p) -> SpliceExplicitFlag -> SDoc

pprPatBind :: forall (bndr :: Pass) (p :: Pass) body. (OutputableBndrId bndr, OutputableBndrId p, Outputable body) => LPat (GhcPass bndr) -> GRHSs (GhcPass p) body -> SDoc

pprFunBind :: forall (idR :: Pass) body. (OutputableBndrId idR, Outputable body) => MatchGroup (GhcPass idR) body -> SDoc

data HsExpr p

A Haskell expression.

Constructors

HsVar (XVar p) (Located (IdP p))

Variable

HsUnboundVar (XUnboundVar p) UnboundVar

Unbound variable; also used for "holes" (_ or _x). Turned from HsVar to HsUnboundVar by the renamer, when it finds an out-of-scope variable or hole. Turned into HsVar by type checker, to support deferred type errors.

HsConLikeOut (XConLikeOut p) ConLike

After typechecker only; must be different HsVar for pretty printing

HsRecFld (XRecFld p) (AmbiguousFieldOcc p)

Variable pointing to record selector Not in use after typechecking

HsOverLabel (XOverLabel p) (Maybe (IdP p)) FastString

Overloaded label (Note [Overloaded labels] in GHC.OverloadedLabels) Just id means RebindableSyntax is in use, and gives the id of the in-scope fromLabel. NB: Not in use after typechecking

HsIPVar (XIPVar p) HsIPName

Implicit parameter (not in use after typechecking)

HsOverLit (XOverLitE p) (HsOverLit p)

Overloaded literals

HsLit (XLitE p) (HsLit p)

Simple (non-overloaded) literals

HsLam (XLam p) (MatchGroup p (LHsExpr p))

Lambda abstraction. Currently always a single match

• AnnKeywordId : AnnLam, AnnRarrow,

HsLamCase (XLamCase p) (MatchGroup p (LHsExpr p))

Lambda-case

• AnnKeywordId : AnnLam, AnnCase,AnnOpen, AnnClose

HsApp (XApp p) (LHsExpr p) (LHsExpr p)

Application

HsAppType (XAppTypeE p) (LHsExpr p) (LHsWcType (NoGhcTc p))

Visible type application

Explicit type argument; e.g f @Int x y NB: Has wildcards, but no implicit quantification

• AnnKeywordId : AnnAt,

OpApp (XOpApp p) (LHsExpr p) (LHsExpr p) (LHsExpr p)

Operator applications: NB Bracketed ops such as (+) come out as Vars.

NegApp (XNegApp p) (LHsExpr p) (SyntaxExpr p)

Negation operator. Contains the negated expression and the name of negate

• AnnKeywordId : AnnMinus

HsPar (XPar p) (LHsExpr p)

Parenthesised expr; see Note [Parens in HsSyn]

SectionL (XSectionL p) (LHsExpr p) (LHsExpr p)

SectionR (XSectionR p) (LHsExpr p) (LHsExpr p)

ExplicitTuple (XExplicitTuple p) [LHsTupArg p] Boxity

Used for explicit tuples and sections thereof

• AnnKeywordId : AnnOpen, AnnClose

ExplicitSum (XExplicitSum p) ConTag Arity (LHsExpr p)

Used for unboxed sum types

• AnnKeywordId : AnnOpen '(#', AnnVbar, AnnClose '#)',

There will be multiple AnnVbar, (1 - alternative) before the expression, (arity - alternative) after it

HsCase (XCase p) (LHsExpr p) (MatchGroup p (LHsExpr p))

• AnnKeywordId : AnnCase, AnnOf,AnnOpen '{', AnnClose '}'

HsIf (XIf p) (Maybe (SyntaxExpr p)) (LHsExpr p) (LHsExpr p) (LHsExpr p)

• AnnKeywordId : AnnIf, AnnSemi, AnnThen,AnnSemi, AnnElse,

HsMultiIf (XMultiIf p) [LGRHS p (LHsExpr p)]

Multi-way if

• AnnKeywordId : AnnIf AnnOpen,AnnClose,

HsLet (XLet p) (LHsLocalBinds p) (LHsExpr p)

let(rec)

• AnnKeywordId : AnnLet, AnnOpen '{', AnnClose '}',AnnIn

HsDo (XDo p) (HsStmtContext Name) (Located [ExprLStmt p])

• AnnKeywordId : AnnDo, AnnOpen, AnnSemi, AnnVbar, AnnClose

ExplicitList (XExplicitList p) (Maybe (SyntaxExpr p)) [LHsExpr p]

Syntactic list: [a,b,c,...]

• AnnKeywordId : AnnOpen '[', AnnClose ']'

RecordCon

Record construction

• AnnKeywordId : AnnOpen '{', AnnDotdot,AnnClose '}'

Fields

• rcon_ext :: XRecordCon p
• rcon_con_name :: Located (IdP p)
• rcon_flds :: HsRecordBinds p

RecordUpd

Record update

• AnnKeywordId : AnnOpen '{', AnnDotdot,AnnClose '}'

Fields

• rupd_ext :: XRecordUpd p
• rupd_expr :: LHsExpr p
• rupd_flds :: [LHsRecUpdField p]

ExprWithTySig (XExprWithTySig p) (LHsExpr p) (LHsSigWcType (NoGhcTc p))

Expression with an explicit type signature. e :: type

• AnnKeywordId : AnnDcolon

ArithSeq (XArithSeq p) (Maybe (SyntaxExpr p)) (ArithSeqInfo p)

Arithmetic sequence

• AnnKeywordId : AnnOpen '[', AnnComma,AnnDotdot, AnnClose ']'

HsSCC (XSCC p) SourceText StringLiteral (LHsExpr p)

HsCoreAnn (XCoreAnn p) SourceText StringLiteral (LHsExpr p)

• AnnKeywordId : AnnOpen '{-# CORE', AnnVal, AnnClose '#-}'

HsBracket (XBracket p) (HsBracket p)

• AnnKeywordId : AnnOpen, AnnOpenE,AnnOpenEQ, AnnClose,AnnCloseQ

HsRnBracketOut (XRnBracketOut p) (HsBracket GhcRn) [PendingRnSplice]

HsTcBracketOut (XTcBracketOut p) (HsBracket GhcRn) [PendingTcSplice]

HsSpliceE (XSpliceE p) (HsSplice p)

• AnnKeywordId : AnnOpen, AnnClose

HsProc (XProc p) (LPat p) (LHsCmdTop p)

proc notation for Arrows

• AnnKeywordId : AnnProc, AnnRarrow

HsStatic (XStatic p) (LHsExpr p)

• AnnKeywordId : AnnStatic,

HsTick (XTick p) (Tickish (IdP p)) (LHsExpr p)

HsBinTick (XBinTick p) Int Int (LHsExpr p)

HsTickPragma (XTickPragma p) SourceText (StringLiteral, (Int, Int), (Int, Int)) ((SourceText, SourceText), (SourceText, SourceText)) (LHsExpr p)

• AnnKeywordId : AnnOpen, AnnOpen '{-# GENERATED', AnnVal,AnnVal, AnnColon,AnnVal, AnnMinus, AnnVal,AnnColon, AnnVal, AnnClose '#-}'

HsWrap (XWrap p) HsWrapper (HsExpr p)

XExpr (XXExpr p)

Instances

p ~ GhcPs => DisambInfixOp (HsExpr p)

Defined in RdrHsSyn

Methods

mkHsVarOpPV :: Located RdrName -> PV (Located (HsExpr p))

mkHsConOpPV :: Located RdrName -> PV (Located (HsExpr p))

mkHsInfixHolePV :: SrcSpan -> PV (Located (HsExpr p))

p ~ GhcPs => DisambECP (HsExpr p)

Defined in RdrHsSyn

Associated Types

type Body (HsExpr p) :: Type -> Type

type InfixOp (HsExpr p)

type FunArg (HsExpr p)

Methods

ecpFromCmd' :: LHsCmd GhcPs -> PV (Located (HsExpr p))

ecpFromExp' :: LHsExpr GhcPs -> PV (Located (HsExpr p))

mkHsLamPV :: SrcSpan -> MatchGroup GhcPs (Located (HsExpr p)) -> PV (Located (HsExpr p))

mkHsLetPV :: SrcSpan -> LHsLocalBinds GhcPs -> Located (HsExpr p) -> PV (Located (HsExpr p))

superInfixOp :: (DisambInfixOp (InfixOp (HsExpr p)) => PV (Located (HsExpr p))) -> PV (Located (HsExpr p))

mkHsOpAppPV :: SrcSpan -> Located (HsExpr p) -> Located (InfixOp (HsExpr p)) -> Located (HsExpr p) -> PV (Located (HsExpr p))

mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> MatchGroup GhcPs (Located (HsExpr p)) -> PV (Located (HsExpr p))

superFunArg :: (DisambECP (FunArg (HsExpr p)) => PV (Located (HsExpr p))) -> PV (Located (HsExpr p))

mkHsAppPV :: SrcSpan -> Located (HsExpr p) -> Located (FunArg (HsExpr p)) -> PV (Located (HsExpr p))

mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> Located (HsExpr p) -> Bool -> Located (HsExpr p) -> PV (Located (HsExpr p))

mkHsDoPV :: SrcSpan -> Located [LStmt GhcPs (Located (HsExpr p))] -> PV (Located (HsExpr p))

mkHsParPV :: SrcSpan -> Located (HsExpr p) -> PV (Located (HsExpr p))

mkHsVarPV :: Located RdrName -> PV (Located (HsExpr p))

mkHsLitPV :: Located (HsLit GhcPs) -> PV (Located (HsExpr p))

mkHsOverLitPV :: Located (HsOverLit GhcPs) -> PV (Located (HsExpr p))

mkHsWildCardPV :: SrcSpan -> PV (Located (HsExpr p))

mkHsTySigPV :: SrcSpan -> Located (HsExpr p) -> LHsType GhcPs -> PV (Located (HsExpr p))

mkHsExplicitListPV :: SrcSpan -> [Located (HsExpr p)] -> PV (Located (HsExpr p))

mkHsSplicePV :: Located (HsSplice GhcPs) -> PV (Located (HsExpr p))

mkHsRecordPV :: SrcSpan -> SrcSpan -> Located (HsExpr p) -> ([LHsRecField GhcPs (Located (HsExpr p))], Maybe SrcSpan) -> PV (Located (HsExpr p))

mkHsNegAppPV :: SrcSpan -> Located (HsExpr p) -> PV (Located (HsExpr p))

mkHsSectionR_PV :: SrcSpan -> Located (InfixOp (HsExpr p)) -> Located (HsExpr p) -> PV (Located (HsExpr p))

mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> Located (HsExpr p) -> PV (Located (HsExpr p))

mkHsAsPatPV :: SrcSpan -> Located RdrName -> Located (HsExpr p) -> PV (Located (HsExpr p))

mkHsLazyPatPV :: SrcSpan -> Located (HsExpr p) -> PV (Located (HsExpr p))

mkSumOrTuplePV :: SrcSpan -> Boxity -> SumOrTuple (HsExpr p) -> PV (Located (HsExpr p))

OutputableBndrId p => Outputable (HsExpr (GhcPass p))

Defined in GHC.Hs.Expr

Methods

ppr :: HsExpr (GhcPass p) -> SDoc

pprPrec :: Rational -> HsExpr (GhcPass p) -> SDoc

type FunArg (HsExpr p)

Defined in RdrHsSyn

type FunArg (HsExpr p) = HsExpr p

type InfixOp (HsExpr p)

Defined in RdrHsSyn

type InfixOp (HsExpr p) = HsExpr p

type Body (HsExpr p)

Defined in RdrHsSyn

type Body (HsExpr p) = HsExpr

data HsCmd id

Haskell Command (e.g. a "statement" in an Arrow proc block)

Constructors

HsCmdArrApp (XCmdArrApp id) (LHsExpr id) (LHsExpr id) HsArrAppType Bool

• AnnKeywordId : Annlarrowtail, Annrarrowtail,AnnLarrowtail, AnnRarrowtail

HsCmdArrForm (XCmdArrForm id) (LHsExpr id) LexicalFixity (Maybe Fixity) [LHsCmdTop id]

• AnnKeywordId : AnnOpenB '(|', AnnCloseB '|)'

HsCmdApp (XCmdApp id) (LHsCmd id) (LHsExpr id)

HsCmdLam (XCmdLam id) (MatchGroup id (LHsCmd id))

• AnnKeywordId : AnnLam, AnnRarrow,

HsCmdPar (XCmdPar id) (LHsCmd id)

• AnnKeywordId : AnnOpen '(', AnnClose ')'

HsCmdCase (XCmdCase id) (LHsExpr id) (MatchGroup id (LHsCmd id))

• AnnKeywordId : AnnCase, AnnOf,AnnOpen '{', AnnClose '}'

HsCmdIf (XCmdIf id) (Maybe (SyntaxExpr id)) (LHsExpr id) (LHsCmd id) (LHsCmd id)

• AnnKeywordId : AnnIf, AnnSemi, AnnThen,AnnSemi, AnnElse,

HsCmdLet (XCmdLet id) (LHsLocalBinds id) (LHsCmd id)

• AnnKeywordId : AnnLet, AnnOpen '{', AnnClose '}',AnnIn

HsCmdDo (XCmdDo id) (Located [CmdLStmt id])

• AnnKeywordId : AnnDo, AnnOpen, AnnSemi, AnnVbar, AnnClose

HsCmdWrap (XCmdWrap id) HsWrapper (HsCmd id)

XCmd (XXCmd id)

Instances

p ~ GhcPs => DisambECP (HsCmd p)

Defined in RdrHsSyn

Associated Types

type Body (HsCmd p) :: Type -> Type

type InfixOp (HsCmd p)

type FunArg (HsCmd p)

Methods

ecpFromCmd' :: LHsCmd GhcPs -> PV (Located (HsCmd p))

ecpFromExp' :: LHsExpr GhcPs -> PV (Located (HsCmd p))

mkHsLamPV :: SrcSpan -> MatchGroup GhcPs (Located (HsCmd p)) -> PV (Located (HsCmd p))

mkHsLetPV :: SrcSpan -> LHsLocalBinds GhcPs -> Located (HsCmd p) -> PV (Located (HsCmd p))

superInfixOp :: (DisambInfixOp (InfixOp (HsCmd p)) => PV (Located (HsCmd p))) -> PV (Located (HsCmd p))

mkHsOpAppPV :: SrcSpan -> Located (HsCmd p) -> Located (InfixOp (HsCmd p)) -> Located (HsCmd p) -> PV (Located (HsCmd p))

mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> MatchGroup GhcPs (Located (HsCmd p)) -> PV (Located (HsCmd p))

superFunArg :: (DisambECP (FunArg (HsCmd p)) => PV (Located (HsCmd p))) -> PV (Located (HsCmd p))

mkHsAppPV :: SrcSpan -> Located (HsCmd p) -> Located (FunArg (HsCmd p)) -> PV (Located (HsCmd p))

mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> Located (HsCmd p) -> Bool -> Located (HsCmd p) -> PV (Located (HsCmd p))

mkHsDoPV :: SrcSpan -> Located [LStmt GhcPs (Located (HsCmd p))] -> PV (Located (HsCmd p))

mkHsParPV :: SrcSpan -> Located (HsCmd p) -> PV (Located (HsCmd p))

mkHsVarPV :: Located RdrName -> PV (Located (HsCmd p))

mkHsLitPV :: Located (HsLit GhcPs) -> PV (Located (HsCmd p))

mkHsOverLitPV :: Located (HsOverLit GhcPs) -> PV (Located (HsCmd p))

mkHsWildCardPV :: SrcSpan -> PV (Located (HsCmd p))

mkHsTySigPV :: SrcSpan -> Located (HsCmd p) -> LHsType GhcPs -> PV (Located (HsCmd p))

mkHsExplicitListPV :: SrcSpan -> [Located (HsCmd p)] -> PV (Located (HsCmd p))

mkHsSplicePV :: Located (HsSplice GhcPs) -> PV (Located (HsCmd p))

mkHsRecordPV :: SrcSpan -> SrcSpan -> Located (HsCmd p) -> ([LHsRecField GhcPs (Located (HsCmd p))], Maybe SrcSpan) -> PV (Located (HsCmd p))

mkHsNegAppPV :: SrcSpan -> Located (HsCmd p) -> PV (Located (HsCmd p))

mkHsSectionR_PV :: SrcSpan -> Located (InfixOp (HsCmd p)) -> Located (HsCmd p) -> PV (Located (HsCmd p))

mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> Located (HsCmd p) -> PV (Located (HsCmd p))

mkHsAsPatPV :: SrcSpan -> Located RdrName -> Located (HsCmd p) -> PV (Located (HsCmd p))

mkHsLazyPatPV :: SrcSpan -> Located (HsCmd p) -> PV (Located (HsCmd p))

mkSumOrTuplePV :: SrcSpan -> Boxity -> SumOrTuple (HsCmd p) -> PV (Located (HsCmd p))

OutputableBndrId p => Outputable (HsCmd (GhcPass p))

Defined in GHC.Hs.Expr

Methods

ppr :: HsCmd (GhcPass p) -> SDoc

pprPrec :: Rational -> HsCmd (GhcPass p) -> SDoc

type FunArg (HsCmd p)

Defined in RdrHsSyn

type FunArg (HsCmd p) = HsExpr p

type InfixOp (HsCmd p)

Defined in RdrHsSyn

type InfixOp (HsCmd p) = HsExpr p

type Body (HsCmd p)

Defined in RdrHsSyn

type Body (HsCmd p) = HsCmd

data HsSplice id

Haskell Splice

Constructors

HsTypedSplice (XTypedSplice id) SpliceDecoration (IdP id) (LHsExpr id)

HsUntypedSplice (XUntypedSplice id) SpliceDecoration (IdP id) (LHsExpr id)

HsQuasiQuote (XQuasiQuote id) (IdP id) (IdP id) SrcSpan FastString

HsSpliced (XSpliced id) ThModFinalizers (HsSplicedThing id)

HsSplicedT DelayedSplice

XSplice (XXSplice id)

Instances

OutputableBndrId p => Outputable (HsSplice (GhcPass p))

Defined in GHC.Hs.Expr

Methods

ppr :: HsSplice (GhcPass p) -> SDoc

pprPrec :: Rational -> HsSplice (GhcPass p) -> SDoc

data MatchGroup p body

Constructors

MG

Fields

• mg_ext :: XMG p body
• mg_alts :: Located [LMatch p body]
• mg_origin :: Origin

XMatchGroup (XXMatchGroup p body)

data GRHSs p body

Guarded Right-Hand Sides

GRHSs are used both for pattern bindings and for Matches

• AnnKeywordId : AnnVbar, AnnEqual,AnnWhere, AnnOpen,AnnClose AnnRarrow,AnnSemi

Constructors

GRHSs

Fields

• grhssExt :: XCGRHSs p body
• grhssGRHSs :: [LGRHS p body]

  Guarded RHSs

• grhssLocalBinds :: LHsLocalBinds p

  The where clause

XGRHSs (XXGRHSs p body)

data SyntaxExpr p

Syntax Expression

SyntaxExpr is like PostTcExpr, but it's filled in a little earlier, by the renamer. It's used for rebindable syntax.

E.g. (>>=) is filled in before the renamer by the appropriate Name for (>>=), and then instantiated by the type checker with its type args etc

This should desugar to

syn_res_wrap $ syn_expr (syn_arg_wraps[0] arg0)
                        (syn_arg_wraps[1] arg1) ...

where the actual arguments come from elsewhere in the AST. This could be defined using GhcPass p and such, but it's harder to get it all to work out that way. (noSyntaxExpr is hard to write, for example.)

Constructors

SyntaxExpr

Fields

• syn_expr :: HsExpr p
• syn_arg_wraps :: [HsWrapper]
• syn_res_wrap :: HsWrapper

Instances

OutputableBndrId p => Outputable (SyntaxExpr (GhcPass p))

Defined in GHC.Hs.Expr

Methods

ppr :: SyntaxExpr (GhcPass p) -> SDoc

pprPrec :: Rational -> SyntaxExpr (GhcPass p) -> SDoc

type LHsExpr p

Arguments

 = Located (HsExpr p)

May have AnnKeywordId : AnnComma when in a list

Located Haskell Expression

pprImpExp :: (HasOccName name, OutputableBndr name) => name -> SDoc

replaceLWrappedName :: LIEWrappedName name1 -> name2 -> LIEWrappedName name2

replaceWrappedName :: IEWrappedName name1 -> name2 -> IEWrappedName name2

ieLWrappedName :: LIEWrappedName name -> Located name

lieWrappedName :: LIEWrappedName name -> name

ieWrappedName :: IEWrappedName name -> name

ieNames :: forall (p :: Pass). IE (GhcPass p) -> [IdP (GhcPass p)]

ieName :: forall (p :: Pass). IE (GhcPass p) -> IdP (GhcPass p)

simpleImportDecl :: forall (p :: Pass). ModuleName -> ImportDecl (GhcPass p)

isImportDeclQualified :: ImportDeclQualifiedStyle -> Bool

Convenience function to answer the question if an import decl. is qualified.

importDeclQualifiedStyle :: Maybe (Located a) -> Maybe (Located a) -> ImportDeclQualifiedStyle

Given two possible located qualified tokens, compute a style (in a conforming Haskell program only one of the two can be not Nothing). This is called from y.

type LImportDecl pass

Arguments

 = Located (ImportDecl pass)

When in a list this may have

• AnnKeywordId : AnnSemi

Located Import Declaration

data ImportDeclQualifiedStyle

If/how an import is qualified.

Constructors

QualifiedPre

qualified appears in prepositive position.

QualifiedPost

qualified appears in postpositive position.

NotQualified

Not qualified.

Instances

Eq ImportDeclQualifiedStyle

Defined in GHC.Hs.ImpExp

Methods

(==) :: ImportDeclQualifiedStyle -> ImportDeclQualifiedStyle -> Bool

(/=) :: ImportDeclQualifiedStyle -> ImportDeclQualifiedStyle -> Bool

Data ImportDeclQualifiedStyle

Defined in GHC.Hs.ImpExp

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImportDeclQualifiedStyle -> c ImportDeclQualifiedStyle

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ImportDeclQualifiedStyle

toConstr :: ImportDeclQualifiedStyle -> Constr

dataTypeOf :: ImportDeclQualifiedStyle -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ImportDeclQualifiedStyle)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImportDeclQualifiedStyle)

gmapT :: (forall b. Data b => b -> b) -> ImportDeclQualifiedStyle -> ImportDeclQualifiedStyle

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImportDeclQualifiedStyle -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImportDeclQualifiedStyle -> r

gmapQ :: (forall d. Data d => d -> u) -> ImportDeclQualifiedStyle -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ImportDeclQualifiedStyle -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImportDeclQualifiedStyle -> m ImportDeclQualifiedStyle

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportDeclQualifiedStyle -> m ImportDeclQualifiedStyle

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportDeclQualifiedStyle -> m ImportDeclQualifiedStyle

data ImportDecl pass

Import Declaration

A single Haskell import declaration.

Constructors

ImportDecl

Fields

• ideclExt :: XCImportDecl pass
• ideclSourceSrc :: SourceText
• ideclName :: Located ModuleName

  Module name.

• ideclPkgQual :: Maybe StringLiteral

  Package qualifier.

• ideclSource :: Bool

  True = {-# SOURCE #-} import

• ideclSafe :: Bool

  True => safe import

• ideclQualified :: ImportDeclQualifiedStyle

  If/how the import is qualified.

• ideclImplicit :: Bool

  True => implicit import (of Prelude)

• ideclAs :: Maybe (Located ModuleName)

  as Module

• ideclHiding :: Maybe (Bool, Located [LIE pass])

  (True => hiding, names)

XImportDecl (XXImportDecl pass)

AnnKeywordIds

• AnnImport
• AnnOpen, AnnClose for ideclSource
• AnnSafe,AnnQualified, AnnPackageName,AnnAs, AnnVal
• AnnHiding,AnnOpen, AnnClose attached to location in ideclHiding

Instances

OutputableBndrId p => Outputable (ImportDecl (GhcPass p))

Defined in GHC.Hs.ImpExp

Methods

ppr :: ImportDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> ImportDecl (GhcPass p) -> SDoc

data IEWrappedName name

A name in an import or export specification which may have adornments. Used primarily for accurate pretty printing of ParsedSource, and API Annotation placement.

Constructors

IEName (Located name)

no extra

IEPattern (Located name)

pattern X

IEType (Located name)

type (:+:)

Instances

Eq name => Eq (IEWrappedName name)

Defined in GHC.Hs.ImpExp

Methods

(==) :: IEWrappedName name -> IEWrappedName name -> Bool

(/=) :: IEWrappedName name -> IEWrappedName name -> Bool

Data name => Data (IEWrappedName name)

Defined in GHC.Hs.ImpExp

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IEWrappedName name -> c (IEWrappedName name)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (IEWrappedName name)

toConstr :: IEWrappedName name -> Constr

dataTypeOf :: IEWrappedName name -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (IEWrappedName name))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IEWrappedName name))

gmapT :: (forall b. Data b => b -> b) -> IEWrappedName name -> IEWrappedName name

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IEWrappedName name -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IEWrappedName name -> r

gmapQ :: (forall d. Data d => d -> u) -> IEWrappedName name -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> IEWrappedName name -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> IEWrappedName name -> m (IEWrappedName name)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IEWrappedName name -> m (IEWrappedName name)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IEWrappedName name -> m (IEWrappedName name)

HasOccName name => HasOccName (IEWrappedName name)

Defined in GHC.Hs.ImpExp

Methods

occName :: IEWrappedName name -> OccName

OutputableBndr name => Outputable (IEWrappedName name)

Defined in GHC.Hs.ImpExp

Methods

ppr :: IEWrappedName name -> SDoc

pprPrec :: Rational -> IEWrappedName name -> SDoc

OutputableBndr name => OutputableBndr (IEWrappedName name)

Defined in GHC.Hs.ImpExp

Methods

pprBndr :: BindingSite -> IEWrappedName name -> SDoc

pprPrefixOcc :: IEWrappedName name -> SDoc

pprInfixOcc :: IEWrappedName name -> SDoc

bndrIsJoin_maybe :: IEWrappedName name -> Maybe Int

type LIEWrappedName name = Located (IEWrappedName name)

Located name with possible adornment - AnnKeywordIds : AnnType, AnnPattern

type LIE pass

Arguments

 = Located (IE pass)

When in a list this may have

• AnnKeywordId : AnnComma

Located Import or Export

data IE pass

Imported or exported entity.

Constructors

IEVar (XIEVar pass) (LIEWrappedName (IdP pass))

Imported or Exported Variable

IEThingAbs (XIEThingAbs pass) (LIEWrappedName (IdP pass))

Imported or exported Thing with Absent list

The thing is a Class/Type (can't tell) - AnnKeywordIds : AnnPattern, AnnType,AnnVal

IEThingAll (XIEThingAll pass) (LIEWrappedName (IdP pass))

Imported or exported Thing with All imported or exported

The thing is a ClassType and the All refers to methodsconstructors

• AnnKeywordIds : AnnOpen, AnnDotdot,AnnClose, AnnType

IEThingWith (XIEThingWith pass) (LIEWrappedName (IdP pass)) IEWildcard [LIEWrappedName (IdP pass)] [Located (FieldLbl (IdP pass))]

Imported or exported Thing With given imported or exported

The thing is a Class/Type and the imported or exported things are methods/constructors and record fields; see Note [IEThingWith] - AnnKeywordIds : AnnOpen, AnnClose, AnnComma, AnnType

IEModuleContents (XIEModuleContents pass) (Located ModuleName)

Imported or exported module contents

(Export Only)

• AnnKeywordIds : AnnModule

IEGroup (XIEGroup pass) Int HsDocString

Doc section heading

IEDoc (XIEDoc pass) HsDocString

Some documentation

IEDocNamed (XIEDocNamed pass) String

Reference to named doc

XIE (XXIE pass)

Instances

OutputableBndrId p => Outputable (IE (GhcPass p))

Defined in GHC.Hs.ImpExp

Methods

ppr :: IE (GhcPass p) -> SDoc

pprPrec :: Rational -> IE (GhcPass p) -> SDoc

data IEWildcard

Imported or Exported Wildcard

Constructors

NoIEWildcard

IEWildcard Int

Instances

Eq IEWildcard

Defined in GHC.Hs.ImpExp

Methods

(==) :: IEWildcard -> IEWildcard -> Bool

(/=) :: IEWildcard -> IEWildcard -> Bool

Data IEWildcard

Defined in GHC.Hs.ImpExp

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IEWildcard -> c IEWildcard

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IEWildcard

toConstr :: IEWildcard -> Constr

dataTypeOf :: IEWildcard -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c IEWildcard)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IEWildcard)

gmapT :: (forall b. Data b => b -> b) -> IEWildcard -> IEWildcard

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IEWildcard -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IEWildcard -> r

gmapQ :: (forall d. Data d => d -> u) -> IEWildcard -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> IEWildcard -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> IEWildcard -> m IEWildcard

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IEWildcard -> m IEWildcard

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IEWildcard -> m IEWildcard

data Pat p

Pattern

• AnnKeywordId : AnnBang

Constructors

WildPat (XWildPat p)

Wildcard Pattern The sole reason for a type on a WildPat is to support hsPatType :: Pat Id -> Type

VarPat (XVarPat p) (Located (IdP p))

Variable Pattern

LazyPat (XLazyPat p) (LPat p)

Lazy Pattern ^ - AnnKeywordId : AnnTilde

AsPat (XAsPat p) (Located (IdP p)) (LPat p)

As pattern ^ - AnnKeywordId : AnnAt

ParPat (XParPat p) (LPat p)

Parenthesised pattern See Note [Parens in HsSyn] in GHC.Hs.Expr ^ - AnnKeywordId : AnnOpen '(', AnnClose ')'

BangPat (XBangPat p) (LPat p)

Bang pattern ^ - AnnKeywordId : AnnBang

ListPat (XListPat p) [LPat p]

Syntactic List

• AnnKeywordId : AnnOpen '[', AnnClose ']'

TuplePat (XTuplePat p) [LPat p] Boxity

Tuple sub-patterns

• AnnKeywordId : AnnOpen '(' or '(#', AnnClose ')' or '#)'

SumPat (XSumPat p) (LPat p) ConTag Arity

Anonymous sum pattern

• AnnKeywordId : AnnOpen '(#', AnnClose '#)'

ConPatIn (Located (IdP p)) (HsConPatDetails p)

Constructor Pattern In

ConPatOut

Constructor Pattern Out

Fields

• pat_con :: Located ConLike
• pat_arg_tys :: [Type]
• pat_tvs :: [TyVar]
• pat_dicts :: [EvVar]
• pat_binds :: TcEvBinds
• pat_args :: HsConPatDetails p
• pat_wrap :: HsWrapper

ViewPat (XViewPat p) (LHsExpr p) (LPat p)

View Pattern

SplicePat (XSplicePat p) (HsSplice p)

Splice Pattern (Includes quasi-quotes)

LitPat (XLitPat p) (HsLit p)

Literal Pattern Used for *non-overloaded* literal patterns: Int, Int, Char, String, etc.

NPat (XNPat p) (Located (HsOverLit p)) (Maybe (SyntaxExpr p)) (SyntaxExpr p)

Natural Pattern

• AnnKeywordId : AnnVal +

NPlusKPat (XNPlusKPat p) (Located (IdP p)) (Located (HsOverLit p)) (HsOverLit p) (SyntaxExpr p) (SyntaxExpr p)

n+k pattern

SigPat (XSigPat p) (LPat p) (LHsSigWcType (NoGhcTc p))

Pattern with a type signature

CoPat (XCoPat p) HsWrapper (Pat p) Type

Coercion Pattern

XPat (XXPat p)

Trees that Grow extension point for new constructors

Instances

OutputableBndrId p => Outputable (Pat (GhcPass p))

Defined in GHC.Hs.Pat

Methods

ppr :: Pat (GhcPass p) -> SDoc

pprPrec :: Rational -> Pat (GhcPass p) -> SDoc

type LPat p = XRec p Pat

noExtCon :: NoExtCon -> a

Eliminate a NoExtCon. Much like absurd.

noExtField :: NoExtField

Used when constructing a term with an unused extension point.

data NoExtField

A placeholder type for TTG extension points that are not currently unused to represent any particular value.

This should not be confused with NoExtCon, which are found in unused extension constructors and therefore should never be inhabited. In contrast, NoExtField is used in extension points (e.g., as the field of some constructor), so it must have an inhabitant to construct AST passes that manipulate fields with that extension point as their type.

Constructors

NoExtField

Instances

Eq NoExtField

Defined in GHC.Hs.Extension

Methods

(==) :: NoExtField -> NoExtField -> Bool

(/=) :: NoExtField -> NoExtField -> Bool

Data NoExtField

Defined in GHC.Hs.Extension

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NoExtField -> c NoExtField

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NoExtField

toConstr :: NoExtField -> Constr

dataTypeOf :: NoExtField -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NoExtField)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NoExtField)

gmapT :: (forall b. Data b => b -> b) -> NoExtField -> NoExtField

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NoExtField -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NoExtField -> r

gmapQ :: (forall d. Data d => d -> u) -> NoExtField -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> NoExtField -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NoExtField -> m NoExtField

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NoExtField -> m NoExtField

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NoExtField -> m NoExtField

Ord NoExtField

Defined in GHC.Hs.Extension

Methods

compare :: NoExtField -> NoExtField -> Ordering

(<) :: NoExtField -> NoExtField -> Bool

(<=) :: NoExtField -> NoExtField -> Bool

(>) :: NoExtField -> NoExtField -> Bool

(>=) :: NoExtField -> NoExtField -> Bool

max :: NoExtField -> NoExtField -> NoExtField

min :: NoExtField -> NoExtField -> NoExtField

Outputable NoExtField

Defined in GHC.Hs.Extension

Methods

ppr :: NoExtField -> SDoc

pprPrec :: Rational -> NoExtField -> SDoc

data NoExtCon

Used in TTG extension constructors that have yet to be extended with anything. If an extension constructor has NoExtCon as its field, it is not intended to ever be constructed anywhere, and any function that consumes the extension constructor can eliminate it by way of noExtCon.

This should not be confused with NoExtField, which are found in unused extension points (not constructors) and therefore can be inhabited.

Instances

Eq NoExtCon

Defined in GHC.Hs.Extension

Methods

(==) :: NoExtCon -> NoExtCon -> Bool

(/=) :: NoExtCon -> NoExtCon -> Bool

Data NoExtCon

Defined in GHC.Hs.Extension

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NoExtCon -> c NoExtCon

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NoExtCon

toConstr :: NoExtCon -> Constr

dataTypeOf :: NoExtCon -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NoExtCon)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NoExtCon)

gmapT :: (forall b. Data b => b -> b) -> NoExtCon -> NoExtCon

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NoExtCon -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NoExtCon -> r

gmapQ :: (forall d. Data d => d -> u) -> NoExtCon -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> NoExtCon -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NoExtCon -> m NoExtCon

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NoExtCon -> m NoExtCon

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NoExtCon -> m NoExtCon

Ord NoExtCon

Defined in GHC.Hs.Extension

Methods

compare :: NoExtCon -> NoExtCon -> Ordering

(<) :: NoExtCon -> NoExtCon -> Bool

(<=) :: NoExtCon -> NoExtCon -> Bool

(>) :: NoExtCon -> NoExtCon -> Bool

(>=) :: NoExtCon -> NoExtCon -> Bool

max :: NoExtCon -> NoExtCon -> NoExtCon

min :: NoExtCon -> NoExtCon -> NoExtCon

Outputable NoExtCon

Defined in GHC.Hs.Extension

Methods

ppr :: NoExtCon -> SDoc

pprPrec :: Rational -> NoExtCon -> SDoc

data GhcPass (c :: Pass)

Used as a data type index for the hsSyn AST

Instances

Eq (XCFieldOcc (GhcPass p)) => Eq (FieldOcc (GhcPass p))

Defined in GHC.Hs.Types

Methods

(==) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool

(/=) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool

Eq (GhcPass c)

Defined in GHC.Hs.Extension

Methods

(==) :: GhcPass c -> GhcPass c -> Bool

(/=) :: GhcPass c -> GhcPass c -> Bool

Data (HsModule GhcPs)

Defined in GHC.Hs

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsModule GhcPs -> c (HsModule GhcPs)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsModule GhcPs)

toConstr :: HsModule GhcPs -> Constr

dataTypeOf :: HsModule GhcPs -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsModule GhcPs))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsModule GhcPs))

gmapT :: (forall b. Data b => b -> b) -> HsModule GhcPs -> HsModule GhcPs

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsModule GhcPs -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsModule GhcPs -> r

gmapQ :: (forall d. Data d => d -> u) -> HsModule GhcPs -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsModule GhcPs -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsModule GhcPs -> m (HsModule GhcPs)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsModule GhcPs -> m (HsModule GhcPs)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsModule GhcPs -> m (HsModule GhcPs)

Data (HsModule GhcRn)

Defined in GHC.Hs

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsModule GhcRn -> c (HsModule GhcRn)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsModule GhcRn)

toConstr :: HsModule GhcRn -> Constr

dataTypeOf :: HsModule GhcRn -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsModule GhcRn))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsModule GhcRn))

gmapT :: (forall b. Data b => b -> b) -> HsModule GhcRn -> HsModule GhcRn

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsModule GhcRn -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsModule GhcRn -> r

gmapQ :: (forall d. Data d => d -> u) -> HsModule GhcRn -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsModule GhcRn -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsModule GhcRn -> m (HsModule GhcRn)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsModule GhcRn -> m (HsModule GhcRn)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsModule GhcRn -> m (HsModule GhcRn)

Data (HsModule GhcTc)

Defined in GHC.Hs

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsModule GhcTc -> c (HsModule GhcTc)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsModule GhcTc)

toConstr :: HsModule GhcTc -> Constr

dataTypeOf :: HsModule GhcTc -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsModule GhcTc))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsModule GhcTc))

gmapT :: (forall b. Data b => b -> b) -> HsModule GhcTc -> HsModule GhcTc

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsModule GhcTc -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsModule GhcTc -> r

gmapQ :: (forall d. Data d => d -> u) -> HsModule GhcTc -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsModule GhcTc -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsModule GhcTc -> m (HsModule GhcTc)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsModule GhcTc -> m (HsModule GhcTc)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsModule GhcTc -> m (HsModule GhcTc)

Typeable c => Data (GhcPass c)

Defined in GHC.Hs.Extension

Methods

gfoldl :: (forall d b. Data d => c0 (d -> b) -> d -> c0 b) -> (forall g. g -> c0 g) -> GhcPass c -> c0 (GhcPass c)

gunfold :: (forall b r. Data b => c0 (b -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (GhcPass c)

toConstr :: GhcPass c -> Constr

dataTypeOf :: GhcPass c -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c0 (t d)) -> Maybe (c0 (GhcPass c))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c0 (t d e)) -> Maybe (c0 (GhcPass c))

gmapT :: (forall b. Data b => b -> b) -> GhcPass c -> GhcPass c

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GhcPass c -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GhcPass c -> r

gmapQ :: (forall d. Data d => d -> u) -> GhcPass c -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> GhcPass c -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GhcPass c -> m (GhcPass c)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GhcPass c -> m (GhcPass c)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GhcPass c -> m (GhcPass c)

Ord (XCFieldOcc (GhcPass p)) => Ord (FieldOcc (GhcPass p))

Defined in GHC.Hs.Types

Methods

compare :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Ordering

(<) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool

(<=) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool

(>) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool

(>=) :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> Bool

max :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> FieldOcc (GhcPass p)

min :: FieldOcc (GhcPass p) -> FieldOcc (GhcPass p) -> FieldOcc (GhcPass p)

DisambECP (PatBuilder GhcPs)

Defined in RdrHsSyn

Associated Types

type Body (PatBuilder GhcPs) :: Type -> Type

type InfixOp (PatBuilder GhcPs)

type FunArg (PatBuilder GhcPs)

Methods

ecpFromCmd' :: LHsCmd GhcPs -> PV (Located (PatBuilder GhcPs))

ecpFromExp' :: LHsExpr GhcPs -> PV (Located (PatBuilder GhcPs))

mkHsLamPV :: SrcSpan -> MatchGroup GhcPs (Located (PatBuilder GhcPs)) -> PV (Located (PatBuilder GhcPs))

mkHsLetPV :: SrcSpan -> LHsLocalBinds GhcPs -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

superInfixOp :: (DisambInfixOp (InfixOp (PatBuilder GhcPs)) => PV (Located (PatBuilder GhcPs))) -> PV (Located (PatBuilder GhcPs))

mkHsOpAppPV :: SrcSpan -> Located (PatBuilder GhcPs) -> Located (InfixOp (PatBuilder GhcPs)) -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsCasePV :: SrcSpan -> LHsExpr GhcPs -> MatchGroup GhcPs (Located (PatBuilder GhcPs)) -> PV (Located (PatBuilder GhcPs))

superFunArg :: (DisambECP (FunArg (PatBuilder GhcPs)) => PV (Located (PatBuilder GhcPs))) -> PV (Located (PatBuilder GhcPs))

mkHsAppPV :: SrcSpan -> Located (PatBuilder GhcPs) -> Located (FunArg (PatBuilder GhcPs)) -> PV (Located (PatBuilder GhcPs))

mkHsIfPV :: SrcSpan -> LHsExpr GhcPs -> Bool -> Located (PatBuilder GhcPs) -> Bool -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsDoPV :: SrcSpan -> Located [LStmt GhcPs (Located (PatBuilder GhcPs))] -> PV (Located (PatBuilder GhcPs))

mkHsParPV :: SrcSpan -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsVarPV :: Located RdrName -> PV (Located (PatBuilder GhcPs))

mkHsLitPV :: Located (HsLit GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsOverLitPV :: Located (HsOverLit GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsWildCardPV :: SrcSpan -> PV (Located (PatBuilder GhcPs))

mkHsTySigPV :: SrcSpan -> Located (PatBuilder GhcPs) -> LHsType GhcPs -> PV (Located (PatBuilder GhcPs))

mkHsExplicitListPV :: SrcSpan -> [Located (PatBuilder GhcPs)] -> PV (Located (PatBuilder GhcPs))

mkHsSplicePV :: Located (HsSplice GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsRecordPV :: SrcSpan -> SrcSpan -> Located (PatBuilder GhcPs) -> ([LHsRecField GhcPs (Located (PatBuilder GhcPs))], Maybe SrcSpan) -> PV (Located (PatBuilder GhcPs))

mkHsNegAppPV :: SrcSpan -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsSectionR_PV :: SrcSpan -> Located (InfixOp (PatBuilder GhcPs)) -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsViewPatPV :: SrcSpan -> LHsExpr GhcPs -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsAsPatPV :: SrcSpan -> Located RdrName -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

mkHsLazyPatPV :: SrcSpan -> Located (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

mkSumOrTuplePV :: SrcSpan -> Boxity -> SumOrTuple (PatBuilder GhcPs) -> PV (Located (PatBuilder GhcPs))

NamedThing (HsTyVarBndr GhcRn)

Defined in GHC.Hs.Types

Methods

getOccName :: HsTyVarBndr GhcRn -> OccName

getName :: HsTyVarBndr GhcRn -> Name

OutputableBndrId a => Outputable (InstInfo (GhcPass a))

Defined in TcEnv

Methods

ppr :: InstInfo (GhcPass a) -> SDoc

pprPrec :: Rational -> InstInfo (GhcPass a) -> SDoc

Outputable (PatBuilder GhcPs)

Defined in RdrHsSyn

Methods

ppr :: PatBuilder GhcPs -> SDoc

pprPrec :: Rational -> PatBuilder GhcPs -> SDoc

OutputableBndrId p => Outputable (HsModule (GhcPass p))

Defined in GHC.Hs

Methods

ppr :: HsModule (GhcPass p) -> SDoc

pprPrec :: Rational -> HsModule (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (HsCmdTop (GhcPass p))

Defined in GHC.Hs.Expr

Methods

ppr :: HsCmdTop (GhcPass p) -> SDoc

pprPrec :: Rational -> HsCmdTop (GhcPass p) -> SDoc

OutputableBndrId idL => Outputable (ApplicativeArg (GhcPass idL))

Defined in GHC.Hs.Expr

Methods

ppr :: ApplicativeArg (GhcPass idL) -> SDoc

pprPrec :: Rational -> ApplicativeArg (GhcPass idL) -> SDoc

OutputableBndrId p => Outputable (HsSplicedThing (GhcPass p))

Defined in GHC.Hs.Expr

Methods

ppr :: HsSplicedThing (GhcPass p) -> SDoc

pprPrec :: Rational -> HsSplicedThing (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (HsBracket (GhcPass p))

Defined in GHC.Hs.Expr

Methods

ppr :: HsBracket (GhcPass p) -> SDoc

pprPrec :: Rational -> HsBracket (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (ArithSeqInfo (GhcPass p))

Defined in GHC.Hs.Expr

Methods

ppr :: ArithSeqInfo (GhcPass p) -> SDoc

pprPrec :: Rational -> ArithSeqInfo (GhcPass p) -> SDoc

(Outputable (GhcPass p), Outputable (NameOrRdrName (GhcPass p))) => Outputable (HsStmtContext (GhcPass p))

Defined in GHC.Hs.Expr

Methods

ppr :: HsStmtContext (GhcPass p) -> SDoc

pprPrec :: Rational -> HsStmtContext (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (HsDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: HsDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> HsDecl (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (HsGroup (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: HsGroup (GhcPass p) -> SDoc

pprPrec :: Rational -> HsGroup (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (SpliceDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: SpliceDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> SpliceDecl (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (TyClDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: TyClDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> TyClDecl (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (TyClGroup (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: TyClGroup (GhcPass p) -> SDoc

pprPrec :: Rational -> TyClGroup (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (FamilyDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: FamilyDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> FamilyDecl (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (HsDataDefn (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: HsDataDefn (GhcPass p) -> SDoc

pprPrec :: Rational -> HsDataDefn (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (HsDerivingClause (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: HsDerivingClause (GhcPass p) -> SDoc

pprPrec :: Rational -> HsDerivingClause (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (StandaloneKindSig (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: StandaloneKindSig (GhcPass p) -> SDoc

pprPrec :: Rational -> StandaloneKindSig (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (ConDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: ConDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> ConDecl (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (TyFamInstDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: TyFamInstDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> TyFamInstDecl (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (DataFamInstDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: DataFamInstDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> DataFamInstDecl (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (ClsInstDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: ClsInstDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> ClsInstDecl (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (InstDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: InstDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> InstDecl (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (DerivDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: DerivDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> DerivDecl (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (DerivStrategy (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: DerivStrategy (GhcPass p) -> SDoc

pprPrec :: Rational -> DerivStrategy (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (DefaultDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: DefaultDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> DefaultDecl (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (ForeignDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: ForeignDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> ForeignDecl (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (RuleDecls (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: RuleDecls (GhcPass p) -> SDoc

pprPrec :: Rational -> RuleDecls (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (RuleDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: RuleDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> RuleDecl (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (RuleBndr (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: RuleBndr (GhcPass p) -> SDoc

pprPrec :: Rational -> RuleBndr (GhcPass p) -> SDoc

OutputableBndr (IdP (GhcPass p)) => Outputable (WarnDecls (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: WarnDecls (GhcPass p) -> SDoc

pprPrec :: Rational -> WarnDecls (GhcPass p) -> SDoc

OutputableBndr (IdP (GhcPass p)) => Outputable (WarnDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: WarnDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> WarnDecl (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (AnnDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: AnnDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> AnnDecl (GhcPass p) -> SDoc

OutputableBndr (IdP (GhcPass p)) => Outputable (RoleAnnotDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: RoleAnnotDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> RoleAnnotDecl (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (ABExport (GhcPass p))

Defined in GHC.Hs.Binds

Methods

ppr :: ABExport (GhcPass p) -> SDoc

pprPrec :: Rational -> ABExport (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (HsIPBinds (GhcPass p))

Defined in GHC.Hs.Binds

Methods

ppr :: HsIPBinds (GhcPass p) -> SDoc

pprPrec :: Rational -> HsIPBinds (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (IPBind (GhcPass p))

Defined in GHC.Hs.Binds

Methods

ppr :: IPBind (GhcPass p) -> SDoc

pprPrec :: Rational -> IPBind (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (Sig (GhcPass p))

Defined in GHC.Hs.Binds

Methods

ppr :: Sig (GhcPass p) -> SDoc

pprPrec :: Rational -> Sig (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (FixitySig (GhcPass p))

Defined in GHC.Hs.Binds

Methods

ppr :: FixitySig (GhcPass p) -> SDoc

pprPrec :: Rational -> FixitySig (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (LHsQTyVars (GhcPass p))

Defined in GHC.Hs.Types

Methods

ppr :: LHsQTyVars (GhcPass p) -> SDoc

pprPrec :: Rational -> LHsQTyVars (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (HsTyVarBndr (GhcPass p))

Defined in GHC.Hs.Types

Methods

ppr :: HsTyVarBndr (GhcPass p) -> SDoc

pprPrec :: Rational -> HsTyVarBndr (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (HsType (GhcPass p))

Defined in GHC.Hs.Types

Methods

ppr :: HsType (GhcPass p) -> SDoc

pprPrec :: Rational -> HsType (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (ConDeclField (GhcPass p))

Defined in GHC.Hs.Types

Methods

ppr :: ConDeclField (GhcPass p) -> SDoc

pprPrec :: Rational -> ConDeclField (GhcPass p) -> SDoc

Outputable (AmbiguousFieldOcc (GhcPass p))

Defined in GHC.Hs.Types

Methods

ppr :: AmbiguousFieldOcc (GhcPass p) -> SDoc

pprPrec :: Rational -> AmbiguousFieldOcc (GhcPass p) -> SDoc

Outputable (HsLit (GhcPass p))

Defined in GHC.Hs.Lit

Methods

ppr :: HsLit (GhcPass p) -> SDoc

pprPrec :: Rational -> HsLit (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (HsOverLit (GhcPass p))

Defined in GHC.Hs.Lit

Methods

ppr :: HsOverLit (GhcPass p) -> SDoc

pprPrec :: Rational -> HsOverLit (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (HsExpr (GhcPass p))

Defined in GHC.Hs.Expr

Methods

ppr :: HsExpr (GhcPass p) -> SDoc

pprPrec :: Rational -> HsExpr (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (HsCmd (GhcPass p))

Defined in GHC.Hs.Expr

Methods

ppr :: HsCmd (GhcPass p) -> SDoc

pprPrec :: Rational -> HsCmd (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (HsSplice (GhcPass p))

Defined in GHC.Hs.Expr

Methods

ppr :: HsSplice (GhcPass p) -> SDoc

pprPrec :: Rational -> HsSplice (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (SyntaxExpr (GhcPass p))

Defined in GHC.Hs.Expr

Methods

ppr :: SyntaxExpr (GhcPass p) -> SDoc

pprPrec :: Rational -> SyntaxExpr (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (ImportDecl (GhcPass p))

Defined in GHC.Hs.ImpExp

Methods

ppr :: ImportDecl (GhcPass p) -> SDoc

pprPrec :: Rational -> ImportDecl (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (IE (GhcPass p))

Defined in GHC.Hs.ImpExp

Methods

ppr :: IE (GhcPass p) -> SDoc

pprPrec :: Rational -> IE (GhcPass p) -> SDoc

OutputableBndrId p => Outputable (Pat (GhcPass p))

Defined in GHC.Hs.Pat

Methods

ppr :: Pat (GhcPass p) -> SDoc

pprPrec :: Rational -> Pat (GhcPass p) -> SDoc

OutputableBndr (AmbiguousFieldOcc (GhcPass p))

Defined in GHC.Hs.Types

Methods

pprBndr :: BindingSite -> AmbiguousFieldOcc (GhcPass p) -> SDoc

pprPrefixOcc :: AmbiguousFieldOcc (GhcPass p) -> SDoc

pprInfixOcc :: AmbiguousFieldOcc (GhcPass p) -> SDoc

bndrIsJoin_maybe :: AmbiguousFieldOcc (GhcPass p) -> Maybe Int

(OutputableBndrId pr, Outputable body) => Outputable (Match (GhcPass pr) body)

Defined in GHC.Hs.Expr

Methods

ppr :: Match (GhcPass pr) body -> SDoc

pprPrec :: Rational -> Match (GhcPass pr) body -> SDoc

(OutputableBndrId pl, OutputableBndrId pr) => Outputable (HsLocalBindsLR (GhcPass pl) (GhcPass pr))

Defined in GHC.Hs.Binds

Methods

ppr :: HsLocalBindsLR (GhcPass pl) (GhcPass pr) -> SDoc

pprPrec :: Rational -> HsLocalBindsLR (GhcPass pl) (GhcPass pr) -> SDoc

(OutputableBndrId pl, OutputableBndrId pr) => Outputable (HsValBindsLR (GhcPass pl) (GhcPass pr))

Defined in GHC.Hs.Binds

Methods

ppr :: HsValBindsLR (GhcPass pl) (GhcPass pr) -> SDoc

pprPrec :: Rational -> HsValBindsLR (GhcPass pl) (GhcPass pr) -> SDoc

(OutputableBndrId pl, OutputableBndrId pr) => Outputable (HsBindLR (GhcPass pl) (GhcPass pr))

Defined in GHC.Hs.Binds

Methods

ppr :: HsBindLR (GhcPass pl) (GhcPass pr) -> SDoc

pprPrec :: Rational -> HsBindLR (GhcPass pl) (GhcPass pr) -> SDoc

(OutputableBndrId l, OutputableBndrId r, Outputable (XXPatSynBind (GhcPass l) (GhcPass r))) => Outputable (PatSynBind (GhcPass l) (GhcPass r))

Defined in GHC.Hs.Binds

Methods

ppr :: PatSynBind (GhcPass l) (GhcPass r) -> SDoc

pprPrec :: Rational -> PatSynBind (GhcPass l) (GhcPass r) -> SDoc

Outputable thing => Outputable (HsImplicitBndrs (GhcPass p) thing)

Defined in GHC.Hs.Types

Methods

ppr :: HsImplicitBndrs (GhcPass p) thing -> SDoc

pprPrec :: Rational -> HsImplicitBndrs (GhcPass p) thing -> SDoc

Outputable thing => Outputable (HsWildCardBndrs (GhcPass p) thing)

Defined in GHC.Hs.Types

Methods

ppr :: HsWildCardBndrs (GhcPass p) thing -> SDoc

pprPrec :: Rational -> HsWildCardBndrs (GhcPass p) thing -> SDoc

(OutputableBndrId pl, OutputableBndrId pr, Outputable body) => Outputable (StmtLR (GhcPass pl) (GhcPass pr) body)

Defined in GHC.Hs.Expr

Methods

ppr :: StmtLR (GhcPass pl) (GhcPass pr) body -> SDoc

pprPrec :: Rational -> StmtLR (GhcPass pl) (GhcPass pr) body -> SDoc

type IdP GhcPs

Defined in GHC.Hs.Extension

type IdP GhcPs = RdrName

type IdP GhcRn

Defined in GHC.Hs.Extension

type IdP GhcRn = Name

type IdP GhcTc

Defined in GHC.Hs.Extension

type IdP GhcTc = Id

type XIPBinds GhcPs

Defined in GHC.Hs.Binds

type XIPBinds GhcPs = NoExtField

type XIPBinds GhcRn

Defined in GHC.Hs.Binds

type XIPBinds GhcRn = NoExtField

type XIPBinds GhcTc

Defined in GHC.Hs.Binds

type XIPBinds GhcTc = TcEvBinds

type XSynDecl GhcPs

Defined in GHC.Hs.Decls

type XSynDecl GhcPs = NoExtField

type XSynDecl GhcRn

Defined in GHC.Hs.Decls

type XSynDecl GhcRn = NameSet

type XSynDecl GhcTc

Defined in GHC.Hs.Decls

type XSynDecl GhcTc = NameSet

type XDataDecl GhcPs

Defined in GHC.Hs.Decls

type XDataDecl GhcPs = NoExtField

type XDataDecl GhcRn

Defined in GHC.Hs.Decls

type XDataDecl GhcRn = DataDeclRn

type XDataDecl GhcTc

Defined in GHC.Hs.Decls

type XDataDecl GhcTc = DataDeclRn

type XClassDecl GhcPs

Defined in GHC.Hs.Decls

type XClassDecl GhcPs = NoExtField

type XClassDecl GhcRn

Defined in GHC.Hs.Decls

type XClassDecl GhcRn = NameSet

type XClassDecl GhcTc

Defined in GHC.Hs.Decls

type XClassDecl GhcTc = NameSet

type XViaStrategy GhcPs

Defined in GHC.Hs.Decls

type XViaStrategy GhcPs = LHsSigType GhcPs

type XViaStrategy GhcRn

Defined in GHC.Hs.Decls

type XViaStrategy GhcRn = LHsSigType GhcRn

type XViaStrategy GhcTc

Defined in GHC.Hs.Decls

type XViaStrategy GhcTc = Type

type XForeignImport GhcPs

Defined in GHC.Hs.Decls

type XForeignImport GhcPs = NoExtField

type XForeignImport GhcRn

Defined in GHC.Hs.Decls

type XForeignImport GhcRn = NoExtField

type XForeignImport GhcTc

Defined in GHC.Hs.Decls

type XForeignImport GhcTc = Coercion

type XForeignExport GhcPs

Defined in GHC.Hs.Decls

type XForeignExport GhcPs = NoExtField

type XForeignExport GhcRn

Defined in GHC.Hs.Decls

type XForeignExport GhcRn = NoExtField

type XForeignExport GhcTc

Defined in GHC.Hs.Decls

type XForeignExport GhcTc = Coercion

type XHsRule GhcPs

Defined in GHC.Hs.Decls

type XHsRule GhcPs = NoExtField

type XHsRule GhcRn

Defined in GHC.Hs.Decls

type XHsRule GhcRn = HsRuleRn

type XHsRule GhcTc

Defined in GHC.Hs.Decls

type XHsRule GhcTc = HsRuleRn

type XOpApp GhcPs

Defined in GHC.Hs.Expr

type XOpApp GhcPs = NoExtField

type XOpApp GhcRn

Defined in GHC.Hs.Expr

type XOpApp GhcRn = Fixity

type XOpApp GhcTc

Defined in GHC.Hs.Expr

type XOpApp GhcTc = Fixity

type XExplicitSum GhcPs

Defined in GHC.Hs.Expr

type XExplicitSum GhcPs = NoExtField

type XExplicitSum GhcRn

Defined in GHC.Hs.Expr

type XExplicitSum GhcRn = NoExtField

type XExplicitSum GhcTc

Defined in GHC.Hs.Expr

type XExplicitSum GhcTc = [Type]

type XMultiIf GhcPs

Defined in GHC.Hs.Expr

type XMultiIf GhcPs = NoExtField

type XMultiIf GhcRn

Defined in GHC.Hs.Expr

type XMultiIf GhcRn = NoExtField

type XMultiIf GhcTc

Defined in GHC.Hs.Expr

type XMultiIf GhcTc = Type

type XDo GhcPs

Defined in GHC.Hs.Expr

type XDo GhcPs = NoExtField

type XDo GhcRn

Defined in GHC.Hs.Expr

type XDo GhcRn = NoExtField

type XDo GhcTc

Defined in GHC.Hs.Expr

type XDo GhcTc = Type

type XExplicitList GhcPs

Defined in GHC.Hs.Expr

type XExplicitList GhcPs = NoExtField

type XExplicitList GhcRn

Defined in GHC.Hs.Expr

type XExplicitList GhcRn = NoExtField

type XExplicitList GhcTc

Defined in GHC.Hs.Expr

type XExplicitList GhcTc = Type

type XRecordCon GhcPs

Defined in GHC.Hs.Expr

type XRecordCon GhcPs = NoExtField

type XRecordCon GhcRn

Defined in GHC.Hs.Expr

type XRecordCon GhcRn = NoExtField

type XRecordCon GhcTc

Defined in GHC.Hs.Expr

type XRecordCon GhcTc = RecordConTc

type XRecordUpd GhcPs

Defined in GHC.Hs.Expr

type XRecordUpd GhcPs = NoExtField

type XRecordUpd GhcRn

Defined in GHC.Hs.Expr

type XRecordUpd GhcRn = NoExtField

type XRecordUpd GhcTc

Defined in GHC.Hs.Expr

type XRecordUpd GhcTc = RecordUpdTc

type XArithSeq GhcPs

Defined in GHC.Hs.Expr

type XArithSeq GhcPs = NoExtField

type XArithSeq GhcRn

Defined in GHC.Hs.Expr

type XArithSeq GhcRn = NoExtField

type XArithSeq GhcTc

Defined in GHC.Hs.Expr

type XArithSeq GhcTc = PostTcExpr

type XStatic GhcPs

Defined in GHC.Hs.Expr

type XStatic GhcPs = NoExtField

type XStatic GhcRn

Defined in GHC.Hs.Expr

type XStatic GhcRn = NameSet

type XStatic GhcTc

Defined in GHC.Hs.Expr

type XStatic GhcTc = NameSet

type XUnambiguous GhcPs

Defined in GHC.Hs.Types

type XUnambiguous GhcPs = NoExtField

type XUnambiguous GhcRn

Defined in GHC.Hs.Types

type XUnambiguous GhcRn = Name

type XUnambiguous GhcTc

Defined in GHC.Hs.Types

type XUnambiguous GhcTc = Id

type XAmbiguous GhcPs

Defined in GHC.Hs.Types

type XAmbiguous GhcPs = NoExtField

type XAmbiguous GhcRn

Defined in GHC.Hs.Types

type XAmbiguous GhcRn = NoExtField

type XAmbiguous GhcTc

Defined in GHC.Hs.Types

type XAmbiguous GhcTc = Id

type XMissing GhcPs

Defined in GHC.Hs.Expr

type XMissing GhcPs = NoExtField

type XMissing GhcRn

Defined in GHC.Hs.Expr

type XMissing GhcRn = NoExtField

type XMissing GhcTc

Defined in GHC.Hs.Expr

type XMissing GhcTc = Type

type XCmdTop GhcPs

Defined in GHC.Hs.Expr

type XCmdTop GhcPs = NoExtField

type XCmdTop GhcRn

Defined in GHC.Hs.Expr

type XCmdTop GhcRn = CmdSyntaxTable GhcRn

type XCmdTop GhcTc

Defined in GHC.Hs.Expr

type XCmdTop GhcTc = CmdTopTc

type XCmdArrApp GhcPs

Defined in GHC.Hs.Expr

type XCmdArrApp GhcPs = NoExtField

type XCmdArrApp GhcRn

Defined in GHC.Hs.Expr

type XCmdArrApp GhcRn = NoExtField

type XCmdArrApp GhcTc

Defined in GHC.Hs.Expr

type XCmdArrApp GhcTc = Type

type XCmdDo GhcPs

Defined in GHC.Hs.Expr

type XCmdDo GhcPs = NoExtField

type XCmdDo GhcRn

Defined in GHC.Hs.Expr

type XCmdDo GhcRn = NoExtField

type XCmdDo GhcTc

Defined in GHC.Hs.Expr

type XCmdDo GhcTc = Type

type XOverLit GhcPs

Defined in GHC.Hs.Lit

type XOverLit GhcPs = NoExtField

type XOverLit GhcRn

Defined in GHC.Hs.Lit

type XOverLit GhcRn = Bool

type XOverLit GhcTc

Defined in GHC.Hs.Lit

type XOverLit GhcTc = OverLitTc

type XWildPat GhcPs

Defined in GHC.Hs.Pat

type XWildPat GhcPs = NoExtField

type XWildPat GhcRn

Defined in GHC.Hs.Pat

type XWildPat GhcRn = NoExtField

type XWildPat GhcTc

Defined in GHC.Hs.Pat

type XWildPat GhcTc = Type

type XListPat GhcPs

Defined in GHC.Hs.Pat

type XListPat GhcPs = NoExtField

type XListPat GhcRn

Defined in GHC.Hs.Pat

type XListPat GhcRn = Maybe (SyntaxExpr GhcRn)

type XListPat GhcTc

Defined in GHC.Hs.Pat

type XListPat GhcTc = ListPatTc

type XTuplePat GhcPs

Defined in GHC.Hs.Pat

type XTuplePat GhcPs = NoExtField

type XTuplePat GhcRn

Defined in GHC.Hs.Pat

type XTuplePat GhcRn = NoExtField

type XTuplePat GhcTc

Defined in GHC.Hs.Pat

type XTuplePat GhcTc = [Type]

type XSumPat GhcPs

Defined in GHC.Hs.Pat

type XSumPat GhcPs = NoExtField

type XSumPat GhcRn

Defined in GHC.Hs.Pat

type XSumPat GhcRn = NoExtField

type XSumPat GhcTc

Defined in GHC.Hs.Pat

type XSumPat GhcTc = [Type]

type XViewPat GhcPs

Defined in GHC.Hs.Pat

type XViewPat GhcPs = NoExtField

type XViewPat GhcRn

Defined in GHC.Hs.Pat

type XViewPat GhcRn = NoExtField

type XViewPat GhcTc

Defined in GHC.Hs.Pat

type XViewPat GhcTc = Type

type XNPat GhcPs

Defined in GHC.Hs.Pat

type XNPat GhcPs = NoExtField

type XNPat GhcRn

Defined in GHC.Hs.Pat

type XNPat GhcRn = NoExtField

type XNPat GhcTc

Defined in GHC.Hs.Pat

type XNPat GhcTc = Type

type XNPlusKPat GhcPs

Defined in GHC.Hs.Pat

type XNPlusKPat GhcPs = NoExtField

type XNPlusKPat GhcRn

Defined in GHC.Hs.Pat

type XNPlusKPat GhcRn = NoExtField

type XNPlusKPat GhcTc

Defined in GHC.Hs.Pat

type XNPlusKPat GhcTc = Type

type XSigPat GhcPs

Defined in GHC.Hs.Pat

type XSigPat GhcPs = NoExtField

type XSigPat GhcRn

Defined in GHC.Hs.Pat

type XSigPat GhcRn = NoExtField

type XSigPat GhcTc

Defined in GHC.Hs.Pat

type XSigPat GhcTc = Type

type XHsQTvs GhcPs

Defined in GHC.Hs.Types

type XHsQTvs GhcPs = NoExtField

type XHsQTvs GhcRn

Defined in GHC.Hs.Types

type XHsQTvs GhcRn = HsQTvsRn

type XHsQTvs GhcTc

Defined in GHC.Hs.Types

type XHsQTvs GhcTc = HsQTvsRn

type XSpliceTy GhcPs

Defined in GHC.Hs.Types

type XSpliceTy GhcPs = NoExtField

type XSpliceTy GhcRn

Defined in GHC.Hs.Types

type XSpliceTy GhcRn = NoExtField

type XSpliceTy GhcTc

Defined in GHC.Hs.Types

type XSpliceTy GhcTc = Kind

type XExplicitListTy GhcPs

Defined in GHC.Hs.Types

type XExplicitListTy GhcPs = NoExtField

type XExplicitListTy GhcRn

Defined in GHC.Hs.Types

type XExplicitListTy GhcRn = NoExtField

type XExplicitListTy GhcTc

Defined in GHC.Hs.Types

type XExplicitListTy GhcTc = Kind

type XExplicitTupleTy GhcPs

Defined in GHC.Hs.Types

type XExplicitTupleTy GhcPs = NoExtField

type XExplicitTupleTy GhcRn

Defined in GHC.Hs.Types

type XExplicitTupleTy GhcRn = NoExtField

type XExplicitTupleTy GhcTc

Defined in GHC.Hs.Types

type XExplicitTupleTy GhcTc = [Kind]

type XCFieldOcc GhcPs

Defined in GHC.Hs.Types

type XCFieldOcc GhcPs = NoExtField

type XCFieldOcc GhcRn

Defined in GHC.Hs.Types

type XCFieldOcc GhcRn = Name

type XCFieldOcc GhcTc

Defined in GHC.Hs.Types

type XCFieldOcc GhcTc = Id

type XMG GhcPs b

Defined in GHC.Hs.Expr

type XMG GhcPs b = NoExtField

type XMG GhcRn b

Defined in GHC.Hs.Expr

type XMG GhcRn b = NoExtField

type XMG GhcTc b

Defined in GHC.Hs.Expr

type XMG GhcTc b = MatchGroupTc

type XHsIB GhcPs _1

Defined in GHC.Hs.Types

type XHsIB GhcPs _1 = NoExtField

type XHsIB GhcRn _1

Defined in GHC.Hs.Types

type XHsIB GhcRn _1 = [Name]

type XHsIB GhcTc _1

Defined in GHC.Hs.Types

type XHsIB GhcTc _1 = [Name]

type XHsWC GhcPs b

Defined in GHC.Hs.Types

type XHsWC GhcPs b = NoExtField

type XHsWC GhcRn b

Defined in GHC.Hs.Types

type XHsWC GhcRn b = [Name]

type XHsWC GhcTc b

Defined in GHC.Hs.Types

type XHsWC GhcTc b = [Name]

type XPatBind GhcPs (GhcPass pR)

Defined in GHC.Hs.Binds

type XPatBind GhcPs (GhcPass pR) = NoExtField

type XPatBind GhcRn (GhcPass pR)

Defined in GHC.Hs.Binds

type XPatBind GhcRn (GhcPass pR) = NameSet

type XPatBind GhcTc (GhcPass pR)

Defined in GHC.Hs.Binds

type XPatBind GhcTc (GhcPass pR) = NPatBindTc

type FunArg (PatBuilder GhcPs)

Defined in RdrHsSyn

type FunArg (PatBuilder GhcPs) = PatBuilder GhcPs

type InfixOp (PatBuilder GhcPs)

Defined in RdrHsSyn

type InfixOp (PatBuilder GhcPs) = RdrName

type Body (PatBuilder GhcPs)

Defined in RdrHsSyn

type Body (PatBuilder GhcPs) = PatBuilder

type XABE (GhcPass p)

Defined in GHC.Hs.Binds

type XABE (GhcPass p) = NoExtField

type XXABExport (GhcPass p)

Defined in GHC.Hs.Binds

type XXABExport (GhcPass p) = NoExtCon

type XXHsIPBinds (GhcPass p)

Defined in GHC.Hs.Binds

type XXHsIPBinds (GhcPass p) = NoExtCon

type XCIPBind (GhcPass p)

Defined in GHC.Hs.Binds

type XCIPBind (GhcPass p) = NoExtField

type XXIPBind (GhcPass p)

Defined in GHC.Hs.Binds

type XXIPBind (GhcPass p) = NoExtCon

type XTypeSig (GhcPass p)

Defined in GHC.Hs.Binds

type XTypeSig (GhcPass p) = NoExtField

type XPatSynSig (GhcPass p)

Defined in GHC.Hs.Binds

type XPatSynSig (GhcPass p) = NoExtField

type XClassOpSig (GhcPass p)

Defined in GHC.Hs.Binds

type XClassOpSig (GhcPass p) = NoExtField

type XIdSig (GhcPass p)

Defined in GHC.Hs.Binds

type XIdSig (GhcPass p) = NoExtField

type XFixSig (GhcPass p)

Defined in GHC.Hs.Binds

type XFixSig (GhcPass p) = NoExtField

type XInlineSig (GhcPass p)

Defined in GHC.Hs.Binds

type XInlineSig (GhcPass p) = NoExtField

type XSpecSig (GhcPass p)

Defined in GHC.Hs.Binds

type XSpecSig (GhcPass p) = NoExtField

type XSpecInstSig (GhcPass p)

Defined in GHC.Hs.Binds

type XSpecInstSig (GhcPass p) = NoExtField

type XMinimalSig (GhcPass p)

Defined in GHC.Hs.Binds

type XMinimalSig (GhcPass p) = NoExtField

type XSCCFunSig (GhcPass p)

Defined in GHC.Hs.Binds

type XSCCFunSig (GhcPass p) = NoExtField

type XCompleteMatchSig (GhcPass p)

Defined in GHC.Hs.Binds

type XCompleteMatchSig (GhcPass p) = NoExtField

type XXSig (GhcPass p)

Defined in GHC.Hs.Binds

type XXSig (GhcPass p) = NoExtCon

type XFixitySig (GhcPass p)

Defined in GHC.Hs.Binds

type XFixitySig (GhcPass p) = NoExtField

type XXFixitySig (GhcPass p)

Defined in GHC.Hs.Binds

type XXFixitySig (GhcPass p) = NoExtCon

type XStandaloneKindSig (GhcPass p)

Defined in GHC.Hs.Decls

type XStandaloneKindSig (GhcPass p) = NoExtField

type XXStandaloneKindSig (GhcPass p)

Defined in GHC.Hs.Decls

type XXStandaloneKindSig (GhcPass p) = NoExtCon

type XTyClD (GhcPass _1)

Defined in GHC.Hs.Decls

type XTyClD (GhcPass _1) = NoExtField

type XInstD (GhcPass _1)

Defined in GHC.Hs.Decls

type XInstD (GhcPass _1) = NoExtField

type XDerivD (GhcPass _1)

Defined in GHC.Hs.Decls

type XDerivD (GhcPass _1) = NoExtField

type XValD (GhcPass _1)

Defined in GHC.Hs.Decls

type XValD (GhcPass _1) = NoExtField

type XSigD (GhcPass _1)

Defined in GHC.Hs.Decls

type XSigD (GhcPass _1) = NoExtField

type XKindSigD (GhcPass _1)

Defined in GHC.Hs.Decls

type XKindSigD (GhcPass _1) = NoExtField

type XDefD (GhcPass _1)

Defined in GHC.Hs.Decls

type XDefD (GhcPass _1) = NoExtField

type XForD (GhcPass _1)

Defined in GHC.Hs.Decls

type XForD (GhcPass _1) = NoExtField

type XWarningD (GhcPass _1)

Defined in GHC.Hs.Decls

type XWarningD (GhcPass _1) = NoExtField

type XAnnD (GhcPass _1)

Defined in GHC.Hs.Decls

type XAnnD (GhcPass _1) = NoExtField

type XRuleD (GhcPass _1)

Defined in GHC.Hs.Decls

type XRuleD (GhcPass _1) = NoExtField

type XSpliceD (GhcPass _1)

Defined in GHC.Hs.Decls

type XSpliceD (GhcPass _1) = NoExtField

type XDocD (GhcPass _1)

Defined in GHC.Hs.Decls

type XDocD (GhcPass _1) = NoExtField

type XRoleAnnotD (GhcPass _1)

Defined in GHC.Hs.Decls

type XRoleAnnotD (GhcPass _1) = NoExtField

type XXHsDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXHsDecl (GhcPass _1) = NoExtCon

type XCHsGroup (GhcPass _1)

Defined in GHC.Hs.Decls

type XCHsGroup (GhcPass _1) = NoExtField

type XXHsGroup (GhcPass _1)

Defined in GHC.Hs.Decls

type XXHsGroup (GhcPass _1) = NoExtCon

type XSpliceDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XSpliceDecl (GhcPass _1) = NoExtField

type XXSpliceDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXSpliceDecl (GhcPass _1) = NoExtCon

type XFamDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XFamDecl (GhcPass _1) = NoExtField

type XXTyClDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXTyClDecl (GhcPass _1) = NoExtCon

type XCTyClGroup (GhcPass _1)

Defined in GHC.Hs.Decls

type XCTyClGroup (GhcPass _1) = NoExtField

type XXTyClGroup (GhcPass _1)

Defined in GHC.Hs.Decls

type XXTyClGroup (GhcPass _1) = NoExtCon

type XNoSig (GhcPass _1)

Defined in GHC.Hs.Decls

type XNoSig (GhcPass _1) = NoExtField

type XCKindSig (GhcPass _1)

Defined in GHC.Hs.Decls

type XCKindSig (GhcPass _1) = NoExtField

type XTyVarSig (GhcPass _1)

Defined in GHC.Hs.Decls

type XTyVarSig (GhcPass _1) = NoExtField

type XXFamilyResultSig (GhcPass _1)

Defined in GHC.Hs.Decls

type XXFamilyResultSig (GhcPass _1) = NoExtCon

type XCFamilyDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XCFamilyDecl (GhcPass _1) = NoExtField

type XXFamilyDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXFamilyDecl (GhcPass _1) = NoExtCon

type XCHsDataDefn (GhcPass _1)

Defined in GHC.Hs.Decls

type XCHsDataDefn (GhcPass _1) = NoExtField

type XXHsDataDefn (GhcPass _1)

Defined in GHC.Hs.Decls

type XXHsDataDefn (GhcPass _1) = NoExtCon

type XCHsDerivingClause (GhcPass _1)

Defined in GHC.Hs.Decls

type XCHsDerivingClause (GhcPass _1) = NoExtField

type XXHsDerivingClause (GhcPass _1)

Defined in GHC.Hs.Decls

type XXHsDerivingClause (GhcPass _1) = NoExtCon

type XConDeclGADT (GhcPass _1)

Defined in GHC.Hs.Decls

type XConDeclGADT (GhcPass _1) = NoExtField

type XConDeclH98 (GhcPass _1)

Defined in GHC.Hs.Decls

type XConDeclH98 (GhcPass _1) = NoExtField

type XXConDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXConDecl (GhcPass _1) = NoExtCon

type XCClsInstDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XCClsInstDecl (GhcPass _1) = NoExtField

type XXClsInstDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXClsInstDecl (GhcPass _1) = NoExtCon

type XClsInstD (GhcPass _1)

Defined in GHC.Hs.Decls

type XClsInstD (GhcPass _1) = NoExtField

type XDataFamInstD (GhcPass _1)

Defined in GHC.Hs.Decls

type XDataFamInstD (GhcPass _1) = NoExtField

type XTyFamInstD (GhcPass _1)

Defined in GHC.Hs.Decls

type XTyFamInstD (GhcPass _1) = NoExtField

type XXInstDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXInstDecl (GhcPass _1) = NoExtCon

type XCDerivDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XCDerivDecl (GhcPass _1) = NoExtField

type XXDerivDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXDerivDecl (GhcPass _1) = NoExtCon

type XCDefaultDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XCDefaultDecl (GhcPass _1) = NoExtField

type XXDefaultDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXDefaultDecl (GhcPass _1) = NoExtCon

type XXForeignDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXForeignDecl (GhcPass _1) = NoExtCon

type XCRuleDecls (GhcPass _1)

Defined in GHC.Hs.Decls

type XCRuleDecls (GhcPass _1) = NoExtField

type XXRuleDecls (GhcPass _1)

Defined in GHC.Hs.Decls

type XXRuleDecls (GhcPass _1) = NoExtCon

type XXRuleDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXRuleDecl (GhcPass _1) = NoExtCon

type XCRuleBndr (GhcPass _1)

Defined in GHC.Hs.Decls

type XCRuleBndr (GhcPass _1) = NoExtField

type XRuleBndrSig (GhcPass _1)

Defined in GHC.Hs.Decls

type XRuleBndrSig (GhcPass _1) = NoExtField

type XXRuleBndr (GhcPass _1)

Defined in GHC.Hs.Decls

type XXRuleBndr (GhcPass _1) = NoExtCon

type XWarnings (GhcPass _1)

Defined in GHC.Hs.Decls

type XWarnings (GhcPass _1) = NoExtField

type XXWarnDecls (GhcPass _1)

Defined in GHC.Hs.Decls

type XXWarnDecls (GhcPass _1) = NoExtCon

type XWarning (GhcPass _1)

Defined in GHC.Hs.Decls

type XWarning (GhcPass _1) = NoExtField

type XXWarnDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXWarnDecl (GhcPass _1) = NoExtCon

type XHsAnnotation (GhcPass _1)

Defined in GHC.Hs.Decls

type XHsAnnotation (GhcPass _1) = NoExtField

type XXAnnDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXAnnDecl (GhcPass _1) = NoExtCon

type XCRoleAnnotDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XCRoleAnnotDecl (GhcPass _1) = NoExtField

type XXRoleAnnotDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXRoleAnnotDecl (GhcPass _1) = NoExtCon

type XVar (GhcPass _1)

Defined in GHC.Hs.Expr

type XVar (GhcPass _1) = NoExtField

type XUnboundVar (GhcPass _1)

Defined in GHC.Hs.Expr

type XUnboundVar (GhcPass _1) = NoExtField

type XConLikeOut (GhcPass _1)

Defined in GHC.Hs.Expr

type XConLikeOut (GhcPass _1) = NoExtField

type XRecFld (GhcPass _1)

Defined in GHC.Hs.Expr

type XRecFld (GhcPass _1) = NoExtField

type XOverLabel (GhcPass _1)

Defined in GHC.Hs.Expr

type XOverLabel (GhcPass _1) = NoExtField

type XIPVar (GhcPass _1)

Defined in GHC.Hs.Expr

type XIPVar (GhcPass _1) = NoExtField

type XOverLitE (GhcPass _1)

Defined in GHC.Hs.Expr

type XOverLitE (GhcPass _1) = NoExtField

type XLitE (GhcPass _1)

Defined in GHC.Hs.Expr

type XLitE (GhcPass _1) = NoExtField

type XLam (GhcPass _1)

Defined in GHC.Hs.Expr

type XLam (GhcPass _1) = NoExtField

type XLamCase (GhcPass _1)

Defined in GHC.Hs.Expr

type XLamCase (GhcPass _1) = NoExtField

type XApp (GhcPass _1)

Defined in GHC.Hs.Expr

type XApp (GhcPass _1) = NoExtField

type XAppTypeE (GhcPass _1)

Defined in GHC.Hs.Expr

type XAppTypeE (GhcPass _1) = NoExtField

type XNegApp (GhcPass _1)

Defined in GHC.Hs.Expr

type XNegApp (GhcPass _1) = NoExtField

type XPar (GhcPass _1)

Defined in GHC.Hs.Expr

type XPar (GhcPass _1) = NoExtField

type XSectionL (GhcPass _1)

Defined in GHC.Hs.Expr

type XSectionL (GhcPass _1) = NoExtField

type XSectionR (GhcPass _1)

Defined in GHC.Hs.Expr

type XSectionR (GhcPass _1) = NoExtField

type XExplicitTuple (GhcPass _1)

Defined in GHC.Hs.Expr

type XExplicitTuple (GhcPass _1) = NoExtField

type XCase (GhcPass _1)

Defined in GHC.Hs.Expr

type XCase (GhcPass _1) = NoExtField

type XIf (GhcPass _1)

Defined in GHC.Hs.Expr

type XIf (GhcPass _1) = NoExtField

type XLet (GhcPass _1)

Defined in GHC.Hs.Expr

type XLet (GhcPass _1) = NoExtField

type XExprWithTySig (GhcPass _1)

Defined in GHC.Hs.Expr

type XExprWithTySig (GhcPass _1) = NoExtField

type XSCC (GhcPass _1)

Defined in GHC.Hs.Expr

type XSCC (GhcPass _1) = NoExtField

type XCoreAnn (GhcPass _1)

Defined in GHC.Hs.Expr

type XCoreAnn (GhcPass _1) = NoExtField

type XBracket (GhcPass _1)

Defined in GHC.Hs.Expr

type XBracket (GhcPass _1) = NoExtField

type XRnBracketOut (GhcPass _1)

Defined in GHC.Hs.Expr

type XRnBracketOut (GhcPass _1) = NoExtField

type XTcBracketOut (GhcPass _1)

Defined in GHC.Hs.Expr

type XTcBracketOut (GhcPass _1) = NoExtField

type XSpliceE (GhcPass _1)

Defined in GHC.Hs.Expr

type XSpliceE (GhcPass _1) = NoExtField

type XProc (GhcPass _1)

Defined in GHC.Hs.Expr

type XProc (GhcPass _1) = NoExtField

type XTick (GhcPass _1)

Defined in GHC.Hs.Expr

type XTick (GhcPass _1) = NoExtField

type XBinTick (GhcPass _1)

Defined in GHC.Hs.Expr

type XBinTick (GhcPass _1) = NoExtField

type XTickPragma (GhcPass _1)

Defined in GHC.Hs.Expr

type XTickPragma (GhcPass _1) = NoExtField

type XWrap (GhcPass _1)

Defined in GHC.Hs.Expr

type XWrap (GhcPass _1) = NoExtField

type XXExpr (GhcPass _1)

Defined in GHC.Hs.Expr

type XXExpr (GhcPass _1) = NoExtCon

type XXAmbiguousFieldOcc (GhcPass _1)

Defined in GHC.Hs.Types

type XXAmbiguousFieldOcc (GhcPass _1) = NoExtCon

type XPresent (GhcPass _1)

Defined in GHC.Hs.Expr

type XPresent (GhcPass _1) = NoExtField

type XXTupArg (GhcPass _1)

Defined in GHC.Hs.Expr

type XXTupArg (GhcPass _1) = NoExtCon

type XTypedSplice (GhcPass _1)

Defined in GHC.Hs.Expr

type XTypedSplice (GhcPass _1) = NoExtField

type XUntypedSplice (GhcPass _1)

Defined in GHC.Hs.Expr

type XUntypedSplice (GhcPass _1) = NoExtField

type XQuasiQuote (GhcPass _1)

Defined in GHC.Hs.Expr

type XQuasiQuote (GhcPass _1) = NoExtField

type XSpliced (GhcPass _1)

Defined in GHC.Hs.Expr

type XSpliced (GhcPass _1) = NoExtField

type XXSplice (GhcPass _1)

Defined in GHC.Hs.Expr

type XXSplice (GhcPass _1) = NoExtCon

type XExpBr (GhcPass _1)

Defined in GHC.Hs.Expr

type XExpBr (GhcPass _1) = NoExtField

type XPatBr (GhcPass _1)

Defined in GHC.Hs.Expr

type XPatBr (GhcPass _1) = NoExtField

type XDecBrL (GhcPass _1)

Defined in GHC.Hs.Expr

type XDecBrL (GhcPass _1) = NoExtField

type XDecBrG (GhcPass _1)

Defined in GHC.Hs.Expr

type XDecBrG (GhcPass _1) = NoExtField

type XTypBr (GhcPass _1)

Defined in GHC.Hs.Expr

type XTypBr (GhcPass _1) = NoExtField

type XVarBr (GhcPass _1)

Defined in GHC.Hs.Expr

type XVarBr (GhcPass _1) = NoExtField

type XTExpBr (GhcPass _1)

Defined in GHC.Hs.Expr

type XTExpBr (GhcPass _1) = NoExtField

type XXBracket (GhcPass _1)

Defined in GHC.Hs.Expr

type XXBracket (GhcPass _1) = NoExtCon

type XXCmdTop (GhcPass _1)

Defined in GHC.Hs.Expr

type XXCmdTop (GhcPass _1) = NoExtCon

type XCmdArrForm (GhcPass _1)

Defined in GHC.Hs.Expr

type XCmdArrForm (GhcPass _1) = NoExtField

type XCmdApp (GhcPass _1)

Defined in GHC.Hs.Expr

type XCmdApp (GhcPass _1) = NoExtField

type XCmdLam (GhcPass _1)

Defined in GHC.Hs.Expr

type XCmdLam (GhcPass _1) = NoExtField

type XCmdPar (GhcPass _1)

Defined in GHC.Hs.Expr

type XCmdPar (GhcPass _1) = NoExtField

type XCmdCase (GhcPass _1)

Defined in GHC.Hs.Expr

type XCmdCase (GhcPass _1) = NoExtField

type XCmdIf (GhcPass _1)

Defined in GHC.Hs.Expr

type XCmdIf (GhcPass _1) = NoExtField

type XCmdLet (GhcPass _1)

Defined in GHC.Hs.Expr

type XCmdLet (GhcPass _1) = NoExtField

type XCmdWrap (GhcPass _1)

Defined in GHC.Hs.Expr

type XCmdWrap (GhcPass _1) = NoExtField

type XXCmd (GhcPass _1)

Defined in GHC.Hs.Expr

type XXCmd (GhcPass _1) = NoExtCon

type XApplicativeArgOne (GhcPass _1)

Defined in GHC.Hs.Expr

type XApplicativeArgOne (GhcPass _1) = NoExtField

type XApplicativeArgMany (GhcPass _1)

Defined in GHC.Hs.Expr

type XApplicativeArgMany (GhcPass _1) = NoExtField

type XXApplicativeArg (GhcPass _1)

Defined in GHC.Hs.Expr

type XXApplicativeArg (GhcPass _1) = NoExtCon

type XHsChar (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsChar (GhcPass _1) = SourceText

type XHsCharPrim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsCharPrim (GhcPass _1) = SourceText

type XHsString (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsString (GhcPass _1) = SourceText

type XHsStringPrim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsStringPrim (GhcPass _1) = SourceText

type XHsInt (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsInt (GhcPass _1) = NoExtField

type XHsIntPrim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsIntPrim (GhcPass _1) = SourceText

type XHsWordPrim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsWordPrim (GhcPass _1) = SourceText

type XHsInt64Prim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsInt64Prim (GhcPass _1) = SourceText

type XHsWord64Prim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsWord64Prim (GhcPass _1) = SourceText

type XHsInteger (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsInteger (GhcPass _1) = SourceText

type XHsRat (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsRat (GhcPass _1) = NoExtField

type XHsFloatPrim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsFloatPrim (GhcPass _1) = NoExtField

type XHsDoublePrim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsDoublePrim (GhcPass _1) = NoExtField

type XXLit (GhcPass _1)

Defined in GHC.Hs.Lit

type XXLit (GhcPass _1) = NoExtCon

type XXOverLit (GhcPass _1)

Defined in GHC.Hs.Lit

type XXOverLit (GhcPass _1) = NoExtCon

type XVarPat (GhcPass _1)

Defined in GHC.Hs.Pat

type XVarPat (GhcPass _1) = NoExtField

type XLazyPat (GhcPass _1)

Defined in GHC.Hs.Pat

type XLazyPat (GhcPass _1) = NoExtField

type XAsPat (GhcPass _1)

Defined in GHC.Hs.Pat

type XAsPat (GhcPass _1) = NoExtField

type XParPat (GhcPass _1)

Defined in GHC.Hs.Pat

type XParPat (GhcPass _1) = NoExtField

type XBangPat (GhcPass _1)

Defined in GHC.Hs.Pat

type XBangPat (GhcPass _1) = NoExtField

type XSplicePat (GhcPass _1)

Defined in GHC.Hs.Pat

type XSplicePat (GhcPass _1) = NoExtField

type XLitPat (GhcPass _1)

Defined in GHC.Hs.Pat

type XLitPat (GhcPass _1) = NoExtField

type XCoPat (GhcPass _1)

Defined in GHC.Hs.Pat

type XCoPat (GhcPass _1) = NoExtField

type XXPat (GhcPass _1)

Defined in GHC.Hs.Pat

type XXPat (GhcPass _1) = NoExtCon

type XXLHsQTyVars (GhcPass _1)

Defined in GHC.Hs.Types

type XXLHsQTyVars (GhcPass _1) = NoExtCon

type XForAllTy (GhcPass _1)

Defined in GHC.Hs.Types

type XForAllTy (GhcPass _1) = NoExtField

type XQualTy (GhcPass _1)

Defined in GHC.Hs.Types

type XQualTy (GhcPass _1) = NoExtField

type XTyVar (GhcPass _1)

Defined in GHC.Hs.Types

type XTyVar (GhcPass _1) = NoExtField

type XAppTy (GhcPass _1)

Defined in GHC.Hs.Types

type XAppTy (GhcPass _1) = NoExtField

type XAppKindTy (GhcPass _1)

Defined in GHC.Hs.Types

type XAppKindTy (GhcPass _1) = SrcSpan

type XFunTy (GhcPass _1)

Defined in GHC.Hs.Types

type XFunTy (GhcPass _1) = NoExtField

type XListTy (GhcPass _1)

Defined in GHC.Hs.Types

type XListTy (GhcPass _1) = NoExtField

type XTupleTy (GhcPass _1)

Defined in GHC.Hs.Types

type XTupleTy (GhcPass _1) = NoExtField

type XSumTy (GhcPass _1)

Defined in GHC.Hs.Types

type XSumTy (GhcPass _1) = NoExtField

type XOpTy (GhcPass _1)

Defined in GHC.Hs.Types

type XOpTy (GhcPass _1) = NoExtField

type XParTy (GhcPass _1)

Defined in GHC.Hs.Types

type XParTy (GhcPass _1) = NoExtField

type XIParamTy (GhcPass _1)

Defined in GHC.Hs.Types

type XIParamTy (GhcPass _1) = NoExtField

type XStarTy (GhcPass _1)

Defined in GHC.Hs.Types

type XStarTy (GhcPass _1) = NoExtField

type XKindSig (GhcPass _1)

Defined in GHC.Hs.Types

type XKindSig (GhcPass _1) = NoExtField

type XDocTy (GhcPass _1)

Defined in GHC.Hs.Types

type XDocTy (GhcPass _1) = NoExtField

type XBangTy (GhcPass _1)

Defined in GHC.Hs.Types

type XBangTy (GhcPass _1) = NoExtField

type XRecTy (GhcPass _1)

Defined in GHC.Hs.Types

type XRecTy (GhcPass _1) = NoExtField

type XTyLit (GhcPass _1)

Defined in GHC.Hs.Types

type XTyLit (GhcPass _1) = NoExtField

type XWildCardTy (GhcPass _1)

Defined in GHC.Hs.Types

type XWildCardTy (GhcPass _1) = NoExtField

type XXType (GhcPass _1)

Defined in GHC.Hs.Types

type XXType (GhcPass _1) = NewHsTypeX

type XUserTyVar (GhcPass _1)

Defined in GHC.Hs.Types

type XUserTyVar (GhcPass _1) = NoExtField

type XKindedTyVar (GhcPass _1)

Defined in GHC.Hs.Types

type XKindedTyVar (GhcPass _1) = NoExtField

type XXTyVarBndr (GhcPass _1)

Defined in GHC.Hs.Types

type XXTyVarBndr (GhcPass _1) = NoExtCon

type XConDeclField (GhcPass _1)

Defined in GHC.Hs.Types

type XConDeclField (GhcPass _1) = NoExtField

type XXConDeclField (GhcPass _1)

Defined in GHC.Hs.Types

type XXConDeclField (GhcPass _1) = NoExtCon

type XXFieldOcc (GhcPass _1)

Defined in GHC.Hs.Types

type XXFieldOcc (GhcPass _1) = NoExtCon

type XCImportDecl (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XCImportDecl (GhcPass _1) = NoExtField

type XXImportDecl (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XXImportDecl (GhcPass _1) = NoExtCon

type XIEVar (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XIEVar (GhcPass _1) = NoExtField

type XIEThingAbs (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XIEThingAbs (GhcPass _1) = NoExtField

type XIEThingAll (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XIEThingAll (GhcPass _1) = NoExtField

type XIEThingWith (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XIEThingWith (GhcPass _1) = NoExtField

type XIEModuleContents (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XIEModuleContents (GhcPass _1) = NoExtField

type XIEGroup (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XIEGroup (GhcPass _1) = NoExtField

type XIEDoc (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XIEDoc (GhcPass _1) = NoExtField

type XIEDocNamed (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XIEDocNamed (GhcPass _1) = NoExtField

type XXIE (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XXIE (GhcPass _1) = NoExtCon

type XRec (GhcPass p) f

Defined in GHC.Hs.Extension

type XRec (GhcPass p) f = Located (f (GhcPass p))

type XFunBind (GhcPass pL) GhcTc

Defined in GHC.Hs.Binds

type XFunBind (GhcPass pL) GhcTc = NameSet

type XFunBind (GhcPass pL) GhcRn

Defined in GHC.Hs.Binds

type XFunBind (GhcPass pL) GhcRn = NameSet

type XFunBind (GhcPass pL) GhcPs

Defined in GHC.Hs.Binds

type XFunBind (GhcPass pL) GhcPs = NoExtField

type XPSB (GhcPass idL) GhcTc

Defined in GHC.Hs.Binds

type XPSB (GhcPass idL) GhcTc = NameSet

type XPSB (GhcPass idL) GhcRn

Defined in GHC.Hs.Binds

type XPSB (GhcPass idL) GhcRn = NameSet

type XPSB (GhcPass idL) GhcPs

Defined in GHC.Hs.Binds

type XPSB (GhcPass idL) GhcPs = NoExtField

type XCFamEqn (GhcPass _1) r

Defined in GHC.Hs.Decls

type XCFamEqn (GhcPass _1) r = NoExtField

type XXFamEqn (GhcPass _1) r

Defined in GHC.Hs.Decls

type XXFamEqn (GhcPass _1) r = NoExtCon

type XXMatchGroup (GhcPass _1) b

Defined in GHC.Hs.Expr

type XXMatchGroup (GhcPass _1) b = NoExtCon

type XCMatch (GhcPass _1) b

Defined in GHC.Hs.Expr

type XCMatch (GhcPass _1) b = NoExtField

type XXMatch (GhcPass _1) b

Defined in GHC.Hs.Expr

type XXMatch (GhcPass _1) b = NoExtCon

type XCGRHSs (GhcPass _1) b

Defined in GHC.Hs.Expr

type XCGRHSs (GhcPass _1) b = NoExtField

type XXGRHSs (GhcPass _1) b

Defined in GHC.Hs.Expr

type XXGRHSs (GhcPass _1) b = NoExtCon

type XCGRHS (GhcPass _1) b

Defined in GHC.Hs.Expr

type XCGRHS (GhcPass _1) b = NoExtField

type XXGRHS (GhcPass _1) b

Defined in GHC.Hs.Expr

type XXGRHS (GhcPass _1) b = NoExtCon

type XXHsImplicitBndrs (GhcPass _1) _2

Defined in GHC.Hs.Types

type XXHsImplicitBndrs (GhcPass _1) _2 = NoExtCon

type XXHsWildCardBndrs (GhcPass _1) b

Defined in GHC.Hs.Types

type XXHsWildCardBndrs (GhcPass _1) b = NoExtCon

type XBindStmt (GhcPass _1) GhcTc b

Defined in GHC.Hs.Expr

type XBindStmt (GhcPass _1) GhcTc b = Type

type XBindStmt (GhcPass _1) GhcRn b

Defined in GHC.Hs.Expr

type XBindStmt (GhcPass _1) GhcRn b = NoExtField

type XBindStmt (GhcPass _1) GhcPs b

Defined in GHC.Hs.Expr

type XBindStmt (GhcPass _1) GhcPs b = NoExtField

type XApplicativeStmt (GhcPass _1) GhcTc b

Defined in GHC.Hs.Expr

type XApplicativeStmt (GhcPass _1) GhcTc b = Type

type XApplicativeStmt (GhcPass _1) GhcRn b

Defined in GHC.Hs.Expr

type XApplicativeStmt (GhcPass _1) GhcRn b = NoExtField

type XApplicativeStmt (GhcPass _1) GhcPs b

Defined in GHC.Hs.Expr

type XApplicativeStmt (GhcPass _1) GhcPs b = NoExtField

type XBodyStmt (GhcPass _1) GhcTc b

Defined in GHC.Hs.Expr

type XBodyStmt (GhcPass _1) GhcTc b = Type

type XBodyStmt (GhcPass _1) GhcRn b

Defined in GHC.Hs.Expr

type XBodyStmt (GhcPass _1) GhcRn b = NoExtField

type XBodyStmt (GhcPass _1) GhcPs b

Defined in GHC.Hs.Expr

type XBodyStmt (GhcPass _1) GhcPs b = NoExtField

type XParStmt (GhcPass _1) GhcTc b

Defined in GHC.Hs.Expr

type XParStmt (GhcPass _1) GhcTc b = Type

type XParStmt (GhcPass _1) GhcRn b

Defined in GHC.Hs.Expr

type XParStmt (GhcPass _1) GhcRn b = NoExtField

type XParStmt (GhcPass _1) GhcPs b

Defined in GHC.Hs.Expr

type XParStmt (GhcPass _1) GhcPs b = NoExtField

type XTransStmt (GhcPass _1) GhcTc b

Defined in GHC.Hs.Expr

type XTransStmt (GhcPass _1) GhcTc b = Type

type XTransStmt (GhcPass _1) GhcRn b

Defined in GHC.Hs.Expr

type XTransStmt (GhcPass _1) GhcRn b = NoExtField

type XTransStmt (GhcPass _1) GhcPs b

Defined in GHC.Hs.Expr

type XTransStmt (GhcPass _1) GhcPs b = NoExtField

type XRecStmt (GhcPass _1) GhcRn b

Defined in GHC.Hs.Expr

type XRecStmt (GhcPass _1) GhcRn b = NoExtField

type XRecStmt (GhcPass _1) GhcPs b

Defined in GHC.Hs.Expr

type XRecStmt (GhcPass _1) GhcPs b = NoExtField

type XRecStmt (GhcPass _1) GhcTc b

Defined in GHC.Hs.Expr

type XRecStmt (GhcPass _1) GhcTc b = RecStmtTc

type XHsValBinds (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XHsValBinds (GhcPass pL) (GhcPass pR) = NoExtField

type XHsIPBinds (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XHsIPBinds (GhcPass pL) (GhcPass pR) = NoExtField

type XEmptyLocalBinds (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XEmptyLocalBinds (GhcPass pL) (GhcPass pR) = NoExtField

type XXHsLocalBindsLR (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XXHsLocalBindsLR (GhcPass pL) (GhcPass pR) = NoExtCon

type XValBinds (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XValBinds (GhcPass pL) (GhcPass pR) = NoExtField

type XXValBindsLR (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XXValBindsLR (GhcPass pL) (GhcPass pR) = NHsValBindsLR (GhcPass pL)

type XVarBind (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XVarBind (GhcPass pL) (GhcPass pR) = NoExtField

type XAbsBinds (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XAbsBinds (GhcPass pL) (GhcPass pR) = NoExtField

type XPatSynBind (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XPatSynBind (GhcPass pL) (GhcPass pR) = NoExtField

type XXHsBindsLR (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XXHsBindsLR (GhcPass pL) (GhcPass pR) = NoExtCon

type XXPatSynBind (GhcPass idL) (GhcPass idR)

Defined in GHC.Hs.Binds

type XXPatSynBind (GhcPass idL) (GhcPass idR) = NoExtCon

type XParStmtBlock (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Expr

type XParStmtBlock (GhcPass pL) (GhcPass pR) = NoExtField

type XXParStmtBlock (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Expr

type XXParStmtBlock (GhcPass pL) (GhcPass pR) = NoExtCon

type XLastStmt (GhcPass _1) (GhcPass _2) b

Defined in GHC.Hs.Expr

type XLastStmt (GhcPass _1) (GhcPass _2) b = NoExtField

type XLetStmt (GhcPass _1) (GhcPass _2) b

Defined in GHC.Hs.Expr

type XLetStmt (GhcPass _1) (GhcPass _2) b = NoExtField

type XXStmtLR (GhcPass _1) (GhcPass _2) b

Defined in GHC.Hs.Expr

type XXStmtLR (GhcPass _1) (GhcPass _2) b = NoExtCon

data Pass

Constructors

Parsed

Renamed

Typechecked

Instances

Data Pass

Defined in GHC.Hs.Extension

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Pass -> c Pass

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Pass

toConstr :: Pass -> Constr

dataTypeOf :: Pass -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Pass)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pass)

gmapT :: (forall b. Data b => b -> b) -> Pass -> Pass

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pass -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pass -> r

gmapQ :: (forall d. Data d => d -> u) -> Pass -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Pass -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Pass -> m Pass

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Pass -> m Pass

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Pass -> m Pass

type GhcPs = GhcPass 'Parsed

type GhcRn = GhcPass 'Renamed

type GhcTc = GhcPass 'Typechecked

type GhcTcId = GhcTc

type family XRec p (f :: Type -> Type) = (r :: Type) | r -> p f

GHC's L prefixed variants wrap their vanilla variant in this type family, to add SrcLoc info via Located. Other passes than GhcPass not interested in location information can define this instance as f p.

Instances

type XRec (GhcPass p) f

Defined in GHC.Hs.Extension

type XRec (GhcPass p) f = Located (f (GhcPass p))

type family IdP p

Maps the "normal" id type for a given pass

Instances

type IdP GhcPs

Defined in GHC.Hs.Extension

type IdP GhcPs = RdrName

type IdP GhcRn

Defined in GHC.Hs.Extension

type IdP GhcRn = Name

type IdP GhcTc

Defined in GHC.Hs.Extension

type IdP GhcTc = Id

type LIdP p = Located (IdP p)

type family NoGhcTc p where ...

Marks that a field uses the GhcRn variant even when the pass parameter is GhcTc. Useful for storing HsTypes in GHC.Hs.Exprs, say, because HsType GhcTc should never occur.

Equations

NoGhcTc (GhcPass pass) = GhcPass (NoGhcTcPass pass)

NoGhcTc other = other

type family NoGhcTcPass (p :: Pass) :: Pass where ...

Equations

NoGhcTcPass 'Typechecked = 'Renamed

NoGhcTcPass other = other

type family XHsValBinds x x'

Instances

type XHsValBinds (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XHsValBinds (GhcPass pL) (GhcPass pR) = NoExtField

type family XHsIPBinds x x'

Instances

type XHsIPBinds (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XHsIPBinds (GhcPass pL) (GhcPass pR) = NoExtField

type family XEmptyLocalBinds x x'

Instances

type XEmptyLocalBinds (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XEmptyLocalBinds (GhcPass pL) (GhcPass pR) = NoExtField

type family XXHsLocalBindsLR x x'

Instances

type XXHsLocalBindsLR (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XXHsLocalBindsLR (GhcPass pL) (GhcPass pR) = NoExtCon

type ForallXHsLocalBindsLR (c :: Type -> Constraint) x x' = (c (XHsValBinds x x'), c (XHsIPBinds x x'), c (XEmptyLocalBinds x x'), c (XXHsLocalBindsLR x x'))

type family XValBinds x x'

Instances

type XValBinds (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XValBinds (GhcPass pL) (GhcPass pR) = NoExtField

type family XXValBindsLR x x'

Instances

type XXValBindsLR (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XXValBindsLR (GhcPass pL) (GhcPass pR) = NHsValBindsLR (GhcPass pL)

type ForallXValBindsLR (c :: Type -> Constraint) x x' = (c (XValBinds x x'), c (XXValBindsLR x x'))

type family XFunBind x x'

Instances

type XFunBind (GhcPass pL) GhcTc

Defined in GHC.Hs.Binds

type XFunBind (GhcPass pL) GhcTc = NameSet

type XFunBind (GhcPass pL) GhcRn

Defined in GHC.Hs.Binds

type XFunBind (GhcPass pL) GhcRn = NameSet

type XFunBind (GhcPass pL) GhcPs

Defined in GHC.Hs.Binds

type XFunBind (GhcPass pL) GhcPs = NoExtField

type family XPatBind x x'

Instances

type XPatBind GhcPs (GhcPass pR)

Defined in GHC.Hs.Binds

type XPatBind GhcPs (GhcPass pR) = NoExtField

type XPatBind GhcRn (GhcPass pR)

Defined in GHC.Hs.Binds

type XPatBind GhcRn (GhcPass pR) = NameSet

type XPatBind GhcTc (GhcPass pR)

Defined in GHC.Hs.Binds

type XPatBind GhcTc (GhcPass pR) = NPatBindTc

type family XVarBind x x'

Instances

type XVarBind (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XVarBind (GhcPass pL) (GhcPass pR) = NoExtField

type family XAbsBinds x x'

Instances

type XAbsBinds (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XAbsBinds (GhcPass pL) (GhcPass pR) = NoExtField

type family XPatSynBind x x'

Instances

type XPatSynBind (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XPatSynBind (GhcPass pL) (GhcPass pR) = NoExtField

type family XXHsBindsLR x x'

Instances

type XXHsBindsLR (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Binds

type XXHsBindsLR (GhcPass pL) (GhcPass pR) = NoExtCon

type ForallXHsBindsLR (c :: Type -> Constraint) x x' = (c (XFunBind x x'), c (XPatBind x x'), c (XVarBind x x'), c (XAbsBinds x x'), c (XPatSynBind x x'), c (XXHsBindsLR x x'))

type family XABE x

Instances

type XABE (GhcPass p)

Defined in GHC.Hs.Binds

type XABE (GhcPass p) = NoExtField

type family XXABExport x

Instances

type XXABExport (GhcPass p)

Defined in GHC.Hs.Binds

type XXABExport (GhcPass p) = NoExtCon

type ForallXABExport (c :: Type -> Constraint) x = (c (XABE x), c (XXABExport x))

type family XPSB x x'

Instances

type XPSB (GhcPass idL) GhcTc

Defined in GHC.Hs.Binds

type XPSB (GhcPass idL) GhcTc = NameSet

type XPSB (GhcPass idL) GhcRn

Defined in GHC.Hs.Binds

type XPSB (GhcPass idL) GhcRn = NameSet

type XPSB (GhcPass idL) GhcPs

Defined in GHC.Hs.Binds

type XPSB (GhcPass idL) GhcPs = NoExtField

type family XXPatSynBind x x'

Instances

type XXPatSynBind (GhcPass idL) (GhcPass idR)

Defined in GHC.Hs.Binds

type XXPatSynBind (GhcPass idL) (GhcPass idR) = NoExtCon

type ForallXPatSynBind (c :: Type -> Constraint) x x' = (c (XPSB x x'), c (XXPatSynBind x x'))

type family XIPBinds x

Instances

type XIPBinds GhcPs

Defined in GHC.Hs.Binds

type XIPBinds GhcPs = NoExtField

type XIPBinds GhcRn

Defined in GHC.Hs.Binds

type XIPBinds GhcRn = NoExtField

type XIPBinds GhcTc

Defined in GHC.Hs.Binds

type XIPBinds GhcTc = TcEvBinds

type family XXHsIPBinds x

Instances

type XXHsIPBinds (GhcPass p)

Defined in GHC.Hs.Binds

type XXHsIPBinds (GhcPass p) = NoExtCon

type ForallXHsIPBinds (c :: Type -> Constraint) x = (c (XIPBinds x), c (XXHsIPBinds x))

type family XCIPBind x

Instances

type XCIPBind (GhcPass p)

Defined in GHC.Hs.Binds

type XCIPBind (GhcPass p) = NoExtField

type family XXIPBind x

Instances

type XXIPBind (GhcPass p)

Defined in GHC.Hs.Binds

type XXIPBind (GhcPass p) = NoExtCon

type ForallXIPBind (c :: Type -> Constraint) x = (c (XCIPBind x), c (XXIPBind x))

type family XTypeSig x

Instances

type XTypeSig (GhcPass p)

Defined in GHC.Hs.Binds

type XTypeSig (GhcPass p) = NoExtField

type family XPatSynSig x

Instances

type XPatSynSig (GhcPass p)

Defined in GHC.Hs.Binds

type XPatSynSig (GhcPass p) = NoExtField

type family XClassOpSig x

Instances

type XClassOpSig (GhcPass p)

Defined in GHC.Hs.Binds

type XClassOpSig (GhcPass p) = NoExtField

type family XIdSig x

Instances

type XIdSig (GhcPass p)

Defined in GHC.Hs.Binds

type XIdSig (GhcPass p) = NoExtField

type family XFixSig x

Instances

type XFixSig (GhcPass p)

Defined in GHC.Hs.Binds

type XFixSig (GhcPass p) = NoExtField

type family XInlineSig x

Instances

type XInlineSig (GhcPass p)

Defined in GHC.Hs.Binds

type XInlineSig (GhcPass p) = NoExtField

type family XSpecSig x

Instances

type XSpecSig (GhcPass p)

Defined in GHC.Hs.Binds

type XSpecSig (GhcPass p) = NoExtField

type family XSpecInstSig x

Instances

type XSpecInstSig (GhcPass p)

Defined in GHC.Hs.Binds

type XSpecInstSig (GhcPass p) = NoExtField

type family XMinimalSig x

Instances

type XMinimalSig (GhcPass p)

Defined in GHC.Hs.Binds

type XMinimalSig (GhcPass p) = NoExtField

type family XSCCFunSig x

Instances

type XSCCFunSig (GhcPass p)

Defined in GHC.Hs.Binds

type XSCCFunSig (GhcPass p) = NoExtField

type family XCompleteMatchSig x

Instances

type XCompleteMatchSig (GhcPass p)

Defined in GHC.Hs.Binds

type XCompleteMatchSig (GhcPass p) = NoExtField

type family XXSig x

Instances

type XXSig (GhcPass p)

Defined in GHC.Hs.Binds

type XXSig (GhcPass p) = NoExtCon

type ForallXSig (c :: Type -> Constraint) x = (c (XTypeSig x), c (XPatSynSig x), c (XClassOpSig x), c (XIdSig x), c (XFixSig x), c (XInlineSig x), c (XSpecSig x), c (XSpecInstSig x), c (XMinimalSig x), c (XSCCFunSig x), c (XCompleteMatchSig x), c (XXSig x))

type family XFixitySig x

Instances

type XFixitySig (GhcPass p)

Defined in GHC.Hs.Binds

type XFixitySig (GhcPass p) = NoExtField

type family XXFixitySig x

Instances

type XXFixitySig (GhcPass p)

Defined in GHC.Hs.Binds

type XXFixitySig (GhcPass p) = NoExtCon

type ForallXFixitySig (c :: Type -> Constraint) x = (c (XFixitySig x), c (XXFixitySig x))

type family XStandaloneKindSig x

Instances

type XStandaloneKindSig (GhcPass p)

Defined in GHC.Hs.Decls

type XStandaloneKindSig (GhcPass p) = NoExtField

type family XXStandaloneKindSig x

Instances

type XXStandaloneKindSig (GhcPass p)

Defined in GHC.Hs.Decls

type XXStandaloneKindSig (GhcPass p) = NoExtCon

type family XTyClD x

Instances

type XTyClD (GhcPass _1)

Defined in GHC.Hs.Decls

type XTyClD (GhcPass _1) = NoExtField

type family XInstD x

Instances

type XInstD (GhcPass _1)

Defined in GHC.Hs.Decls

type XInstD (GhcPass _1) = NoExtField

type family XDerivD x

Instances

type XDerivD (GhcPass _1)

Defined in GHC.Hs.Decls

type XDerivD (GhcPass _1) = NoExtField

type family XValD x

Instances

type XValD (GhcPass _1)

Defined in GHC.Hs.Decls

type XValD (GhcPass _1) = NoExtField

type family XSigD x

Instances

type XSigD (GhcPass _1)

Defined in GHC.Hs.Decls

type XSigD (GhcPass _1) = NoExtField

type family XKindSigD x

Instances

type XKindSigD (GhcPass _1)

Defined in GHC.Hs.Decls

type XKindSigD (GhcPass _1) = NoExtField

type family XDefD x

Instances

type XDefD (GhcPass _1)

Defined in GHC.Hs.Decls

type XDefD (GhcPass _1) = NoExtField

type family XForD x

Instances

type XForD (GhcPass _1)

Defined in GHC.Hs.Decls

type XForD (GhcPass _1) = NoExtField

type family XWarningD x

Instances

type XWarningD (GhcPass _1)

Defined in GHC.Hs.Decls

type XWarningD (GhcPass _1) = NoExtField

type family XAnnD x

Instances

type XAnnD (GhcPass _1)

Defined in GHC.Hs.Decls

type XAnnD (GhcPass _1) = NoExtField

type family XRuleD x

Instances

type XRuleD (GhcPass _1)

Defined in GHC.Hs.Decls

type XRuleD (GhcPass _1) = NoExtField

type family XSpliceD x

Instances

type XSpliceD (GhcPass _1)

Defined in GHC.Hs.Decls

type XSpliceD (GhcPass _1) = NoExtField

type family XDocD x

Instances

type XDocD (GhcPass _1)

Defined in GHC.Hs.Decls

type XDocD (GhcPass _1) = NoExtField

type family XRoleAnnotD x

Instances

type XRoleAnnotD (GhcPass _1)

Defined in GHC.Hs.Decls

type XRoleAnnotD (GhcPass _1) = NoExtField

type family XXHsDecl x

Instances

type XXHsDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXHsDecl (GhcPass _1) = NoExtCon

type ForallXHsDecl (c :: Type -> Constraint) x = (c (XTyClD x), c (XInstD x), c (XDerivD x), c (XValD x), c (XSigD x), c (XKindSigD x), c (XDefD x), c (XForD x), c (XWarningD x), c (XAnnD x), c (XRuleD x), c (XSpliceD x), c (XDocD x), c (XRoleAnnotD x), c (XXHsDecl x))

type family XCHsGroup x

Instances

type XCHsGroup (GhcPass _1)

Defined in GHC.Hs.Decls

type XCHsGroup (GhcPass _1) = NoExtField

type family XXHsGroup x

Instances

type XXHsGroup (GhcPass _1)

Defined in GHC.Hs.Decls

type XXHsGroup (GhcPass _1) = NoExtCon

type ForallXHsGroup (c :: Type -> Constraint) x = (c (XCHsGroup x), c (XXHsGroup x))

type family XSpliceDecl x

Instances

type XSpliceDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XSpliceDecl (GhcPass _1) = NoExtField

type family XXSpliceDecl x

Instances

type XXSpliceDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXSpliceDecl (GhcPass _1) = NoExtCon

type ForallXSpliceDecl (c :: Type -> Constraint) x = (c (XSpliceDecl x), c (XXSpliceDecl x))

type family XFamDecl x

Instances

type XFamDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XFamDecl (GhcPass _1) = NoExtField

type family XSynDecl x

Instances

type XSynDecl GhcPs

Defined in GHC.Hs.Decls

type XSynDecl GhcPs = NoExtField

type XSynDecl GhcRn

Defined in GHC.Hs.Decls

type XSynDecl GhcRn = NameSet

type XSynDecl GhcTc

Defined in GHC.Hs.Decls

type XSynDecl GhcTc = NameSet

type family XDataDecl x

Instances

type XDataDecl GhcPs

Defined in GHC.Hs.Decls

type XDataDecl GhcPs = NoExtField

type XDataDecl GhcRn

Defined in GHC.Hs.Decls

type XDataDecl GhcRn = DataDeclRn

type XDataDecl GhcTc

Defined in GHC.Hs.Decls

type XDataDecl GhcTc = DataDeclRn

type family XClassDecl x

Instances

type XClassDecl GhcPs

Defined in GHC.Hs.Decls

type XClassDecl GhcPs = NoExtField

type XClassDecl GhcRn

Defined in GHC.Hs.Decls

type XClassDecl GhcRn = NameSet

type XClassDecl GhcTc

Defined in GHC.Hs.Decls

type XClassDecl GhcTc = NameSet

type family XXTyClDecl x

Instances

type XXTyClDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXTyClDecl (GhcPass _1) = NoExtCon

type ForallXTyClDecl (c :: Type -> Constraint) x = (c (XFamDecl x), c (XSynDecl x), c (XDataDecl x), c (XClassDecl x), c (XXTyClDecl x))

type family XCTyClGroup x

Instances

type XCTyClGroup (GhcPass _1)

Defined in GHC.Hs.Decls

type XCTyClGroup (GhcPass _1) = NoExtField

type family XXTyClGroup x

Instances

type XXTyClGroup (GhcPass _1)

Defined in GHC.Hs.Decls

type XXTyClGroup (GhcPass _1) = NoExtCon

type ForallXTyClGroup (c :: Type -> Constraint) x = (c (XCTyClGroup x), c (XXTyClGroup x))

type family XNoSig x

Instances

type XNoSig (GhcPass _1)

Defined in GHC.Hs.Decls

type XNoSig (GhcPass _1) = NoExtField

type family XCKindSig x

Instances

type XCKindSig (GhcPass _1)

Defined in GHC.Hs.Decls

type XCKindSig (GhcPass _1) = NoExtField

type family XTyVarSig x

Instances

type XTyVarSig (GhcPass _1)

Defined in GHC.Hs.Decls

type XTyVarSig (GhcPass _1) = NoExtField

type family XXFamilyResultSig x

Instances

type XXFamilyResultSig (GhcPass _1)

Defined in GHC.Hs.Decls

type XXFamilyResultSig (GhcPass _1) = NoExtCon

type ForallXFamilyResultSig (c :: Type -> Constraint) x = (c (XNoSig x), c (XCKindSig x), c (XTyVarSig x), c (XXFamilyResultSig x))

type family XCFamilyDecl x

Instances

type XCFamilyDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XCFamilyDecl (GhcPass _1) = NoExtField

type family XXFamilyDecl x

Instances

type XXFamilyDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXFamilyDecl (GhcPass _1) = NoExtCon

type ForallXFamilyDecl (c :: Type -> Constraint) x = (c (XCFamilyDecl x), c (XXFamilyDecl x))

type family XCHsDataDefn x

Instances

type XCHsDataDefn (GhcPass _1)

Defined in GHC.Hs.Decls

type XCHsDataDefn (GhcPass _1) = NoExtField

type family XXHsDataDefn x

Instances

type XXHsDataDefn (GhcPass _1)

Defined in GHC.Hs.Decls

type XXHsDataDefn (GhcPass _1) = NoExtCon

type ForallXHsDataDefn (c :: Type -> Constraint) x = (c (XCHsDataDefn x), c (XXHsDataDefn x))

type family XCHsDerivingClause x

Instances

type XCHsDerivingClause (GhcPass _1)

Defined in GHC.Hs.Decls

type XCHsDerivingClause (GhcPass _1) = NoExtField

type family XXHsDerivingClause x

Instances

type XXHsDerivingClause (GhcPass _1)

Defined in GHC.Hs.Decls

type XXHsDerivingClause (GhcPass _1) = NoExtCon

type ForallXHsDerivingClause (c :: Type -> Constraint) x = (c (XCHsDerivingClause x), c (XXHsDerivingClause x))

type family XConDeclGADT x

Instances

type XConDeclGADT (GhcPass _1)

Defined in GHC.Hs.Decls

type XConDeclGADT (GhcPass _1) = NoExtField

type family XConDeclH98 x

Instances

type XConDeclH98 (GhcPass _1)

Defined in GHC.Hs.Decls

type XConDeclH98 (GhcPass _1) = NoExtField

type family XXConDecl x

Instances

type XXConDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXConDecl (GhcPass _1) = NoExtCon

type ForallXConDecl (c :: Type -> Constraint) x = (c (XConDeclGADT x), c (XConDeclH98 x), c (XXConDecl x))

type family XCFamEqn x r

Instances

type XCFamEqn (GhcPass _1) r

Defined in GHC.Hs.Decls

type XCFamEqn (GhcPass _1) r = NoExtField

type family XXFamEqn x r

Instances

type XXFamEqn (GhcPass _1) r

Defined in GHC.Hs.Decls

type XXFamEqn (GhcPass _1) r = NoExtCon

type ForallXFamEqn (c :: Type -> Constraint) x r = (c (XCFamEqn x r), c (XXFamEqn x r))

type family XCClsInstDecl x

Instances

type XCClsInstDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XCClsInstDecl (GhcPass _1) = NoExtField

type family XXClsInstDecl x

Instances

type XXClsInstDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXClsInstDecl (GhcPass _1) = NoExtCon

type ForallXClsInstDecl (c :: Type -> Constraint) x = (c (XCClsInstDecl x), c (XXClsInstDecl x))

type family XClsInstD x

Instances

type XClsInstD (GhcPass _1)

Defined in GHC.Hs.Decls

type XClsInstD (GhcPass _1) = NoExtField

type family XDataFamInstD x

Instances

type XDataFamInstD (GhcPass _1)

Defined in GHC.Hs.Decls

type XDataFamInstD (GhcPass _1) = NoExtField

type family XTyFamInstD x

Instances

type XTyFamInstD (GhcPass _1)

Defined in GHC.Hs.Decls

type XTyFamInstD (GhcPass _1) = NoExtField

type family XXInstDecl x

Instances

type XXInstDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXInstDecl (GhcPass _1) = NoExtCon

type ForallXInstDecl (c :: Type -> Constraint) x = (c (XClsInstD x), c (XDataFamInstD x), c (XTyFamInstD x), c (XXInstDecl x))

type family XCDerivDecl x

Instances

type XCDerivDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XCDerivDecl (GhcPass _1) = NoExtField

type family XXDerivDecl x

Instances

type XXDerivDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXDerivDecl (GhcPass _1) = NoExtCon

type ForallXDerivDecl (c :: Type -> Constraint) x = (c (XCDerivDecl x), c (XXDerivDecl x))

type family XViaStrategy x

Instances

type XViaStrategy GhcPs

Defined in GHC.Hs.Decls

type XViaStrategy GhcPs = LHsSigType GhcPs

type XViaStrategy GhcRn

Defined in GHC.Hs.Decls

type XViaStrategy GhcRn = LHsSigType GhcRn

type XViaStrategy GhcTc

Defined in GHC.Hs.Decls

type XViaStrategy GhcTc = Type

type family XCDefaultDecl x

Instances

type XCDefaultDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XCDefaultDecl (GhcPass _1) = NoExtField

type family XXDefaultDecl x

Instances

type XXDefaultDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXDefaultDecl (GhcPass _1) = NoExtCon

type ForallXDefaultDecl (c :: Type -> Constraint) x = (c (XCDefaultDecl x), c (XXDefaultDecl x))

type family XForeignImport x

Instances

type XForeignImport GhcPs

Defined in GHC.Hs.Decls

type XForeignImport GhcPs = NoExtField

type XForeignImport GhcRn

Defined in GHC.Hs.Decls

type XForeignImport GhcRn = NoExtField

type XForeignImport GhcTc

Defined in GHC.Hs.Decls

type XForeignImport GhcTc = Coercion

type family XForeignExport x

Instances

type XForeignExport GhcPs

Defined in GHC.Hs.Decls

type XForeignExport GhcPs = NoExtField

type XForeignExport GhcRn

Defined in GHC.Hs.Decls

type XForeignExport GhcRn = NoExtField

type XForeignExport GhcTc

Defined in GHC.Hs.Decls

type XForeignExport GhcTc = Coercion

type family XXForeignDecl x

Instances

type XXForeignDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXForeignDecl (GhcPass _1) = NoExtCon

type ForallXForeignDecl (c :: Type -> Constraint) x = (c (XForeignImport x), c (XForeignExport x), c (XXForeignDecl x))

type family XCRuleDecls x

Instances

type XCRuleDecls (GhcPass _1)

Defined in GHC.Hs.Decls

type XCRuleDecls (GhcPass _1) = NoExtField

type family XXRuleDecls x

Instances

type XXRuleDecls (GhcPass _1)

Defined in GHC.Hs.Decls

type XXRuleDecls (GhcPass _1) = NoExtCon

type ForallXRuleDecls (c :: Type -> Constraint) x = (c (XCRuleDecls x), c (XXRuleDecls x))

type family XHsRule x

Instances

type XHsRule GhcPs

Defined in GHC.Hs.Decls

type XHsRule GhcPs = NoExtField

type XHsRule GhcRn

Defined in GHC.Hs.Decls

type XHsRule GhcRn = HsRuleRn

type XHsRule GhcTc

Defined in GHC.Hs.Decls

type XHsRule GhcTc = HsRuleRn

type family XXRuleDecl x

Instances

type XXRuleDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXRuleDecl (GhcPass _1) = NoExtCon

type ForallXRuleDecl (c :: Type -> Constraint) x = (c (XHsRule x), c (XXRuleDecl x))

type family XCRuleBndr x

Instances

type XCRuleBndr (GhcPass _1)

Defined in GHC.Hs.Decls

type XCRuleBndr (GhcPass _1) = NoExtField

type family XRuleBndrSig x

Instances

type XRuleBndrSig (GhcPass _1)

Defined in GHC.Hs.Decls

type XRuleBndrSig (GhcPass _1) = NoExtField

type family XXRuleBndr x

Instances

type XXRuleBndr (GhcPass _1)

Defined in GHC.Hs.Decls

type XXRuleBndr (GhcPass _1) = NoExtCon

type ForallXRuleBndr (c :: Type -> Constraint) x = (c (XCRuleBndr x), c (XRuleBndrSig x), c (XXRuleBndr x))

type family XWarnings x

Instances

type XWarnings (GhcPass _1)

Defined in GHC.Hs.Decls

type XWarnings (GhcPass _1) = NoExtField

type family XXWarnDecls x

Instances

type XXWarnDecls (GhcPass _1)

Defined in GHC.Hs.Decls

type XXWarnDecls (GhcPass _1) = NoExtCon

type ForallXWarnDecls (c :: Type -> Constraint) x = (c (XWarnings x), c (XXWarnDecls x))

type family XWarning x

Instances

type XWarning (GhcPass _1)

Defined in GHC.Hs.Decls

type XWarning (GhcPass _1) = NoExtField

type family XXWarnDecl x

Instances

type XXWarnDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXWarnDecl (GhcPass _1) = NoExtCon

type ForallXWarnDecl (c :: Type -> Constraint) x = (c (XWarning x), c (XXWarnDecl x))

type family XHsAnnotation x

Instances

type XHsAnnotation (GhcPass _1)

Defined in GHC.Hs.Decls

type XHsAnnotation (GhcPass _1) = NoExtField

type family XXAnnDecl x

Instances

type XXAnnDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXAnnDecl (GhcPass _1) = NoExtCon

type ForallXAnnDecl (c :: Type -> Constraint) x = (c (XHsAnnotation x), c (XXAnnDecl x))

type family XCRoleAnnotDecl x

Instances

type XCRoleAnnotDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XCRoleAnnotDecl (GhcPass _1) = NoExtField

type family XXRoleAnnotDecl x

Instances

type XXRoleAnnotDecl (GhcPass _1)

Defined in GHC.Hs.Decls

type XXRoleAnnotDecl (GhcPass _1) = NoExtCon

type ForallXRoleAnnotDecl (c :: Type -> Constraint) x = (c (XCRoleAnnotDecl x), c (XXRoleAnnotDecl x))

type family XVar x

Instances

type XVar (GhcPass _1)

Defined in GHC.Hs.Expr

type XVar (GhcPass _1) = NoExtField

type family XUnboundVar x

Instances

type XUnboundVar (GhcPass _1)

Defined in GHC.Hs.Expr

type XUnboundVar (GhcPass _1) = NoExtField

type family XConLikeOut x

Instances

type XConLikeOut (GhcPass _1)

Defined in GHC.Hs.Expr

type XConLikeOut (GhcPass _1) = NoExtField

type family XRecFld x

Instances

type XRecFld (GhcPass _1)

Defined in GHC.Hs.Expr

type XRecFld (GhcPass _1) = NoExtField

type family XOverLabel x

Instances

type XOverLabel (GhcPass _1)

Defined in GHC.Hs.Expr

type XOverLabel (GhcPass _1) = NoExtField

type family XIPVar x

Instances

type XIPVar (GhcPass _1)

Defined in GHC.Hs.Expr

type XIPVar (GhcPass _1) = NoExtField

type family XOverLitE x

Instances

type XOverLitE (GhcPass _1)

Defined in GHC.Hs.Expr

type XOverLitE (GhcPass _1) = NoExtField

type family XLitE x

Instances

type XLitE (GhcPass _1)

Defined in GHC.Hs.Expr

type XLitE (GhcPass _1) = NoExtField

type family XLam x

Instances

type XLam (GhcPass _1)

Defined in GHC.Hs.Expr

type XLam (GhcPass _1) = NoExtField

type family XLamCase x

Instances

type XLamCase (GhcPass _1)

Defined in GHC.Hs.Expr

type XLamCase (GhcPass _1) = NoExtField

type family XApp x

Instances

type XApp (GhcPass _1)

Defined in GHC.Hs.Expr

type XApp (GhcPass _1) = NoExtField

type family XAppTypeE x

Instances

type XAppTypeE (GhcPass _1)

Defined in GHC.Hs.Expr

type XAppTypeE (GhcPass _1) = NoExtField

type family XOpApp x

Instances

type XOpApp GhcPs

Defined in GHC.Hs.Expr

type XOpApp GhcPs = NoExtField

type XOpApp GhcRn

Defined in GHC.Hs.Expr

type XOpApp GhcRn = Fixity

type XOpApp GhcTc

Defined in GHC.Hs.Expr

type XOpApp GhcTc = Fixity

type family XNegApp x

Instances

type XNegApp (GhcPass _1)

Defined in GHC.Hs.Expr

type XNegApp (GhcPass _1) = NoExtField

type family XPar x

Instances

type XPar (GhcPass _1)

Defined in GHC.Hs.Expr

type XPar (GhcPass _1) = NoExtField

type family XSectionL x

Instances

type XSectionL (GhcPass _1)

Defined in GHC.Hs.Expr

type XSectionL (GhcPass _1) = NoExtField

type family XSectionR x

Instances

type XSectionR (GhcPass _1)

Defined in GHC.Hs.Expr

type XSectionR (GhcPass _1) = NoExtField

type family XExplicitTuple x

Instances

type XExplicitTuple (GhcPass _1)

Defined in GHC.Hs.Expr

type XExplicitTuple (GhcPass _1) = NoExtField

type family XExplicitSum x

Instances

type XExplicitSum GhcPs

Defined in GHC.Hs.Expr

type XExplicitSum GhcPs = NoExtField

type XExplicitSum GhcRn

Defined in GHC.Hs.Expr

type XExplicitSum GhcRn = NoExtField

type XExplicitSum GhcTc

Defined in GHC.Hs.Expr

type XExplicitSum GhcTc = [Type]

type family XCase x

Instances

type XCase (GhcPass _1)

Defined in GHC.Hs.Expr

type XCase (GhcPass _1) = NoExtField

type family XIf x

Instances

type XIf (GhcPass _1)

Defined in GHC.Hs.Expr

type XIf (GhcPass _1) = NoExtField

type family XMultiIf x

Instances

type XMultiIf GhcPs

Defined in GHC.Hs.Expr

type XMultiIf GhcPs = NoExtField

type XMultiIf GhcRn

Defined in GHC.Hs.Expr

type XMultiIf GhcRn = NoExtField

type XMultiIf GhcTc

Defined in GHC.Hs.Expr

type XMultiIf GhcTc = Type

type family XLet x

Instances

type XLet (GhcPass _1)

Defined in GHC.Hs.Expr

type XLet (GhcPass _1) = NoExtField

type family XDo x

Instances

type XDo GhcPs

Defined in GHC.Hs.Expr

type XDo GhcPs = NoExtField

type XDo GhcRn

Defined in GHC.Hs.Expr

type XDo GhcRn = NoExtField

type XDo GhcTc

Defined in GHC.Hs.Expr

type XDo GhcTc = Type

type family XExplicitList x

Instances

type XExplicitList GhcPs

Defined in GHC.Hs.Expr

type XExplicitList GhcPs = NoExtField

type XExplicitList GhcRn

Defined in GHC.Hs.Expr

type XExplicitList GhcRn = NoExtField

type XExplicitList GhcTc

Defined in GHC.Hs.Expr

type XExplicitList GhcTc = Type

type family XRecordCon x

Instances

type XRecordCon GhcPs

Defined in GHC.Hs.Expr

type XRecordCon GhcPs = NoExtField

type XRecordCon GhcRn

Defined in GHC.Hs.Expr

type XRecordCon GhcRn = NoExtField

type XRecordCon GhcTc

Defined in GHC.Hs.Expr

type XRecordCon GhcTc = RecordConTc

type family XRecordUpd x

Instances

type XRecordUpd GhcPs

Defined in GHC.Hs.Expr

type XRecordUpd GhcPs = NoExtField

type XRecordUpd GhcRn

Defined in GHC.Hs.Expr

type XRecordUpd GhcRn = NoExtField

type XRecordUpd GhcTc

Defined in GHC.Hs.Expr

type XRecordUpd GhcTc = RecordUpdTc

type family XExprWithTySig x

Instances

type XExprWithTySig (GhcPass _1)

Defined in GHC.Hs.Expr

type XExprWithTySig (GhcPass _1) = NoExtField

type family XArithSeq x

Instances

type XArithSeq GhcPs

Defined in GHC.Hs.Expr

type XArithSeq GhcPs = NoExtField

type XArithSeq GhcRn

Defined in GHC.Hs.Expr

type XArithSeq GhcRn = NoExtField

type XArithSeq GhcTc

Defined in GHC.Hs.Expr

type XArithSeq GhcTc = PostTcExpr

type family XSCC x

Instances

type XSCC (GhcPass _1)

Defined in GHC.Hs.Expr

type XSCC (GhcPass _1) = NoExtField

type family XCoreAnn x

Instances

type XCoreAnn (GhcPass _1)

Defined in GHC.Hs.Expr

type XCoreAnn (GhcPass _1) = NoExtField

type family XBracket x

Instances

type XBracket (GhcPass _1)

Defined in GHC.Hs.Expr

type XBracket (GhcPass _1) = NoExtField

type family XRnBracketOut x

Instances

type XRnBracketOut (GhcPass _1)

Defined in GHC.Hs.Expr

type XRnBracketOut (GhcPass _1) = NoExtField

type family XTcBracketOut x

Instances

type XTcBracketOut (GhcPass _1)

Defined in GHC.Hs.Expr

type XTcBracketOut (GhcPass _1) = NoExtField

type family XSpliceE x

Instances

type XSpliceE (GhcPass _1)

Defined in GHC.Hs.Expr

type XSpliceE (GhcPass _1) = NoExtField

type family XProc x

Instances

type XProc (GhcPass _1)

Defined in GHC.Hs.Expr

type XProc (GhcPass _1) = NoExtField

type family XStatic x

Instances

type XStatic GhcPs

Defined in GHC.Hs.Expr

type XStatic GhcPs = NoExtField

type XStatic GhcRn

Defined in GHC.Hs.Expr

type XStatic GhcRn = NameSet

type XStatic GhcTc

Defined in GHC.Hs.Expr

type XStatic GhcTc = NameSet

type family XTick x

Instances

type XTick (GhcPass _1)

Defined in GHC.Hs.Expr

type XTick (GhcPass _1) = NoExtField

type family XBinTick x

Instances

type XBinTick (GhcPass _1)

Defined in GHC.Hs.Expr

type XBinTick (GhcPass _1) = NoExtField

type family XTickPragma x

Instances

type XTickPragma (GhcPass _1)

Defined in GHC.Hs.Expr

type XTickPragma (GhcPass _1) = NoExtField

type family XWrap x

Instances

type XWrap (GhcPass _1)

Defined in GHC.Hs.Expr

type XWrap (GhcPass _1) = NoExtField

type family XXExpr x

Instances

type XXExpr (GhcPass _1)

Defined in GHC.Hs.Expr

type XXExpr (GhcPass _1) = NoExtCon

type ForallXExpr (c :: Type -> Constraint) x = (c (XVar x), c (XUnboundVar x), c (XConLikeOut x), c (XRecFld x), c (XOverLabel x), c (XIPVar x), c (XOverLitE x), c (XLitE x), c (XLam x), c (XLamCase x), c (XApp x), c (XAppTypeE x), c (XOpApp x), c (XNegApp x), c (XPar x), c (XSectionL x), c (XSectionR x), c (XExplicitTuple x), c (XExplicitSum x), c (XCase x), c (XIf x), c (XMultiIf x), c (XLet x), c (XDo x), c (XExplicitList x), c (XRecordCon x), c (XRecordUpd x), c (XExprWithTySig x), c (XArithSeq x), c (XSCC x), c (XCoreAnn x), c (XBracket x), c (XRnBracketOut x), c (XTcBracketOut x), c (XSpliceE x), c (XProc x), c (XStatic x), c (XTick x), c (XBinTick x), c (XTickPragma x), c (XWrap x), c (XXExpr x))

type family XUnambiguous x

Instances

type XUnambiguous GhcPs

Defined in GHC.Hs.Types

type XUnambiguous GhcPs = NoExtField

type XUnambiguous GhcRn

Defined in GHC.Hs.Types

type XUnambiguous GhcRn = Name

type XUnambiguous GhcTc

Defined in GHC.Hs.Types

type XUnambiguous GhcTc = Id

type family XAmbiguous x

Instances

type XAmbiguous GhcPs

Defined in GHC.Hs.Types

type XAmbiguous GhcPs = NoExtField

type XAmbiguous GhcRn

Defined in GHC.Hs.Types

type XAmbiguous GhcRn = NoExtField

type XAmbiguous GhcTc

Defined in GHC.Hs.Types

type XAmbiguous GhcTc = Id

type family XXAmbiguousFieldOcc x

Instances

type XXAmbiguousFieldOcc (GhcPass _1)

Defined in GHC.Hs.Types

type XXAmbiguousFieldOcc (GhcPass _1) = NoExtCon

type ForallXAmbiguousFieldOcc (c :: Type -> Constraint) x = (c (XUnambiguous x), c (XAmbiguous x), c (XXAmbiguousFieldOcc x))

type family XPresent x

Instances

type XPresent (GhcPass _1)

Defined in GHC.Hs.Expr

type XPresent (GhcPass _1) = NoExtField

type family XMissing x

Instances

type XMissing GhcPs

Defined in GHC.Hs.Expr

type XMissing GhcPs = NoExtField

type XMissing GhcRn

Defined in GHC.Hs.Expr

type XMissing GhcRn = NoExtField

type XMissing GhcTc

Defined in GHC.Hs.Expr

type XMissing GhcTc = Type

type family XXTupArg x

Instances

type XXTupArg (GhcPass _1)

Defined in GHC.Hs.Expr

type XXTupArg (GhcPass _1) = NoExtCon

type ForallXTupArg (c :: Type -> Constraint) x = (c (XPresent x), c (XMissing x), c (XXTupArg x))

type family XTypedSplice x

Instances

type XTypedSplice (GhcPass _1)

Defined in GHC.Hs.Expr

type XTypedSplice (GhcPass _1) = NoExtField

type family XUntypedSplice x

Instances

type XUntypedSplice (GhcPass _1)

Defined in GHC.Hs.Expr

type XUntypedSplice (GhcPass _1) = NoExtField

type family XQuasiQuote x

Instances

type XQuasiQuote (GhcPass _1)

Defined in GHC.Hs.Expr

type XQuasiQuote (GhcPass _1) = NoExtField

type family XSpliced x

Instances

type XSpliced (GhcPass _1)

Defined in GHC.Hs.Expr

type XSpliced (GhcPass _1) = NoExtField

type family XXSplice x

Instances

type XXSplice (GhcPass _1)

Defined in GHC.Hs.Expr

type XXSplice (GhcPass _1) = NoExtCon

type ForallXSplice (c :: Type -> Constraint) x = (c (XTypedSplice x), c (XUntypedSplice x), c (XQuasiQuote x), c (XSpliced x), c (XXSplice x))

type family XExpBr x

Instances

type XExpBr (GhcPass _1)

Defined in GHC.Hs.Expr

type XExpBr (GhcPass _1) = NoExtField

type family XPatBr x

Instances

type XPatBr (GhcPass _1)

Defined in GHC.Hs.Expr

type XPatBr (GhcPass _1) = NoExtField

type family XDecBrL x

Instances

type XDecBrL (GhcPass _1)

Defined in GHC.Hs.Expr

type XDecBrL (GhcPass _1) = NoExtField

type family XDecBrG x

Instances

type XDecBrG (GhcPass _1)

Defined in GHC.Hs.Expr

type XDecBrG (GhcPass _1) = NoExtField

type family XTypBr x

Instances

type XTypBr (GhcPass _1)

Defined in GHC.Hs.Expr

type XTypBr (GhcPass _1) = NoExtField

type family XVarBr x

Instances

type XVarBr (GhcPass _1)

Defined in GHC.Hs.Expr

type XVarBr (GhcPass _1) = NoExtField

type family XTExpBr x

Instances

type XTExpBr (GhcPass _1)

Defined in GHC.Hs.Expr

type XTExpBr (GhcPass _1) = NoExtField

type family XXBracket x

Instances

type XXBracket (GhcPass _1)

Defined in GHC.Hs.Expr

type XXBracket (GhcPass _1) = NoExtCon

type ForallXBracket (c :: Type -> Constraint) x = (c (XExpBr x), c (XPatBr x), c (XDecBrL x), c (XDecBrG x), c (XTypBr x), c (XVarBr x), c (XTExpBr x), c (XXBracket x))

type family XCmdTop x

Instances

type XCmdTop GhcPs

Defined in GHC.Hs.Expr

type XCmdTop GhcPs = NoExtField

type XCmdTop GhcRn

Defined in GHC.Hs.Expr

type XCmdTop GhcRn = CmdSyntaxTable GhcRn

type XCmdTop GhcTc

Defined in GHC.Hs.Expr

type XCmdTop GhcTc = CmdTopTc

type family XXCmdTop x

Instances

type XXCmdTop (GhcPass _1)

Defined in GHC.Hs.Expr

type XXCmdTop (GhcPass _1) = NoExtCon

type ForallXCmdTop (c :: Type -> Constraint) x = (c (XCmdTop x), c (XXCmdTop x))

type family XMG x b

Instances

type XMG GhcPs b

Defined in GHC.Hs.Expr

type XMG GhcPs b = NoExtField

type XMG GhcRn b

Defined in GHC.Hs.Expr

type XMG GhcRn b = NoExtField

type XMG GhcTc b

Defined in GHC.Hs.Expr

type XMG GhcTc b = MatchGroupTc

type family XXMatchGroup x b

Instances

type XXMatchGroup (GhcPass _1) b

Defined in GHC.Hs.Expr

type XXMatchGroup (GhcPass _1) b = NoExtCon

type ForallXMatchGroup (c :: Type -> Constraint) x b = (c (XMG x b), c (XXMatchGroup x b))

type family XCMatch x b

Instances

type XCMatch (GhcPass _1) b

Defined in GHC.Hs.Expr

type XCMatch (GhcPass _1) b = NoExtField

type family XXMatch x b

Instances

type XXMatch (GhcPass _1) b

Defined in GHC.Hs.Expr

type XXMatch (GhcPass _1) b = NoExtCon

type ForallXMatch (c :: Type -> Constraint) x b = (c (XCMatch x b), c (XXMatch x b))

type family XCGRHSs x b

Instances

type XCGRHSs (GhcPass _1) b

Defined in GHC.Hs.Expr

type XCGRHSs (GhcPass _1) b = NoExtField

type family XXGRHSs x b

Instances

type XXGRHSs (GhcPass _1) b

Defined in GHC.Hs.Expr

type XXGRHSs (GhcPass _1) b = NoExtCon

type ForallXGRHSs (c :: Type -> Constraint) x b = (c (XCGRHSs x b), c (XXGRHSs x b))

type family XCGRHS x b

Instances

type XCGRHS (GhcPass _1) b

Defined in GHC.Hs.Expr

type XCGRHS (GhcPass _1) b = NoExtField

type family XXGRHS x b

Instances

type XXGRHS (GhcPass _1) b

Defined in GHC.Hs.Expr

type XXGRHS (GhcPass _1) b = NoExtCon

type ForallXGRHS (c :: Type -> Constraint) x b = (c (XCGRHS x b), c (XXGRHS x b))

type family XLastStmt x x' b

Instances

type XLastStmt (GhcPass _1) (GhcPass _2) b

Defined in GHC.Hs.Expr

type XLastStmt (GhcPass _1) (GhcPass _2) b = NoExtField

type family XBindStmt x x' b

Instances

type XBindStmt (GhcPass _1) GhcTc b

Defined in GHC.Hs.Expr

type XBindStmt (GhcPass _1) GhcTc b = Type

type XBindStmt (GhcPass _1) GhcRn b

Defined in GHC.Hs.Expr

type XBindStmt (GhcPass _1) GhcRn b = NoExtField

type XBindStmt (GhcPass _1) GhcPs b

Defined in GHC.Hs.Expr

type XBindStmt (GhcPass _1) GhcPs b = NoExtField

type family XApplicativeStmt x x' b

Instances

type XApplicativeStmt (GhcPass _1) GhcTc b

Defined in GHC.Hs.Expr

type XApplicativeStmt (GhcPass _1) GhcTc b = Type

type XApplicativeStmt (GhcPass _1) GhcRn b

Defined in GHC.Hs.Expr

type XApplicativeStmt (GhcPass _1) GhcRn b = NoExtField

type XApplicativeStmt (GhcPass _1) GhcPs b

Defined in GHC.Hs.Expr

type XApplicativeStmt (GhcPass _1) GhcPs b = NoExtField

type family XBodyStmt x x' b

Instances

type XBodyStmt (GhcPass _1) GhcTc b

Defined in GHC.Hs.Expr

type XBodyStmt (GhcPass _1) GhcTc b = Type

type XBodyStmt (GhcPass _1) GhcRn b

Defined in GHC.Hs.Expr

type XBodyStmt (GhcPass _1) GhcRn b = NoExtField

type XBodyStmt (GhcPass _1) GhcPs b

Defined in GHC.Hs.Expr

type XBodyStmt (GhcPass _1) GhcPs b = NoExtField

type family XLetStmt x x' b

Instances

type XLetStmt (GhcPass _1) (GhcPass _2) b

Defined in GHC.Hs.Expr

type XLetStmt (GhcPass _1) (GhcPass _2) b = NoExtField

type family XParStmt x x' b

Instances

type XParStmt (GhcPass _1) GhcTc b

Defined in GHC.Hs.Expr

type XParStmt (GhcPass _1) GhcTc b = Type

type XParStmt (GhcPass _1) GhcRn b

Defined in GHC.Hs.Expr

type XParStmt (GhcPass _1) GhcRn b = NoExtField

type XParStmt (GhcPass _1) GhcPs b

Defined in GHC.Hs.Expr

type XParStmt (GhcPass _1) GhcPs b = NoExtField

type family XTransStmt x x' b

Instances

type XTransStmt (GhcPass _1) GhcTc b

Defined in GHC.Hs.Expr

type XTransStmt (GhcPass _1) GhcTc b = Type

type XTransStmt (GhcPass _1) GhcRn b

Defined in GHC.Hs.Expr

type XTransStmt (GhcPass _1) GhcRn b = NoExtField

type XTransStmt (GhcPass _1) GhcPs b

Defined in GHC.Hs.Expr

type XTransStmt (GhcPass _1) GhcPs b = NoExtField

type family XRecStmt x x' b

Instances

type XRecStmt (GhcPass _1) GhcRn b

Defined in GHC.Hs.Expr

type XRecStmt (GhcPass _1) GhcRn b = NoExtField

type XRecStmt (GhcPass _1) GhcPs b

Defined in GHC.Hs.Expr

type XRecStmt (GhcPass _1) GhcPs b = NoExtField

type XRecStmt (GhcPass _1) GhcTc b

Defined in GHC.Hs.Expr

type XRecStmt (GhcPass _1) GhcTc b = RecStmtTc

type family XXStmtLR x x' b

Instances

type XXStmtLR (GhcPass _1) (GhcPass _2) b

Defined in GHC.Hs.Expr

type XXStmtLR (GhcPass _1) (GhcPass _2) b = NoExtCon

type ForallXStmtLR (c :: Type -> Constraint) x x' b = (c (XLastStmt x x' b), c (XBindStmt x x' b), c (XApplicativeStmt x x' b), c (XBodyStmt x x' b), c (XLetStmt x x' b), c (XParStmt x x' b), c (XTransStmt x x' b), c (XRecStmt x x' b), c (XXStmtLR x x' b))

type family XCmdArrApp x

Instances

type XCmdArrApp GhcPs

Defined in GHC.Hs.Expr

type XCmdArrApp GhcPs = NoExtField

type XCmdArrApp GhcRn

Defined in GHC.Hs.Expr

type XCmdArrApp GhcRn = NoExtField

type XCmdArrApp GhcTc

Defined in GHC.Hs.Expr

type XCmdArrApp GhcTc = Type

type family XCmdArrForm x

Instances

type XCmdArrForm (GhcPass _1)

Defined in GHC.Hs.Expr

type XCmdArrForm (GhcPass _1) = NoExtField

type family XCmdApp x

Instances

type XCmdApp (GhcPass _1)

Defined in GHC.Hs.Expr

type XCmdApp (GhcPass _1) = NoExtField

type family XCmdLam x

Instances

type XCmdLam (GhcPass _1)

Defined in GHC.Hs.Expr

type XCmdLam (GhcPass _1) = NoExtField

type family XCmdPar x

Instances

type XCmdPar (GhcPass _1)

Defined in GHC.Hs.Expr

type XCmdPar (GhcPass _1) = NoExtField

type family XCmdCase x

Instances

type XCmdCase (GhcPass _1)

Defined in GHC.Hs.Expr

type XCmdCase (GhcPass _1) = NoExtField

type family XCmdIf x

Instances

type XCmdIf (GhcPass _1)

Defined in GHC.Hs.Expr

type XCmdIf (GhcPass _1) = NoExtField

type family XCmdLet x

Instances

type XCmdLet (GhcPass _1)

Defined in GHC.Hs.Expr

type XCmdLet (GhcPass _1) = NoExtField

type family XCmdDo x

Instances

type XCmdDo GhcPs

Defined in GHC.Hs.Expr

type XCmdDo GhcPs = NoExtField

type XCmdDo GhcRn

Defined in GHC.Hs.Expr

type XCmdDo GhcRn = NoExtField

type XCmdDo GhcTc

Defined in GHC.Hs.Expr

type XCmdDo GhcTc = Type

type family XCmdWrap x

Instances

type XCmdWrap (GhcPass _1)

Defined in GHC.Hs.Expr

type XCmdWrap (GhcPass _1) = NoExtField

type family XXCmd x

Instances

type XXCmd (GhcPass _1)

Defined in GHC.Hs.Expr

type XXCmd (GhcPass _1) = NoExtCon

type ForallXCmd (c :: Type -> Constraint) x = (c (XCmdArrApp x), c (XCmdArrForm x), c (XCmdApp x), c (XCmdLam x), c (XCmdPar x), c (XCmdCase x), c (XCmdIf x), c (XCmdLet x), c (XCmdDo x), c (XCmdWrap x), c (XXCmd x))

type family XParStmtBlock x x'

Instances

type XParStmtBlock (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Expr

type XParStmtBlock (GhcPass pL) (GhcPass pR) = NoExtField

type family XXParStmtBlock x x'

Instances

type XXParStmtBlock (GhcPass pL) (GhcPass pR)

Defined in GHC.Hs.Expr

type XXParStmtBlock (GhcPass pL) (GhcPass pR) = NoExtCon

type ForallXParStmtBlock (c :: Type -> Constraint) x x' = (c (XParStmtBlock x x'), c (XXParStmtBlock x x'))

type family XApplicativeArgOne x

Instances

type XApplicativeArgOne (GhcPass _1)

Defined in GHC.Hs.Expr

type XApplicativeArgOne (GhcPass _1) = NoExtField

type family XApplicativeArgMany x

Instances

type XApplicativeArgMany (GhcPass _1)

Defined in GHC.Hs.Expr

type XApplicativeArgMany (GhcPass _1) = NoExtField

type family XXApplicativeArg x

Instances

type XXApplicativeArg (GhcPass _1)

Defined in GHC.Hs.Expr

type XXApplicativeArg (GhcPass _1) = NoExtCon

type ForallXApplicativeArg (c :: Type -> Constraint) x = (c (XApplicativeArgOne x), c (XApplicativeArgMany x), c (XXApplicativeArg x))

type family XHsChar x

Instances

type XHsChar (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsChar (GhcPass _1) = SourceText

type family XHsCharPrim x

Instances

type XHsCharPrim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsCharPrim (GhcPass _1) = SourceText

type family XHsString x

Instances

type XHsString (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsString (GhcPass _1) = SourceText

type family XHsStringPrim x

Instances

type XHsStringPrim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsStringPrim (GhcPass _1) = SourceText

type family XHsInt x

Instances

type XHsInt (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsInt (GhcPass _1) = NoExtField

type family XHsIntPrim x

Instances

type XHsIntPrim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsIntPrim (GhcPass _1) = SourceText

type family XHsWordPrim x

Instances

type XHsWordPrim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsWordPrim (GhcPass _1) = SourceText

type family XHsInt64Prim x

Instances

type XHsInt64Prim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsInt64Prim (GhcPass _1) = SourceText

type family XHsWord64Prim x

Instances

type XHsWord64Prim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsWord64Prim (GhcPass _1) = SourceText

type family XHsInteger x

Instances

type XHsInteger (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsInteger (GhcPass _1) = SourceText

type family XHsRat x

Instances

type XHsRat (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsRat (GhcPass _1) = NoExtField

type family XHsFloatPrim x

Instances

type XHsFloatPrim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsFloatPrim (GhcPass _1) = NoExtField

type family XHsDoublePrim x

Instances

type XHsDoublePrim (GhcPass _1)

Defined in GHC.Hs.Lit

type XHsDoublePrim (GhcPass _1) = NoExtField

type family XXLit x

Instances

type XXLit (GhcPass _1)

Defined in GHC.Hs.Lit

type XXLit (GhcPass _1) = NoExtCon

type ForallXHsLit (c :: Type -> Constraint) x = (c (XHsChar x), c (XHsCharPrim x), c (XHsDoublePrim x), c (XHsFloatPrim x), c (XHsInt x), c (XHsInt64Prim x), c (XHsIntPrim x), c (XHsInteger x), c (XHsRat x), c (XHsString x), c (XHsStringPrim x), c (XHsWord64Prim x), c (XHsWordPrim x), c (XXLit x))

Helper to apply a constraint to all extension points. It has one entry per extension point type family.

type family XOverLit x

Instances

type XOverLit GhcPs

Defined in GHC.Hs.Lit

type XOverLit GhcPs = NoExtField

type XOverLit GhcRn

Defined in GHC.Hs.Lit

type XOverLit GhcRn = Bool

type XOverLit GhcTc

Defined in GHC.Hs.Lit

type XOverLit GhcTc = OverLitTc

type family XXOverLit x

Instances

type XXOverLit (GhcPass _1)

Defined in GHC.Hs.Lit

type XXOverLit (GhcPass _1) = NoExtCon

type ForallXOverLit (c :: Type -> Constraint) x = (c (XOverLit x), c (XXOverLit x))

type family XWildPat x

Instances

type XWildPat GhcPs

Defined in GHC.Hs.Pat

type XWildPat GhcPs = NoExtField

type XWildPat GhcRn

Defined in GHC.Hs.Pat

type XWildPat GhcRn = NoExtField

type XWildPat GhcTc

Defined in GHC.Hs.Pat

type XWildPat GhcTc = Type

type family XVarPat x

Instances

type XVarPat (GhcPass _1)

Defined in GHC.Hs.Pat

type XVarPat (GhcPass _1) = NoExtField

type family XLazyPat x

Instances

type XLazyPat (GhcPass _1)

Defined in GHC.Hs.Pat

type XLazyPat (GhcPass _1) = NoExtField

type family XAsPat x

Instances

type XAsPat (GhcPass _1)

Defined in GHC.Hs.Pat

type XAsPat (GhcPass _1) = NoExtField

type family XParPat x

Instances

type XParPat (GhcPass _1)

Defined in GHC.Hs.Pat

type XParPat (GhcPass _1) = NoExtField

type family XBangPat x

Instances

type XBangPat (GhcPass _1)

Defined in GHC.Hs.Pat

type XBangPat (GhcPass _1) = NoExtField

type family XListPat x

Instances

type XListPat GhcPs

Defined in GHC.Hs.Pat

type XListPat GhcPs = NoExtField

type XListPat GhcRn

Defined in GHC.Hs.Pat

type XListPat GhcRn = Maybe (SyntaxExpr GhcRn)

type XListPat GhcTc

Defined in GHC.Hs.Pat

type XListPat GhcTc = ListPatTc

type family XTuplePat x

Instances

type XTuplePat GhcPs

Defined in GHC.Hs.Pat

type XTuplePat GhcPs = NoExtField

type XTuplePat GhcRn

Defined in GHC.Hs.Pat

type XTuplePat GhcRn = NoExtField

type XTuplePat GhcTc

Defined in GHC.Hs.Pat

type XTuplePat GhcTc = [Type]

type family XSumPat x

Instances

type XSumPat GhcPs

Defined in GHC.Hs.Pat

type XSumPat GhcPs = NoExtField

type XSumPat GhcRn

Defined in GHC.Hs.Pat

type XSumPat GhcRn = NoExtField

type XSumPat GhcTc

Defined in GHC.Hs.Pat

type XSumPat GhcTc = [Type]

type family XConPat x

type family XViewPat x

Instances

type XViewPat GhcPs

Defined in GHC.Hs.Pat

type XViewPat GhcPs = NoExtField

type XViewPat GhcRn

Defined in GHC.Hs.Pat

type XViewPat GhcRn = NoExtField

type XViewPat GhcTc

Defined in GHC.Hs.Pat

type XViewPat GhcTc = Type

type family XSplicePat x

Instances

type XSplicePat (GhcPass _1)

Defined in GHC.Hs.Pat

type XSplicePat (GhcPass _1) = NoExtField

type family XLitPat x

Instances

type XLitPat (GhcPass _1)

Defined in GHC.Hs.Pat

type XLitPat (GhcPass _1) = NoExtField

type family XNPat x

Instances

type XNPat GhcPs

Defined in GHC.Hs.Pat

type XNPat GhcPs = NoExtField

type XNPat GhcRn

Defined in GHC.Hs.Pat

type XNPat GhcRn = NoExtField

type XNPat GhcTc

Defined in GHC.Hs.Pat

type XNPat GhcTc = Type

type family XNPlusKPat x

Instances

type XNPlusKPat GhcPs

Defined in GHC.Hs.Pat

type XNPlusKPat GhcPs = NoExtField

type XNPlusKPat GhcRn

Defined in GHC.Hs.Pat

type XNPlusKPat GhcRn = NoExtField

type XNPlusKPat GhcTc

Defined in GHC.Hs.Pat

type XNPlusKPat GhcTc = Type

type family XSigPat x

Instances

type XSigPat GhcPs

Defined in GHC.Hs.Pat

type XSigPat GhcPs = NoExtField

type XSigPat GhcRn

Defined in GHC.Hs.Pat

type XSigPat GhcRn = NoExtField

type XSigPat GhcTc

Defined in GHC.Hs.Pat

type XSigPat GhcTc = Type

type family XCoPat x

Instances

type XCoPat (GhcPass _1)

Defined in GHC.Hs.Pat

type XCoPat (GhcPass _1) = NoExtField

type family XXPat x

Instances

type XXPat (GhcPass _1)

Defined in GHC.Hs.Pat

type XXPat (GhcPass _1) = NoExtCon

type ForallXPat (c :: Type -> Constraint) x = (c (XWildPat x), c (XVarPat x), c (XLazyPat x), c (XAsPat x), c (XParPat x), c (XBangPat x), c (XListPat x), c (XTuplePat x), c (XSumPat x), c (XViewPat x), c (XSplicePat x), c (XLitPat x), c (XNPat x), c (XNPlusKPat x), c (XSigPat x), c (XCoPat x), c (XXPat x))

type family XHsQTvs x

Instances

type XHsQTvs GhcPs

Defined in GHC.Hs.Types

type XHsQTvs GhcPs = NoExtField

type XHsQTvs GhcRn

Defined in GHC.Hs.Types

type XHsQTvs GhcRn = HsQTvsRn

type XHsQTvs GhcTc

Defined in GHC.Hs.Types

type XHsQTvs GhcTc = HsQTvsRn

type family XXLHsQTyVars x

Instances

type XXLHsQTyVars (GhcPass _1)

Defined in GHC.Hs.Types

type XXLHsQTyVars (GhcPass _1) = NoExtCon

type ForallXLHsQTyVars (c :: Type -> Constraint) x = (c (XHsQTvs x), c (XXLHsQTyVars x))

type family XHsIB x b

Instances

type XHsIB GhcPs _1

Defined in GHC.Hs.Types

type XHsIB GhcPs _1 = NoExtField

type XHsIB GhcRn _1

Defined in GHC.Hs.Types

type XHsIB GhcRn _1 = [Name]

type XHsIB GhcTc _1

Defined in GHC.Hs.Types

type XHsIB GhcTc _1 = [Name]

type family XXHsImplicitBndrs x b

Instances

type XXHsImplicitBndrs (GhcPass _1) _2

Defined in GHC.Hs.Types

type XXHsImplicitBndrs (GhcPass _1) _2 = NoExtCon

type ForallXHsImplicitBndrs (c :: Type -> Constraint) x b = (c (XHsIB x b), c (XXHsImplicitBndrs x b))

type family XHsWC x b

Instances

type XHsWC GhcPs b

Defined in GHC.Hs.Types

type XHsWC GhcPs b = NoExtField

type XHsWC GhcRn b

Defined in GHC.Hs.Types

type XHsWC GhcRn b = [Name]

type XHsWC GhcTc b

Defined in GHC.Hs.Types

type XHsWC GhcTc b = [Name]

type family XXHsWildCardBndrs x b

Instances

type XXHsWildCardBndrs (GhcPass _1) b

Defined in GHC.Hs.Types

type XXHsWildCardBndrs (GhcPass _1) b = NoExtCon

type ForallXHsWildCardBndrs (c :: Type -> Constraint) x b = (c (XHsWC x b), c (XXHsWildCardBndrs x b))

type family XForAllTy x

Instances

type XForAllTy (GhcPass _1)

Defined in GHC.Hs.Types

type XForAllTy (GhcPass _1) = NoExtField

type family XQualTy x

Instances

type XQualTy (GhcPass _1)

Defined in GHC.Hs.Types

type XQualTy (GhcPass _1) = NoExtField

type family XTyVar x

Instances

type XTyVar (GhcPass _1)

Defined in GHC.Hs.Types

type XTyVar (GhcPass _1) = NoExtField

type family XAppTy x

Instances

type XAppTy (GhcPass _1)

Defined in GHC.Hs.Types

type XAppTy (GhcPass _1) = NoExtField

type family XAppKindTy x

Instances

type XAppKindTy (GhcPass _1)

Defined in GHC.Hs.Types

type XAppKindTy (GhcPass _1) = SrcSpan

type family XFunTy x

Instances

type XFunTy (GhcPass _1)

Defined in GHC.Hs.Types

type XFunTy (GhcPass _1) = NoExtField

type family XListTy x

Instances

type XListTy (GhcPass _1)

Defined in GHC.Hs.Types

type XListTy (GhcPass _1) = NoExtField

type family XTupleTy x

Instances

type XTupleTy (GhcPass _1)

Defined in GHC.Hs.Types

type XTupleTy (GhcPass _1) = NoExtField

type family XSumTy x

Instances

type XSumTy (GhcPass _1)

Defined in GHC.Hs.Types

type XSumTy (GhcPass _1) = NoExtField

type family XOpTy x

Instances

type XOpTy (GhcPass _1)

Defined in GHC.Hs.Types

type XOpTy (GhcPass _1) = NoExtField

type family XParTy x

Instances

type XParTy (GhcPass _1)

Defined in GHC.Hs.Types

type XParTy (GhcPass _1) = NoExtField

type family XIParamTy x

Instances

type XIParamTy (GhcPass _1)

Defined in GHC.Hs.Types

type XIParamTy (GhcPass _1) = NoExtField

type family XStarTy x

Instances

type XStarTy (GhcPass _1)

Defined in GHC.Hs.Types

type XStarTy (GhcPass _1) = NoExtField

type family XKindSig x

Instances

type XKindSig (GhcPass _1)

Defined in GHC.Hs.Types

type XKindSig (GhcPass _1) = NoExtField

type family XSpliceTy x

Instances

type XSpliceTy GhcPs

Defined in GHC.Hs.Types

type XSpliceTy GhcPs = NoExtField

type XSpliceTy GhcRn

Defined in GHC.Hs.Types

type XSpliceTy GhcRn = NoExtField

type XSpliceTy GhcTc

Defined in GHC.Hs.Types

type XSpliceTy GhcTc = Kind

type family XDocTy x

Instances

type XDocTy (GhcPass _1)

Defined in GHC.Hs.Types

type XDocTy (GhcPass _1) = NoExtField

type family XBangTy x

Instances

type XBangTy (GhcPass _1)

Defined in GHC.Hs.Types

type XBangTy (GhcPass _1) = NoExtField

type family XRecTy x

Instances

type XRecTy (GhcPass _1)

Defined in GHC.Hs.Types

type XRecTy (GhcPass _1) = NoExtField

type family XExplicitListTy x

Instances

type XExplicitListTy GhcPs

Defined in GHC.Hs.Types

type XExplicitListTy GhcPs = NoExtField

type XExplicitListTy GhcRn

Defined in GHC.Hs.Types

type XExplicitListTy GhcRn = NoExtField

type XExplicitListTy GhcTc

Defined in GHC.Hs.Types

type XExplicitListTy GhcTc = Kind

type family XExplicitTupleTy x

Instances

type XExplicitTupleTy GhcPs

Defined in GHC.Hs.Types

type XExplicitTupleTy GhcPs = NoExtField

type XExplicitTupleTy GhcRn

Defined in GHC.Hs.Types

type XExplicitTupleTy GhcRn = NoExtField

type XExplicitTupleTy GhcTc

Defined in GHC.Hs.Types

type XExplicitTupleTy GhcTc = [Kind]

type family XTyLit x

Instances

type XTyLit (GhcPass _1)

Defined in GHC.Hs.Types

type XTyLit (GhcPass _1) = NoExtField

type family XWildCardTy x

Instances

type XWildCardTy (GhcPass _1)

Defined in GHC.Hs.Types

type XWildCardTy (GhcPass _1) = NoExtField

type family XXType x

Instances

type XXType (GhcPass _1)

Defined in GHC.Hs.Types

type XXType (GhcPass _1) = NewHsTypeX

type ForallXType (c :: Type -> Constraint) x = (c (XForAllTy x), c (XQualTy x), c (XTyVar x), c (XAppTy x), c (XAppKindTy x), c (XFunTy x), c (XListTy x), c (XTupleTy x), c (XSumTy x), c (XOpTy x), c (XParTy x), c (XIParamTy x), c (XStarTy x), c (XKindSig x), c (XSpliceTy x), c (XDocTy x), c (XBangTy x), c (XRecTy x), c (XExplicitListTy x), c (XExplicitTupleTy x), c (XTyLit x), c (XWildCardTy x), c (XXType x))

Helper to apply a constraint to all extension points. It has one entry per extension point type family.

type family XUserTyVar x

Instances

type XUserTyVar (GhcPass _1)

Defined in GHC.Hs.Types

type XUserTyVar (GhcPass _1) = NoExtField

type family XKindedTyVar x

Instances

type XKindedTyVar (GhcPass _1)

Defined in GHC.Hs.Types

type XKindedTyVar (GhcPass _1) = NoExtField

type family XXTyVarBndr x

Instances

type XXTyVarBndr (GhcPass _1)

Defined in GHC.Hs.Types

type XXTyVarBndr (GhcPass _1) = NoExtCon

type ForallXTyVarBndr (c :: Type -> Constraint) x = (c (XUserTyVar x), c (XKindedTyVar x), c (XXTyVarBndr x))

type family XConDeclField x

Instances

type XConDeclField (GhcPass _1)

Defined in GHC.Hs.Types

type XConDeclField (GhcPass _1) = NoExtField

type family XXConDeclField x

Instances

type XXConDeclField (GhcPass _1)

Defined in GHC.Hs.Types

type XXConDeclField (GhcPass _1) = NoExtCon

type ForallXConDeclField (c :: Type -> Constraint) x = (c (XConDeclField x), c (XXConDeclField x))

type family XCFieldOcc x

Instances

type XCFieldOcc GhcPs

Defined in GHC.Hs.Types

type XCFieldOcc GhcPs = NoExtField

type XCFieldOcc GhcRn

Defined in GHC.Hs.Types

type XCFieldOcc GhcRn = Name

type XCFieldOcc GhcTc

Defined in GHC.Hs.Types

type XCFieldOcc GhcTc = Id

type family XXFieldOcc x

Instances

type XXFieldOcc (GhcPass _1)

Defined in GHC.Hs.Types

type XXFieldOcc (GhcPass _1) = NoExtCon

type ForallXFieldOcc (c :: Type -> Constraint) x = (c (XCFieldOcc x), c (XXFieldOcc x))

type family XCImportDecl x

Instances

type XCImportDecl (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XCImportDecl (GhcPass _1) = NoExtField

type family XXImportDecl x

Instances

type XXImportDecl (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XXImportDecl (GhcPass _1) = NoExtCon

type ForallXImportDecl (c :: Type -> Constraint) x = (c (XCImportDecl x), c (XXImportDecl x))

type family XIEVar x

Instances

type XIEVar (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XIEVar (GhcPass _1) = NoExtField

type family XIEThingAbs x

Instances

type XIEThingAbs (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XIEThingAbs (GhcPass _1) = NoExtField

type family XIEThingAll x

Instances

type XIEThingAll (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XIEThingAll (GhcPass _1) = NoExtField

type family XIEThingWith x

Instances

type XIEThingWith (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XIEThingWith (GhcPass _1) = NoExtField

type family XIEModuleContents x

Instances

type XIEModuleContents (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XIEModuleContents (GhcPass _1) = NoExtField

type family XIEGroup x

Instances

type XIEGroup (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XIEGroup (GhcPass _1) = NoExtField

type family XIEDoc x

Instances

type XIEDoc (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XIEDoc (GhcPass _1) = NoExtField

type family XIEDocNamed x

Instances

type XIEDocNamed (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XIEDocNamed (GhcPass _1) = NoExtField

type family XXIE x

Instances

type XXIE (GhcPass _1)

Defined in GHC.Hs.ImpExp

type XXIE (GhcPass _1) = NoExtCon

type ForallXIE (c :: Type -> Constraint) x = (c (XIEVar x), c (XIEThingAbs x), c (XIEThingAll x), c (XIEThingWith x), c (XIEModuleContents x), c (XIEGroup x), c (XIEDoc x), c (XIEDocNamed x), c (XXIE x))

class Convertable a b | a -> b where

Conversion of annotations from one type index to another. This is required where the AST is converted from one pass to another, and the extension values need to be brought along if possible. So for example a SourceText is converted via id, but needs a type signature to keep the type checker happy.

Methods

convert :: a -> b

Instances

Convertable a a

Defined in GHC.Hs.Extension

Methods

convert :: a -> a

type ConvertIdX a b = (XHsDoublePrim a ~ XHsDoublePrim b, XHsFloatPrim a ~ XHsFloatPrim b, XHsRat a ~ XHsRat b, XHsInteger a ~ XHsInteger b, XHsWord64Prim a ~ XHsWord64Prim b, XHsInt64Prim a ~ XHsInt64Prim b, XHsWordPrim a ~ XHsWordPrim b, XHsIntPrim a ~ XHsIntPrim b, XHsInt a ~ XHsInt b, XHsStringPrim a ~ XHsStringPrim b, XHsString a ~ XHsString b, XHsCharPrim a ~ XHsCharPrim b, XHsChar a ~ XHsChar b, XXLit a ~ XXLit b)

A constraint capturing all the extension points that can be converted via instance Convertable a a

type OutputableX p = (Outputable (XIPBinds p), Outputable (XViaStrategy p), Outputable (XViaStrategy GhcRn))

Provide a summary constraint that gives all am Outputable constraint to extension points needing one

type OutputableBndrId (pass :: Pass) = (OutputableBndr (NameOrRdrName (IdP (GhcPass pass))), OutputableBndr (IdP (GhcPass pass)), OutputableBndr (NameOrRdrName (IdP (NoGhcTc (GhcPass pass)))), OutputableBndr (IdP (NoGhcTc (GhcPass pass))), NoGhcTc (GhcPass pass) ~ NoGhcTc (NoGhcTc (GhcPass pass)), OutputableX (GhcPass pass), OutputableX (NoGhcTc (GhcPass pass)))

Constraint type to bundle up the requirement for OutputableBndr on both the p and the NameOrRdrName type for it

placeHolderNamesTc :: NameSet

type family NameOrRdrName id where ...

Follow the id, but never beyond Name. This is used in a HsMatchContext, for printing messages related to a Match

Equations

NameOrRdrName Id = Name

NameOrRdrName Name = Name

NameOrRdrName RdrName = RdrName

isExportedId :: Var -> Bool

isExportedIdVar means "don't throw this away"

mustHaveLocalBinding :: Var -> Bool

mustHaveLocalBinding returns True of Ids and TyVars that must have a binding in this module. The converse is not quite right: there are some global Ids that must have bindings, such as record selectors. But that doesn't matter, because it's only used for assertions

isGlobalId :: Var -> Bool

isLocalVar :: Var -> Bool

isLocalVar returns True for type variables as well as local Ids These are the variables that we need to pay attention to when finding free variables, or doing dependency analysis.

isLocalId :: Var -> Bool

isNonCoVarId :: Var -> Bool

Is this a term variable (Id) that is not a coercion variable? Satisfies isId v ==> isCoVar v == not (isNonCoVarId v).

isCoVar :: Var -> Bool

Is this a coercion variable? Satisfies isId v ==> isCoVar v == not (isNonCoVarId v).

isId :: Var -> Bool

Is this a value-level (i.e., computationally relevant) Identifier? Satisfies isId = not . isTyVar.

isTyCoVar :: Var -> Bool

isTcTyVar :: Var -> Bool

isTyVar :: Var -> Bool

Is this a type-level (i.e., computationally irrelevant, thus erasable) variable? Satisfies isTyVar = not . isId.

setIdNotExported :: Id -> Id

We can only do this to LocalIds

setIdExported :: Id -> Id

Exports the given local Id. Can also be called on global Ids, such as data constructors and class operations, which are born as global Ids and automatically exported

globaliseId :: Id -> Id

If it's a local, make it global

setIdDetails :: Id -> IdDetails -> Id

lazySetIdInfo :: Id -> IdInfo -> Var

mkExportedLocalVar :: IdDetails -> Name -> Type -> IdInfo -> Id

Exported Vars will not be removed as dead code

mkCoVar :: Name -> Type -> CoVar

mkLocalVar :: IdDetails -> Name -> Type -> IdInfo -> Id

mkGlobalVar :: IdDetails -> Name -> Type -> IdInfo -> Id

idDetails :: Id -> IdDetails

idInfo :: HasDebugCallStack => Id -> IdInfo

setTcTyVarDetails :: TyVar -> TcTyVarDetails -> TyVar

tcTyVarDetails :: TyVar -> TcTyVarDetails

mkTcTyVar :: Name -> Kind -> TcTyVarDetails -> TyVar

mkTyVar :: Name -> Kind -> TyVar

updateTyVarKindM :: Monad m => (Kind -> m Kind) -> TyVar -> m TyVar

updateTyVarKind :: (Kind -> Kind) -> TyVar -> TyVar

setTyVarKind :: TyVar -> Kind -> TyVar

setTyVarName :: TyVar -> Name -> TyVar

setTyVarUnique :: TyVar -> Unique -> TyVar

tyVarKind :: TyVar -> Kind

tyVarName :: TyVar -> Name

isTyVarBinder :: TyCoVarBinder -> Bool

mkTyVarBinders :: ArgFlag -> [TyVar] -> [TyVarBinder]

Make many named binders Input vars should be type variables

mkTyCoVarBinders :: ArgFlag -> [TyCoVar] -> [TyCoVarBinder]

Make many named binders

mkTyVarBinder :: ArgFlag -> TyVar -> TyVarBinder

Make a named binder var should be a type variable

mkTyCoVarBinder :: ArgFlag -> TyCoVar -> TyCoVarBinder

Make a named binder

binderType :: VarBndr TyCoVar argf -> Type

binderArgFlag :: VarBndr tv argf -> argf

binderVars :: [VarBndr tv argf] -> [tv]

binderVar :: VarBndr tv argf -> tv

argToForallVisFlag :: ArgFlag -> ForallVisFlag

Convert an ArgFlag to its corresponding ForallVisFlag.

sameVis :: ArgFlag -> ArgFlag -> Bool

Do these denote the same level of visibility? Required arguments are visible, others are not. So this function equates Specified and Inferred. Used for printing.

isInvisibleArgFlag :: ArgFlag -> Bool

Does this ArgFlag classify an argument that is not written in Haskell?

isVisibleArgFlag :: ArgFlag -> Bool

Does this ArgFlag classify an argument that is written in Haskell?

updateVarTypeM :: Monad m => (Type -> m Type) -> Id -> m Id

updateVarType :: (Type -> Type) -> Id -> Id

setVarType :: Id -> Type -> Id

setVarName :: Var -> Name -> Var

setVarUnique :: Var -> Unique -> Var

varUnique :: Var -> Unique

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]

type Id = Var

Identifier

type CoVar = Id

Coercion Variable

type NcId = Id

type TyVar = Var

Type or kind Variable

type TKVar = Var

Type or Kind Variable

type TcTyVar = Var

Type variable that might be a metavariable

type TypeVar = Var

Type Variable

type KindVar = Var

Kind Variable

type EvId = Id

Evidence Identifier

type EvVar = EvId

Evidence Variable

type DFunId = Id

Dictionary Function Identifier

type DictId = EvId

Dictionary Identifier

type IpId = EvId

Implicit parameter Identifier

type EqVar = EvId

Equality Variable

type JoinId = Id

type TyCoVar = Id

Type or Coercion Variable

type InVar = Var

type InTyVar = TyVar

type InCoVar = CoVar

type InId = Id

type OutVar = Var

type OutTyVar = TyVar

type OutCoVar = CoVar

type OutId = Id

data ForallVisFlag

Is a forall invisible (e.g., forall a b. {...}, with a dot) or visible (e.g., forall a b -> {...}, with an arrow)?

Constructors

ForallVis

A visible forall (with an arrow)

ForallInvis

An invisible forall (with a dot)

Instances

Eq ForallVisFlag

Defined in Var

Methods

(==) :: ForallVisFlag -> ForallVisFlag -> Bool

(/=) :: ForallVisFlag -> ForallVisFlag -> Bool

Data ForallVisFlag

Defined in Var

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForallVisFlag -> c ForallVisFlag

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ForallVisFlag

toConstr :: ForallVisFlag -> Constr

dataTypeOf :: ForallVisFlag -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ForallVisFlag)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ForallVisFlag)

gmapT :: (forall b. Data b => b -> b) -> ForallVisFlag -> ForallVisFlag

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForallVisFlag -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForallVisFlag -> r

gmapQ :: (forall d. Data d => d -> u) -> ForallVisFlag -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ForallVisFlag -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForallVisFlag -> m ForallVisFlag

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForallVisFlag -> m ForallVisFlag

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForallVisFlag -> m ForallVisFlag

Ord ForallVisFlag

Defined in Var

Methods

compare :: ForallVisFlag -> ForallVisFlag -> Ordering

(<) :: ForallVisFlag -> ForallVisFlag -> Bool

(<=) :: ForallVisFlag -> ForallVisFlag -> Bool

(>) :: ForallVisFlag -> ForallVisFlag -> Bool

(>=) :: ForallVisFlag -> ForallVisFlag -> Bool

max :: ForallVisFlag -> ForallVisFlag -> ForallVisFlag

min :: ForallVisFlag -> ForallVisFlag -> ForallVisFlag

Outputable ForallVisFlag

Defined in Var

Methods

ppr :: ForallVisFlag -> SDoc

pprPrec :: Rational -> ForallVisFlag -> SDoc

data VarBndr var argf

Constructors

Bndr var argf

Instances

(Eq tyvar, Eq argf) => Eq (VarBndr tyvar argf)

Defined in Language.Haskell.Liquid.GHC.TypeRep

Methods

(==) :: VarBndr tyvar argf -> VarBndr tyvar argf -> Bool

(/=) :: VarBndr tyvar argf -> VarBndr tyvar argf -> Bool

(Data var, Data argf) => Data (VarBndr var argf)

Defined in 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)

Defined in Var

Methods

getOccName :: VarBndr tv flag -> OccName

getName :: VarBndr tv flag -> Name

(Binary tv, Binary vis) => Binary (VarBndr tv vis)

Defined in Var

Methods

put_ :: BinHandle -> VarBndr tv vis -> IO ()

put :: BinHandle -> VarBndr tv vis -> IO (Bin (VarBndr tv vis))

get :: BinHandle -> IO (VarBndr tv vis)

Outputable tv => Outputable (VarBndr tv TyConBndrVis)

Defined in TyCon

Methods

ppr :: VarBndr tv TyConBndrVis -> SDoc

pprPrec :: Rational -> VarBndr tv TyConBndrVis -> SDoc

Outputable tv => Outputable (VarBndr tv ArgFlag)

Defined in Var

Methods

ppr :: VarBndr tv ArgFlag -> SDoc

pprPrec :: Rational -> VarBndr tv ArgFlag -> SDoc

type TyCoVarBinder = VarBndr TyCoVar ArgFlag

Variable Binder

A TyCoVarBinder is the binder of a ForAllTy It's convenient to define this synonym here rather its natural home in TyCoRep, because it's used in DataCon.hs-boot

A TyVarBinder is a binder with only TyVar

type TyVarBinder = VarBndr TyVar ArgFlag

data Token

Instances

Show Token

Defined in Lexer

Methods

showsPrec :: Int -> Token -> ShowS

show :: Token -> String

showList :: [Token] -> ShowS

Outputable Token

Defined in Lexer

Methods

ppr :: Token -> SDoc

pprPrec :: Rational -> Token -> SDoc

unicodeAnn :: AnnKeywordId -> AnnKeywordId

Convert a normal annotation into its unicode equivalent one

getAndRemoveAnnotationComments :: ApiAnns -> SrcSpan -> ([Located AnnotationComment], ApiAnns)

Retrieve the comments allocated to the current SrcSpan, and remove them from the annotations

getAnnotationComments :: ApiAnns -> SrcSpan -> [Located AnnotationComment]

Retrieve the comments allocated to the current SrcSpan

Note: A given SrcSpan may appear in multiple AST elements, beware of duplicates

getAndRemoveAnnotation :: ApiAnns -> SrcSpan -> AnnKeywordId -> ([SrcSpan], ApiAnns)

Retrieve a list of annotation SrcSpans based on the SrcSpan of the annotated AST element, and the known type of the annotation. The list is removed from the annotations.

getAnnotation :: ApiAnns -> SrcSpan -> AnnKeywordId -> [SrcSpan]

Retrieve a list of annotation SrcSpans based on the SrcSpan of the annotated AST element, and the known type of the annotation.

type ApiAnns = (Map ApiAnnKey [SrcSpan], Map SrcSpan [Located AnnotationComment])

data AnnKeywordId

API Annotations exist so that tools can perform source to source conversions of Haskell code. They are used to keep track of the various syntactic keywords that are not captured in the existing AST.

The annotations, together with original source comments are made available in the pm_annotations field of ParsedModule. Comments are only retained if Opt_KeepRawTokenStream is set in DynFlags before parsing.

The wiki page describing this feature is https://gitlab.haskell.org/ghc/ghc/wikis/api-annotations

Note: in general the names of these are taken from the corresponding token, unless otherwise noted See note [Api annotations] above for details of the usage

Constructors

AnnAnyclass

AnnAs

AnnAt

AnnBang

!

AnnBackquote

'`'

AnnBy

AnnCase

case or lambda case

AnnClass

AnnClose

'#)' or '#-}' etc

AnnCloseB

'|)'

AnnCloseBU

'|)', unicode variant

AnnCloseC

'}'

AnnCloseQ

'|]'

AnnCloseQU

'|]', unicode variant

AnnCloseP

')'

AnnCloseS

']'

AnnColon

AnnComma

as a list separator

AnnCommaTuple

in a RdrName for a tuple

AnnDarrow

'=>'

AnnDarrowU

'=>', unicode variant

AnnData

AnnDcolon

'::'

AnnDcolonU

'::', unicode variant

AnnDefault

AnnDeriving

AnnDo

AnnDot

.

AnnDotdot

'..'

AnnElse

AnnEqual

AnnExport

AnnFamily

AnnForall

AnnForallU

Unicode variant

AnnForeign

AnnFunId

for function name in matches where there are multiple equations for the function.

AnnGroup

AnnHeader

for CType

AnnHiding

AnnIf

AnnImport

AnnIn

AnnInfix

'infix' or 'infixl' or 'infixr'

AnnInstance

AnnLam

AnnLarrow

'<-'

AnnLarrowU

'<-', unicode variant

AnnLet

AnnMdo

AnnMinus

-

AnnModule

AnnNewtype

AnnName

where a name loses its location in the AST, this carries it

AnnOf

AnnOpen

'(#' or '{-# LANGUAGE' etc

AnnOpenB

'(|'

AnnOpenBU

'(|', unicode variant

AnnOpenC

'{'

AnnOpenE

'[e|' or '[e||'

AnnOpenEQ

'[|'

AnnOpenEQU

'[|', unicode variant

AnnOpenP

'('

AnnOpenPE

'$('

AnnOpenPTE

'$$('

AnnOpenS

'['

AnnPackageName

AnnPattern

AnnProc

AnnQualified

AnnRarrow

'->'

AnnRarrowU

'->', unicode variant

AnnRec

AnnRole

AnnSafe

AnnSemi

';'

AnnSimpleQuote

'''

AnnSignature

AnnStatic

static

AnnStock

AnnThen

AnnThIdSplice

$

AnnThIdTySplice

$$

AnnThTyQuote

double '''

AnnTilde

'~'

AnnType

AnnUnit

() for types

AnnUsing

AnnVal

e.g. INTEGER

AnnValStr

String value, will need quotes when output

AnnVbar

'|'

AnnVia

via

AnnWhere

Annlarrowtail

-<

AnnlarrowtailU

-<, unicode variant

Annrarrowtail

'->'

AnnrarrowtailU

'->', unicode variant

AnnLarrowtail

-<<

AnnLarrowtailU

-<<, unicode variant

AnnRarrowtail

>>-

AnnRarrowtailU

>>-, unicode variant

AnnEofPos

Instances

Eq AnnKeywordId

Defined in ApiAnnotation

Methods

(==) :: AnnKeywordId -> AnnKeywordId -> Bool

(/=) :: AnnKeywordId -> AnnKeywordId -> Bool

Data AnnKeywordId

Defined in ApiAnnotation

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnKeywordId -> c AnnKeywordId

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnKeywordId

toConstr :: AnnKeywordId -> Constr

dataTypeOf :: AnnKeywordId -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnnKeywordId)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnKeywordId)

gmapT :: (forall b. Data b => b -> b) -> AnnKeywordId -> AnnKeywordId

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnKeywordId -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnKeywordId -> r

gmapQ :: (forall d. Data d => d -> u) -> AnnKeywordId -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnKeywordId -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnKeywordId -> m AnnKeywordId

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnKeywordId -> m AnnKeywordId

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnKeywordId -> m AnnKeywordId

Ord AnnKeywordId

Defined in ApiAnnotation

Methods

compare :: AnnKeywordId -> AnnKeywordId -> Ordering

(<) :: AnnKeywordId -> AnnKeywordId -> Bool

(<=) :: AnnKeywordId -> AnnKeywordId -> Bool

(>) :: AnnKeywordId -> AnnKeywordId -> Bool

(>=) :: AnnKeywordId -> AnnKeywordId -> Bool

max :: AnnKeywordId -> AnnKeywordId -> AnnKeywordId

min :: AnnKeywordId -> AnnKeywordId -> AnnKeywordId

Show AnnKeywordId

Defined in ApiAnnotation

Methods

showsPrec :: Int -> AnnKeywordId -> ShowS

show :: AnnKeywordId -> String

showList :: [AnnKeywordId] -> ShowS

Outputable AnnKeywordId

Defined in ApiAnnotation

Methods

ppr :: AnnKeywordId -> SDoc

pprPrec :: Rational -> AnnKeywordId -> SDoc

data AnnotationComment

Constructors

AnnDocCommentNext String

something beginning '-- |'

AnnDocCommentPrev String

something beginning '-- ^'

AnnDocCommentNamed String

something beginning '-- $'

AnnDocSection Int String

a section heading

AnnDocOptions String

doc options (prune, ignore-exports, etc)

AnnLineComment String

comment starting by "--"

AnnBlockComment String

comment in {- -}

Instances

Eq AnnotationComment

Defined in ApiAnnotation

Methods

(==) :: AnnotationComment -> AnnotationComment -> Bool

(/=) :: AnnotationComment -> AnnotationComment -> Bool

Data AnnotationComment

Defined in ApiAnnotation

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnotationComment -> c AnnotationComment

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnotationComment

toConstr :: AnnotationComment -> Constr

dataTypeOf :: AnnotationComment -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnnotationComment)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnotationComment)

gmapT :: (forall b. Data b => b -> b) -> AnnotationComment -> AnnotationComment

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnotationComment -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnotationComment -> r

gmapQ :: (forall d. Data d => d -> u) -> AnnotationComment -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnotationComment -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnotationComment -> m AnnotationComment

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnotationComment -> m AnnotationComment

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnotationComment -> m AnnotationComment

Ord AnnotationComment

Defined in ApiAnnotation

Methods

compare :: AnnotationComment -> AnnotationComment -> Ordering

(<) :: AnnotationComment -> AnnotationComment -> Bool

(<=) :: AnnotationComment -> AnnotationComment -> Bool

(>) :: AnnotationComment -> AnnotationComment -> Bool

(>=) :: AnnotationComment -> AnnotationComment -> Bool

max :: AnnotationComment -> AnnotationComment -> AnnotationComment

min :: AnnotationComment -> AnnotationComment -> AnnotationComment

Show AnnotationComment

Defined in ApiAnnotation

Methods

showsPrec :: Int -> AnnotationComment -> ShowS

show :: AnnotationComment -> String

showList :: [AnnotationComment] -> ShowS

Outputable AnnotationComment

Defined in ApiAnnotation

Methods

ppr :: AnnotationComment -> SDoc

pprPrec :: Rational -> AnnotationComment -> SDoc

nilDataConKey :: Unique

listTyConKey :: Unique

starInfo :: Bool -> RdrName -> SDoc

Display info about the treatment of * under NoStarIsType.

With StarIsType, three properties of * hold:

(a) it is not an infix operator (b) it is always in scope (c) it is a synonym for Data.Kind.Type

However, the user might not know that he's working on a module with NoStarIsType and write code that still assumes (a), (b), and (c), which actually do not hold in that module.

Violation of (a) shows up in the parser. For instance, in the following examples, we have * not applied to enough arguments:

data A :: * data F :: * -> *

Violation of (b) or (c) show up in the renamer and the typechecker respectively. For instance:

type K = Either * Bool

This will parse differently depending on whether StarIsType is enabled, but it will parse nonetheless. With NoStarIsType it is parsed as a type operator, thus we have ((*) Either Bool). Now there are two cases to consider:

1. There is no definition of (*) in scope. In this case the renamer will fail to look it up. This is a violation of assumption (b).
2. There is a definition of the (*) type operator in scope (for example coming from GHC.TypeNats). In this case the user will get a kind mismatch error. This is a violation of assumption (c).

The user might unknowingly be working on a module with NoStarIsType or use * as Type out of habit. So it is important to give a hint whenever an assumption about * is violated. Unfortunately, it is somewhat difficult to deal with (c), so we limit ourselves to (a) and (b).

starInfo generates an appropriate hint to the user depending on the extensions enabled in the module and the name that triggered the error. That is, if we have NoStarIsType and the error is related to * or its Unicode variant, the resulting SDoc will contain a helpful suggestion. Otherwise it is empty.

pprNameProvenance :: GlobalRdrElt -> SDoc

Print out one place where the name was define/imported (With -dppr-debug, print them all)

isExplicitItem :: ImpItemSpec -> Bool

importSpecModule :: ImportSpec -> ModuleName

importSpecLoc :: ImportSpec -> SrcSpan

qualSpecOK :: ModuleName -> ImportSpec -> Bool

Is in scope qualified with the given module?

unQualSpecOK :: ImportSpec -> Bool

Is in scope unqualified?

bestImport :: [ImportSpec] -> ImportSpec

shadowNames :: GlobalRdrEnv -> [Name] -> GlobalRdrEnv

extendGlobalRdrEnv :: GlobalRdrEnv -> GlobalRdrElt -> GlobalRdrEnv

transformGREs :: (GlobalRdrElt -> GlobalRdrElt) -> [OccName] -> GlobalRdrEnv -> GlobalRdrEnv

Apply a transformation function to the GREs for these OccNames

mkGlobalRdrEnv :: [GlobalRdrElt] -> GlobalRdrEnv

plusGlobalRdrEnv :: GlobalRdrEnv -> GlobalRdrEnv -> GlobalRdrEnv

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 RnNames.exports_from_avail

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]

unQualOK :: GlobalRdrElt -> Bool

Test if an unqualified version of this thing would be in scope

greLabel :: GlobalRdrElt -> Maybe FieldLabelString

isRecFldGRE :: GlobalRdrElt -> Bool

isLocalGRE :: GlobalRdrElt -> Bool

getGRE_NameQualifier_maybes :: GlobalRdrEnv -> Name -> [Maybe [ModuleName]]

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 [Parents for record fields].

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 [Parents for record fields] for why this happens.

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_RdrName :: RdrName -> GlobalRdrEnv -> [GlobalRdrElt]

greOccName :: GlobalRdrElt -> OccName

lookupGlobalRdrEnv :: GlobalRdrEnv -> OccName -> [GlobalRdrElt]

pprGlobalRdrEnv :: Bool -> GlobalRdrEnv -> SDoc

globalRdrEnvElts :: GlobalRdrEnv -> [GlobalRdrElt]

emptyGlobalRdrEnv :: GlobalRdrEnv

availFromGRE :: GlobalRdrElt -> AvailInfo

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.

greParent_maybe :: GlobalRdrElt -> Maybe Name

greSrcSpan :: GlobalRdrElt -> SrcSpan

greRdrNames :: GlobalRdrElt -> [RdrName]

greQualModName :: GlobalRdrElt -> ModuleName

gresFromAvail :: (Name -> Maybe ImportSpec) -> AvailInfo -> [GlobalRdrElt]

localGREsFromAvail :: AvailInfo -> [GlobalRdrElt]

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).

delLocalRdrEnvList :: LocalRdrEnv -> [OccName] -> LocalRdrEnv

inLocalRdrEnvScope :: Name -> LocalRdrEnv -> Bool

localRdrEnvElts :: LocalRdrEnv -> [Name]

elemLocalRdrEnv :: RdrName -> LocalRdrEnv -> Bool

lookupLocalRdrOcc :: LocalRdrEnv -> OccName -> Maybe Name

lookupLocalRdrEnv :: LocalRdrEnv -> RdrName -> Maybe Name

extendLocalRdrEnvList :: LocalRdrEnv -> [Name] -> LocalRdrEnv

extendLocalRdrEnv :: LocalRdrEnv -> Name -> LocalRdrEnv

emptyLocalRdrEnv :: LocalRdrEnv

isExact_maybe :: RdrName -> Maybe Name

isExact :: RdrName -> Bool

isOrig_maybe :: RdrName -> Maybe (Module, OccName)

isOrig :: RdrName -> Bool

isQual_maybe :: RdrName -> Maybe (ModuleName, OccName)

isQual :: RdrName -> Bool

isUnqual :: RdrName -> Bool

isSrcRdrName :: RdrName -> Bool

isRdrTc :: RdrName -> Bool

isRdrTyVar :: RdrName -> Bool

isRdrDataCon :: RdrName -> Bool

nameRdrName :: Name -> RdrName

getRdrName :: NamedThing thing => thing -> 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

mkVarUnqual :: FastString -> RdrName

mkUnqual :: NameSpace -> FastString -> RdrName

mkOrig :: Module -> OccName -> RdrName

mkRdrQual :: ModuleName -> OccName -> RdrName

mkRdrUnqual :: OccName -> RdrName

demoteRdrName :: RdrName -> Maybe RdrName

rdrNameSpace :: RdrName -> NameSpace

rdrNameOcc :: RdrName -> OccName

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:

1. When the parser parses built-in syntax like [] and (,), but wants a RdrName from it
2. By Template Haskell, when TH has generated a unique name

Such a RdrName can be created by using getRdrName on a Name

Instances

Eq RdrName

Defined in RdrName

Methods

(==) :: RdrName -> RdrName -> Bool

(/=) :: RdrName -> RdrName -> Bool

Data RdrName

Defined in RdrName

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RdrName -> c RdrName

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RdrName

toConstr :: RdrName -> Constr

dataTypeOf :: RdrName -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RdrName)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RdrName)

gmapT :: (forall b. Data b => b -> b) -> RdrName -> RdrName

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RdrName -> r

gmapQr :: 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

Ord RdrName

Defined in RdrName

Methods

compare :: RdrName -> RdrName -> Ordering

(<) :: RdrName -> RdrName -> Bool

(<=) :: RdrName -> RdrName -> Bool

(>) :: RdrName -> RdrName -> Bool

(>=) :: RdrName -> RdrName -> Bool

max :: RdrName -> RdrName -> RdrName

min :: RdrName -> RdrName -> RdrName

DisambInfixOp RdrName

Defined in RdrHsSyn

Methods

mkHsVarOpPV :: Located RdrName -> PV (Located RdrName)

mkHsConOpPV :: Located RdrName -> PV (Located RdrName)

mkHsInfixHolePV :: SrcSpan -> PV (Located RdrName)

HasOccName RdrName

Defined in RdrName

Methods

occName :: RdrName -> OccName

Outputable RdrName

Defined in RdrName

Methods

ppr :: RdrName -> SDoc

pprPrec :: Rational -> RdrName -> SDoc

OutputableBndr RdrName

Defined in RdrName

Methods

pprBndr :: BindingSite -> RdrName -> SDoc

pprPrefixOcc :: RdrName -> SDoc

pprInfixOcc :: RdrName -> SDoc

bndrIsJoin_maybe :: RdrName -> Maybe Int

data LocalRdrEnv

Local Reader Environment

This environment is used to store local bindings (let, where, lambda, case). It is keyed by OccName, because we never use it for qualified names We keep the current mapping, *and* the set of all Names in scope Reason: see Note [Splicing Exact names] in RnEnv

Instances

Outputable LocalRdrEnv

Defined in RdrName

Methods

ppr :: LocalRdrEnv -> SDoc

pprPrec :: Rational -> LocalRdrEnv -> 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 RnNames 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 (gre_name gre), but not always in the case of record seectors; see greOccName

data GlobalRdrElt

Global Reader Element

An element of the GlobalRdrEnv

Constructors

GRE

Fields

• gre_name :: Name
• gre_par :: Parent
• gre_lcl :: Bool

  True = the thing was defined locally

• gre_imp :: [ImportSpec]

  In scope through these imports

Instances

Eq GlobalRdrElt

Defined in RdrName

Methods

(==) :: GlobalRdrElt -> GlobalRdrElt -> Bool

(/=) :: GlobalRdrElt -> GlobalRdrElt -> Bool

Data GlobalRdrElt

Defined in RdrName

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

Outputable GlobalRdrElt

Defined in RdrName

Methods

ppr :: GlobalRdrElt -> SDoc

pprPrec :: Rational -> GlobalRdrElt -> SDoc

data Parent

The children of a Name are the things that are abbreviated by the ".." notation in export lists. See Note [Parents]

Constructors

NoParent

ParentIs

Fields

• par_is :: Name

FldParent

See Note [Parents for record fields]

Fields

• par_is :: Name
• par_lbl :: Maybe FieldLabelString

Instances

Eq Parent

Defined in RdrName

Methods

(==) :: Parent -> Parent -> Bool

(/=) :: Parent -> Parent -> Bool

Data Parent

Defined in RdrName

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Parent -> c Parent

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Parent

toConstr :: Parent -> Constr

dataTypeOf :: Parent -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Parent)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Parent)

gmapT :: (forall b. Data b => b -> b) -> Parent -> Parent

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Parent -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Parent -> r

gmapQ :: (forall d. Data d => d -> u) -> Parent -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Parent -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Parent -> m Parent

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Parent -> m Parent

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Parent -> m Parent

Outputable Parent

Defined in RdrName

Methods

ppr :: Parent -> SDoc

pprPrec :: Rational -> Parent -> SDoc

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

Eq ImportSpec

Defined in RdrName

Methods

(==) :: ImportSpec -> ImportSpec -> Bool

(/=) :: ImportSpec -> ImportSpec -> Bool

Data ImportSpec

Defined in RdrName

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

Ord ImportSpec

Defined in RdrName

Methods

compare :: ImportSpec -> ImportSpec -> Ordering

(<) :: ImportSpec -> ImportSpec -> Bool

(<=) :: ImportSpec -> ImportSpec -> Bool

(>) :: ImportSpec -> ImportSpec -> Bool

(>=) :: ImportSpec -> ImportSpec -> Bool

max :: ImportSpec -> ImportSpec -> ImportSpec

min :: ImportSpec -> ImportSpec -> ImportSpec

Outputable ImportSpec

Defined in RdrName

Methods

ppr :: ImportSpec -> SDoc

pprPrec :: Rational -> ImportSpec -> SDoc

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

Eq ImpDeclSpec

Defined in RdrName

Methods

(==) :: ImpDeclSpec -> ImpDeclSpec -> Bool

(/=) :: ImpDeclSpec -> ImpDeclSpec -> Bool

Data ImpDeclSpec

Defined in RdrName

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

Ord ImpDeclSpec

Defined in RdrName

Methods

compare :: ImpDeclSpec -> ImpDeclSpec -> Ordering

(<) :: ImpDeclSpec -> ImpDeclSpec -> Bool

(<=) :: ImpDeclSpec -> ImpDeclSpec -> Bool

(>) :: ImpDeclSpec -> ImpDeclSpec -> Bool

(>=) :: ImpDeclSpec -> ImpDeclSpec -> Bool

max :: ImpDeclSpec -> ImpDeclSpec -> ImpDeclSpec

min :: ImpDeclSpec -> ImpDeclSpec -> ImpDeclSpec

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

Eq ImpItemSpec

Defined in RdrName

Methods

(==) :: ImpItemSpec -> ImpItemSpec -> Bool

(/=) :: ImpItemSpec -> ImpItemSpec -> Bool

Data ImpItemSpec

Defined in RdrName

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

Ord ImpItemSpec

Defined in RdrName

Methods

compare :: ImpItemSpec -> ImpItemSpec -> Ordering

(<) :: ImpItemSpec -> ImpItemSpec -> Bool

(<=) :: ImpItemSpec -> ImpItemSpec -> Bool

(>) :: ImpItemSpec -> ImpItemSpec -> Bool

(>=) :: ImpItemSpec -> ImpItemSpec -> Bool

max :: ImpItemSpec -> ImpItemSpec -> ImpItemSpec

min :: ImpItemSpec -> ImpItemSpec -> ImpItemSpec

nubAvails :: [AvailInfo] -> [AvailInfo]

Combines AvailInfos from the same family avails may have several items with the same availName E.g import Ix( Ix(..), index ) will give Ix(Ix,index,range) and Ix(index) We want to combine these; addAvail does that

filterAvail :: (Name -> Bool) -> AvailInfo -> [AvailInfo] -> [AvailInfo]

filters an AvailInfo by the given predicate

filterAvails :: (Name -> Bool) -> [AvailInfo] -> [AvailInfo]

filters AvailInfos by the given predicate

trimAvail :: AvailInfo -> Name -> AvailInfo

trims an AvailInfo to keep only a single name

plusAvail :: AvailInfo -> AvailInfo -> AvailInfo

availNamesWithOccs :: AvailInfo -> [(Name, OccName)]

Names made available by the availability information, paired with the OccName used to refer to each one.

When DuplicateRecordFields is in use, the Name may be the mangled name of a record selector (e.g. $sel:foo:MkT) while the OccName will be the label of the field (e.g. foo).

See Note [Representing fields in AvailInfo].

availsNamesWithOccs :: [AvailInfo] -> [(Name, OccName)]

availFlds :: AvailInfo -> [FieldLabel]

Fields made available by the availability information

availNonFldNames :: AvailInfo -> [Name]

Names for non-fields made available by the availability information

availNamesWithSelectors :: AvailInfo -> [Name]

All names made available by the availability information (including overloaded selectors)

availNames :: AvailInfo -> [Name]

All names made available by the availability information (excluding overloaded selectors)

availName :: AvailInfo -> Name

Just the main name made available, i.e. not the available pieces of type or class brought into scope by the GenAvailInfo

availsToNameEnv :: [AvailInfo] -> NameEnv AvailInfo

availsToNameSetWithSelectors :: [AvailInfo] -> NameSet

availsToNameSet :: [AvailInfo] -> NameSet

avail :: Name -> AvailInfo

stableAvailCmp :: AvailInfo -> AvailInfo -> Ordering

Compare lexicographically

data AvailInfo

Records what things are "available", i.e. in scope

Constructors

Avail Name

An ordinary identifier in scope

AvailTC

A type or class in scope

The AvailTC Invariant: If the type or class is itself to be in scope, it must be first in this list. Thus, typically:

AvailTC Eq [Eq, ==, \/=] []

Fields

• Name

  The name of the type or class

• [Name]

  The available pieces of type or class, excluding field selectors.

• [FieldLabel]

  The record fields of the type (see Note [Representing fields in AvailInfo]).

Instances

Eq AvailInfo

Used when deciding if the interface has changed

Defined in Avail

Methods

(==) :: AvailInfo -> AvailInfo -> Bool

(/=) :: AvailInfo -> AvailInfo -> Bool

Data AvailInfo

Defined in Avail

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AvailInfo -> c AvailInfo

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AvailInfo

toConstr :: AvailInfo -> Constr

dataTypeOf :: AvailInfo -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AvailInfo)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AvailInfo)

gmapT :: (forall b. Data b => b -> b) -> AvailInfo -> AvailInfo

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AvailInfo -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AvailInfo -> r

gmapQ :: (forall d. Data d => d -> u) -> AvailInfo -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> AvailInfo -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AvailInfo -> m AvailInfo

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AvailInfo -> m AvailInfo

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AvailInfo -> m AvailInfo

Binary AvailInfo

Defined in Avail

Methods

put_ :: BinHandle -> AvailInfo -> IO ()

put :: BinHandle -> AvailInfo -> IO (Bin AvailInfo)

get :: BinHandle -> IO AvailInfo

Outputable AvailInfo

Defined in Avail

Methods

ppr :: AvailInfo -> SDoc

pprPrec :: Rational -> AvailInfo -> SDoc

type Avails = [AvailInfo]

A collection of AvailInfo - several things that are "available"

type FieldLabelString = FastString

Field labels are just represented as strings; they are not necessarily unique (even within a module)

type FieldLabel = FieldLbl Name

data FieldLbl a

Fields in an algebraic record type

Constructors

FieldLabel

Fields

• flLabel :: FieldLabelString

  User-visible label of the field

• flIsOverloaded :: Bool

  Was DuplicateRecordFields on in the defining module for this datatype?

• flSelector :: a

  Record selector function

Instances

Functor FieldLbl

Defined in FieldLabel

Methods

fmap :: (a -> b) -> FieldLbl a -> FieldLbl b

(<$) :: a -> FieldLbl b -> FieldLbl a

Foldable FieldLbl

Defined in FieldLabel

Methods

fold :: Monoid m => FieldLbl m -> m

foldMap :: Monoid m => (a -> m) -> FieldLbl a -> m

foldMap' :: Monoid m => (a -> m) -> FieldLbl a -> m

foldr :: (a -> b -> b) -> b -> FieldLbl a -> b

foldr' :: (a -> b -> b) -> b -> FieldLbl a -> b

foldl :: (b -> a -> b) -> b -> FieldLbl a -> b

foldl' :: (b -> a -> b) -> b -> FieldLbl a -> b

foldr1 :: (a -> a -> a) -> FieldLbl a -> a

foldl1 :: (a -> a -> a) -> FieldLbl a -> a

toList :: FieldLbl a -> [a]

null :: FieldLbl a -> Bool

length :: FieldLbl a -> Int

elem :: Eq a => a -> FieldLbl a -> Bool

maximum :: Ord a => FieldLbl a -> a

minimum :: Ord a => FieldLbl a -> a

sum :: Num a => FieldLbl a -> a

product :: Num a => FieldLbl a -> a

Traversable FieldLbl

Defined in FieldLabel

Methods

traverse :: Applicative f => (a -> f b) -> FieldLbl a -> f (FieldLbl b)

sequenceA :: Applicative f => FieldLbl (f a) -> f (FieldLbl a)

mapM :: Monad m => (a -> m b) -> FieldLbl a -> m (FieldLbl b)

sequence :: Monad m => FieldLbl (m a) -> m (FieldLbl a)

Eq a => Eq (FieldLbl a)

Defined in FieldLabel

Methods

(==) :: FieldLbl a -> FieldLbl a -> Bool

(/=) :: FieldLbl a -> FieldLbl a -> Bool

Data a => Data (FieldLbl a)

Defined in FieldLabel

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FieldLbl a -> c (FieldLbl a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FieldLbl a)

toConstr :: FieldLbl a -> Constr

dataTypeOf :: FieldLbl a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FieldLbl a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FieldLbl a))

gmapT :: (forall b. Data b => b -> b) -> FieldLbl a -> FieldLbl a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FieldLbl a -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FieldLbl a -> r

gmapQ :: (forall d. Data d => d -> u) -> FieldLbl a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldLbl a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FieldLbl a -> m (FieldLbl a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldLbl a -> m (FieldLbl a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldLbl a -> m (FieldLbl a)

Binary a => Binary (FieldLbl a)

Defined in FieldLabel

Methods

put_ :: BinHandle -> FieldLbl a -> IO ()

put :: BinHandle -> FieldLbl a -> IO (Bin (FieldLbl a))

get :: BinHandle -> IO (FieldLbl a)

Outputable a => Outputable (FieldLbl a)

Defined in FieldLabel

Methods

ppr :: FieldLbl a -> SDoc

pprPrec :: Rational -> FieldLbl a -> SDoc

emptyArgDocMap :: ArgDocMap

emptyDeclDocMap :: DeclDocMap

concatDocs :: [HsDocString] -> Maybe HsDocString

Concat docstrings with two newlines in between.

Empty docstrings are skipped.

If all inputs are empty, Nothing is returned.

appendDocs :: HsDocString -> HsDocString -> HsDocString

Join two docstrings.

Non-empty docstrings are joined with two newlines in between, resulting in separate paragraphs.

ppr_mbDoc :: Maybe LHsDocString -> SDoc

hsDocStringToByteString :: HsDocString -> ByteString

Return the contents of a HsDocString as a UTF8-encoded ByteString.

unpackHDS :: HsDocString -> String

mkHsDocStringUtf8ByteString :: ByteString -> HsDocString

Create a HsDocString from a UTF8-encoded ByteString.

mkHsDocString :: String -> HsDocString

data HsDocString

Haskell Documentation String

Internally this is a UTF8-Encoded ByteString.

Instances

Eq HsDocString

Defined in GHC.Hs.Doc

Methods

(==) :: HsDocString -> HsDocString -> Bool

(/=) :: HsDocString -> HsDocString -> Bool

Data HsDocString

Defined in GHC.Hs.Doc

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsDocString -> c HsDocString

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsDocString

toConstr :: HsDocString -> Constr

dataTypeOf :: HsDocString -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsDocString)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsDocString)

gmapT :: (forall b. Data b => b -> b) -> HsDocString -> HsDocString

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDocString -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDocString -> r

gmapQ :: (forall d. Data d => d -> u) -> HsDocString -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsDocString -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsDocString -> m HsDocString

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDocString -> m HsDocString

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDocString -> m HsDocString

Show HsDocString

Defined in GHC.Hs.Doc

Methods

showsPrec :: Int -> HsDocString -> ShowS

show :: HsDocString -> String

showList :: [HsDocString] -> ShowS

Binary HsDocString

Defined in GHC.Hs.Doc

Methods

put_ :: BinHandle -> HsDocString -> IO ()

put :: BinHandle -> HsDocString -> IO (Bin HsDocString)

get :: BinHandle -> IO HsDocString

Outputable HsDocString

Defined in GHC.Hs.Doc

Methods

ppr :: HsDocString -> SDoc

pprPrec :: Rational -> HsDocString -> SDoc

type LHsDocString = Located HsDocString

Located Haskell Documentation String

newtype DeclDocMap

Docs for declarations: functions, data types, instances, methods etc.

Constructors

DeclDocMap (Map Name HsDocString)

Instances

Binary DeclDocMap

Defined in GHC.Hs.Doc

Methods

put_ :: BinHandle -> DeclDocMap -> IO ()

put :: BinHandle -> DeclDocMap -> IO (Bin DeclDocMap)

get :: BinHandle -> IO DeclDocMap

Outputable DeclDocMap

Defined in GHC.Hs.Doc

Methods

ppr :: DeclDocMap -> SDoc

pprPrec :: Rational -> DeclDocMap -> SDoc

newtype ArgDocMap

Docs for arguments. E.g. function arguments, method arguments.

Constructors

ArgDocMap (Map Name (Map Int HsDocString))

Instances

Binary ArgDocMap

Defined in GHC.Hs.Doc

Methods

put_ :: BinHandle -> ArgDocMap -> IO ()

put :: BinHandle -> ArgDocMap -> IO (Bin ArgDocMap)

get :: BinHandle -> IO ArgDocMap

Outputable ArgDocMap

Defined in GHC.Hs.Doc

Methods

ppr :: ArgDocMap -> SDoc

pprPrec :: Rational -> ArgDocMap -> SDoc

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)

duUses :: DefUses -> Uses

Collect all Uses, regardless of whether the group is itself used, but remove Defs on the way

allUses :: DefUses -> Uses

Just like duUses, but Defs are not eliminated from the Uses returned

duDefs :: DefUses -> Defs

plusDU :: DefUses -> DefUses -> DefUses

mkDUs :: [(Defs, Uses)] -> DefUses

usesOnly :: Uses -> DefUses

emptyDUs :: DefUses

intersectFVs :: FreeVars -> FreeVars -> FreeVars

delFVs :: [Name] -> FreeVars -> FreeVars

delFV :: Name -> FreeVars -> FreeVars

unitFV :: Name -> FreeVars

addOneFV :: FreeVars -> Name -> FreeVars

mkFVs :: [Name] -> FreeVars

plusFV :: FreeVars -> FreeVars -> FreeVars

plusFVs :: [FreeVars] -> FreeVars

emptyFVs :: FreeVars

isEmptyFVs :: 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

nameSetAll :: (Name -> Bool) -> NameSet -> Bool

nameSetAny :: (Name -> Bool) -> NameSet -> Bool

intersectsNameSet :: 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

intersectNameSet :: NameSet -> NameSet -> NameSet

filterNameSet :: (Name -> Bool) -> NameSet -> NameSet

delFromNameSet :: NameSet -> Name -> NameSet

elemNameSet :: Name -> NameSet -> Bool

minusNameSet :: NameSet -> NameSet -> NameSet

unionNameSets :: [NameSet] -> NameSet

unionNameSet :: NameSet -> NameSet -> NameSet

extendNameSet :: NameSet -> Name -> NameSet

extendNameSetList :: NameSet -> [Name] -> NameSet

mkNameSet :: [Name] -> NameSet

unitNameSet :: Name -> NameSet

emptyNameSet :: NameSet

isEmptyNameSet :: NameSet -> Bool

type NameSet = UniqSet Name

type FreeVars = NameSet

type Defs = NameSet

A set of names that are defined somewhere

type Uses = NameSet

A set of names that are used somewhere

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 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

listTyCon :: TyCon

typeSymbolKind :: Kind

typeNatKind :: Kind

mkBoxedTupleTy :: [Type] -> Type

Build the type of a small tuple that holds the specified type of thing Flattens 1-tuples. See Note [One-tuples].

heqTyCon :: TyCon

coercibleTyCon :: TyCon

unitTy :: Type

liftedTypeKind :: Kind

constraintKind :: Kind

vecElemTyCon :: TyCon

vecCountTyCon :: TyCon

runtimeRepTyCon :: TyCon

runtimeRepTy :: Type

tupleRepDataConTyCon :: TyCon

vecRepDataConTyCon :: TyCon

liftedRepDataConTyCon :: TyCon

doubleRepDataConTy :: Type

floatRepDataConTy :: Type

addrRepDataConTy :: Type

word64RepDataConTy :: Type

word32RepDataConTy :: Type

word16RepDataConTy :: Type

word8RepDataConTy :: Type

wordRepDataConTy :: Type

int64RepDataConTy :: Type

int32RepDataConTy :: Type

int16RepDataConTy :: Type

int8RepDataConTy :: Type

intRepDataConTy :: Type

unliftedRepDataConTy :: Type

liftedRepDataConTy :: Type

vec64DataConTy :: Type

vec32DataConTy :: Type

vec16DataConTy :: Type

vec8DataConTy :: Type

vec4DataConTy :: Type

vec2DataConTy :: Type

doubleElemRepDataConTy :: Type

floatElemRepDataConTy :: Type

word64ElemRepDataConTy :: Type

word32ElemRepDataConTy :: Type

word16ElemRepDataConTy :: Type

word8ElemRepDataConTy :: Type

int64ElemRepDataConTy :: Type

int32ElemRepDataConTy :: Type

int16ElemRepDataConTy :: Type

int8ElemRepDataConTy :: Type

anyTypeOfKind :: Kind -> Type

unboxedTupleKind :: [Type] -> Kind

Specialization of unboxedTupleSumKind for tuples

mkPromotedListTy

Arguments

:: Kind

of the elements of the list

-> [Type]

elements

-> Type

Make a *promoted* list.

tupleTyConName :: TupleSort -> Arity -> Name

pprPrefixName :: NamedThing a => a -> SDoc

pprInfixName :: (Outputable a, NamedThing a) => a -> SDoc

getOccFS :: NamedThing a => a -> FastString

getOccString :: NamedThing a => a -> String

getSrcSpan :: NamedThing a => a -> SrcSpan

getSrcLoc :: NamedThing a => a -> SrcLoc

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"

pprNameDefnLoc :: Name -> SDoc

pprDefinedAt :: Name -> SDoc

pprModulePrefix :: PprStyle -> Module -> OccName -> SDoc

pprNameUnqualified :: Name -> SDoc

Print the string of Name unqualifiedly directly.

stableNameCmp :: Name -> Name -> Ordering

Compare Names lexicographically This only works for Names that originate in the source code or have been tidied.

localiseName :: Name -> Name

Make the Name into an internal name, regardless of what it was to begin with

tidyNameOcc :: Name -> OccName -> Name

setNameLoc :: Name -> SrcSpan -> Name

setNameUnique :: Name -> Unique -> Name

mkFCallName :: Unique -> String -> Name

Make a name for a foreign call

mkSysTvName :: Unique -> FastString -> Name

mkSystemVarName :: Unique -> FastString -> Name

mkSystemNameAt :: Unique -> OccName -> SrcSpan -> Name

mkSystemName :: Unique -> OccName -> Name

Create a name brought into being by the compiler

mkWiredInName :: Module -> OccName -> Unique -> TyThing -> BuiltInSyntax -> Name

Create a name which is actually defined by the compiler itself

mkExternalName :: Unique -> Module -> OccName -> SrcSpan -> Name

Create a name which definitely originates in the given module

mkDerivedInternalName :: (OccName -> OccName) -> Unique -> Name -> Name

mkClonedInternalName :: Unique -> Name -> Name

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 Module to disambiguate it from other Names

isSystemName :: Name -> Bool

isVarName :: Name -> Bool

isValName :: Name -> Bool

isDataConName :: Name -> Bool

isTyConName :: Name -> Bool

isTyVarName :: Name -> Bool

nameIsFromExternalPackage :: UnitId -> Name -> Bool

Returns True if the Name comes from some other package: neither this package nor the interactive package.

nameIsHomePackageImport :: Module -> Name -> Bool

nameIsHomePackage :: Module -> Name -> Bool

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 HscTypes

nameModule_maybe :: Name -> Maybe Module

nameModule :: HasDebugCallStack => Name -> Module

isHoleName :: Name -> Bool

isInternalName :: Name -> Bool

isExternalName :: Name -> Bool

isBuiltInSyntax :: Name -> Bool

wiredInNameTyThing_maybe :: Name -> Maybe TyThing

isWiredInName :: Name -> Bool

nameSrcSpan :: Name -> SrcSpan

nameSrcLoc :: Name -> SrcLoc

nameNameSpace :: Name -> NameSpace

nameOccName :: Name -> OccName

nameUnique :: Name -> Unique

data BuiltInSyntax

BuiltInSyntax is for things like (:), [] and tuples, which have special syntactic forms. They aren't in scope as such.

Constructors

BuiltInSyntax

UserSyntax

class NamedThing a where

A class allowing convenient access to the Name of various datatypes

Minimal complete definition

getName

Methods

getOccName :: a -> OccName

getName :: a -> Name

Instances

NamedThing HoleFitCandidate

Defined in TcHoleFitTypes

Methods

getOccName :: HoleFitCandidate -> OccName

getName :: HoleFitCandidate -> Name

NamedThing ClsInst

Defined in InstEnv

Methods

getOccName :: ClsInst -> OccName

getName :: ClsInst -> Name

NamedThing FamInst

Defined in FamInstEnv

Methods

getOccName :: FamInst -> OccName

getName :: FamInst -> Name

NamedThing IfaceDecl

Defined in IfaceSyn

Methods

getOccName :: IfaceDecl -> OccName

getName :: IfaceDecl -> Name

NamedThing IfaceClassOp

Defined in IfaceSyn

Methods

getOccName :: IfaceClassOp -> OccName

getName :: IfaceClassOp -> Name

NamedThing IfaceConDecl

Defined in IfaceSyn

Methods

getOccName :: IfaceConDecl -> OccName

getName :: IfaceConDecl -> Name

NamedThing Class

Defined in Class

Methods

getOccName :: Class -> OccName

getName :: Class -> Name

NamedThing ConLike

Defined in ConLike

Methods

getOccName :: ConLike -> OccName

getName :: ConLike -> Name

NamedThing DataCon

Defined in DataCon

Methods

getOccName :: DataCon -> OccName

getName :: DataCon -> Name

NamedThing PatSyn

Defined in PatSyn

Methods

getOccName :: PatSyn -> OccName

getName :: PatSyn -> Name

NamedThing TyThing

Defined in TyCoRep

Methods

getOccName :: TyThing -> OccName

getName :: TyThing -> Name

NamedThing Var

Defined in Var

Methods

getOccName :: Var -> OccName

getName :: Var -> Name

NamedThing TyCon

Defined in TyCon

Methods

getOccName :: TyCon -> OccName

getName :: TyCon -> Name

NamedThing Name

Defined in Name

Methods

getOccName :: Name -> OccName

getName :: Name -> Name

NamedThing (HsTyVarBndr GhcRn)

Defined in GHC.Hs.Types

Methods

getOccName :: HsTyVarBndr GhcRn -> OccName

getName :: HsTyVarBndr GhcRn -> Name

NamedThing (CoAxiom br)

Defined in CoAxiom

Methods

getOccName :: CoAxiom br -> OccName

getName :: CoAxiom br -> Name

NamedThing e => NamedThing (Located e)

Defined in Name

Methods

getOccName :: Located e -> OccName

getName :: Located e -> Name

NamedThing tv => NamedThing (VarBndr tv flag)

Defined in Var

Methods

getOccName :: VarBndr tv flag -> OccName

getName :: VarBndr tv flag -> Name

mkFunTy :: AnonArgFlag -> Type -> Type -> Type infixr 3

mkForAllTy :: TyCoVar -> ArgFlag -> Type -> Type

Like mkTyCoForAllTy, but does not check the occurrence of the binder See Note [Unused coercion variable in ForAllTy]

data Type

Constructors

TyVarTy Var

Vanilla type or kind variable (*never* a coercion variable)

AppTy Type Type

Type application to something other than a TyCon. Parameters:

1) Function: must not be a TyConApp or CastTy, must be another AppTy, or TyVarTy See Note Respecting definitional equality about the no CastTy requirement

2) Argument type

TyConApp TyCon [KindOrType]

Application of a TyCon, including newtypes and synonyms. Invariant: saturated applications of FunTyCon must use FunTy and saturated synonyms must use their own constructors. However, unsaturated FunTyCons do appear as TyConApps. Parameters:

1) Type constructor being applied to.

2) Type arguments. Might not have enough type arguments here to saturate the constructor. Even type synonyms are not necessarily saturated; for example unsaturated type synonyms can appear as the right hand side of a type synonym.

ForAllTy !TyCoVarBinder Type

A Π type.

FunTy

t1 -> t2 Very common, so an important special case See Note [Function types]

Fields

• ft_af :: AnonArgFlag
• ft_arg :: Type
• ft_res :: Type

LitTy TyLit

Type literals are similar to type constructors.

CastTy Type KindCoercion

A kind cast. The coercion is always nominal. INVARIANT: The cast is never refl. INVARIANT: The Type is not a CastTy (use TransCo instead) See Note Respecting definitional equality and (EQ3)

CoercionTy Coercion

Injection of a Coercion into a type This should only ever be used in the RHS of an AppTy, in the list of a TyConApp, when applying a promoted GADT data constructor

Instances

Eq Type

Defined in Language.Haskell.Liquid.GHC.TypeRep

Methods

(==) :: Type -> Type -> Bool

(/=) :: Type -> Type -> Bool

Data Type

Defined in TyCoRep

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Type -> c Type

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Type

toConstr :: Type -> Constr

dataTypeOf :: Type -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Type)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type)

gmapT :: (forall b. Data b => b -> b) -> Type -> Type

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r

gmapQ :: (forall d. Data d => d -> u) -> Type -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Type -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Type -> m Type

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Type -> m Type

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Type -> m Type

NFData Type

Defined in Language.Haskell.Liquid.GHC.Misc

Methods

rnf :: Type -> ()

Outputable Type

Defined in TyCoRep

Methods

ppr :: Type -> SDoc

pprPrec :: Rational -> Type -> SDoc

Fixpoint Type

Defined in Language.Haskell.Liquid.GHC.Misc

Methods

toFix :: Type -> Doc

simplify :: Type -> Type

PPrint Type

Defined in Language.Haskell.Liquid.Types.PrettyPrint

Methods

pprintTidy :: Tidy -> Type -> Doc

pprintPrec :: Int -> Tidy -> Type -> Doc

Default Type

Defined in Language.Haskell.Liquid.Synthesize.GHC

Methods

def :: Type

Subable Type

Defined in Language.Haskell.Liquid.GHC.Play

Methods

sub :: HashMap CoreBndr CoreExpr -> Type -> Type

subTy :: HashMap TyVar Type -> Type -> Type

SubsTy TyVar Type SpecType

Defined in Language.Haskell.Liquid.Types.RefType

Methods

subt :: (TyVar, Type) -> SpecType -> SpecType

Eq (DeBruijn Type)

Defined in CoreMap

Methods

(==) :: DeBruijn Type -> DeBruijn Type -> Bool

(/=) :: DeBruijn Type -> DeBruijn Type -> Bool

Show (Axiom Var Type CoreExpr)

Defined in Language.Haskell.Liquid.Types.Types

Methods

showsPrec :: Int -> Axiom Var Type CoreExpr -> ShowS

show :: Axiom Var Type CoreExpr -> String

showList :: [Axiom Var Type CoreExpr] -> ShowS

data TyThing

A global typecheckable-thing, essentially anything that has a name. Not to be confused with a TcTyThing, which is also a typecheckable thing but in the *local* context. See TcEnv for how to retrieve a TyThing given a Name.

Constructors

AnId Id

AConLike ConLike

ATyCon TyCon

ACoAxiom (CoAxiom Branched)

Instances

NamedThing TyThing

Defined in TyCoRep

Methods

getOccName :: TyThing -> OccName

getName :: TyThing -> Name

Outputable TyThing

Defined in TyCoRep

Methods

ppr :: TyThing -> SDoc

pprPrec :: Rational -> TyThing -> SDoc

PPrint TyThing

Defined in Language.Haskell.Liquid.Types.Types

Methods

pprintTidy :: Tidy -> TyThing -> Doc

pprintPrec :: Int -> Tidy -> TyThing -> Doc

data Coercion

A Coercion is concrete evidence of the equality/convertibility of two types.

Constructors

Refl Type

GRefl Role Type MCoercionN

TyConAppCo Role TyCon [Coercion]

AppCo Coercion CoercionN

ForAllCo TyCoVar KindCoercion Coercion

FunCo Role Coercion Coercion

CoVarCo CoVar

AxiomInstCo (CoAxiom Branched) BranchIndex [Coercion]

AxiomRuleCo CoAxiomRule [Coercion]

UnivCo UnivCoProvenance Role Type Type

SymCo Coercion

TransCo Coercion Coercion

NthCo Role Int Coercion

LRCo LeftOrRight CoercionN

InstCo Coercion CoercionN

KindCo Coercion

SubCo CoercionN

HoleCo CoercionHole

See Note [Coercion holes] Only present during typechecking

Instances

Eq Coercion

Defined in Language.Haskell.Liquid.GHC.TypeRep

Methods

(==) :: Coercion -> Coercion -> Bool

(/=) :: Coercion -> Coercion -> Bool

Data Coercion

Defined in TyCoRep

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

Defined in TyCoRep

Methods

ppr :: Coercion -> SDoc

pprPrec :: Rational -> Coercion -> SDoc

Subable Coercion

Defined in Language.Haskell.Liquid.GHC.Play

Methods

sub :: HashMap CoreBndr CoreExpr -> Coercion -> Coercion

subTy :: HashMap TyVar Type -> Coercion -> Coercion

Eq (DeBruijn Coercion)

Defined in CoreMap

Methods

(==) :: DeBruijn Coercion -> DeBruijn Coercion -> Bool

(/=) :: DeBruijn Coercion -> DeBruijn Coercion -> Bool

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.

Constructors

UnsafeCoerceProv

From unsafeCoerce#. These are unsound.

PhantomProv KindCoercion

See Note [Phantom coercions]. Only in Phantom roled coercions

ProofIrrelProv KindCoercion

From the fact that any two coercions are considered equivalent. See Note [ProofIrrelProv]. Can be used in Nominal or Representational coercions

PluginProv String

From a plugin, which asserts that this coercion is sound. The string is for the use of the plugin.

Instances

Data UnivCoProvenance

Defined in TyCoRep

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

Defined in TyCoRep

Methods

ppr :: UnivCoProvenance -> SDoc

pprPrec :: Rational -> UnivCoProvenance -> SDoc

data TyLit

Constructors

NumTyLit Integer

StrTyLit FastString

Instances

Eq TyLit

Defined in TyCoRep

Methods

(==) :: TyLit -> TyLit -> Bool

(/=) :: TyLit -> TyLit -> Bool

Data TyLit

Defined in TyCoRep

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyLit -> c TyLit

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TyLit

toConstr :: TyLit -> Constr

dataTypeOf :: TyLit -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TyLit)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyLit)

gmapT :: (forall b. Data b => b -> b) -> TyLit -> TyLit

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r

gmapQ :: (forall d. Data d => d -> u) -> TyLit -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> TyLit -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit

Ord TyLit

Defined in TyCoRep

Methods

compare :: TyLit -> TyLit -> Ordering

(<) :: TyLit -> TyLit -> Bool

(<=) :: TyLit -> TyLit -> Bool

(>) :: TyLit -> TyLit -> Bool

(>=) :: TyLit -> TyLit -> Bool

max :: TyLit -> TyLit -> TyLit

min :: TyLit -> TyLit -> TyLit

Outputable TyLit

Defined in TyCoRep

Methods

ppr :: TyLit -> SDoc

pprPrec :: Rational -> TyLit -> SDoc

data TyCoBinder

A TyCoBinder represents an argument to a function. TyCoBinders can be dependent (Named) or nondependent (Anon). They may also be visible or not. See Note [TyCoBinders]

Constructors

Named TyCoVarBinder

Anon AnonArgFlag Type

Instances

Data TyCoBinder

Defined in TyCoRep

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyCoBinder -> c TyCoBinder

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TyCoBinder

toConstr :: TyCoBinder -> Constr

dataTypeOf :: TyCoBinder -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TyCoBinder)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyCoBinder)

gmapT :: (forall b. Data b => b -> b) -> TyCoBinder -> TyCoBinder

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyCoBinder -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyCoBinder -> r

gmapQ :: (forall d. Data d => d -> u) -> TyCoBinder -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> TyCoBinder -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyCoBinder -> m TyCoBinder

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyCoBinder -> m TyCoBinder

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyCoBinder -> m TyCoBinder

Outputable TyCoBinder

Defined in TyCoRep

Methods

ppr :: TyCoBinder -> SDoc

pprPrec :: Rational -> TyCoBinder -> SDoc

data MCoercion

A semantically more meaningful type to represent what may or may not be a useful Coercion.

Constructors

MRefl

MCo Coercion

Instances

Data MCoercion

Defined in TyCoRep

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

Defined in TyCoRep

Methods

ppr :: MCoercion -> SDoc

pprPrec :: Rational -> MCoercion -> SDoc

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 Kind = Type

The key type representing kinds in the compiler.

type ThetaType = [PredType]

A collection of PredTypes

type CoercionN = Coercion

type MCoercionN = MCoercion

data ArgFlag

Argument Flag

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, TyCoVarBinders, TyConBinders, and visibility] in TyCoRep

Constructors

Inferred

Specified

Required

Instances

Eq ArgFlag

Defined in Var

Methods

(==) :: ArgFlag -> ArgFlag -> Bool

(/=) :: ArgFlag -> ArgFlag -> Bool

Data ArgFlag

Defined in Var

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ArgFlag -> c ArgFlag

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ArgFlag

toConstr :: ArgFlag -> Constr

dataTypeOf :: ArgFlag -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ArgFlag)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ArgFlag)

gmapT :: (forall b. Data b => b -> b) -> ArgFlag -> ArgFlag

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ArgFlag -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ArgFlag -> r

gmapQ :: (forall d. Data d => d -> u) -> ArgFlag -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ArgFlag -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ArgFlag -> m ArgFlag

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ArgFlag -> m ArgFlag

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ArgFlag -> m ArgFlag

Ord ArgFlag

Defined in Var

Methods

compare :: ArgFlag -> ArgFlag -> Ordering

(<) :: ArgFlag -> ArgFlag -> Bool

(<=) :: ArgFlag -> ArgFlag -> Bool

(>) :: ArgFlag -> ArgFlag -> Bool

(>=) :: ArgFlag -> ArgFlag -> Bool

max :: ArgFlag -> ArgFlag -> ArgFlag

min :: ArgFlag -> ArgFlag -> ArgFlag

Binary ArgFlag

Defined in Var

Methods

put_ :: BinHandle -> ArgFlag -> IO ()

put :: BinHandle -> ArgFlag -> IO (Bin ArgFlag)

get :: BinHandle -> IO ArgFlag

Outputable ArgFlag

Defined in Var

Methods

ppr :: ArgFlag -> SDoc

pprPrec :: Rational -> ArgFlag -> SDoc

Outputable tv => Outputable (VarBndr tv ArgFlag)

Defined in Var

Methods

ppr :: VarBndr tv ArgFlag -> SDoc

pprPrec :: Rational -> VarBndr tv ArgFlag -> SDoc

data AnonArgFlag

The non-dependent version of ArgFlag.

Constructors

VisArg

Used for (->): an ordinary non-dependent arrow. The argument is visible in source code.

InvisArg

Used for (=>): a non-dependent predicate arrow. The argument is invisible in source code.

Instances

Eq AnonArgFlag

Defined in Var

Methods

(==) :: AnonArgFlag -> AnonArgFlag -> Bool

(/=) :: AnonArgFlag -> AnonArgFlag -> Bool

Data AnonArgFlag

Defined in Var

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnonArgFlag -> c AnonArgFlag

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnonArgFlag

toConstr :: AnonArgFlag -> Constr

dataTypeOf :: AnonArgFlag -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnonArgFlag)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnonArgFlag)

gmapT :: (forall b. Data b => b -> b) -> AnonArgFlag -> AnonArgFlag

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnonArgFlag -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnonArgFlag -> r

gmapQ :: (forall d. Data d => d -> u) -> AnonArgFlag -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnonArgFlag -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnonArgFlag -> m AnonArgFlag

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnonArgFlag -> m AnonArgFlag

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnonArgFlag -> m AnonArgFlag

Ord AnonArgFlag

Defined in Var

Methods

compare :: AnonArgFlag -> AnonArgFlag -> Ordering

(<) :: AnonArgFlag -> AnonArgFlag -> Bool

(<=) :: AnonArgFlag -> AnonArgFlag -> Bool

(>) :: AnonArgFlag -> AnonArgFlag -> Bool

(>=) :: AnonArgFlag -> AnonArgFlag -> Bool

max :: AnonArgFlag -> AnonArgFlag -> AnonArgFlag

min :: AnonArgFlag -> AnonArgFlag -> AnonArgFlag

Binary AnonArgFlag

Defined in Var

Methods

put_ :: BinHandle -> AnonArgFlag -> IO ()

put :: BinHandle -> AnonArgFlag -> IO (Bin AnonArgFlag)

get :: BinHandle -> IO AnonArgFlag

Outputable AnonArgFlag

Defined in Var

Methods

ppr :: AnonArgFlag -> SDoc

pprPrec :: Rational -> AnonArgFlag -> SDoc

data Var

Variable

Essentially a typed Name, that may also contain some additional information about the Var and its use sites.

Instances

Eq Var

Defined in Var

Methods

(==) :: Var -> Var -> Bool

(/=) :: Var -> Var -> Bool

Data Var

Defined in 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

Ord Var

Defined in 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

Show CoreExpr

Defined in Language.Haskell.Liquid.Transforms.CoreToLogic

Methods

showsPrec :: Int -> CoreExpr -> ShowS

show :: CoreExpr -> String

showList :: [CoreExpr] -> ShowS

Show Var

Defined in Language.Haskell.Liquid.GHC.Misc

Methods

showsPrec :: Int -> Var -> ShowS

show :: Var -> String

showList :: [Var] -> ShowS

NFData Var

Defined in Language.Haskell.Liquid.GHC.Misc

Methods

rnf :: Var -> ()

NamedThing Var

Defined in Var

Methods

getOccName :: Var -> OccName

getName :: Var -> Name

HasOccName Var

Defined in Var

Methods

occName :: Var -> OccName

Uniquable Var

Defined in Var

Methods

getUnique :: Var -> Unique

Outputable Var

Defined in Var

Methods

ppr :: Var -> SDoc

pprPrec :: Rational -> Var -> SDoc

Symbolic Var

NOTE:REFLECT-IMPORTS

we **eschew** the unique suffix for exported vars, to make it possible to lookup names from symbols _across_ modules; anyways exported names are top-level and you shouldn't have local binders that shadow them. However, we **keep** the unique suffix for local variables, as otherwise there are spurious, but extremely problematic, name collisions in the fixpoint environment.

Defined in Language.Haskell.Liquid.GHC.Misc

Methods

symbol :: Var -> Symbol

Fixpoint Var

Defined in Language.Haskell.Liquid.GHC.Misc

Methods

toFix :: Var -> Doc

simplify :: Var -> Var

PPrint Var

Defined in Language.Haskell.Liquid.Types.PrettyPrint

Methods

pprintTidy :: Tidy -> Var -> Doc

pprintPrec :: Int -> Tidy -> Var -> Doc

Expression Var

Converting to Fixpoint ----------------------------------------------------

Defined in Language.Haskell.Liquid.Types.RefType

Methods

expr :: Var -> Expr

Loc Var

Defined in Language.Haskell.Liquid.GHC.Misc

Methods

srcSpan :: Var -> SrcSpan

Hashable Var

Defined in Language.Haskell.Liquid.GHC.Misc

Methods

hashWithSalt :: Int -> Var -> Int

hash :: Var -> Int

Default Var

Defined in Language.Haskell.Liquid.Synthesize.GHC

Methods

def :: Var

CBVisitable CoreBind

Defined in Language.Haskell.Liquid.Types.Visitors

Methods

freeVars :: HashSet Var -> CoreBind -> [Var]

readVars :: CoreBind -> [Var]

letVars :: CoreBind -> [Var]

literals :: CoreBind -> [Literal]

Subable CoreExpr

Defined in Language.Haskell.Liquid.GHC.Play

Methods

sub :: HashMap CoreBndr CoreExpr -> CoreExpr -> CoreExpr

subTy :: HashMap TyVar Type -> CoreExpr -> CoreExpr

Subable Var

Defined in Language.Haskell.Liquid.GHC.Play

Methods

sub :: HashMap CoreBndr CoreExpr -> Var -> Var

subTy :: HashMap TyVar Type -> Var -> Var

ResolveSym Var

Defined in Language.Haskell.Liquid.Bare.Resolve

Methods

resolveLocSym :: Env -> ModName -> String -> LocSymbol -> Either UserError Var

SubsTy TyVar Type SpecType

Defined in Language.Haskell.Liquid.Types.RefType

Methods

subt :: (TyVar, Type) -> SpecType -> SpecType

Eq (DeBruijn CoreExpr)

Defined in CoreMap

Methods

(==) :: DeBruijn CoreExpr -> DeBruijn CoreExpr -> Bool

(/=) :: DeBruijn CoreExpr -> DeBruijn CoreExpr -> Bool

Eq (DeBruijn CoreAlt)

Defined in CoreMap

Methods

(==) :: DeBruijn CoreAlt -> DeBruijn CoreAlt -> Bool

(/=) :: DeBruijn CoreAlt -> DeBruijn CoreAlt -> Bool

PPrint (Expr Var)

Defined in Language.Haskell.Liquid.Types.PrettyPrint

Methods

pprintTidy :: Tidy -> Expr Var -> Doc

pprintPrec :: Int -> Tidy -> Expr Var -> Doc

PPrint (Bind Var)

Defined in Language.Haskell.Liquid.Types.PrettyPrint

Methods

pprintTidy :: Tidy -> Bind Var -> Doc

pprintPrec :: Int -> Tidy -> Bind Var -> Doc

CBVisitable [CoreBind]

Defined in Language.Haskell.Liquid.Types.Visitors

Methods

freeVars :: HashSet Var -> [CoreBind] -> [Var]

readVars :: [CoreBind] -> [Var]

letVars :: [CoreBind] -> [Var]

literals :: [CoreBind] -> [Literal]

CBVisitable (Expr Var)

Defined in Language.Haskell.Liquid.Types.Visitors

Methods

freeVars :: HashSet Var -> Expr Var -> [Var]

readVars :: Expr Var -> [Var]

letVars :: Expr Var -> [Var]

literals :: Expr Var -> [Literal]

CBVisitable (Alt Var)

Defined in Language.Haskell.Liquid.Types.Visitors

Methods

freeVars :: HashSet Var -> Alt Var -> [Var]

readVars :: Alt Var -> [Var]

letVars :: Alt Var -> [Var]

literals :: Alt Var -> [Literal]

Subable (Alt Var)

Defined in Language.Haskell.Liquid.GHC.Play

Methods

sub :: HashMap CoreBndr CoreExpr -> Alt Var -> Alt Var

subTy :: HashMap TyVar Type -> Alt Var -> Alt Var

Subable (Bind Var)

Defined in Language.Haskell.Liquid.GHC.Play

Methods

sub :: HashMap CoreBndr CoreExpr -> Bind Var -> Bind Var

subTy :: HashMap TyVar Type -> Bind Var -> Bind Var

Show (Axiom Var Type CoreExpr)

Defined in Language.Haskell.Liquid.Types.Types

Methods

showsPrec :: Int -> Axiom Var Type CoreExpr -> ShowS

show :: Axiom Var Type CoreExpr -> String

showList :: [Axiom Var Type CoreExpr] -> ShowS

traceCmd :: DynFlags -> String -> String -> IO a -> IO a

isWarnMsgFatal :: DynFlags -> WarnMsg -> Maybe (Maybe WarningFlag)

Checks if given WarnMsg is a fatal warning.

prettyPrintGhcErrors :: ExceptionMonad m => DynFlags -> m a -> m a

logOutput :: DynFlags -> PprStyle -> MsgDoc -> IO ()

Like logInfo but with SevOutput rather then SevInfo

logInfo :: DynFlags -> PprStyle -> MsgDoc -> IO ()

printOutputForUser :: DynFlags -> PrintUnqualified -> MsgDoc -> IO ()

printInfoForUser :: DynFlags -> PrintUnqualified -> MsgDoc -> IO ()

putMsg :: DynFlags -> MsgDoc -> IO ()

debugTraceMsg :: DynFlags -> Int -> MsgDoc -> IO ()

withTimingSilentD

Arguments

:: (MonadIO m, HasDynFlags m)

=> 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) and gets the DynFlags from the given Monad.

See Note [withTiming] for more.

withTimingSilent

Arguments

:: MonadIO m

=> DynFlags

DynFlags

-> 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.

withTimingD

Arguments

:: (MonadIO m, HasDynFlags m)

=> 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

Like withTiming but get DynFlags from the Monad.

withTiming

Arguments

:: MonadIO m

=> DynFlags

DynFlags

-> 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.

showPass :: DynFlags -> String -> IO ()

compilationProgressMsg :: DynFlags -> String -> IO ()

fatalErrorMsg'' :: FatalMessager -> String -> IO ()

fatalErrorMsg :: DynFlags -> MsgDoc -> IO ()

warningMsg :: DynFlags -> MsgDoc -> IO ()

errorMsg :: DynFlags -> MsgDoc -> IO ()

dumpSDocWithStyle :: PprStyle -> DynFlags -> DumpFlag -> String -> SDoc -> IO ()

Write out a dump. If --dump-to-file is set then this goes to a file. otherwise emit to stdout.

When hdr is empty, we print in a more compact format (no separators and blank lines)

The DumpFlag is used only to choose the filename to use if --dump-to-file is used; it is not used to decide whether to dump the output

dumpSDocForUser :: DynFlags -> PrintUnqualified -> DumpFlag -> String -> SDoc -> IO ()

A wrapper around dumpSDocWithStyle which uses PprUser style.

mkDumpDoc :: String -> SDoc -> SDoc

dumpIfSet_dyn_printer :: PrintUnqualified -> DynFlags -> DumpFlag -> SDoc -> IO ()

a wrapper around dumpSDoc. First check whether the dump flag is set Do nothing if it is unset

Unlike dumpIfSet_dyn, has a printer argument but no header argument

dumpIfSet_dyn :: DynFlags -> DumpFlag -> String -> SDoc -> IO ()

a wrapper around dumpSDoc. First check whether the dump flag is set Do nothing if it is unset

dumpIfSet :: DynFlags -> Bool -> String -> SDoc -> IO ()

doIfSet_dyn :: DynFlags -> GeneralFlag -> IO () -> IO ()

doIfSet :: Bool -> IO () -> IO ()

ghcExit :: DynFlags -> Int -> IO ()

pprLocErrMsg :: ErrMsg -> SDoc

pprErrMsgBagWithLoc :: Bag ErrMsg -> [SDoc]

formatErrDoc :: DynFlags -> ErrDoc -> SDoc

printBagOfErrors :: DynFlags -> Bag ErrMsg -> IO ()

warningsToMessages :: DynFlags -> WarningMessages -> Messages

errorsFound :: DynFlags -> Messages -> Bool

isEmptyMessages :: Messages -> Bool

emptyMessages :: Messages

mkPlainWarnMsg :: DynFlags -> SrcSpan -> MsgDoc -> ErrMsg

Variant that doesn't care about qualified/unqualified names

mkWarnMsg :: DynFlags -> SrcSpan -> PrintUnqualified -> MsgDoc -> ErrMsg

A short (one-line) error message

mkLongWarnMsg :: DynFlags -> SrcSpan -> PrintUnqualified -> MsgDoc -> MsgDoc -> ErrMsg

A long (multi-line) error message

mkPlainErrMsg :: DynFlags -> SrcSpan -> MsgDoc -> ErrMsg

Variant that doesn't care about qualified/unqualified names

mkErrMsg :: DynFlags -> SrcSpan -> PrintUnqualified -> MsgDoc -> ErrMsg

A short (one-line) error message

mkLongErrMsg :: DynFlags -> SrcSpan -> PrintUnqualified -> MsgDoc -> MsgDoc -> ErrMsg

A long (multi-line) error message

mkErrDoc :: DynFlags -> SrcSpan -> PrintUnqualified -> ErrDoc -> ErrMsg

makeIntoWarning :: WarnReason -> ErrMsg -> ErrMsg

pprMessageBag :: Bag MsgDoc -> SDoc

errDoc :: [MsgDoc] -> [MsgDoc] -> [MsgDoc] -> ErrDoc

unionMessages :: Messages -> Messages -> Messages

orValid :: Validity -> Validity -> Validity

getInvalids :: [Validity] -> [MsgDoc]

allValid :: [Validity] -> Validity

If they aren't all valid, return the first

andValid :: Validity -> Validity -> Validity

isValid :: Validity -> Bool

data Validity

Constructors

IsValid

Everything is fine

NotValid MsgDoc

A problem, and some indication of why

type Messages = (WarningMessages, ErrorMessages)

type WarningMessages = Bag WarnMsg

type ErrorMessages = Bag ErrMsg

data ErrMsg

Instances

Show ErrMsg

Defined in ErrUtils

Methods

showsPrec :: Int -> ErrMsg -> ShowS

show :: ErrMsg -> String

showList :: [ErrMsg] -> ShowS

PPrint ErrMsg

A whole bunch of PPrint instances follow ----------------------------------

Defined in Language.Haskell.Liquid.Types.PrettyPrint

Methods

pprintTidy :: Tidy -> ErrMsg -> Doc

pprintPrec :: Int -> Tidy -> ErrMsg -> Doc

data ErrDoc

Categorise error msgs by their importance. This is so each section can be rendered visually distinct. See Note [Error report] for where these come from.

type WarnMsg = ErrMsg

tidyOccName :: TidyOccEnv -> OccName -> (TidyOccEnv, OccName)

avoidClashesOccEnv :: TidyOccEnv -> [OccName] -> TidyOccEnv

initTidyOccEnv :: [OccName] -> TidyOccEnv

emptyTidyOccEnv :: TidyOccEnv

mkMethodOcc :: OccName -> OccName

mkDataCOcc

Arguments

:: OccName

TyCon or data con string

-> OccSet

avoid these Occs

-> OccName

E.g. $f3OrdMaybe data T = MkT ... deriving( Data ) needs definitions for $tT :: Data.Generics.Basics.DataType $cMkT :: Data.Generics.Basics.Constr

mkDataTOcc

Arguments

:: OccName

TyCon or data con string

-> OccSet

avoid these Occs

-> OccName

E.g. $f3OrdMaybe data T = MkT ... deriving( Data ) needs definitions for $tT :: Data.Generics.Basics.DataType $cMkT :: Data.Generics.Basics.Constr

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

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.

mkLocalOcc

Arguments

:: Unique

Unique to combine with the OccName

-> OccName

Local name, e.g. sat

-> OccName

Nice unique version, e.g. $L23sat

mkSuperDictSelOcc

Arguments

:: Int

Index of superclass, e.g. 3

-> OccName

Class, e.g. Ord

-> OccName

Derived Occname, e.g. $p3Ord

mkSuperDictAuxOcc :: Int -> OccName -> OccName

mkDataConWorkerOcc :: OccName -> OccName

mkRecFldSelOcc :: String -> OccName

mkGen1R :: OccName -> OccName

mkGenR :: OccName -> OccName

mkTyConRepOcc :: OccName -> OccName

mkMaxTagOcc :: OccName -> OccName

mkTag2ConOcc :: OccName -> OccName

mkCon2TagOcc :: OccName -> OccName

mkEqPredCoOcc :: OccName -> OccName

mkInstTyCoOcc :: OccName -> OccName

mkNewTyCoOcc :: OccName -> OccName

mkClassDataConOcc :: OccName -> OccName

mkRepEqOcc :: OccName -> OccName

mkForeignExportOcc :: OccName -> OccName

mkSpecOcc :: OccName -> OccName

mkIPOcc :: OccName -> OccName

mkDictOcc :: OccName -> OccName

mkClassOpAuxOcc :: OccName -> OccName

mkDefaultMethodOcc :: OccName -> OccName

mkBuilderOcc :: OccName -> OccName

mkMatcherOcc :: OccName -> OccName

mkWorkerOcc :: OccName -> OccName

mkDataConWrapperOcc :: OccName -> OccName

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 TcTypeable.

isDefaultMethodOcc :: OccName -> Bool

isDerivedOccName :: OccName -> Bool

Test for definitions internally generated by GHC. This predicte is used to suppress printing of internal definitions in some debug prints

startsWithUnderscore :: OccName -> Bool

Haskell 98 encourages compilers to suppress warnings about unsed names in a pattern if they start with _: this implements that test

parenSymOcc :: OccName -> SDoc -> SDoc

Wrap parens around an operator

isSymOcc :: OccName -> Bool

Test if the OccName is that for any operator (whether it is a data constructor or variable or whatever)

isDataSymOcc :: OccName -> Bool

Test if the OccName is a data constructor that starts with a symbol (e.g. :, or [])

isDataOcc :: OccName -> Bool

isValOcc :: OccName -> Bool

Value OccNamess are those that are either in the variable or data constructor namespaces

isTcOcc :: OccName -> Bool

isTvOcc :: OccName -> Bool

isVarOcc :: OccName -> Bool

setOccNameSpace :: NameSpace -> OccName -> OccName

occNameString :: OccName -> String

filterOccSet :: (OccName -> Bool) -> OccSet -> OccSet

intersectsOccSet :: OccSet -> OccSet -> Bool

intersectOccSet :: OccSet -> OccSet -> OccSet

isEmptyOccSet :: OccSet -> Bool

elemOccSet :: OccName -> OccSet -> Bool

minusOccSet :: OccSet -> OccSet -> OccSet

unionManyOccSets :: [OccSet] -> OccSet

unionOccSets :: OccSet -> OccSet -> OccSet

extendOccSetList :: OccSet -> [OccName] -> OccSet

extendOccSet :: OccSet -> OccName -> OccSet

mkOccSet :: [OccName] -> OccSet

unitOccSet :: OccName -> OccSet

emptyOccSet :: OccSet

pprOccEnv :: (a -> SDoc) -> OccEnv a -> SDoc

alterOccEnv :: (Maybe elt -> Maybe elt) -> OccEnv elt -> OccName -> OccEnv elt

filterOccEnv :: (elt -> Bool) -> OccEnv elt -> OccEnv elt

delListFromOccEnv :: OccEnv a -> [OccName] -> OccEnv a

delFromOccEnv :: OccEnv a -> OccName -> OccEnv a

mkOccEnv_C :: (a -> a -> a) -> [(OccName, a)] -> OccEnv a

mapOccEnv :: (a -> b) -> OccEnv a -> OccEnv b

extendOccEnv_Acc :: (a -> b -> b) -> (a -> b) -> OccEnv b -> OccName -> a -> OccEnv b

extendOccEnv_C :: (a -> a -> a) -> OccEnv a -> OccName -> a -> OccEnv a

plusOccEnv_C :: (a -> a -> a) -> OccEnv a -> OccEnv a -> OccEnv a

plusOccEnv :: OccEnv a -> OccEnv a -> OccEnv a

occEnvElts :: OccEnv a -> [a]

foldOccEnv :: (a -> b -> b) -> b -> OccEnv a -> b

elemOccEnv :: OccName -> OccEnv a -> Bool

mkOccEnv :: [(OccName, a)] -> OccEnv a

lookupOccEnv :: OccEnv a -> OccName -> Maybe a

extendOccEnvList :: OccEnv a -> [(OccName, a)] -> OccEnv a

extendOccEnv :: OccEnv a -> OccName -> a -> OccEnv a

unitOccEnv :: OccName -> a -> OccEnv a

emptyOccEnv :: OccEnv a

nameSpacesRelated :: NameSpace -> NameSpace -> Bool

demoteOccName :: OccName -> Maybe OccName

mkClsOccFS :: FastString -> OccName

mkClsOcc :: String -> OccName

mkTcOccFS :: FastString -> OccName

mkTcOcc :: String -> OccName

mkTyVarOccFS :: FastString -> OccName

mkTyVarOcc :: String -> OccName

mkDataOccFS :: FastString -> OccName

mkDataOcc :: String -> OccName

mkVarOccFS :: FastString -> OccName

mkVarOcc :: String -> OccName

mkOccNameFS :: NameSpace -> FastString -> OccName

mkOccName :: NameSpace -> String -> OccName

pprOccName :: OccName -> SDoc

pprNameSpaceBrief :: NameSpace -> SDoc

pprNonVarNameSpace :: NameSpace -> SDoc

pprNameSpace :: NameSpace -> SDoc

isValNameSpace :: NameSpace -> Bool

isVarNameSpace :: NameSpace -> Bool

isTvNameSpace :: NameSpace -> Bool

isTcClsNameSpace :: NameSpace -> Bool

isDataConNameSpace :: NameSpace -> Bool

tvName :: NameSpace

srcDataName :: NameSpace

dataName :: NameSpace

tcClsName :: NameSpace

clsName :: NameSpace

tcName :: NameSpace

data NameSpace

Instances

Eq NameSpace

Defined in OccName

Methods

(==) :: NameSpace -> NameSpace -> Bool

(/=) :: NameSpace -> NameSpace -> Bool

Ord NameSpace

Defined in OccName

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

Binary NameSpace

Defined in OccName

Methods

put_ :: BinHandle -> NameSpace -> IO ()

put :: BinHandle -> NameSpace -> IO (Bin NameSpace)

get :: BinHandle -> IO NameSpace

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

HasOccName HoleFitCandidate

Defined in TcHoleFitTypes

Methods

occName :: HoleFitCandidate -> OccName

HasOccName TcBinder

Defined in TcRnTypes

Methods

occName :: TcBinder -> OccName

HasOccName IfaceDecl

Defined in IfaceSyn

Methods

occName :: IfaceDecl -> OccName

HasOccName IfaceClassOp

Defined in IfaceSyn

Methods

occName :: IfaceClassOp -> OccName

HasOccName IfaceConDecl

Defined in IfaceSyn

Methods

occName :: IfaceConDecl -> OccName

HasOccName RdrName

Defined in RdrName

Methods

occName :: RdrName -> OccName

HasOccName Var

Defined in Var

Methods

occName :: Var -> OccName

HasOccName OccName

Defined in OccName

Methods

occName :: OccName -> OccName

HasOccName Name

Defined in Name

Methods

occName :: Name -> OccName

HasOccName name => HasOccName (IEWrappedName name)

Defined in GHC.Hs.ImpExp

Methods

occName :: IEWrappedName name -> OccName

data OccEnv a

Instances

Data a => Data (OccEnv a)

Defined in OccName

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OccEnv a -> c (OccEnv a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (OccEnv a)

toConstr :: OccEnv a -> Constr

dataTypeOf :: OccEnv a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (OccEnv a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (OccEnv a))

gmapT :: (forall b. Data b => b -> b) -> OccEnv a -> OccEnv a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OccEnv a -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OccEnv a -> r

gmapQ :: (forall d. Data d => d -> u) -> OccEnv a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> OccEnv a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> OccEnv a -> m (OccEnv a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OccEnv a -> m (OccEnv a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OccEnv a -> m (OccEnv a)

Outputable a => Outputable (OccEnv a)

Defined in OccName

Methods

ppr :: OccEnv a -> SDoc

pprPrec :: Rational -> OccEnv a -> SDoc

type OccSet = UniqSet OccName

type TidyOccEnv = UniqFM Int

emptyFilesToClean :: FilesToClean

An empty FilesToClean

isBmi2Enabled :: DynFlags -> Bool

isBmiEnabled :: DynFlags -> Bool

isAvx512pfEnabled :: DynFlags -> Bool

isAvx512fEnabled :: DynFlags -> Bool

isAvx512erEnabled :: DynFlags -> Bool

isAvx512cdEnabled :: DynFlags -> Bool

isAvx2Enabled :: DynFlags -> Bool

isAvxEnabled :: DynFlags -> Bool

isSse4_2Enabled :: DynFlags -> Bool

isSse2Enabled :: DynFlags -> Bool

isSseEnabled :: DynFlags -> Bool

setUnsafeGlobalDynFlags :: DynFlags -> IO ()

makeDynFlagsConsistent :: DynFlags -> (DynFlags, [Located String])

Resolve any internal inconsistencies in a set of DynFlags. Returns the consistent DynFlags as well as a list of warnings to report to the user.

tARGET_MAX_WORD :: DynFlags -> Integer

tARGET_MAX_INT :: DynFlags -> Integer

tARGET_MIN_INT :: DynFlags -> Integer

mAX_PTR_TAG :: DynFlags -> Int

tAG_MASK :: DynFlags -> Int

wordAlignment :: DynFlags -> Alignment

wORD_SIZE_IN_BITS :: DynFlags -> Int

bLOCK_SIZE_W :: DynFlags -> Int

iLDV_STATE_USE :: DynFlags -> Integer

iLDV_STATE_CREATE :: DynFlags -> Integer

iLDV_CREATE_MASK :: DynFlags -> Integer

lDV_SHIFT :: DynFlags -> Int

dYNAMIC_BY_DEFAULT :: DynFlags -> Bool

wORDS_BIGENDIAN :: DynFlags -> Bool

tAG_BITS :: DynFlags -> Int

bITMAP_BITS_SHIFT :: DynFlags -> Int

cLONG_LONG_SIZE :: DynFlags -> Int

cLONG_SIZE :: DynFlags -> Int

cINT_SIZE :: DynFlags -> Int

dOUBLE_SIZE :: DynFlags -> Int

wORD_SIZE :: DynFlags -> Int

aP_STACK_SPLIM :: DynFlags -> Int

rESERVED_STACK_WORDS :: DynFlags -> Int

rESERVED_C_STACK_BYTES :: DynFlags -> Int

mAX_Real_Long_REG :: DynFlags -> Int

mAX_Real_XMM_REG :: DynFlags -> Int

mAX_Real_Double_REG :: DynFlags -> Int

mAX_Real_Float_REG :: DynFlags -> Int

mAX_Real_Vanilla_REG :: DynFlags -> Int

mAX_XMM_REG :: DynFlags -> Int

mAX_Long_REG :: DynFlags -> Int

mAX_Double_REG :: DynFlags -> Int

mAX_Float_REG :: DynFlags -> Int

mAX_Vanilla_REG :: DynFlags -> Int

mUT_ARR_PTRS_CARD_BITS :: DynFlags -> Int

mAX_CHARLIKE :: DynFlags -> Int

mIN_CHARLIKE :: DynFlags -> Int

mAX_INTLIKE :: DynFlags -> Int

mIN_INTLIKE :: DynFlags -> Int

mIN_PAYLOAD_SIZE :: DynFlags -> Int

mAX_SPEC_AP_SIZE :: DynFlags -> Int

mAX_SPEC_SELECTEE_SIZE :: DynFlags -> Int

oFFSET_StgFunInfoExtraRev_arity :: DynFlags -> Int

sIZEOF_StgFunInfoExtraRev :: DynFlags -> Int

oFFSET_StgFunInfoExtraFwd_arity :: DynFlags -> Int

oFFSET_StgUpdateFrame_updatee :: DynFlags -> Int

oFFSET_StgStack_stack :: DynFlags -> Int

oFFSET_StgStack_sp :: DynFlags -> Int

oFFSET_StgTSO_stackobj :: DynFlags -> Int

oFFSET_StgTSO_cccs :: DynFlags -> Int

oFFSET_StgTSO_alloc_limit :: DynFlags -> Int

oFFSET_StgArrBytes_bytes :: DynFlags -> Int

sIZEOF_StgArrBytes_NoHdr :: DynFlags -> Int

oFFSET_StgSmallMutArrPtrs_ptrs :: DynFlags -> Int

sIZEOF_StgSmallMutArrPtrs_NoHdr :: DynFlags -> Int

oFFSET_StgMutArrPtrs_size :: DynFlags -> Int

oFFSET_StgMutArrPtrs_ptrs :: DynFlags -> Int

sIZEOF_StgMutArrPtrs_NoHdr :: DynFlags -> Int

sIZEOF_StgUpdateFrame_NoHdr :: DynFlags -> Int

oFFSET_StgEntCounter_entry_count :: DynFlags -> Int

oFFSET_StgEntCounter_link :: DynFlags -> Int

oFFSET_StgEntCounter_registeredp :: DynFlags -> Int

oFFSET_StgEntCounter_allocd :: DynFlags -> Int

oFFSET_StgEntCounter_allocs :: DynFlags -> Int

sIZEOF_StgSMPThunkHeader :: DynFlags -> Int

oFFSET_StgHeader_ldvw :: DynFlags -> Int

oFFSET_StgHeader_ccs :: DynFlags -> Int

oFFSET_CostCentreStack_scc_count :: DynFlags -> Int

oFFSET_CostCentreStack_mem_alloc :: DynFlags -> Int

sIZEOF_CostCentreStack :: DynFlags -> Int

oFFSET_bdescr_flags :: DynFlags -> Int

oFFSET_bdescr_blocks :: DynFlags -> Int

oFFSET_bdescr_free :: DynFlags -> Int

oFFSET_bdescr_start :: DynFlags -> Int

oFFSET_Capability_r :: DynFlags -> Int

oFFSET_stgGCFun :: DynFlags -> Int

oFFSET_stgGCEnter1 :: DynFlags -> Int

oFFSET_stgEagerBlackholeInfo :: DynFlags -> Int

oFFSET_StgRegTable_rHpAlloc :: DynFlags -> Int

oFFSET_StgRegTable_rCurrentNursery :: DynFlags -> Int

oFFSET_StgRegTable_rCurrentTSO :: DynFlags -> Int

oFFSET_StgRegTable_rCCCS :: DynFlags -> Int

oFFSET_StgRegTable_rHpLim :: DynFlags -> Int

oFFSET_StgRegTable_rHp :: DynFlags -> Int

oFFSET_StgRegTable_rSpLim :: DynFlags -> Int

oFFSET_StgRegTable_rSp :: DynFlags -> Int

oFFSET_StgRegTable_rL1 :: DynFlags -> Int

oFFSET_StgRegTable_rZMM6 :: DynFlags -> Int

oFFSET_StgRegTable_rZMM5 :: DynFlags -> Int

oFFSET_StgRegTable_rZMM4 :: DynFlags -> Int

oFFSET_StgRegTable_rZMM3 :: DynFlags -> Int

oFFSET_StgRegTable_rZMM2 :: DynFlags -> Int

oFFSET_StgRegTable_rZMM1 :: DynFlags -> Int

oFFSET_StgRegTable_rYMM6 :: DynFlags -> Int

oFFSET_StgRegTable_rYMM5 :: DynFlags -> Int

oFFSET_StgRegTable_rYMM4 :: DynFlags -> Int

oFFSET_StgRegTable_rYMM3 :: DynFlags -> Int

oFFSET_StgRegTable_rYMM2 :: DynFlags -> Int

oFFSET_StgRegTable_rYMM1 :: DynFlags -> Int

oFFSET_StgRegTable_rXMM6 :: DynFlags -> Int

oFFSET_StgRegTable_rXMM5 :: DynFlags -> Int

oFFSET_StgRegTable_rXMM4 :: DynFlags -> Int

oFFSET_StgRegTable_rXMM3 :: DynFlags -> Int

oFFSET_StgRegTable_rXMM2 :: DynFlags -> Int

oFFSET_StgRegTable_rXMM1 :: DynFlags -> Int

oFFSET_StgRegTable_rD6 :: DynFlags -> Int

oFFSET_StgRegTable_rD5 :: DynFlags -> Int

oFFSET_StgRegTable_rD4 :: DynFlags -> Int

oFFSET_StgRegTable_rD3 :: DynFlags -> Int

oFFSET_StgRegTable_rD2 :: DynFlags -> Int

oFFSET_StgRegTable_rD1 :: DynFlags -> Int

oFFSET_StgRegTable_rF6 :: DynFlags -> Int

oFFSET_StgRegTable_rF5 :: DynFlags -> Int

oFFSET_StgRegTable_rF4 :: DynFlags -> Int

oFFSET_StgRegTable_rF3 :: DynFlags -> Int

oFFSET_StgRegTable_rF2 :: DynFlags -> Int

oFFSET_StgRegTable_rF1 :: DynFlags -> Int

oFFSET_StgRegTable_rR10 :: DynFlags -> Int

oFFSET_StgRegTable_rR9 :: DynFlags -> Int

oFFSET_StgRegTable_rR8 :: DynFlags -> Int

oFFSET_StgRegTable_rR7 :: DynFlags -> Int

oFFSET_StgRegTable_rR6 :: DynFlags -> Int

oFFSET_StgRegTable_rR5 :: DynFlags -> Int

oFFSET_StgRegTable_rR4 :: DynFlags -> Int

oFFSET_StgRegTable_rR3 :: DynFlags -> Int

oFFSET_StgRegTable_rR2 :: DynFlags -> Int

oFFSET_StgRegTable_rR1 :: DynFlags -> Int

tICKY_BIN_COUNT :: DynFlags -> Int

bLOCKS_PER_MBLOCK :: DynFlags -> Int

bLOCK_SIZE :: DynFlags -> Int

pROF_HDR_SIZE :: DynFlags -> Int

sTD_HDR_SIZE :: DynFlags -> Int

cONTROL_GROUP_CONST_291 :: DynFlags -> Int

compilerInfo :: DynFlags -> [(String, String)]

picPOpts :: DynFlags -> [String]

picCCOpts :: DynFlags -> [String]

setTmpDir :: FilePath -> DynFlags -> DynFlags

setFlagsFromEnvFile :: FilePath -> String -> DynP ()

canonicalizeModuleIfHome :: DynFlags -> Module -> Module

canonicalizeHomeModule :: DynFlags -> ModuleName -> Module

Given a ModuleName of a signature in the home library, find out how it is instantiated. E.g., the canonical form of A in p[A=q[]:A] is q[]:A.

setUnitId :: String -> DynFlags -> DynFlags

unSetGeneralFlag' :: GeneralFlag -> DynFlags -> DynFlags

setGeneralFlag' :: GeneralFlag -> DynFlags -> DynFlags

addWay' :: Way -> DynFlags -> DynFlags

dynamicGhc :: Bool

rtsIsProfiled :: Bool

Was the runtime system built with profiling enabled?

glasgowExtsFlags :: [Extension]

warningHierarchies :: [[String]]

Warning group hierarchies, where there is an explicit inclusion relation.

Each inner list is a hierarchy of warning groups, ordered from smallest to largest, where each group is a superset of the one before it.

Separating this from warningGroups allows for multiple hierarchies with no inherent relation to be defined.

The special-case Weverything group is not included.

warningGroups :: [(String, [WarningFlag])]

Warning groups.

As all warnings are in the Weverything set, it is ignored when displaying to the user which group a warning is in.

xFlags :: [FlagSpec Extension]

These -Xblah flags can all be reversed with -XNoblah

supportedLanguagesAndExtensions :: PlatformMini -> [String]

fLangFlags :: [FlagSpec Extension]

These -f<blah> flags can all be reversed with -fno-<blah>

fFlags :: [FlagSpec GeneralFlag]

These -f<blah> flags can all be reversed with -fno-<blah>

wWarningFlags :: [FlagSpec WarningFlag]

These -W<blah> flags can all be reversed with -Wno-<blah>

flagsForCompletion :: Bool -> [String]

Make a list of flags for shell completion. Filter all available flags into two groups, for interactive GHC vs all other.

flagsPackage :: [Flag (CmdLineP DynFlags)]

flagsDynamic :: [Flag (CmdLineP DynFlags)]

flagsAll :: [Flag (CmdLineP DynFlags)]

allNonDeprecatedFlags :: [String]

All dynamic flags option strings without the deprecated ones. These are the user facing strings for enabling and disabling options.

updateWays :: DynFlags -> DynFlags

putLogMsg :: DynFlags -> WarnReason -> Severity -> SrcSpan -> PprStyle -> MsgDoc -> IO ()

Write an error or warning to the LogOutput.

parseDynamicFlagsFull

Arguments

:: 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])

Parses the dynamically set flags for GHC. This is the most general form of the dynamic flag parser that the other methods simply wrap. It allows saying which flags are valid flags and indicating if we are parsing arguments from the command line or from a file pragma.

parseDynamicFilePragma

Arguments

:: MonadIO m

=> DynFlags

-> [Located String]

-> m (DynFlags, [Located String], [Warn])

Updated DynFlags, left-over arguments, and list of warnings.

Like parseDynamicFlagsCmdLine but does not allow the package flags (-package, -hide-package, -ignore-package, -hide-all-packages, -package-db). Used to parse flags set in a modules pragma.

parseDynamicFlagsCmdLine

Arguments

:: MonadIO m

=> DynFlags

-> [Located String]

-> m (DynFlags, [Located String], [Warn])

Updated DynFlags, left-over arguments, and list of warnings.

Parse dynamic flags from a list of command line arguments. Returns the parsed DynFlags, the left-over arguments, and a list of warnings. Throws a UsageError if errors occurred during parsing (such as unknown flags or missing arguments).

updOptLevel :: Int -> DynFlags -> DynFlags

Sets the DynFlags to be appropriate to the optimisation level

addPluginModuleName :: String -> DynFlags -> DynFlags

thisPackage :: DynFlags -> UnitId

thisUnitIdInsts :: DynFlags -> [(ModuleName, Module)]

thisComponentId :: DynFlags -> ComponentId

getVerbFlags :: DynFlags -> [String]

Gets the verbosity flag for the current verbosity level. This is fed to other tools, so GHC-specific verbosity flags like -ddump-most are not included

getOpts

Arguments

:: DynFlags

DynFlags to retrieve the options from

-> (DynFlags -> [a])

Relevant record accessor: one of the opt_* accessors

-> [a]

Correctly ordered extracted options

Retrieve the options corresponding to a particular opt_* field in the correct order

unsafeFlagsForInfer :: [(String, DynFlags -> SrcSpan, DynFlags -> Bool, DynFlags -> DynFlags)]

A list of unsafe flags under Safe Haskell. Tuple elements are: * name of the flag * function to get srcspan that enabled the flag * function to test if the flag is on * function to turn the flag off

unsafeFlags :: [(String, DynFlags -> SrcSpan, DynFlags -> Bool, DynFlags -> DynFlags)]

A list of unsafe flags under Safe Haskell. Tuple elements are: * name of the flag * function to get srcspan that enabled the flag * function to test if the flag is on * function to turn the flag off

safeImplicitImpsReq :: DynFlags -> Bool

Are all implicit imports required to be safe for this Safe Haskell mode? Implicit imports are things in the prelude. e.g System.IO when print is used.

safeDirectImpsReq :: DynFlags -> Bool

Are all direct imports required to be safe for this Safe Haskell mode? Direct imports are when the code explicitly imports a module

safeImportsOn :: DynFlags -> Bool

Test if Safe Imports are on in some form

safeInferOn :: DynFlags -> Bool

Is the Safe Haskell safe inference mode active

safeLanguageOn :: DynFlags -> Bool

Is the Safe Haskell safe language in use

safeHaskellModeEnabled :: DynFlags -> Bool

safeHaskellOn :: DynFlags -> Bool

Is Safe Haskell on in some way (including inference mode)

packageTrustOn :: DynFlags -> Bool

Is the -fpackage-trust mode on

dynFlagDependencies :: DynFlags -> [ModuleName]

Some modules have dependencies on others through the DynFlags rather than textual imports

lang_set :: DynFlags -> Maybe Language -> DynFlags

xopt_set_unlessExplSpec :: Extension -> (DynFlags -> Extension -> DynFlags) -> DynFlags -> DynFlags

Set or unset a Extension, unless it has been explicitly set or unset before.

xopt_unset :: DynFlags -> Extension -> DynFlags

Unset a Extension

xopt_set :: DynFlags -> Extension -> DynFlags

Set a Extension

xopt :: Extension -> DynFlags -> Bool

Test whether a Extension is set

wopt_unset_fatal :: DynFlags -> WarningFlag -> DynFlags

Mark a WarningFlag as not fatal

wopt_set_fatal :: DynFlags -> WarningFlag -> DynFlags

Mark a WarningFlag as fatal (do not set the flag)

wopt_fatal :: WarningFlag -> DynFlags -> Bool

Test whether a WarningFlag is set as fatal

wopt_unset :: DynFlags -> WarningFlag -> DynFlags

Unset a WarningFlag

wopt_set :: DynFlags -> WarningFlag -> DynFlags

Set a WarningFlag

wopt :: WarningFlag -> DynFlags -> Bool

Test whether a WarningFlag is set

gopt_unset :: DynFlags -> GeneralFlag -> DynFlags

Unset a GeneralFlag

gopt_set :: DynFlags -> GeneralFlag -> DynFlags

Set a GeneralFlag

gopt :: GeneralFlag -> DynFlags -> Bool

Test whether a GeneralFlag is set

dopt_unset :: DynFlags -> DumpFlag -> DynFlags

Unset a DumpFlag

dopt_set :: DynFlags -> DumpFlag -> DynFlags

Set a DumpFlag

dopt :: DumpFlag -> DynFlags -> Bool

Test whether a DumpFlag is set

hasNoOptCoercion :: DynFlags -> Bool

hasNoStateHack :: DynFlags -> Bool

languageExtensions :: Maybe Language -> [Extension]

The language extensions implied by the various language variants. When updating this be sure to update the flag documentation in docsusers-guideglasgow_exts.rst.

defaultFlushErr :: FlushErr

defaultFlushOut :: FlushOut

defaultLogActionHPutStrDoc :: DynFlags -> Handle -> SDoc -> PprStyle -> IO ()

defaultLogActionHPrintDoc :: DynFlags -> Handle -> SDoc -> PprStyle -> IO ()

Like defaultLogActionHPutStrDoc but appends an extra newline.

defaultLogAction :: LogAction

defaultFatalMessager :: FatalMessager

interpreterDynamic :: DynFlags -> Bool

interpreterProfiled :: DynFlags -> Bool

interpWays :: [Way]

defaultWays :: Settings -> [Way]

defaultDynFlags :: Settings -> LlvmConfig -> DynFlags

The normal DynFlags. Note that they are not suitable for use in this form and must be fully initialized by runGhc first.

initDynFlags :: DynFlags -> IO DynFlags

Used by runGhc to partially initialize a new DynFlags value

dynamicOutputFile :: DynFlags -> FilePath -> FilePath

Compute the path of the dynamic object corresponding to an object file.

dynamicTooMkDynamicDynFlags :: DynFlags -> DynFlags

whenCannotGenerateDynamicToo :: MonadIO m => DynFlags -> m () -> m ()

ifGeneratingDynamicToo :: MonadIO m => DynFlags -> m a -> m a -> m a

whenGeneratingDynamicToo :: MonadIO m => DynFlags -> m () -> m ()

wayUnsetGeneralFlags :: Platform -> Way -> [GeneralFlag]

wayGeneralFlags :: Platform -> Way -> [GeneralFlag]

wayRTSOnly :: Way -> Bool

mkBuildTag :: [Way] -> String

positionIndependent :: DynFlags -> Bool

Are we building with -fPIE or -fPIC enabled?

defaultObjectTarget :: DynFlags -> HscTarget

packageFlagsChanged :: DynFlags -> DynFlags -> Bool

isNoLink :: GhcLink -> Bool

isOneShot :: GhcMode -> Bool

targetRetainsAllBindings :: HscTarget -> Bool

Does this target retain *all* top-level bindings for a module, rather than just the exported bindings, in the TypeEnv and compiled code (if any)? In interpreted mode we do this, so that GHCi can call functions inside a module. In HscNothing mode we also do it, so that Haddock can get access to the GlobalRdrEnv for a module after typechecking it.

isObjectTarget :: HscTarget -> Bool

Will this target result in an object file on the disk?

versionedFilePath :: DynFlags -> FilePath

versionedAppDir :: DynFlags -> MaybeT IO FilePath

The directory for this version of ghc in the user's app directory (typically something like ~.ghcx86_64-linux-7.6.3)

tablesNextToCode :: DynFlags -> Bool

opt_i :: DynFlags -> [String]

opt_lc :: DynFlags -> [String]

opt_lo :: DynFlags -> [String]

opt_lcc :: DynFlags -> [String]

opt_windres :: DynFlags -> [String]

opt_l :: DynFlags -> [String]

opt_a :: DynFlags -> [String]

opt_cxx :: DynFlags -> [String]

opt_c :: DynFlags -> [String]

opt_F :: DynFlags -> [String]

opt_P_signature :: DynFlags -> ([String], Fingerprint)

opt_P :: DynFlags -> [String]

opt_L :: DynFlags -> [String]

pgm_i :: DynFlags -> String

pgm_lc :: DynFlags -> (String, [Option])

pgm_lo :: DynFlags -> (String, [Option])

pgm_ranlib :: DynFlags -> String

pgm_ar :: DynFlags -> String

pgm_lcc :: DynFlags -> (String, [Option])

pgm_libtool :: DynFlags -> String

pgm_windres :: DynFlags -> String

pgm_T :: DynFlags -> String

pgm_dll :: DynFlags -> (String, [Option])

pgm_l :: DynFlags -> (String, [Option])

pgm_a :: DynFlags -> (String, [Option])

pgm_c :: DynFlags -> String

pgm_F :: DynFlags -> String

pgm_P :: DynFlags -> (String, [Option])

pgm_L :: DynFlags -> String

systemPackageConfig :: DynFlags -> FilePath

extraGccViaCFlags :: DynFlags -> [String]

tmpDir :: DynFlags -> String

topDir :: DynFlags -> FilePath

ghciUsagePath :: DynFlags -> FilePath

ghcUsagePath :: DynFlags -> FilePath

projectVersion :: DynFlags -> String

programName :: DynFlags -> String

settings :: DynFlags -> Settings

"unbuild" a Settings from a DynFlags. This shouldn't be needed in the vast majority of code. But GHCi questionably uses this to produce a default DynFlags from which to compute a flags diff for printing.

backendMaintainsCfg :: DynFlags -> Bool

flattenIncludes :: IncludeSpecs -> [String]

Concatenate and flatten the list of global and quoted includes returning just a flat list of paths.

addQuoteInclude :: IncludeSpecs -> [String] -> IncludeSpecs

Append to the list of includes a path that shall be included using `-iquote` when the C compiler is called. These paths only apply when quoted includes are used. e.g. #include "foo.h"

addGlobalInclude :: IncludeSpecs -> [String] -> IncludeSpecs

Append to the list of includes a path that shall be included using `-I` when the C compiler is called. These paths override system search paths.

optimisationFlags :: EnumSet GeneralFlag

data WarnReason

Used when outputting warnings: if a reason is given, it is displayed. If a warning isn't controlled by a flag, this is made explicit at the point of use.

Constructors

NoReason

Reason !WarningFlag

Warning was enabled with the flag

ErrReason !(Maybe WarningFlag)

Warning was made an error because of -Werror or -Werror=WarningFlag

Instances

Show WarnReason

Defined in DynFlags

Methods

showsPrec :: Int -> WarnReason -> ShowS

show :: WarnReason -> String

showList :: [WarnReason] -> ShowS

ToJson WarnReason

Defined in DynFlags

Methods

json :: WarnReason -> JsonDoc

Outputable WarnReason

Defined in DynFlags

Methods

ppr :: WarnReason -> SDoc

pprPrec :: Rational -> WarnReason -> SDoc

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]

Instances

Show IncludeSpecs

Defined in DynFlags

Methods

showsPrec :: Int -> IncludeSpecs -> ShowS

show :: IncludeSpecs -> String

showList :: [IncludeSpecs] -> ShowS

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_WarnRedundantRecordWildcards

Opt_WarnWarningsDeprecations

Opt_WarnDeprecatedFlags

Opt_WarnMissingMonadFailInstances

Opt_WarnSemigroup

Opt_WarnDodgyExports

Opt_WarnDodgyImports

Opt_WarnOrphans

Opt_WarnAutoOrphans

Opt_WarnIdentities

Opt_WarnTabs

Opt_WarnUnrecognisedPragmas

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

Instances

Enum WarningFlag

Defined in DynFlags

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]

Eq WarningFlag

Defined in DynFlags

Methods

(==) :: WarningFlag -> WarningFlag -> Bool

(/=) :: WarningFlag -> WarningFlag -> Bool

Show WarningFlag

Defined in DynFlags

Methods

showsPrec :: Int -> WarningFlag -> ShowS

show :: WarningFlag -> String

showList :: [WarningFlag] -> ShowS

data Language

Constructors

Haskell98

Haskell2010

Instances

Enum Language

Defined in DynFlags

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]

Eq Language

Defined in DynFlags

Methods

(==) :: Language -> Language -> Bool

(/=) :: Language -> Language -> Bool

Show Language

Defined in DynFlags

Methods

showsPrec :: Int -> Language -> ShowS

show :: Language -> String

showList :: [Language] -> ShowS

Outputable Language

Defined in DynFlags

Methods

ppr :: Language -> SDoc

pprPrec :: Rational -> Language -> SDoc

data SafeHaskellMode

The various Safe Haskell modes

Constructors

Sf_None

inferred unsafe

Sf_Unsafe

declared and checked

Sf_Trustworthy

declared and checked

Sf_Safe

declared and checked

Sf_SafeInferred

inferred as safe

Sf_Ignore

-fno-safe-haskell state

Instances

Eq SafeHaskellMode

Defined in DynFlags

Methods

(==) :: SafeHaskellMode -> SafeHaskellMode -> Bool

(/=) :: SafeHaskellMode -> SafeHaskellMode -> Bool

Show SafeHaskellMode

Defined in DynFlags

Methods

showsPrec :: Int -> SafeHaskellMode -> ShowS

show :: SafeHaskellMode -> String

showList :: [SafeHaskellMode] -> ShowS

Outputable SafeHaskellMode

Defined in DynFlags

Methods

ppr :: SafeHaskellMode -> SDoc

pprPrec :: Rational -> SafeHaskellMode -> SDoc

data CfgWeights

Edge weights to use when generating a CFG from CMM

Constructors

CFGWeights

Fields

• uncondWeight :: Int
• condBranchWeight :: Int
• switchWeight :: Int
• callWeight :: Int
• likelyCondWeight :: Int
• unlikelyCondWeight :: Int
• infoTablePenalty :: Int
• backEdgeBonus :: Int

class HasDynFlags (m :: Type -> Type) where

Methods

getDynFlags :: m DynFlags

Instances

HasDynFlags Ghc

Defined in GhcMonad

Methods

getDynFlags :: Ghc DynFlags

HasDynFlags CompPipeline

Defined in PipelineMonad

Methods

getDynFlags :: CompPipeline DynFlags

HasDynFlags Hsc

Defined in HscTypes

Methods

getDynFlags :: Hsc DynFlags

HasDynFlags CoreM

Defined in CoreMonad

Methods

getDynFlags :: CoreM DynFlags

HasDynFlags LintM

Defined in CoreLint

Methods

getDynFlags :: LintM DynFlags

(Monad m, HasDynFlags m) => HasDynFlags (MaybeT m)

Defined in DynFlags

Methods

getDynFlags :: MaybeT m DynFlags

MonadIO m => HasDynFlags (GhcT m)

Defined in GhcMonad

Methods

getDynFlags :: GhcT m DynFlags

ContainsDynFlags env => HasDynFlags (IOEnv env)

Defined in IOEnv

Methods

getDynFlags :: IOEnv env DynFlags

(Monad m, HasDynFlags m) => HasDynFlags (ExceptT e m)

Defined in DynFlags

Methods

getDynFlags :: ExceptT e m DynFlags

(Monad m, HasDynFlags m) => HasDynFlags (ReaderT a m)

Defined in DynFlags

Methods

getDynFlags :: ReaderT a m DynFlags

(Monoid a, Monad m, HasDynFlags m) => HasDynFlags (WriterT a m)

Defined in DynFlags

Methods

getDynFlags :: WriterT a m DynFlags

class ContainsDynFlags t where

Methods

extractDynFlags :: t -> DynFlags

Instances

ContainsDynFlags (Env gbl lcl)

Defined in TcRnTypes

Methods

extractDynFlags :: Env gbl lcl -> DynFlags

data ProfAuto

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

Enum ProfAuto

Defined in DynFlags

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

Defined in DynFlags

Methods

(==) :: ProfAuto -> ProfAuto -> Bool

(/=) :: ProfAuto -> ProfAuto -> Bool

data LlvmTarget

Constructors

LlvmTarget

Fields

• lDataLayout :: String
• lCPU :: String
• lAttributes :: [String]

data LlvmConfig

See Note [LLVM Configuration] in SysTools.

Constructors

LlvmConfig

Fields

• llvmTargets :: [(String, LlvmTarget)]
• llvmPasses :: [(Int, String)]

data HscTarget

The target code type of the compilation (if any).

Whenever you change the target, also make sure to set ghcLink to something sensible.

HscNothing can be used to avoid generating any output, however, note that:

• If a program uses Template Haskell the typechecker may need to run code from an imported module. To facilitate this, code generation is enabled for modules imported by modules that use template haskell. See Note [-fno-code mode].

Constructors

HscC

Generate C code.

HscAsm

Generate assembly using the native code generator.

HscLlvm

Generate assembly using the llvm code generator.

HscInterpreted

Generate bytecode. (Requires LinkInMemory)

HscNothing

Don't generate any code. See notes above.

Instances

Eq HscTarget

Defined in DynFlags

Methods

(==) :: HscTarget -> HscTarget -> Bool

(/=) :: HscTarget -> HscTarget -> Bool

Show HscTarget

Defined in DynFlags

Methods

showsPrec :: Int -> HscTarget -> ShowS

show :: HscTarget -> String

showList :: [HscTarget] -> ShowS

data GhcMode

The GhcMode tells us whether we're doing multi-module compilation (controlled via the GHC API) or one-shot (single-module) compilation. This makes a difference primarily to the Finder: in one-shot mode we look for interface files for imported modules, but in multi-module mode we look for source files in order to check whether they need to be recompiled.

Constructors

CompManager

--make, GHCi, etc.

OneShot

ghc -c Foo.hs

MkDepend

ghc -M, see Finder for why we need this

Instances

Eq GhcMode

Defined in DynFlags

Methods

(==) :: GhcMode -> GhcMode -> Bool

(/=) :: GhcMode -> GhcMode -> Bool

Outputable GhcMode

Defined in DynFlags

Methods

ppr :: GhcMode -> SDoc

pprPrec :: Rational -> GhcMode -> SDoc

data GhcLink

What to do in the link step, if there is one.

Constructors

NoLink

Don't link at all

LinkBinary

Link object code into a binary

LinkInMemory

Use the in-memory dynamic linker (works for both bytecode and object code).

LinkDynLib

Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)

LinkStaticLib

Link objects into a static lib

Instances

Eq GhcLink

Defined in DynFlags

Methods

(==) :: GhcLink -> GhcLink -> Bool

(/=) :: GhcLink -> GhcLink -> Bool

Show GhcLink

Defined in DynFlags

Methods

showsPrec :: Int -> GhcLink -> ShowS

show :: GhcLink -> String

showList :: [GhcLink] -> ShowS

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 UnitId

-package-id, by UnitId

Instances

Eq PackageArg

Defined in DynFlags

Methods

(==) :: PackageArg -> PackageArg -> Bool

(/=) :: PackageArg -> PackageArg -> Bool

Show PackageArg

Defined in DynFlags

Methods

showsPrec :: Int -> PackageArg -> ShowS

show :: PackageArg -> String

showList :: [PackageArg] -> ShowS

Outputable PackageArg

Defined in DynFlags

Methods

ppr :: PackageArg -> SDoc

pprPrec :: Rational -> PackageArg -> SDoc

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

Eq ModRenaming

Defined in DynFlags

Methods

(==) :: ModRenaming -> ModRenaming -> Bool

(/=) :: ModRenaming -> ModRenaming -> Bool

Outputable ModRenaming

Defined in DynFlags

Methods

ppr :: ModRenaming -> SDoc

pprPrec :: Rational -> ModRenaming -> SDoc

newtype IgnorePackageFlag

Flags for manipulating the set of non-broken packages.

Constructors

IgnorePackage String

-ignore-package

Instances

Eq IgnorePackageFlag

Defined in DynFlags

Methods

(==) :: IgnorePackageFlag -> IgnorePackageFlag -> Bool

(/=) :: IgnorePackageFlag -> IgnorePackageFlag -> Bool

data TrustFlag

Flags for manipulating package trust.

Constructors

TrustPackage String

-trust

DistrustPackage String

-distrust

Instances

Eq TrustFlag

Defined in DynFlags

Methods

(==) :: TrustFlag -> TrustFlag -> Bool

(/=) :: TrustFlag -> TrustFlag -> Bool

data PackageFlag

Flags for manipulating packages visibility.

Constructors

ExposePackage String PackageArg ModRenaming

-package, -package-id

HidePackage String

-hide-package

Instances

Eq PackageFlag

Defined in DynFlags

Methods

(==) :: PackageFlag -> PackageFlag -> Bool

(/=) :: PackageFlag -> PackageFlag -> Bool

Outputable PackageFlag

Defined in DynFlags

Methods

ppr :: PackageFlag -> SDoc

pprPrec :: Rational -> PackageFlag -> SDoc

data PackageDBFlag

Constructors

PackageDB PkgConfRef

NoUserPackageDB

NoGlobalPackageDB

ClearPackageDBs

Instances

Eq PackageDBFlag

Defined in DynFlags

Methods

(==) :: PackageDBFlag -> PackageDBFlag -> Bool

(/=) :: PackageDBFlag -> PackageDBFlag -> Bool

data DynLibLoader

Constructors

Deployable

SystemDependent

Instances

Eq DynLibLoader

Defined in DynFlags

Methods

(==) :: DynLibLoader -> DynLibLoader -> Bool

(/=) :: DynLibLoader -> DynLibLoader -> Bool

data RtsOptsEnabled

Constructors

RtsOptsNone

RtsOptsIgnore

RtsOptsIgnoreAll

RtsOptsSafeOnly

RtsOptsAll

Instances

Show RtsOptsEnabled

Defined in DynFlags

Methods

showsPrec :: Int -> RtsOptsEnabled -> ShowS

show :: RtsOptsEnabled -> String

showList :: [RtsOptsEnabled] -> ShowS

data Way

Constructors

WayCustom String

WayThreaded

WayDebug

WayProf

WayEventLog

WayDyn

Instances

Eq Way

Defined in DynFlags

Methods

(==) :: Way -> Way -> Bool

(/=) :: Way -> Way -> Bool

Ord Way

Defined in DynFlags

Methods

compare :: Way -> Way -> Ordering

(<) :: Way -> Way -> Bool

(<=) :: Way -> Way -> Bool

(>) :: Way -> Way -> Bool

(>=) :: Way -> Way -> Bool

max :: Way -> Way -> Way

min :: Way -> Way -> Way

Show Way

Defined in DynFlags

Methods

showsPrec :: Int -> Way -> ShowS

show :: Way -> String

showList :: [Way] -> ShowS

type FatalMessager = String -> IO ()

type LogAction = DynFlags -> WarnReason -> Severity -> SrcSpan -> PprStyle -> MsgDoc -> IO ()

newtype FlushOut

Constructors

FlushOut (IO ())

newtype FlushErr

Constructors

FlushErr (IO ())

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

data PkgConfRef

Constructors

GlobalPkgConf

UserPkgConf

PkgConfFile FilePath

Instances

Eq PkgConfRef

Defined in DynFlags

Methods

(==) :: PkgConfRef -> PkgConfRef -> Bool

(/=) :: PkgConfRef -> PkgConfRef -> Bool

data LinkerInfo

Constructors

GnuLD [Option]

GnuGold [Option]

LlvmLLD [Option]

DarwinLD [Option]

SolarisLD [Option]

AixLD [Option]

UnknownLD

Instances

Eq LinkerInfo

Defined in DynFlags

Methods

(==) :: LinkerInfo -> LinkerInfo -> Bool

(/=) :: LinkerInfo -> LinkerInfo -> Bool

data CompilerInfo

Constructors

GCC

Clang

AppleClang

AppleClang51

UnknownCC

Instances

Eq CompilerInfo

Defined in DynFlags

Methods

(==) :: CompilerInfo -> CompilerInfo -> Bool

(/=) :: CompilerInfo -> CompilerInfo -> Bool

data FilesToClean

A collection of files that must be deleted before ghc exits. The current collection is stored in an IORef in DynFlags, filesToClean.

Constructors

FilesToClean

Fields

• ftcGhcSession :: !(Set FilePath)

  Files that will be deleted at the end of runGhc(T)

• ftcCurrentModule :: !(Set FilePath)

  Files that will be deleted the next time cleanCurrentModuleTempFiles is called, or otherwise at the end of the session.

isHsigFile :: HscSource -> Bool

isHsBootOrSig :: HscSource -> Bool

hscSourceString :: HscSource -> String

data HscSource

Constructors

HsSrcFile

HsBootFile

HsigFile

Instances

Eq HscSource

Defined in DriverPhases

Methods

(==) :: HscSource -> HscSource -> Bool

(/=) :: HscSource -> HscSource -> Bool

Ord HscSource

Defined in DriverPhases

Methods

compare :: HscSource -> HscSource -> Ordering

(<) :: HscSource -> HscSource -> Bool

(<=) :: HscSource -> HscSource -> Bool

(>) :: HscSource -> HscSource -> Bool

(>=) :: HscSource -> HscSource -> Bool

max :: HscSource -> HscSource -> HscSource

min :: HscSource -> HscSource -> HscSource

Show HscSource

Defined in DriverPhases

Methods

showsPrec :: Int -> HscSource -> ShowS

show :: HscSource -> String

showList :: [HscSource] -> ShowS

Binary HscSource

Defined in DriverPhases

Methods

put_ :: BinHandle -> HscSource -> IO ()

put :: BinHandle -> HscSource -> IO (Bin HscSource)

get :: BinHandle -> IO HscSource

data Phase

Instances

Eq Phase

Defined in DriverPhases

Methods

(==) :: Phase -> Phase -> Bool

(/=) :: Phase -> Phase -> Bool

Show Phase

Defined in DriverPhases

Methods

showsPrec :: Int -> Phase -> ShowS

show :: Phase -> String

showList :: [Phase] -> ShowS

Outputable Phase

Defined in DriverPhases

Methods

ppr :: Phase -> SDoc

pprPrec :: Rational -> Phase -> SDoc

unitModuleSet :: Module -> ModuleSet

unionModuleSet :: ModuleSet -> ModuleSet -> ModuleSet

delModuleSet :: ModuleSet -> Module -> ModuleSet

minusModuleSet :: ModuleSet -> ModuleSet -> ModuleSet

intersectModuleSet :: ModuleSet -> ModuleSet -> ModuleSet

elemModuleSet :: Module -> ModuleSet -> Bool

moduleSetElts :: ModuleSet -> [Module]

emptyModuleSet :: ModuleSet

extendModuleSetList :: ModuleSet -> [Module] -> ModuleSet

extendModuleSet :: ModuleSet -> Module -> ModuleSet

mkModuleSet :: [Module] -> ModuleSet

isEmptyModuleEnv :: ModuleEnv a -> Bool

unitModuleEnv :: Module -> a -> ModuleEnv a

moduleEnvToList :: ModuleEnv a -> [(Module, a)]

moduleEnvElts :: ModuleEnv a -> [a]

moduleEnvKeys :: ModuleEnv a -> [Module]

emptyModuleEnv :: ModuleEnv a

mkModuleEnv :: [(Module, a)] -> ModuleEnv a

mapModuleEnv :: (a -> b) -> ModuleEnv a -> ModuleEnv b

lookupWithDefaultModuleEnv :: ModuleEnv a -> a -> Module -> a

lookupModuleEnv :: ModuleEnv a -> Module -> Maybe a

plusModuleEnv :: ModuleEnv a -> ModuleEnv a -> ModuleEnv a

delModuleEnv :: ModuleEnv a -> Module -> ModuleEnv a

delModuleEnvList :: ModuleEnv a -> [Module] -> ModuleEnv a

plusModuleEnv_C :: (a -> a -> a) -> ModuleEnv a -> ModuleEnv a -> ModuleEnv a

extendModuleEnvList_C :: (a -> a -> a) -> ModuleEnv a -> [(Module, a)] -> ModuleEnv a

extendModuleEnvList :: ModuleEnv a -> [(Module, a)] -> ModuleEnv a

extendModuleEnvWith :: (a -> a -> a) -> ModuleEnv a -> Module -> a -> ModuleEnv a

extendModuleEnv :: ModuleEnv a -> Module -> a -> ModuleEnv a

elemModuleEnv :: Module -> ModuleEnv a -> Bool

filterModuleEnv :: (Module -> a -> Bool) -> ModuleEnv a -> ModuleEnv a

wiredInUnitIds :: [UnitId]

isHoleModule :: Module -> Bool

isInteractiveModule :: Module -> Bool

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.

interactiveUnitId :: UnitId

thisGhcUnitId :: UnitId

thUnitId :: UnitId

rtsUnitId :: UnitId

baseUnitId :: UnitId

integerUnitId :: UnitId

primUnitId :: UnitId

parseModSubst :: ReadP [(ModuleName, Module)]

parseModuleId :: ReadP Module

parseComponentId :: ReadP ComponentId

parseUnitId :: ReadP UnitId

parseModuleName :: ReadP ModuleName

generalizeIndefModule :: IndefModule -> IndefModule

generalizeIndefUnitId :: IndefUnitId -> IndefUnitId

splitUnitIdInsts :: UnitId -> (InstalledUnitId, Maybe IndefUnitId)

See splitModuleInsts.

splitModuleInsts :: Module -> (InstalledModule, Maybe IndefModule)

Given a possibly on-the-fly instantiated module, split it into a Module 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.

renameHoleUnitId' :: PackageConfigMap -> ShHoleSubst -> UnitId -> UnitId

Like 'renameHoleUnitId, but requires only PackageConfigMap so it can be used by Packages.

renameHoleModule' :: PackageConfigMap -> ShHoleSubst -> Module -> Module

Like renameHoleModule, but requires only PackageConfigMap so it can be used by Packages.

renameHoleUnitId :: DynFlags -> ShHoleSubst -> UnitId -> UnitId

Substitutes holes in a UnitId, suitable for renaming when an include occurs; see Note [Representation of module/name variable].

p[A=A] maps to p[A=B] with A=B.

renameHoleModule :: DynFlags -> ShHoleSubst -> Module -> Module

Substitutes holes in a Module. NOT suitable for being called directly on a nameModule, see Note [Representation of module/name variable]. p[A=A]:B maps to p[A=q():A]:B with A=q():A; similarly, A maps to q():A.

stringToUnitId :: String -> UnitId

fsToUnitId :: FastString -> UnitId

Create a new simple unit identifier from a FastString. Internally, this is primarily used to specify wired-in unit identifiers.

newSimpleUnitId :: ComponentId -> UnitId

Create a new simple unit identifier (no holes) from a ComponentId.

stableUnitIdCmp :: UnitId -> UnitId -> Ordering

Compares package ids lexically, rather than by their Uniques

newUnitId :: ComponentId -> [(ModuleName, Module)] -> UnitId

Create a new, un-hashed unit identifier.

hashUnitId :: ComponentId -> [(ModuleName, Module)] -> FastString

Generate a uniquely identifying FastString for a unit identifier. This is a one-way function. You can rely on one special property: if a unit identifier is in most general form, its FastString coincides with its ComponentId. This hash is completely internal to GHC and is not used for symbol names or file paths.

unitIdIsDefinite :: UnitId -> Bool

A UnitId is definite if it has no free holes.

unitIdFreeHoles :: UnitId -> UniqDSet ModuleName

Retrieve the set of free holes of a UnitId.

delInstalledModuleEnv :: InstalledModuleEnv a -> InstalledModule -> InstalledModuleEnv a

filterInstalledModuleEnv :: (InstalledModule -> a -> Bool) -> InstalledModuleEnv a -> InstalledModuleEnv a

extendInstalledModuleEnv :: InstalledModuleEnv a -> InstalledModule -> a -> InstalledModuleEnv a

lookupInstalledModuleEnv :: InstalledModuleEnv a -> InstalledModule -> Maybe a

emptyInstalledModuleEnv :: InstalledModuleEnv a

installedUnitIdEq :: InstalledUnitId -> UnitId -> Bool

Test if a UnitId corresponds to a given InstalledUnitId, modulo instantiation.

installedModuleEq :: InstalledModule -> Module -> Bool

Test if a Module corresponds to a given InstalledModule, modulo instantiation.

stringToInstalledUnitId :: String -> InstalledUnitId

componentIdToInstalledUnitId :: ComponentId -> InstalledUnitId

fsToInstalledUnitId :: FastString -> InstalledUnitId

installedUnitIdString :: InstalledUnitId -> String

toInstalledUnitId :: UnitId -> InstalledUnitId

Lossy conversion to the on-disk InstalledUnitId for a component.

indefModuleToModule :: DynFlags -> IndefModule -> Module

Injects an IndefModule to Module (see also indefUnitIdToUnitId.

indefUnitIdToUnitId :: DynFlags -> IndefUnitId -> UnitId

Injects an IndefUnitId (indefinite library which was on-the-fly instantiated) to a UnitId (either an indefinite or definite library).

newIndefUnitId :: ComponentId -> [(ModuleName, Module)] -> IndefUnitId

Create a new IndefUnitId given an explicit module substitution.

unitIdKey :: UnitId -> Unique

unitIdFS :: UnitId -> FastString

pprModule :: Module -> SDoc

mkModule :: UnitId -> ModuleName -> Module

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.

mkHoleModule :: ModuleName -> Module

Create a module variable at some ModuleName. See Note [Representation of module/name variables]

moduleIsDefinite :: Module -> Bool

A Module is definite if it has no free holes.

moduleFreeHoles :: Module -> UniqDSet ModuleName

Calculate the free holes of a Module. 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.

moduleNameColons :: ModuleName -> String

Returns the string version of the module name, with dots replaced by colons.

moduleNameSlashes :: ModuleName -> String

Returns the string version of the module name, with dots replaced by slashes.

mkModuleNameFS :: FastString -> ModuleName

mkModuleName :: String -> ModuleName

moduleStableString :: Module -> String

Get a string representation of a Module that's unique and stable across recompilations. eg. "$aeson_70dylHtv1FFGeai1IoxcQr$Data.Aeson.Types.Internal"

moduleNameString :: ModuleName -> String

moduleNameFS :: ModuleName -> FastString

pprModuleName :: ModuleName -> SDoc

stableModuleNameCmp :: ModuleName -> ModuleName -> Ordering

Compares module names lexically, rather than by their Uniques

addBootSuffixLocnOut :: ModLocation -> ModLocation

Add the -boot suffix to all output file paths associated with the module, not including the input file itself

addBootSuffixLocn :: ModLocation -> ModLocation

Add the -boot suffix to all file paths associated with the module

addBootSuffix_maybe :: Bool -> FilePath -> FilePath

Add the -boot suffix if the Bool argument is True

addBootSuffix :: FilePath -> FilePath

Add the -boot suffix to .hs, .hi and .o files

data ModLocation

Module Location

Where a module lives on the file system: the actual locations of the .hs, .hi and .o files, if we have them

Constructors

ModLocation

Fields

• ml_hs_file :: Maybe FilePath
• ml_hi_file :: FilePath
• ml_obj_file :: FilePath
• ml_hie_file :: FilePath

Instances

Show ModLocation

Defined in Module

Methods

showsPrec :: Int -> ModLocation -> ShowS

show :: ModLocation -> String

showList :: [ModLocation] -> ShowS

Outputable ModLocation

Defined in Module

Methods

ppr :: ModLocation -> SDoc

pprPrec :: Rational -> ModLocation -> SDoc

class ContainsModule t where

Methods

extractModule :: t -> Module

Instances

ContainsModule DsGblEnv

Defined in TcRnTypes

Methods

extractModule :: DsGblEnv -> Module

ContainsModule TcGblEnv

Defined in TcRnTypes

Methods

extractModule :: TcGblEnv -> Module

ContainsModule gbl => ContainsModule (Env gbl lcl)

Defined in TcRnTypes

Methods

extractModule :: Env gbl lcl -> Module

class HasModule (m :: Type -> Type) where

Methods

getModule :: m Module

Instances

HasModule CoreM

Defined in CoreMonad

Methods

getModule :: CoreM Module

ContainsModule env => HasModule (IOEnv env)

Defined in IOEnv

Methods

getModule :: IOEnv env Module

data IndefUnitId

A unit identifier which identifies an indefinite library (with holes) that has been *on-the-fly* instantiated with a substitution indefUnitIdInsts. In fact, an indefinite unit identifier could have no holes, but we haven't gotten around to compiling the actual library yet.

An indefinite unit identifier pretty-prints to something like p[H=H,A=aimpl:A>] (p is the ComponentId, and the brackets enclose the module substitution).

Constructors

IndefUnitId

Fields

• indefUnitIdFS :: FastString

  A private, uniquely identifying representation of a UnitId. This string is completely private to GHC and is just used to get a unique; in particular, we don't use it for symbols (indefinite libraries are not compiled).

• indefUnitIdKey :: Unique

  Cached unique of unitIdFS.

• indefUnitIdComponentId :: !ComponentId

  The component identity of the indefinite library that is being instantiated.

• indefUnitIdInsts :: ![(ModuleName, Module)]

  The sorted (by ModuleName) instantiations of this library.

• indefUnitIdFreeHoles :: UniqDSet ModuleName

  A cache of the free module variables of unitIdInsts. This lets us efficiently tell if a UnitId has been fully instantiated (free module variables are empty) and whether or not a substitution can have any effect.

Instances

Eq IndefUnitId

Defined in Module

Methods

(==) :: IndefUnitId -> IndefUnitId -> Bool

(/=) :: IndefUnitId -> IndefUnitId -> Bool

Ord IndefUnitId

Defined in Module

Methods

compare :: IndefUnitId -> IndefUnitId -> Ordering

(<) :: IndefUnitId -> IndefUnitId -> Bool

(<=) :: IndefUnitId -> IndefUnitId -> Bool

(>) :: IndefUnitId -> IndefUnitId -> Bool

(>=) :: IndefUnitId -> IndefUnitId -> Bool

max :: IndefUnitId -> IndefUnitId -> IndefUnitId

min :: IndefUnitId -> IndefUnitId -> IndefUnitId

Binary IndefUnitId

Defined in Module

Methods

put_ :: BinHandle -> IndefUnitId -> IO ()

put :: BinHandle -> IndefUnitId -> IO (Bin IndefUnitId)

get :: BinHandle -> IO IndefUnitId

Outputable IndefUnitId

Defined in Module

Methods

ppr :: IndefUnitId -> SDoc

pprPrec :: Rational -> IndefUnitId -> SDoc

data IndefModule

Constructors

IndefModule

Fields

• indefModuleUnitId :: IndefUnitId
• indefModuleName :: ModuleName

Instances

Eq IndefModule

Defined in Module

Methods

(==) :: IndefModule -> IndefModule -> Bool

(/=) :: IndefModule -> IndefModule -> Bool

Ord IndefModule

Defined in Module

Methods

compare :: IndefModule -> IndefModule -> Ordering

(<) :: IndefModule -> IndefModule -> Bool

(<=) :: IndefModule -> IndefModule -> Bool

(>) :: IndefModule -> IndefModule -> Bool

(>=) :: IndefModule -> IndefModule -> Bool

max :: IndefModule -> IndefModule -> IndefModule

min :: IndefModule -> IndefModule -> IndefModule

Outputable IndefModule

Defined in Module

Methods

ppr :: IndefModule -> SDoc

pprPrec :: Rational -> IndefModule -> SDoc

data InstalledModule

A InstalledModule is a Module which contains a InstalledUnitId.

Constructors

InstalledModule

Fields

• installedModuleUnitId :: !InstalledUnitId
• installedModuleName :: !ModuleName

Instances

Eq InstalledModule

Defined in Module

Methods

(==) :: InstalledModule -> InstalledModule -> Bool

(/=) :: InstalledModule -> InstalledModule -> Bool

Ord InstalledModule

Defined in Module

Methods

compare :: InstalledModule -> InstalledModule -> Ordering

(<) :: InstalledModule -> InstalledModule -> Bool

(<=) :: InstalledModule -> InstalledModule -> Bool

(>) :: InstalledModule -> InstalledModule -> Bool

(>=) :: InstalledModule -> InstalledModule -> Bool

max :: InstalledModule -> InstalledModule -> InstalledModule

min :: InstalledModule -> InstalledModule -> InstalledModule

Outputable InstalledModule

Defined in Module

Methods

ppr :: InstalledModule -> SDoc

pprPrec :: Rational -> InstalledModule -> SDoc

newtype DefUnitId

A DefUnitId is an InstalledUnitId with the invariant that it only refers to a definite library; i.e., one we have generated code for.

Constructors

DefUnitId

Fields

• unDefUnitId :: InstalledUnitId

Instances

Eq DefUnitId

Defined in Module

Methods

(==) :: DefUnitId -> DefUnitId -> Bool

(/=) :: DefUnitId -> DefUnitId -> Bool

Ord DefUnitId

Defined in Module

Methods

compare :: DefUnitId -> DefUnitId -> Ordering

(<) :: DefUnitId -> DefUnitId -> Bool

(<=) :: DefUnitId -> DefUnitId -> Bool

(>) :: DefUnitId -> DefUnitId -> Bool

(>=) :: DefUnitId -> DefUnitId -> Bool

max :: DefUnitId -> DefUnitId -> DefUnitId

min :: DefUnitId -> DefUnitId -> DefUnitId

Binary DefUnitId

Defined in Module

Methods

put_ :: BinHandle -> DefUnitId -> IO ()

put :: BinHandle -> DefUnitId -> IO (Bin DefUnitId)

get :: BinHandle -> IO DefUnitId

Outputable DefUnitId

Defined in Module

Methods

ppr :: DefUnitId -> SDoc

pprPrec :: Rational -> DefUnitId -> SDoc

data InstalledModuleEnv elt

A map keyed off of InstalledModule

type ShHoleSubst = ModuleNameEnv Module

Substitution on module variables, mapping module names to module identifiers.

data ModuleEnv elt

A map keyed off of Modules

type ModuleSet = Set NDModule

A set of Modules

type ModuleNameEnv elt = UniqFM elt

A map keyed off of ModuleNames (actually, their Uniques)

type DModuleNameEnv elt = UniqDFM elt

A map keyed off of ModuleNames (actually, their Uniques) Has deterministic folds and can be deterministically converted to a list

mkFsEnv :: [(FastString, a)] -> FastStringEnv a

lookupFsEnv :: FastStringEnv a -> FastString -> Maybe a

extendFsEnv :: FastStringEnv a -> FastString -> a -> FastStringEnv a

emptyFsEnv :: FastStringEnv a

type FastStringEnv a = UniqFM a

A non-deterministic set of FastStrings. See Note [Deterministic UniqFM] in UniqDFM 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.

initExitJoinUnique :: Unique

mkTcOccUnique :: FastString -> Unique

mkTvOccUnique :: FastString -> Unique

mkDataOccUnique :: FastString -> Unique

mkVarOccUnique :: FastString -> Unique

mkCostCentreUnique :: Int -> Unique

mkRegClassUnique :: Int -> Unique

mkRegPairUnique :: Int -> Unique

mkRegSubUnique :: Int -> Unique

mkRegSingleUnique :: Int -> Unique

mkPseudoUniqueH :: Int -> Unique

mkPseudoUniqueE :: Int -> Unique

mkPseudoUniqueD :: Int -> Unique

mkBuiltinUnique :: Int -> Unique

initTyVarUnique :: Unique

mkPreludeMiscIdUnique :: Int -> Unique

mkPrimOpWrapperUnique :: Int -> Unique

mkPrimOpIdUnique :: Int -> Unique

dataConTyRepNameUnique :: Unique -> Unique

dataConWorkerUnique :: Unique -> Unique

mkPreludeDataConUnique :: Arity -> Unique

tyConRepNameUnique :: Unique -> Unique

mkPreludeTyConUnique :: Int -> Unique

mkPreludeClassUnique :: Int -> Unique

mkCoVarUnique :: Int -> Unique

mkAlphaTyVarUnique :: Int -> Unique

pprUniqueAlways :: Unique -> SDoc

nonDetCmpUnique :: Unique -> Unique -> Ordering

ltUnique :: Unique -> Unique -> Bool

eqUnique :: Unique -> Unique -> Bool

hasKey :: Uniquable a => a -> Unique -> Bool

isValidKnownKeyUnique :: Unique -> Bool

The interface file symbol-table encoding assumes that known-key uniques fit in 30-bits; verify this.

See Note [Symbol table representation of names] in BinIface for details.

unpkUnique :: Unique -> (Char, Int)

mkUnique :: Char -> Int -> Unique

newTagUnique :: Unique -> Char -> Unique

deriveUnique :: Unique -> Int -> Unique

getKey :: Unique -> Int

mkUniqueGrimily :: Int -> Unique

uNIQUE_BITS :: Int

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

Eq Unique

Defined in Unique

Methods

(==) :: Unique -> Unique -> Bool

(/=) :: Unique -> Unique -> Bool

Show Unique

Defined in Unique

Methods

showsPrec :: Int -> Unique -> ShowS

show :: Unique -> String

showList :: [Unique] -> ShowS

Uniquable Unique

Defined in Unique

Methods

getUnique :: Unique -> Unique

Outputable Unique

Defined in Unique

Methods

ppr :: Unique -> SDoc

pprPrec :: Rational -> Unique -> SDoc

class Uniquable a where

Class of things that we can obtain a Unique from

Methods

getUnique :: a -> Unique

Instances

Uniquable Int

Defined in Unique

Methods

getUnique :: Int -> Unique

Uniquable EvBindsVar

Defined in TcEvidence

Methods

getUnique :: EvBindsVar -> Unique

Uniquable LocalReg

Defined in CmmExpr

Methods

getUnique :: LocalReg -> Unique

Uniquable Label

Defined in Hoopl.Label

Methods

getUnique :: Label -> Unique

Uniquable Class

Defined in Class

Methods

getUnique :: Class -> Unique

Uniquable CoAxiomRule

Defined in CoAxiom

Methods

getUnique :: CoAxiomRule -> Unique

Uniquable ConLike

Defined in ConLike

Methods

getUnique :: ConLike -> Unique

Uniquable DataCon

Defined in DataCon

Methods

getUnique :: DataCon -> Unique

Uniquable PatSyn

Defined in PatSyn

Methods

getUnique :: PatSyn -> Unique

Uniquable Var

Defined in Var

Methods

getUnique :: Var -> Unique

Uniquable SourcePackageId

Defined in PackageConfig

Methods

getUnique :: SourcePackageId -> Unique

Uniquable PackageName

Defined in PackageConfig

Methods

getUnique :: PackageName -> Unique

Uniquable Unique

Defined in Unique

Methods

getUnique :: Unique -> Unique

Uniquable Module

Defined in Module

Methods

getUnique :: Module -> Unique

Uniquable ModuleName

Defined in Module

Methods

getUnique :: ModuleName -> Unique

Uniquable UnitId

Defined in Module

Methods

getUnique :: UnitId -> Unique

Uniquable InstalledUnitId

Defined in Module

Methods

getUnique :: InstalledUnitId -> Unique

Uniquable ComponentId

Defined in Module

Methods

getUnique :: ComponentId -> Unique

Uniquable FastString

Defined in Unique

Methods

getUnique :: FastString -> Unique

Uniquable TyCon

Defined in TyCon

Methods

getUnique :: TyCon -> Unique

Uniquable OccName

Defined in OccName

Methods

getUnique :: OccName -> Unique

Uniquable Name

Defined in Name

Methods

getUnique :: Name -> Unique

Uniquable (CoAxiom br)

Defined in CoAxiom

Methods

getUnique :: CoAxiom br -> Unique

Uniquable name => Uniquable (AnnTarget name)

Defined in Annotations

Methods

getUnique :: AnnTarget name -> Unique

isKindLevel :: TypeOrKind -> Bool

isTypeLevel :: TypeOrKind -> Bool

mkIntWithInf :: Int -> IntWithInf

Inject any integer into an IntWithInf

treatZeroAsInf :: Int -> IntWithInf

Turn a positive number into an IntWithInf, where 0 represents infinity

intGtLimit :: Int -> IntWithInf -> Bool

infinity :: IntWithInf

A representation of infinity

integralFractionalLit :: Bool -> Integer -> FractionalLit

negateFractionalLit :: FractionalLit -> FractionalLit

mkFractionalLit :: Real a => a -> FractionalLit

negateIntegralLit :: IntegralLit -> IntegralLit

mkIntegralLit :: Integral a => a -> IntegralLit

isEarlyActive :: Activation -> Bool

isAlwaysActive :: Activation -> Bool

isNeverActive :: Activation -> Bool

competesWith :: Activation -> Activation -> Bool

isActiveIn :: PhaseNum -> Activation -> Bool

isActive :: CompilerPhase -> Activation -> Bool

pprInlineDebug :: InlinePragma -> SDoc

pprInline :: InlinePragma -> SDoc

setInlinePragmaRuleMatchInfo :: InlinePragma -> RuleMatchInfo -> InlinePragma

setInlinePragmaActivation :: InlinePragma -> Activation -> InlinePragma

inlinePragmaRuleMatchInfo :: InlinePragma -> RuleMatchInfo

inlinePragmaActivation :: InlinePragma -> Activation

inlinePragmaSat :: InlinePragma -> Maybe Arity

isAnyInlinePragma :: InlinePragma -> Bool

isInlinablePragma :: InlinePragma -> Bool

isInlinePragma :: InlinePragma -> Bool

isDefaultInlinePragma :: InlinePragma -> Bool

dfunInlinePragma :: InlinePragma

inlinePragmaSpec :: InlinePragma -> InlineSpec

neverInlinePragma :: InlinePragma

alwaysInlinePragma :: InlinePragma

defaultInlinePragma :: InlinePragma

noUserInlineSpec :: InlineSpec -> Bool

isFunLike :: RuleMatchInfo -> Bool

isConLike :: RuleMatchInfo -> Bool

activeDuringFinal :: Activation

activeAfterInitial :: Activation

pprWithSourceText :: SourceText -> SDoc -> SDoc

Special combinator for showing string literals.

failed :: SuccessFlag -> Bool

succeeded :: SuccessFlag -> Bool

successIf :: Bool -> SuccessFlag

zapFragileOcc :: OccInfo -> OccInfo

isOneOcc :: OccInfo -> Bool

isDeadOcc :: OccInfo -> Bool

isStrongLoopBreaker :: OccInfo -> Bool

isWeakLoopBreaker :: OccInfo -> Bool

weakLoopBreaker :: OccInfo

strongLoopBreaker :: OccInfo

isAlwaysTailCalled :: OccInfo -> Bool

zapOccTailCallInfo :: OccInfo -> OccInfo

tailCallInfo :: OccInfo -> TailCallInfo

notOneBranch :: OneBranch

oneBranch :: OneBranch

notInsideLam :: InsideLam

insideLam :: InsideLam

seqOccInfo :: OccInfo -> ()

isManyOccs :: OccInfo -> Bool

noOccInfo :: OccInfo

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 | |".

sumParens :: SDoc -> SDoc

tupleParens :: TupleSort -> SDoc -> SDoc

boxityTupleSort :: Boxity -> TupleSort

tupleSortBoxity :: TupleSort -> Boxity

maybeParen :: PprPrec -> PprPrec -> SDoc -> SDoc

appPrec :: PprPrec

opPrec :: PprPrec

funPrec :: PprPrec

sigPrec :: PprPrec

topPrec :: PprPrec

hasOverlappingFlag :: OverlapMode -> Bool

hasOverlappableFlag :: OverlapMode -> Bool

hasIncoherentFlag :: OverlapMode -> Bool

setOverlapModeMaybe :: OverlapFlag -> Maybe OverlapMode -> OverlapFlag

isGenerated :: Origin -> Bool

boolToRecFlag :: Bool -> RecFlag

isNonRec :: RecFlag -> Bool

isRec :: RecFlag -> Bool

isBoxed :: Boxity -> Bool

isTopLevel :: TopLevelFlag -> Bool

isNotTopLevel :: TopLevelFlag -> Bool

compareFixity :: Fixity -> Fixity -> (Bool, Bool)

funTyFixity :: Fixity

negateFixity :: Fixity

defaultFixity :: Fixity

minPrecedence :: Int

maxPrecedence :: Int

pprRuleName :: RuleName -> SDoc

pprWarningTxtForMsg :: WarningTxt -> SDoc

initialVersion :: Version

bumpVersion :: Version -> Version

isPromoted :: PromotionFlag -> Bool

unSwap :: SwapFlag -> (a -> a -> b) -> a -> a -> b

isSwapped :: SwapFlag -> Bool

flipSwap :: SwapFlag -> SwapFlag

bestOneShot :: OneShotInfo -> OneShotInfo -> OneShotInfo

worstOneShot :: OneShotInfo -> OneShotInfo -> OneShotInfo

hasNoOneShotInfo :: OneShotInfo -> Bool

isOneShotInfo :: OneShotInfo -> Bool

noOneShotInfo :: OneShotInfo

It is always safe to assume that an Id has no lambda-bound variable information

alignmentOf :: Int -> Alignment

mkAlignment :: Int -> Alignment

fIRST_TAG :: ConTag

Tags are allocated from here for real constructors or for superclass selectors

pickLR :: LeftOrRight -> (a, a) -> a

data LeftOrRight

Constructors

CLeft

CRight

Instances

Eq LeftOrRight

Defined in BasicTypes

Methods

(==) :: LeftOrRight -> LeftOrRight -> Bool

(/=) :: LeftOrRight -> LeftOrRight -> Bool

Data LeftOrRight

Defined in BasicTypes

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

Outputable LeftOrRight

Defined in BasicTypes

Methods

ppr :: LeftOrRight -> SDoc

pprPrec :: Rational -> LeftOrRight -> SDoc

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 CoreArity

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 () -> fib (x + y) has representation arity 2

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 ConTag = Int

Constructor Tag

Type of the tags associated with each constructor possibility or superclass selector

type ConTagZ = Int

A *zero-indexed* constructor tag

data Alignment

A power-of-two alignment

Instances

Eq Alignment

Defined in BasicTypes

Methods

(==) :: Alignment -> Alignment -> Bool

(/=) :: Alignment -> Alignment -> Bool

Ord Alignment

Defined in BasicTypes

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

Outputable Alignment

Defined in BasicTypes

Methods

ppr :: Alignment -> SDoc

pprPrec :: Rational -> Alignment -> 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.

Constructors

NoOneShotInfo

No information

OneShotLam

The lambda is applied at most once.

Instances

Eq OneShotInfo

Defined in BasicTypes

Methods

(==) :: OneShotInfo -> OneShotInfo -> Bool

(/=) :: OneShotInfo -> OneShotInfo -> Bool

Outputable OneShotInfo

Defined in BasicTypes

Methods

ppr :: OneShotInfo -> SDoc

pprPrec :: Rational -> OneShotInfo -> SDoc

data SwapFlag

Constructors

NotSwapped

IsSwapped

Instances

Outputable SwapFlag

Defined in BasicTypes

Methods

ppr :: SwapFlag -> SDoc

pprPrec :: Rational -> SwapFlag -> SDoc

data PromotionFlag

Is a TyCon a promoted data constructor or just a normal type constructor?

Constructors

NotPromoted

IsPromoted

Instances

Eq PromotionFlag

Defined in BasicTypes

Methods

(==) :: PromotionFlag -> PromotionFlag -> Bool

(/=) :: PromotionFlag -> PromotionFlag -> Bool

Data PromotionFlag

Defined in BasicTypes

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

data FunctionOrData

Constructors

IsFunction

IsData

Instances

Eq FunctionOrData

Defined in BasicTypes

Methods

(==) :: FunctionOrData -> FunctionOrData -> Bool

(/=) :: FunctionOrData -> FunctionOrData -> Bool

Data FunctionOrData

Defined in BasicTypes

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

Ord FunctionOrData

Defined in BasicTypes

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

Outputable FunctionOrData

Defined in BasicTypes

Methods

ppr :: FunctionOrData -> SDoc

pprPrec :: Rational -> FunctionOrData -> SDoc

type Version = Int

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

Instances

Eq StringLiteral

Defined in BasicTypes

Methods

(==) :: StringLiteral -> StringLiteral -> Bool

(/=) :: StringLiteral -> StringLiteral -> Bool

Data StringLiteral

Defined in BasicTypes

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

Outputable StringLiteral

Defined in BasicTypes

Methods

ppr :: StringLiteral -> SDoc

pprPrec :: Rational -> StringLiteral -> SDoc

data WarningTxt

Warning Text

reason/explanation from a WARNING or DEPRECATED pragma

Constructors

WarningTxt (Located SourceText) [Located StringLiteral]

DeprecatedTxt (Located SourceText) [Located StringLiteral]

Instances

Eq WarningTxt

Defined in BasicTypes

Methods

(==) :: WarningTxt -> WarningTxt -> Bool

(/=) :: WarningTxt -> WarningTxt -> Bool

Data WarningTxt

Defined in BasicTypes

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WarningTxt -> c WarningTxt

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c WarningTxt

toConstr :: WarningTxt -> Constr

dataTypeOf :: WarningTxt -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c WarningTxt)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WarningTxt)

gmapT :: (forall b. Data b => b -> b) -> WarningTxt -> WarningTxt

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WarningTxt -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WarningTxt -> r

gmapQ :: (forall d. Data d => d -> u) -> WarningTxt -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> WarningTxt -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> WarningTxt -> m WarningTxt

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WarningTxt -> m WarningTxt

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WarningTxt -> m WarningTxt

Outputable WarningTxt

Defined in BasicTypes

Methods

ppr :: WarningTxt -> SDoc

pprPrec :: Rational -> WarningTxt -> SDoc

type RuleName = FastString

data Fixity

Constructors

Fixity SourceText Int FixityDirection

Instances

Eq Fixity

Defined in BasicTypes

Methods

(==) :: Fixity -> Fixity -> Bool

(/=) :: Fixity -> Fixity -> Bool

Data Fixity

Defined in BasicTypes

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Fixity -> c Fixity

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Fixity

toConstr :: Fixity -> Constr

dataTypeOf :: Fixity -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Fixity)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity)

gmapT :: (forall b. Data b => b -> b) -> Fixity -> Fixity

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r

gmapQ :: (forall d. Data d => d -> u) -> Fixity -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Fixity -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity

Outputable Fixity

Defined in BasicTypes

Methods

ppr :: Fixity -> SDoc

pprPrec :: Rational -> Fixity -> SDoc

data FixityDirection

Constructors

InfixL

InfixR

InfixN

Instances

Eq FixityDirection

Defined in BasicTypes

Methods

(==) :: FixityDirection -> FixityDirection -> Bool

(/=) :: FixityDirection -> FixityDirection -> Bool

Data FixityDirection

Defined in BasicTypes

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FixityDirection -> c FixityDirection

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FixityDirection

toConstr :: FixityDirection -> Constr

dataTypeOf :: FixityDirection -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FixityDirection)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FixityDirection)

gmapT :: (forall b. Data b => b -> b) -> FixityDirection -> FixityDirection

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r

gmapQ :: (forall d. Data d => d -> u) -> FixityDirection -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> FixityDirection -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection

Outputable FixityDirection

Defined in BasicTypes

Methods

ppr :: FixityDirection -> SDoc

pprPrec :: Rational -> FixityDirection -> SDoc

data LexicalFixity

Captures the fixity of declarations as they are parsed. This is not necessarily the same as the fixity declaration, as the normal fixity may be overridden using parens or backticks.

Constructors

Prefix

Infix

Instances

Eq LexicalFixity

Defined in BasicTypes

Methods

(==) :: LexicalFixity -> LexicalFixity -> Bool

(/=) :: LexicalFixity -> LexicalFixity -> Bool

Data LexicalFixity

Defined in BasicTypes

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LexicalFixity -> c LexicalFixity

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LexicalFixity

toConstr :: LexicalFixity -> Constr

dataTypeOf :: LexicalFixity -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c LexicalFixity)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LexicalFixity)

gmapT :: (forall b. Data b => b -> b) -> LexicalFixity -> LexicalFixity

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LexicalFixity -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LexicalFixity -> r

gmapQ :: (forall d. Data d => d -> u) -> LexicalFixity -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> LexicalFixity -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> LexicalFixity -> m LexicalFixity

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LexicalFixity -> m LexicalFixity

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LexicalFixity -> m LexicalFixity

Outputable LexicalFixity

Defined in BasicTypes

Methods

ppr :: LexicalFixity -> SDoc

pprPrec :: Rational -> LexicalFixity -> SDoc

data TopLevelFlag

Constructors

TopLevel

NotTopLevel

Instances

Outputable TopLevelFlag

Defined in BasicTypes

Methods

ppr :: TopLevelFlag -> SDoc

pprPrec :: Rational -> TopLevelFlag -> SDoc

data Boxity

Constructors

Boxed

Unboxed

Instances

Eq Boxity

Defined in BasicTypes

Methods

(==) :: Boxity -> Boxity -> Bool

(/=) :: Boxity -> Boxity -> Bool

Data Boxity

Defined in BasicTypes

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

Outputable Boxity

Defined in BasicTypes

Methods

ppr :: Boxity -> SDoc

pprPrec :: Rational -> Boxity -> SDoc

data RecFlag

Recursivity Flag

Constructors

Recursive

NonRecursive

Instances

Eq RecFlag

Defined in BasicTypes

Methods

(==) :: RecFlag -> RecFlag -> Bool

(/=) :: RecFlag -> RecFlag -> Bool

Data RecFlag

Defined in BasicTypes

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

Outputable RecFlag

Defined in BasicTypes

Methods

ppr :: RecFlag -> SDoc

pprPrec :: Rational -> RecFlag -> SDoc

data Origin

Constructors

FromSource

Generated

Instances

Eq Origin

Defined in BasicTypes

Methods

(==) :: Origin -> Origin -> Bool

(/=) :: Origin -> Origin -> Bool

Data Origin

Defined in BasicTypes

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

Defined in BasicTypes

Methods

ppr :: Origin -> SDoc

pprPrec :: Rational -> Origin -> SDoc

data OverlapFlag

The semantics allowed for overlapping instances for a particular instance. See Note [Safe Haskell isSafeOverlap] (in hs) 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

Eq OverlapFlag

Defined in BasicTypes

Methods

(==) :: OverlapFlag -> OverlapFlag -> Bool

(/=) :: OverlapFlag -> OverlapFlag -> Bool

Data OverlapFlag

Defined in BasicTypes

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

Outputable OverlapFlag

Defined in BasicTypes

Methods

ppr :: OverlapFlag -> SDoc

pprPrec :: Rational -> OverlapFlag -> SDoc

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 {--} 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 {--} 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 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 InstEnv

Instances

Eq OverlapMode

Defined in BasicTypes

Methods

(==) :: OverlapMode -> OverlapMode -> Bool

(/=) :: OverlapMode -> OverlapMode -> Bool

Data OverlapMode

Defined in BasicTypes

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

Outputable OverlapMode

Defined in BasicTypes

Methods

ppr :: OverlapMode -> SDoc

pprPrec :: Rational -> OverlapMode -> SDoc

newtype PprPrec

A general-purpose pretty-printing precedence type.

Constructors

PprPrec Int

Instances

Eq PprPrec

Defined in BasicTypes

Methods

(==) :: PprPrec -> PprPrec -> Bool

(/=) :: PprPrec -> PprPrec -> Bool

Ord PprPrec

Defined in BasicTypes

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

Show PprPrec

Defined in BasicTypes

Methods

showsPrec :: Int -> PprPrec -> ShowS

show :: PprPrec -> String

showList :: [PprPrec] -> ShowS

data TupleSort

Constructors

BoxedTuple

UnboxedTuple

ConstraintTuple

Instances

Eq TupleSort

Defined in BasicTypes

Methods

(==) :: TupleSort -> TupleSort -> Bool

(/=) :: TupleSort -> TupleSort -> Bool

Data TupleSort

Defined in BasicTypes

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

Outputable TupleSort

Defined in BasicTypes

Methods

ppr :: TupleSort -> SDoc

pprPrec :: Rational -> TupleSort -> SDoc

data EP a

Embedding Projection pair

Constructors

EP

Fields

• fromEP :: a
• toEP :: a

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_one_br :: !OneBranch
• 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

Eq OccInfo

Defined in BasicTypes

Methods

(==) :: OccInfo -> OccInfo -> Bool

(/=) :: OccInfo -> OccInfo -> Bool

Outputable OccInfo

Defined in BasicTypes

Methods

ppr :: OccInfo -> SDoc

pprPrec :: Rational -> OccInfo -> SDoc

type InterestingCxt = Bool

Interesting Context

type InsideLam = Bool

Inside Lambda

type OneBranch = Bool

data TailCallInfo

Constructors

AlwaysTailCalled JoinArity

NoTailCallInfo

Instances

Eq TailCallInfo

Defined in BasicTypes

Methods

(==) :: TailCallInfo -> TailCallInfo -> Bool

(/=) :: TailCallInfo -> TailCallInfo -> Bool

Outputable TailCallInfo

Defined in BasicTypes

Methods

ppr :: TailCallInfo -> SDoc

pprPrec :: Rational -> TailCallInfo -> SDoc

data DefMethSpec ty

Default Method Specification

Constructors

VanillaDM

GenericDM ty

Instances

Binary (DefMethSpec IfaceType)

Defined in IfaceType

Methods

put_ :: BinHandle -> DefMethSpec IfaceType -> IO ()

put :: BinHandle -> DefMethSpec IfaceType -> IO (Bin (DefMethSpec IfaceType))

get :: BinHandle -> IO (DefMethSpec IfaceType)

Outputable (DefMethSpec ty)

Defined in BasicTypes

Methods

ppr :: DefMethSpec ty -> SDoc

pprPrec :: Rational -> DefMethSpec ty -> SDoc

data SuccessFlag

Constructors

Succeeded

Failed

Instances

Outputable SuccessFlag

Defined in BasicTypes

Methods

ppr :: SuccessFlag -> SDoc

pprPrec :: Rational -> SuccessFlag -> SDoc

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

Eq SourceText

Defined in BasicTypes

Methods

(==) :: SourceText -> SourceText -> Bool

(/=) :: SourceText -> SourceText -> Bool

Data SourceText

Defined in BasicTypes

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SourceText -> c SourceText

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SourceText

toConstr :: SourceText -> Constr

dataTypeOf :: SourceText -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SourceText)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceText)

gmapT :: (forall b. Data b => b -> b) -> SourceText -> SourceText

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SourceText -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SourceText -> r

gmapQ :: (forall d. Data d => d -> u) -> SourceText -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceText -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SourceText -> m SourceText

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceText -> m SourceText

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceText -> m SourceText

Show SourceText

Defined in BasicTypes

Methods

showsPrec :: Int -> SourceText -> ShowS

show :: SourceText -> String

showList :: [SourceText] -> ShowS

Outputable SourceText

Defined in BasicTypes

Methods

ppr :: SourceText -> SDoc

pprPrec :: Rational -> SourceText -> SDoc

type PhaseNum = Int

Phase Number

data CompilerPhase

Constructors

Phase PhaseNum

InitialPhase

Instances

Outputable CompilerPhase

Defined in BasicTypes

Methods

ppr :: CompilerPhase -> SDoc

pprPrec :: Rational -> CompilerPhase -> SDoc

data Activation

Constructors

NeverActive

AlwaysActive

ActiveBefore SourceText PhaseNum

ActiveAfter SourceText PhaseNum

Instances

Eq Activation

Defined in BasicTypes

Methods

(==) :: Activation -> Activation -> Bool

(/=) :: Activation -> Activation -> Bool

Data Activation

Defined in BasicTypes

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

Outputable Activation

Defined in BasicTypes

Methods

ppr :: Activation -> SDoc

pprPrec :: Rational -> Activation -> SDoc

data RuleMatchInfo

Rule Match Information

Constructors

ConLike

FunLike

Instances

Eq RuleMatchInfo

Defined in BasicTypes

Methods

(==) :: RuleMatchInfo -> RuleMatchInfo -> Bool

(/=) :: RuleMatchInfo -> RuleMatchInfo -> Bool

Data RuleMatchInfo

Defined in BasicTypes

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

Defined in BasicTypes

Methods

showsPrec :: Int -> RuleMatchInfo -> ShowS

show :: RuleMatchInfo -> String

showList :: [RuleMatchInfo] -> ShowS

Outputable RuleMatchInfo

Defined in BasicTypes

Methods

ppr :: RuleMatchInfo -> SDoc

pprPrec :: Rational -> RuleMatchInfo -> SDoc

data InlinePragma

Constructors

InlinePragma

Fields

• inl_src :: SourceText
• inl_inline :: InlineSpec
• inl_sat :: Maybe Arity
• inl_act :: Activation
• inl_rule :: RuleMatchInfo

Instances

Eq InlinePragma

Defined in BasicTypes

Methods

(==) :: InlinePragma -> InlinePragma -> Bool

(/=) :: InlinePragma -> InlinePragma -> Bool

Data InlinePragma

Defined in BasicTypes

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

Outputable InlinePragma

Defined in BasicTypes

Methods

ppr :: InlinePragma -> SDoc

pprPrec :: Rational -> InlinePragma -> SDoc

data InlineSpec

Inline Specification

Constructors

Inline

Inlinable

NoInline

NoUserInline

Instances

Eq InlineSpec

Defined in BasicTypes

Methods

(==) :: InlineSpec -> InlineSpec -> Bool

(/=) :: InlineSpec -> InlineSpec -> Bool

Data InlineSpec

Defined in BasicTypes

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

Defined in BasicTypes

Methods

showsPrec :: Int -> InlineSpec -> ShowS

show :: InlineSpec -> String

showList :: [InlineSpec] -> ShowS

Outputable InlineSpec

Defined in BasicTypes

Methods

ppr :: InlineSpec -> SDoc

pprPrec :: Rational -> InlineSpec -> SDoc

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

Eq IntegralLit

Defined in BasicTypes

Methods

(==) :: IntegralLit -> IntegralLit -> Bool

(/=) :: IntegralLit -> IntegralLit -> Bool

Data IntegralLit

Defined in BasicTypes

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

Ord IntegralLit

Defined in BasicTypes

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

Show IntegralLit

Defined in BasicTypes

Methods

showsPrec :: Int -> IntegralLit -> ShowS

show :: IntegralLit -> String

showList :: [IntegralLit] -> ShowS

Outputable IntegralLit

Defined in BasicTypes

Methods

ppr :: IntegralLit -> SDoc

pprPrec :: Rational -> IntegralLit -> SDoc

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.

Constructors

FL

Fields

• fl_text :: SourceText
• fl_neg :: Bool
• fl_value :: Rational

Instances

Eq FractionalLit

Defined in BasicTypes

Methods

(==) :: FractionalLit -> FractionalLit -> Bool

(/=) :: FractionalLit -> FractionalLit -> Bool

Data FractionalLit

Defined in BasicTypes

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

Ord FractionalLit

Defined in BasicTypes

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

Show FractionalLit

Defined in BasicTypes

Methods

showsPrec :: Int -> FractionalLit -> ShowS

show :: FractionalLit -> String

showList :: [FractionalLit] -> ShowS

Outputable FractionalLit

Defined in BasicTypes

Methods

ppr :: FractionalLit -> SDoc

pprPrec :: Rational -> FractionalLit -> SDoc

data IntWithInf

An integer or infinity

Instances

Eq IntWithInf

Defined in BasicTypes

Methods

(==) :: IntWithInf -> IntWithInf -> Bool

(/=) :: IntWithInf -> IntWithInf -> Bool

Num IntWithInf

Defined in BasicTypes

Methods

(+) :: IntWithInf -> IntWithInf -> IntWithInf

(-) :: IntWithInf -> IntWithInf -> IntWithInf

(*) :: IntWithInf -> IntWithInf -> IntWithInf

negate :: IntWithInf -> IntWithInf

abs :: IntWithInf -> IntWithInf

signum :: IntWithInf -> IntWithInf

fromInteger :: Integer -> IntWithInf

Ord IntWithInf

Defined in BasicTypes

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

Outputable IntWithInf

Defined in BasicTypes

Methods

ppr :: IntWithInf -> SDoc

pprPrec :: Rational -> IntWithInf -> SDoc

data SpliceExplicitFlag

Constructors

ExplicitSplice

= $(f x y)

ImplicitSplice

= f x y, i.e. a naked top level expression

Instances

Data SpliceExplicitFlag

Defined in BasicTypes

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SpliceExplicitFlag -> c SpliceExplicitFlag

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SpliceExplicitFlag

toConstr :: SpliceExplicitFlag -> Constr

dataTypeOf :: SpliceExplicitFlag -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SpliceExplicitFlag)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SpliceExplicitFlag)

gmapT :: (forall b. Data b => b -> b) -> SpliceExplicitFlag -> SpliceExplicitFlag

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SpliceExplicitFlag -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SpliceExplicitFlag -> r

gmapQ :: (forall d. Data d => d -> u) -> SpliceExplicitFlag -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> SpliceExplicitFlag -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SpliceExplicitFlag -> m SpliceExplicitFlag

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceExplicitFlag -> m SpliceExplicitFlag

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceExplicitFlag -> m SpliceExplicitFlag

data TypeOrKind

Flag to see whether we're type-checking terms or kind-checking types

Constructors

TypeLevel

KindLevel

Instances

Eq TypeOrKind

Defined in BasicTypes

Methods

(==) :: TypeOrKind -> TypeOrKind -> Bool

(/=) :: TypeOrKind -> TypeOrKind -> Bool

Outputable TypeOrKind

Defined in BasicTypes

Methods

ppr :: TypeOrKind -> SDoc

pprPrec :: Rational -> TypeOrKind -> SDoc

mkLocMessage :: Severity -> SrcSpan -> MsgDoc -> MsgDoc

Make an unannotated error message with location info.

mkLocMessageAnn

Arguments

:: Maybe String

optional annotation

-> Severity

severity

-> SrcSpan

location

-> MsgDoc

message

-> MsgDoc

Make a possibly annotated error message with location info.

getCaretDiagnostic :: Severity -> SrcSpan -> IO MsgDoc

dumpSDoc :: DynFlags -> PrintUnqualified -> DumpFlag -> String -> SDoc -> IO ()

A wrapper around dumpSDocWithStyle which uses PprDump style.

data Severity

Constructors

SevOutput

SevFatal

SevInteractive

SevDump

Log message intended for compiler developers No filelinecolumn stuff

SevInfo

Log messages intended for end users. No filelinecolumn stuff.

SevWarning

SevError

SevWarning and SevError are used for warnings and errors o The message has a filelinecolumn heading, plus "warning:" or "error:", added by mkLocMessags o Output is intended for end users

Instances

Show Severity

Defined in ErrUtils

Methods

showsPrec :: Int -> Severity -> ShowS

show :: Severity -> String

showList :: [Severity] -> ShowS

ToJson Severity

Defined in ErrUtils

Methods

json :: Severity -> JsonDoc

type MsgDoc = SDoc

unRealSrcSpan :: RealLocated a -> a

getRealSrcSpan :: RealLocated a -> RealSrcSpan

liftL :: (HasSrcSpan a, HasSrcSpan b, Monad m) => (SrcSpanLess a -> m (SrcSpanLess b)) -> a -> m b

onHasSrcSpan :: (HasSrcSpan a, HasSrcSpan b) => (SrcSpanLess a -> SrcSpanLess b) -> a -> b

Lifts a function of undecorated entities to one of decorated ones

cL :: HasSrcSpan a => SrcSpan -> SrcSpanLess a -> a

An abbreviated form of composeSrcSpan, mainly to replace the hardcoded L

dL :: HasSrcSpan a => a -> Located (SrcSpanLess a)

An abbreviated form of decomposeSrcSpan, mainly to be used in ViewPatterns

isSubspanOf

Arguments

:: SrcSpan

The span that may be enclosed by the other

-> SrcSpan

The span it may be enclosed by

-> Bool

Determines whether a span is enclosed by another one

spans :: SrcSpan -> (Int, Int) -> Bool

Determines whether a span encloses a given line and column index

leftmost_largest :: SrcSpan -> SrcSpan -> Ordering

Alternative strategies for ordering SrcSpans

leftmost_smallest :: SrcSpan -> SrcSpan -> Ordering

Alternative strategies for ordering SrcSpans

rightmost :: SrcSpan -> SrcSpan -> Ordering

Alternative strategies for ordering SrcSpans

cmpLocated :: (HasSrcSpan a, Ord (SrcSpanLess a)) => a -> a -> Ordering

Tests the ordering of the two located things

eqLocated :: (HasSrcSpan a, Eq (SrcSpanLess a)) => a -> a -> Bool

Tests whether the two located things are equal

addCLoc :: (HasSrcSpan a, HasSrcSpan b, HasSrcSpan c) => a -> b -> SrcSpanLess c -> c

Combine locations from two Located things and add them to a third thing

combineLocs :: (HasSrcSpan a, HasSrcSpan b) => a -> b -> SrcSpan

mkGeneralLocated :: HasSrcSpan e => String -> SrcSpanLess e -> e

noLoc :: HasSrcSpan a => SrcSpanLess a -> a

getLoc :: HasSrcSpan a => a -> SrcSpan

unLoc :: HasSrcSpan a => a -> SrcSpanLess a

mapLoc :: (a -> b) -> GenLocated l a -> GenLocated l b

pprUserRealSpan :: Bool -> RealSrcSpan -> SDoc

srcSpanFileName_maybe :: SrcSpan -> Maybe FastString

Obtains the filename for a SrcSpan if it is "good"

realSrcSpanEnd :: RealSrcSpan -> RealSrcLoc

realSrcSpanStart :: RealSrcSpan -> RealSrcLoc

srcSpanEnd :: SrcSpan -> SrcLoc

Returns the location at the end of the SrcSpan or a "bad" SrcSpan if that is unavailable

srcSpanStart :: SrcSpan -> SrcLoc

Returns the location at the start of the SrcSpan or a "bad" SrcSpan if that is unavailable

srcSpanEndCol :: RealSrcSpan -> Int

srcSpanStartCol :: RealSrcSpan -> Int

srcSpanEndLine :: RealSrcSpan -> Int

srcSpanStartLine :: RealSrcSpan -> Int

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.

isOneLineSpan :: SrcSpan -> Bool

True if the span is known to straddle only one line. For "bad" SrcSpan, it returns False

isGoodSrcSpan :: SrcSpan -> Bool

Test if a SrcSpan is "good", i.e. has precise location information

srcSpanFirstCharacter :: SrcSpan -> SrcSpan

Convert a SrcSpan into one that represents only its first character

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.

mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan

Create a SrcSpan between two points in a file

mkRealSrcSpan :: RealSrcLoc -> RealSrcLoc -> RealSrcSpan

Create a SrcSpan between two points in a file

realSrcLocSpan :: RealSrcLoc -> RealSrcSpan

srcLocSpan :: SrcLoc -> SrcSpan

Create a SrcSpan corresponding to a single point

mkGeneralSrcSpan :: FastString -> SrcSpan

Create a "bad" SrcSpan that has not location information

interactiveSrcSpan :: SrcSpan

Built-in "bad" SrcSpans for common sources of location uncertainty

wiredInSrcSpan :: SrcSpan

Built-in "bad" SrcSpans for common sources of location uncertainty

noSrcSpan :: SrcSpan

Built-in "bad" SrcSpans for common sources of location uncertainty

sortLocated :: HasSrcSpan a => [a] -> [a]

advanceSrcLoc :: RealSrcLoc -> Char -> RealSrcLoc

Move the SrcLoc 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

srcLocCol :: RealSrcLoc -> Int

Raises an error when used on a "bad" SrcLoc

srcLocLine :: RealSrcLoc -> Int

Raises an error when used on a "bad" SrcLoc

srcLocFile :: RealSrcLoc -> FastString

Gives the filename of the RealSrcLoc

mkGeneralSrcLoc :: FastString -> SrcLoc

Creates a "bad" SrcLoc that has no detailed information about its location

interactiveSrcLoc :: SrcLoc

Built-in "bad" SrcLoc values for particular locations

generatedSrcLoc :: SrcLoc

Built-in "bad" SrcLoc values for particular locations

noSrcLoc :: SrcLoc

Built-in "bad" SrcLoc values for particular locations

mkRealSrcLoc :: FastString -> Int -> Int -> RealSrcLoc

mkSrcLoc :: FastString -> Int -> Int -> SrcLoc

pattern LL :: HasSrcSpan a => SrcSpan -> SrcSpanLess a -> a

A Pattern Synonym to Set/Get SrcSpans

data RealSrcLoc

Real Source Location

Represents a single point within a file

Instances

Eq RealSrcLoc

Defined in SrcLoc

Methods

(==) :: RealSrcLoc -> RealSrcLoc -> Bool

(/=) :: RealSrcLoc -> RealSrcLoc -> Bool

Ord RealSrcLoc

Defined in SrcLoc

Methods

compare :: RealSrcLoc -> RealSrcLoc -> Ordering

(<) :: RealSrcLoc -> RealSrcLoc -> Bool

(<=) :: RealSrcLoc -> RealSrcLoc -> Bool

(>) :: RealSrcLoc -> RealSrcLoc -> Bool

(>=) :: RealSrcLoc -> RealSrcLoc -> Bool

max :: RealSrcLoc -> RealSrcLoc -> RealSrcLoc

min :: RealSrcLoc -> RealSrcLoc -> RealSrcLoc

Show RealSrcLoc

Defined in SrcLoc

Methods

showsPrec :: Int -> RealSrcLoc -> ShowS

show :: RealSrcLoc -> String

showList :: [RealSrcLoc] -> ShowS

Outputable RealSrcLoc

Defined in SrcLoc

Methods

ppr :: RealSrcLoc -> SDoc

pprPrec :: Rational -> RealSrcLoc -> SDoc

data SrcLoc

Source Location

Constructors

RealSrcLoc !RealSrcLoc

UnhelpfulLoc FastString

Instances

Eq SrcLoc

Defined in SrcLoc

Methods

(==) :: SrcLoc -> SrcLoc -> Bool

(/=) :: SrcLoc -> SrcLoc -> Bool

Ord SrcLoc

Defined in SrcLoc

Methods

compare :: SrcLoc -> SrcLoc -> Ordering

(<) :: SrcLoc -> SrcLoc -> Bool

(<=) :: SrcLoc -> SrcLoc -> Bool

(>) :: SrcLoc -> SrcLoc -> Bool

(>=) :: SrcLoc -> SrcLoc -> Bool

max :: SrcLoc -> SrcLoc -> SrcLoc

min :: SrcLoc -> SrcLoc -> SrcLoc

Show SrcLoc

Defined in SrcLoc

Methods

showsPrec :: Int -> SrcLoc -> ShowS

show :: SrcLoc -> String

showList :: [SrcLoc] -> ShowS

Outputable SrcLoc

Defined in SrcLoc

Methods

ppr :: SrcLoc -> SDoc

pprPrec :: Rational -> SrcLoc -> SDoc

data RealSrcSpan

A RealSrcSpan delimits a portion of a text file. It could be represented by a pair of (line,column) coordinates, but in fact we optimise slightly by using more compact representations for single-line and zero-length spans, both of which are quite common.

The end position is defined to be the column after the end of the span. That is, a span of (1,1)-(1,2) is one character long, and a span of (1,1)-(1,1) is zero characters long.

Real Source Span

Instances

Eq RealSrcSpan

Defined in SrcLoc

Methods

(==) :: RealSrcSpan -> RealSrcSpan -> Bool

(/=) :: RealSrcSpan -> RealSrcSpan -> Bool

Data RealSrcSpan

Defined in SrcLoc

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RealSrcSpan -> c RealSrcSpan

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RealSrcSpan

toConstr :: RealSrcSpan -> Constr

dataTypeOf :: RealSrcSpan -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RealSrcSpan)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RealSrcSpan)

gmapT :: (forall b. Data b => b -> b) -> RealSrcSpan -> RealSrcSpan

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RealSrcSpan -> r

gmapQr :: 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

Ord RealSrcSpan

Defined in SrcLoc

Methods

compare :: RealSrcSpan -> RealSrcSpan -> Ordering

(<) :: RealSrcSpan -> RealSrcSpan -> Bool

(<=) :: RealSrcSpan -> RealSrcSpan -> Bool

(>) :: RealSrcSpan -> RealSrcSpan -> Bool

(>=) :: RealSrcSpan -> RealSrcSpan -> Bool

max :: RealSrcSpan -> RealSrcSpan -> RealSrcSpan

min :: RealSrcSpan -> RealSrcSpan -> RealSrcSpan

Show RealSrcSpan

Defined in SrcLoc

Methods

showsPrec :: Int -> RealSrcSpan -> ShowS

show :: RealSrcSpan -> String

showList :: [RealSrcSpan] -> ShowS

ToJson RealSrcSpan

Defined in SrcLoc

Methods

json :: RealSrcSpan -> JsonDoc

Outputable RealSrcSpan

Defined in SrcLoc

Methods

ppr :: RealSrcSpan -> SDoc

pprPrec :: Rational -> RealSrcSpan -> SDoc

FromJSON RealSrcSpan

Defined in Language.Haskell.Liquid.Types.Errors

Methods

parseJSON :: Value -> Parser RealSrcSpan

parseJSONList :: Value -> Parser [RealSrcSpan]

ToJSON RealSrcSpan

Defined in Language.Haskell.Liquid.Types.Errors

Methods

toJSON :: RealSrcSpan -> Value

toEncoding :: RealSrcSpan -> Encoding

toJSONList :: [RealSrcSpan] -> Value

toEncodingList :: [RealSrcSpan] -> Encoding

data SrcSpan

Source Span

A SrcSpan identifies either a specific portion of a text file or a human-readable description of a location.

Constructors

RealSrcSpan !RealSrcSpan

UnhelpfulSpan !FastString

Instances

Eq SrcSpan

Defined in SrcLoc

Methods

(==) :: SrcSpan -> SrcSpan -> Bool

(/=) :: SrcSpan -> SrcSpan -> Bool

Data SrcSpan

Defined in SrcLoc

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcSpan -> c SrcSpan

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SrcSpan

toConstr :: SrcSpan -> Constr

dataTypeOf :: SrcSpan -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SrcSpan)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcSpan)

gmapT :: (forall b. Data b => b -> b) -> SrcSpan -> SrcSpan

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcSpan -> r

gmapQr :: 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

Ord SrcSpan

Defined in SrcLoc

Methods

compare :: SrcSpan -> SrcSpan -> Ordering

(<) :: SrcSpan -> SrcSpan -> Bool

(<=) :: SrcSpan -> SrcSpan -> Bool

(>) :: SrcSpan -> SrcSpan -> Bool

(>=) :: SrcSpan -> SrcSpan -> Bool

max :: SrcSpan -> SrcSpan -> SrcSpan

min :: SrcSpan -> SrcSpan -> SrcSpan

Show SrcSpan

Defined in SrcLoc

Methods

showsPrec :: Int -> SrcSpan -> ShowS

show :: SrcSpan -> String

showList :: [SrcSpan] -> ShowS

NFData SrcSpan

Defined in SrcLoc

Methods

rnf :: SrcSpan -> ()

ToJson SrcSpan

Defined in SrcLoc

Methods

json :: SrcSpan -> JsonDoc

Outputable SrcSpan

Defined in SrcLoc

Methods

ppr :: SrcSpan -> SDoc

pprPrec :: Rational -> SrcSpan -> SDoc

PPrint SrcSpan

Defined in Language.Haskell.Liquid.Types.Errors

Methods

pprintTidy :: Tidy -> SrcSpan -> Doc

pprintPrec :: Int -> Tidy -> SrcSpan -> Doc

Hashable SrcSpan

Defined in Language.Haskell.Liquid.GHC.Misc

Methods

hashWithSalt :: Int -> SrcSpan -> Int

hash :: SrcSpan -> Int

FromJSON SrcSpan

Defined in Language.Haskell.Liquid.Types.Errors

Methods

parseJSON :: Value -> Parser SrcSpan

parseJSONList :: Value -> Parser [SrcSpan]

FromJSONKey SrcSpan

Defined in Language.Haskell.Liquid.Types.Errors

Methods

fromJSONKey :: FromJSONKeyFunction SrcSpan

fromJSONKeyList :: FromJSONKeyFunction [SrcSpan]

ToJSON SrcSpan

Defined in Language.Haskell.Liquid.Types.Errors

Methods

toJSON :: SrcSpan -> Value

toEncoding :: SrcSpan -> Encoding

toJSONList :: [SrcSpan] -> Value

toEncodingList :: [SrcSpan] -> Encoding

ToJSONKey SrcSpan

Defined in Language.Haskell.Liquid.Types.Errors

Methods

toJSONKey :: ToJSONKeyFunction SrcSpan

toJSONKeyList :: ToJSONKeyFunction [SrcSpan]

NamedThing e => NamedThing (Located e)

Defined in Name

Methods

getOccName :: Located e -> OccName

getName :: Located e -> Name

HasSrcSpan (Located a)

Defined in SrcLoc

Methods

composeSrcSpan :: Located (SrcSpanLess (Located a)) -> Located a

decomposeSrcSpan :: Located a -> Located (SrcSpanLess (Located a))

data GenLocated l e

We attach SrcSpans to lots of things, so let's have a datatype for it.

Constructors

L l e

Instances

Functor (GenLocated l)

Defined in SrcLoc

Methods

fmap :: (a -> b) -> GenLocated l a -> GenLocated l b

(<$) :: a -> GenLocated l b -> GenLocated l a

Foldable (GenLocated l)

Defined in 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)

Defined in SrcLoc

Methods

traverse :: Applicative f => (a -> f b) -> GenLocated l a -> f (GenLocated l b)

sequenceA :: Applicative f => GenLocated l (f a) -> f (GenLocated l a)

mapM :: Monad m => (a -> m b) -> GenLocated l a -> m (GenLocated l b)

sequence :: Monad m => GenLocated l (m a) -> m (GenLocated l a)

NamedThing e => NamedThing (Located e)

Defined in Name

Methods

getOccName :: Located e -> OccName

getName :: Located e -> Name

HasSrcSpan (Located a)

Defined in SrcLoc

Methods

composeSrcSpan :: Located (SrcSpanLess (Located a)) -> Located a

decomposeSrcSpan :: Located a -> Located (SrcSpanLess (Located a))

(Eq l, Eq e) => Eq (GenLocated l e)

Defined in SrcLoc

Methods

(==) :: GenLocated l e -> GenLocated l e -> Bool

(/=) :: GenLocated l e -> GenLocated l e -> Bool

(Data l, Data e) => Data (GenLocated l e)

Defined in SrcLoc

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GenLocated l e -> c (GenLocated l e)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GenLocated l e)

toConstr :: GenLocated l e -> Constr

dataTypeOf :: GenLocated l e -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GenLocated l e))

dataCast2 :: Typeable t => (forall d e0. (Data d, Data e0) => c (t d e0)) -> Maybe (c (GenLocated l e))

gmapT :: (forall b. Data b => b -> b) -> GenLocated l e -> GenLocated l e

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GenLocated l e -> r

gmapQr :: 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)

(Ord l, Ord e) => Ord (GenLocated l e)

Defined in SrcLoc

Methods

compare :: GenLocated l e -> GenLocated l e -> Ordering

(<) :: GenLocated l e -> GenLocated l e -> Bool

(<=) :: GenLocated l e -> GenLocated l e -> Bool

(>) :: GenLocated l e -> GenLocated l e -> Bool

(>=) :: GenLocated l e -> GenLocated l e -> Bool

max :: GenLocated l e -> GenLocated l e -> GenLocated l e

min :: GenLocated l e -> GenLocated l e -> GenLocated l e

(Outputable l, Outputable e) => Outputable (GenLocated l e)

Defined in SrcLoc

Methods

ppr :: GenLocated l e -> SDoc

pprPrec :: Rational -> GenLocated l e -> SDoc

type SrcSpanLess (GenLocated l e)

Defined in SrcLoc

type SrcSpanLess (GenLocated l e) = e

type Located = GenLocated SrcSpan

type RealLocated = GenLocated RealSrcSpan

type family SrcSpanLess a

Determines the type of undecorated syntactic entities For most syntactic entities E, where source location spans are introduced by a wrapper construtor of the same syntactic entity, we have `SrcSpanLess E = E`. However, some syntactic entities have a different type compared to a syntactic entity `e :: E` may have the type `Located E` when decorated by wrapping it with `L sp e` for a source span sp.

Instances

type SrcSpanLess Name

Defined in Name

type SrcSpanLess Name = Name

type SrcSpanLess (GenLocated l e)

Defined in SrcLoc

type SrcSpanLess (GenLocated l e) = e

class HasSrcSpan a where

A typeclass to set/get SrcSpans

Methods

composeSrcSpan :: Located (SrcSpanLess a) -> a

Composes a SrcSpan decoration with an undecorated syntactic entity to form its decorated variant

decomposeSrcSpan :: a -> Located (SrcSpanLess a)

Decomposes a decorated syntactic entity into its SrcSpan decoration and its undecorated variant

Instances

HasSrcSpan Name

Defined in Name

Methods

composeSrcSpan :: Located (SrcSpanLess Name) -> Name

decomposeSrcSpan :: Name -> Located (SrcSpanLess Name)

HasSrcSpan (Located a)

Defined in SrcLoc

Methods

composeSrcSpan :: Located (SrcSpanLess (Located a)) -> Located a

decomposeSrcSpan :: Located a -> Located (SrcSpanLess (Located a))

alwaysQualify :: PrintUnqualified

data PrintUnqualified

When printing code that contains original names, we need to map the original names back to something the user understands. This is the purpose of the triple of functions that gets passed around when rendering SDoc.

unitIdString :: UnitId -> String

data Module

A Module is a pair of a UnitId and a ModuleName.

Module variables (i.e. H) which can be instantiated to a specific module at some later point in time are represented with moduleUnitId set to holeUnitId (this allows us to avoid having to make moduleUnitId a partial operation.)

Constructors

Module

Fields

• moduleUnitId :: !UnitId
• moduleName :: !ModuleName

Instances

Eq Module

Defined in Module

Methods

(==) :: Module -> Module -> Bool

(/=) :: Module -> Module -> Bool

Data Module

Defined in Module

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Module -> c Module

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Module

toConstr :: Module -> Constr

dataTypeOf :: Module -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Module)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module)

gmapT :: (forall b. Data b => b -> b) -> Module -> Module

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r

gmapQ :: (forall d. Data d => d -> u) -> Module -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Module -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Module -> m Module

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module

Ord Module

Defined in Module

Methods

compare :: Module -> Module -> Ordering

(<) :: Module -> Module -> Bool

(<=) :: Module -> Module -> Bool

(>) :: Module -> Module -> Bool

(>=) :: Module -> Module -> Bool

max :: Module -> Module -> Module

min :: Module -> Module -> Module

NFData Module

Defined in Module

Methods

rnf :: Module -> ()

Binary Module

Defined in Module

Methods

put_ :: BinHandle -> Module -> IO ()

put :: BinHandle -> Module -> IO (Bin Module)

get :: BinHandle -> IO Module

Uniquable Module

Defined in Module

Methods

getUnique :: Module -> Unique

Outputable Module

Defined in Module

Methods

ppr :: Module -> SDoc

pprPrec :: Rational -> Module -> SDoc

DbUnitIdModuleRep InstalledUnitId ComponentId UnitId ModuleName Module

Defined in Module

Methods

fromDbModule :: DbModule InstalledUnitId ComponentId UnitId ModuleName Module -> Module

toDbModule :: Module -> DbModule InstalledUnitId ComponentId UnitId ModuleName Module

fromDbUnitId :: DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module -> UnitId

toDbUnitId :: UnitId -> DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module

data ModuleName

A ModuleName is essentially a simple string, e.g. Data.List.

Instances

Eq ModuleName

Defined in Module

Methods

(==) :: ModuleName -> ModuleName -> Bool

(/=) :: ModuleName -> ModuleName -> Bool

Data ModuleName

Defined in Module

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModuleName -> c ModuleName

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ModuleName

toConstr :: ModuleName -> Constr

dataTypeOf :: ModuleName -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ModuleName)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleName)

gmapT :: (forall b. Data b => b -> b) -> ModuleName -> ModuleName

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModuleName -> r

gmapQr :: 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

Ord ModuleName

Defined in Module

Methods

compare :: ModuleName -> ModuleName -> Ordering

(<) :: ModuleName -> ModuleName -> Bool

(<=) :: ModuleName -> ModuleName -> Bool

(>) :: ModuleName -> ModuleName -> Bool

(>=) :: ModuleName -> ModuleName -> Bool

max :: ModuleName -> ModuleName -> ModuleName

min :: ModuleName -> ModuleName -> ModuleName

Show ModuleName

Defined in Language.Haskell.Liquid.Types.Types

Methods

showsPrec :: Int -> ModuleName -> ShowS

show :: ModuleName -> String

showList :: [ModuleName] -> ShowS

NFData ModuleName

Defined in Module

Methods

rnf :: ModuleName -> ()

Binary ModuleName

Defined in Module

Methods

put_ :: BinHandle -> ModuleName -> IO ()

put :: BinHandle -> ModuleName -> IO (Bin ModuleName)

get :: BinHandle -> IO ModuleName

Uniquable ModuleName

Defined in Module

Methods

getUnique :: ModuleName -> Unique

Outputable ModuleName

Defined in Module

Methods

ppr :: ModuleName -> SDoc

pprPrec :: Rational -> ModuleName -> SDoc

BinaryStringRep ModuleName

Defined in Module

Methods

fromStringRep :: ByteString -> ModuleName

toStringRep :: ModuleName -> ByteString

Symbolic ModuleName

Defined in Language.Haskell.Liquid.Types.Types

Methods

symbol :: ModuleName -> Symbol

Hashable ModuleName

Defined in Language.Haskell.Liquid.Types.Types

Methods

hashWithSalt :: Int -> ModuleName -> Int

hash :: ModuleName -> Int

DbUnitIdModuleRep InstalledUnitId ComponentId UnitId ModuleName Module

Defined in Module

Methods

fromDbModule :: DbModule InstalledUnitId ComponentId UnitId ModuleName Module -> Module

toDbModule :: Module -> DbModule InstalledUnitId ComponentId UnitId ModuleName Module

fromDbUnitId :: DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module -> UnitId

toDbUnitId :: UnitId -> DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module

data UnitId

A unit identifier identifies a (possibly partially) instantiated library. It is primarily used as part of Module, which in turn is used in Name, which is used to give names to entities when typechecking.

There are two possible forms for a UnitId. It can be a DefiniteUnitId, in which case we just have a string that uniquely identifies some fully compiled, installed library we have on disk. However, when we are typechecking a library with missing holes, we may need to instantiate a library on the fly (in which case we don't have any on-disk representation.) In that case, you have an IndefiniteUnitId, which explicitly records the instantiation, so that we can substitute over it.

Constructors

IndefiniteUnitId !IndefUnitId

DefiniteUnitId !DefUnitId

Instances

Eq UnitId

Defined in Module

Methods

(==) :: UnitId -> UnitId -> Bool

(/=) :: UnitId -> UnitId -> Bool

Data UnitId

Defined in Module

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UnitId -> c UnitId

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UnitId

toConstr :: UnitId -> Constr

dataTypeOf :: UnitId -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UnitId)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnitId)

gmapT :: (forall b. Data b => b -> b) -> UnitId -> UnitId

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UnitId -> r

gmapQr :: 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

Ord UnitId

Defined in Module

Methods

compare :: UnitId -> UnitId -> Ordering

(<) :: UnitId -> UnitId -> Bool

(<=) :: UnitId -> UnitId -> Bool

(>) :: UnitId -> UnitId -> Bool

(>=) :: UnitId -> UnitId -> Bool

max :: UnitId -> UnitId -> UnitId

min :: UnitId -> UnitId -> UnitId

Show UnitId

Defined in Module

Methods

showsPrec :: Int -> UnitId -> ShowS

show :: UnitId -> String

showList :: [UnitId] -> ShowS

NFData UnitId

Defined in Module

Methods

rnf :: UnitId -> ()

Binary UnitId

Defined in Module

Methods

put_ :: BinHandle -> UnitId -> IO ()

put :: BinHandle -> UnitId -> IO (Bin UnitId)

get :: BinHandle -> IO UnitId

Uniquable UnitId

Defined in Module

Methods

getUnique :: UnitId -> Unique

Outputable UnitId

Defined in Module

Methods

ppr :: UnitId -> SDoc

pprPrec :: Rational -> UnitId -> SDoc

DbUnitIdModuleRep InstalledUnitId ComponentId UnitId ModuleName Module

Defined in Module

Methods

fromDbModule :: DbModule InstalledUnitId ComponentId UnitId ModuleName Module -> Module

toDbModule :: Module -> DbModule InstalledUnitId ComponentId UnitId ModuleName Module

fromDbUnitId :: DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module -> UnitId

toDbUnitId :: UnitId -> DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module

newtype InstalledUnitId

An installed unit identifier identifies a library which has been installed to the package database. These strings 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.) Put another way, an installed unit id is either fully instantiated, or not instantiated at all.

Installed unit identifiers look something like p+af23SAj2dZ219, or maybe just p if they don't use Backpack.

Constructors

InstalledUnitId

Fields

• installedUnitIdFS :: FastString

  The full hashed unit identifier, including the component id and the hash.

Instances

Eq InstalledUnitId

Defined in Module

Methods

(==) :: InstalledUnitId -> InstalledUnitId -> Bool

(/=) :: InstalledUnitId -> InstalledUnitId -> Bool

Ord InstalledUnitId

Defined in Module

Methods

compare :: InstalledUnitId -> InstalledUnitId -> Ordering

(<) :: InstalledUnitId -> InstalledUnitId -> Bool

(<=) :: InstalledUnitId -> InstalledUnitId -> Bool

(>) :: InstalledUnitId -> InstalledUnitId -> Bool

(>=) :: InstalledUnitId -> InstalledUnitId -> Bool

max :: InstalledUnitId -> InstalledUnitId -> InstalledUnitId

min :: InstalledUnitId -> InstalledUnitId -> InstalledUnitId

Binary InstalledUnitId

Defined in Module

Methods

put_ :: BinHandle -> InstalledUnitId -> IO ()

put :: BinHandle -> InstalledUnitId -> IO (Bin InstalledUnitId)

get :: BinHandle -> IO InstalledUnitId

Uniquable InstalledUnitId

Defined in Module

Methods

getUnique :: InstalledUnitId -> Unique

Outputable InstalledUnitId

Defined in Module

Methods

ppr :: InstalledUnitId -> SDoc

pprPrec :: Rational -> InstalledUnitId -> SDoc

BinaryStringRep InstalledUnitId

Defined in Module

Methods

fromStringRep :: ByteString -> InstalledUnitId

toStringRep :: InstalledUnitId -> ByteString

DbUnitIdModuleRep InstalledUnitId ComponentId UnitId ModuleName Module

Defined in Module

Methods

fromDbModule :: DbModule InstalledUnitId ComponentId UnitId ModuleName Module -> Module

toDbModule :: Module -> DbModule InstalledUnitId ComponentId UnitId ModuleName Module

fromDbUnitId :: DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module -> UnitId

toDbUnitId :: UnitId -> DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module

newtype ComponentId

A ComponentId consists of the package name, package version, component ID, the transitive dependencies of the component, and other information to uniquely identify the source code and build configuration of a component.

This used to be known as an InstalledPackageId, but a package can contain multiple components and a ComponentId uniquely identifies a component within a package. When a package only has one component, the ComponentId coincides with the InstalledPackageId

Constructors

ComponentId FastString

Instances

Eq ComponentId

Defined in Module

Methods

(==) :: ComponentId -> ComponentId -> Bool

(/=) :: ComponentId -> ComponentId -> Bool

Ord ComponentId

Defined in Module

Methods

compare :: ComponentId -> ComponentId -> Ordering

(<) :: ComponentId -> ComponentId -> Bool

(<=) :: ComponentId -> ComponentId -> Bool

(>) :: ComponentId -> ComponentId -> Bool

(>=) :: ComponentId -> ComponentId -> Bool

max :: ComponentId -> ComponentId -> ComponentId

min :: ComponentId -> ComponentId -> ComponentId

Binary ComponentId

Defined in Module

Methods

put_ :: BinHandle -> ComponentId -> IO ()

put :: BinHandle -> ComponentId -> IO (Bin ComponentId)

get :: BinHandle -> IO ComponentId

Uniquable ComponentId

Defined in Module

Methods

getUnique :: ComponentId -> Unique

Outputable ComponentId

Defined in Module

Methods

ppr :: ComponentId -> SDoc

pprPrec :: Rational -> ComponentId -> SDoc

BinaryStringRep ComponentId

Defined in Module

Methods

fromStringRep :: ByteString -> ComponentId

toStringRep :: ComponentId -> ByteString

DbUnitIdModuleRep InstalledUnitId ComponentId UnitId ModuleName Module

Defined in Module

Methods

fromDbModule :: DbModule InstalledUnitId ComponentId UnitId ModuleName Module -> Module

toDbModule :: Module -> DbModule InstalledUnitId ComponentId UnitId ModuleName Module

fromDbUnitId :: DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module -> UnitId

toDbUnitId :: UnitId -> DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module

fsLit :: String -> FastString

sLit :: String -> PtrString

lengthPS :: PtrString -> Int

Return the length of 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.

mkPtrString :: String -> PtrString

Encode a String into a newly allocated PtrString using Latin-1 encoding. The original string must not contain non-Latin-1 characters (above codepoint 0xff).

mkPtrString# :: Addr# -> PtrString

Wrap an unboxed address into a PtrString.

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.

getFastStringZEncCounter :: IO Int

getFastStringTable :: IO [[[FastString]]]

isUnderscoreFS :: FastString -> Bool

nilFS :: FastString

uniqueOfFS :: FastString -> Int

consFS :: Char -> FastString -> FastString

tailFS :: FastString -> FastString

headFS :: FastString -> Char

concatFS :: [FastString] -> FastString

appendFS :: FastString -> FastString -> 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.

unpackFS :: FastString -> String

Unpacks and decodes the FastString

nullFS :: FastString -> Bool

Returns True if the FastString is empty

lengthFS :: FastString -> Int

Returns the length of the FastString in characters

mkFastStringByteList :: [Word8] -> FastString

Creates a FastString from a UTF-8 encoded [Word8]

mkFastString :: String -> FastString

Creates a UTF-8 encoded FastString from a String

mkFastStringByteString :: ByteString -> FastString

Create a FastString from an existing ForeignPtr; the difference between this and mkFastStringBytes is that we don't have to copy the bytes if the string is new to the table.

mkFastStringForeignPtr :: Ptr Word8 -> ForeignPtr Word8 -> Int -> IO FastString

Create a FastString from an existing ForeignPtr; the difference between this and mkFastStringBytes is that we don't have to copy the bytes if the string is new to the table.

mkFastStringBytes :: Ptr Word8 -> Int -> FastString

mkFastString# :: Addr# -> FastString

lengthFZS :: FastZString -> Int

zString :: FastZString -> String

hPutFZS :: Handle -> FastZString -> IO ()

unsafeMkByteString :: String -> ByteString

fastZStringToByteString :: FastZString -> ByteString

fastStringToByteString :: FastString -> ByteString

bytesFS :: FastString -> ByteString

Gives the UTF-8 encoded bytes corresponding to a FastString

data FastZString

Instances

NFData FastZString

Defined in FastString

Methods

rnf :: FastZString -> ()

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_bs :: !ByteString
• fs_zenc :: FastZString

  Lazily computed z-encoding of this string.

  Since FastStrings are globally memoized this is computed at most once for any given string.

Instances

Eq FastString

Defined in FastString

Methods

(==) :: FastString -> FastString -> Bool

(/=) :: FastString -> FastString -> Bool

Data FastString

Defined in 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

Ord FastString

Defined in FastString

Methods

compare :: FastString -> FastString -> Ordering

(<) :: FastString -> FastString -> Bool

(<=) :: FastString -> FastString -> Bool

(>) :: FastString -> FastString -> Bool

(>=) :: FastString -> FastString -> Bool

max :: FastString -> FastString -> FastString

min :: FastString -> FastString -> FastString

Show FastString

Defined in FastString

Methods

showsPrec :: Int -> FastString -> ShowS

show :: FastString -> String

showList :: [FastString] -> ShowS

IsString FastString

Defined in FastString

Methods

fromString :: String -> FastString

Semigroup FastString

Defined in FastString

Methods

(<>) :: FastString -> FastString -> FastString

sconcat :: NonEmpty FastString -> FastString

stimes :: Integral b => b -> FastString -> FastString

Monoid FastString

Defined in FastString

Methods

mempty :: FastString

mappend :: FastString -> FastString -> FastString

mconcat :: [FastString] -> FastString

NFData FastString

Defined in FastString

Methods

rnf :: FastString -> ()

Uniquable FastString

Defined in Unique

Methods

getUnique :: FastString -> Unique

Outputable FastString

Defined in Outputable

Methods

ppr :: FastString -> SDoc

pprPrec :: Rational -> FastString -> SDoc

Symbolic FastString

Defined in Language.Haskell.Liquid.GHC.Misc

Methods

symbol :: FastString -> Symbol

data PtrString

A PtrString is a pointer to some array of Latin-1 encoded chars.

Constructors

PtrString !(Ptr Word8) !Int

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.

isUnboxedTupleTyCon :: TyCon -> Bool

Is this the TyCon for an unboxed tuple?

isFunTyCon :: TyCon -> Bool

data TyCon

TyCons represent type constructors. Type constructors are introduced by things such as:

1) Data declarations: data Foo = ... creates the Foo type constructor of kind *

2) Type synonyms: type Foo = ... creates the Foo type constructor

3) Newtypes: newtype Foo a = MkFoo ... creates the Foo type constructor of kind * -> *

4) Class declarations: class Foo where creates the Foo type constructor of kind *

This data type also encodes a number of primitive, built in type constructors such as those for function and tuple types.

Instances

Eq TyCon

Defined in TyCon

Methods

(==) :: TyCon -> TyCon -> Bool

(/=) :: TyCon -> TyCon -> Bool

Data TyCon

Defined in TyCon

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyCon -> c TyCon

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TyCon

toConstr :: TyCon -> Constr

dataTypeOf :: TyCon -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TyCon)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyCon)

gmapT :: (forall b. Data b => b -> b) -> TyCon -> TyCon

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyCon -> r

gmapQr :: 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

Ord TyCon

Defined in Language.Haskell.Liquid.Types.Types

Methods

compare :: TyCon -> TyCon -> Ordering

(<) :: TyCon -> TyCon -> Bool

(<=) :: TyCon -> TyCon -> Bool

(>) :: TyCon -> TyCon -> Bool

(>=) :: TyCon -> TyCon -> Bool

max :: TyCon -> TyCon -> TyCon

min :: TyCon -> TyCon -> TyCon

Show TyCon

Defined in Language.Haskell.Liquid.GHC.Misc

Methods

showsPrec :: Int -> TyCon -> ShowS

show :: TyCon -> String

showList :: [TyCon] -> ShowS

NFData TyCon

Defined in Language.Haskell.Liquid.GHC.Misc

Methods

rnf :: TyCon -> ()

NamedThing TyCon

Defined in TyCon

Methods

getOccName :: TyCon -> OccName

getName :: TyCon -> Name

Uniquable TyCon

Defined in TyCon

Methods

getUnique :: TyCon -> Unique

Outputable TyCon

Defined in TyCon

Methods

ppr :: TyCon -> SDoc

pprPrec :: Rational -> TyCon -> SDoc

Symbolic TyCon

Symbol Instances

Defined in Language.Haskell.Liquid.GHC.Misc

Methods

symbol :: TyCon -> Symbol

PPrint TyCon

Defined in Language.Haskell.Liquid.Types.PrettyPrint

Methods

pprintTidy :: Tidy -> TyCon -> Doc

pprintPrec :: Int -> Tidy -> TyCon -> Doc

Hashable TyCon

Defined in Language.Haskell.Liquid.GHC.Misc

Methods

hashWithSalt :: Int -> TyCon -> Int

hash :: TyCon -> Int

TyConable TyCon

Defined in Language.Haskell.Liquid.Types.Types

Methods

isFun :: TyCon -> Bool

isList :: TyCon -> Bool

isTuple :: TyCon -> Bool

ppTycon :: TyCon -> Doc

isClass :: TyCon -> Bool

isEqual :: TyCon -> Bool

isNumCls :: TyCon -> Bool

isFracCls :: TyCon -> Bool

ResolveSym TyCon

Defined in Language.Haskell.Liquid.Bare.Resolve

Methods

resolveLocSym :: Env -> ModName -> String -> LocSymbol -> Either UserError TyCon

sGhcRtsWithLibdw :: Settings -> Bool

sGhcDebugged :: Settings -> Bool

sGhcThreaded :: Settings -> Bool

sLibFFI :: Settings -> Bool

sLeadingUnderscore :: Settings -> Bool

sTablesNextToCode :: Settings -> Bool

sGhcRTSWays :: Settings -> String

sGhcWithSMP :: Settings -> Bool

sGhcWithNativeCodeGen :: Settings -> Bool

sGhcWithInterpreter :: Settings -> Bool

sIntegerLibraryType :: Settings -> IntegerLibrary

sIntegerLibrary :: Settings -> String

sTargetPlatformString :: Settings -> String

sExtraGccViaCFlags :: Settings -> [String]

sOpt_i :: Settings -> [String]

sOpt_lcc :: Settings -> [String]

sOpt_lc :: Settings -> [String]

sOpt_lo :: Settings -> [String]

sOpt_windres :: Settings -> [String]

sOpt_l :: Settings -> [String]

sOpt_a :: Settings -> [String]

sOpt_cxx :: Settings -> [String]

sOpt_c :: Settings -> [String]

sOpt_F :: Settings -> [String]

sOpt_P_fingerprint :: Settings -> Fingerprint

sOpt_P :: Settings -> [String]

sOpt_L :: Settings -> [String]

sPgm_i :: Settings -> String

sPgm_lcc :: Settings -> (String, [Option])

sPgm_lc :: Settings -> (String, [Option])

sPgm_lo :: Settings -> (String, [Option])

sPgm_ranlib :: Settings -> String

sPgm_ar :: Settings -> String

sPgm_libtool :: Settings -> String

sPgm_windres :: Settings -> String

sPgm_T :: Settings -> String

sPgm_dll :: Settings -> (String, [Option])

sPgm_l :: Settings -> (String, [Option])

sPgm_a :: Settings -> (String, [Option])

sPgm_c :: Settings -> String

sPgm_F :: Settings -> String

sPgm_P :: Settings -> (String, [Option])

sPgm_L :: Settings -> String

sGccSupportsNoPie :: Settings -> Bool

sLdIsGnuLd :: Settings -> Bool

sLdSupportsFilelist :: Settings -> Bool

sLdSupportsBuildId :: Settings -> Bool

sLdSupportsCompactUnwind :: Settings -> Bool

sSystemPackageConfig :: Settings -> FilePath

sTmpDir :: Settings -> String

sTopDir :: Settings -> FilePath

sToolDir :: Settings -> Maybe FilePath

sGhciUsagePath :: Settings -> FilePath

sGhcUsagePath :: Settings -> FilePath

sProjectVersion :: Settings -> String

sProgramName :: Settings -> String

data Settings

Constructors

Settings

Fields

• sGhcNameVersion :: !GhcNameVersion
• sFileSettings :: !FileSettings
• sTargetPlatform :: Platform
• sToolSettings :: !ToolSettings
• sPlatformMisc :: !PlatformMisc
• sPlatformConstants :: PlatformConstants
• sRawSettings :: [(String, String)]

data PlatformConstants

Constructors

PlatformConstants

Fields

• pc_CONTROL_GROUP_CONST_291 :: Int
• pc_STD_HDR_SIZE :: Int
• pc_PROF_HDR_SIZE :: Int
• pc_BLOCK_SIZE :: Int
• pc_BLOCKS_PER_MBLOCK :: Int
• pc_TICKY_BIN_COUNT :: Int
• pc_OFFSET_StgRegTable_rR1 :: Int
• pc_OFFSET_StgRegTable_rR2 :: Int
• pc_OFFSET_StgRegTable_rR3 :: Int
• pc_OFFSET_StgRegTable_rR4 :: Int
• pc_OFFSET_StgRegTable_rR5 :: Int
• pc_OFFSET_StgRegTable_rR6 :: Int
• pc_OFFSET_StgRegTable_rR7 :: Int
• pc_OFFSET_StgRegTable_rR8 :: Int
• pc_OFFSET_StgRegTable_rR9 :: Int
• pc_OFFSET_StgRegTable_rR10 :: Int
• pc_OFFSET_StgRegTable_rF1 :: Int
• pc_OFFSET_StgRegTable_rF2 :: Int
• pc_OFFSET_StgRegTable_rF3 :: Int
• pc_OFFSET_StgRegTable_rF4 :: Int
• pc_OFFSET_StgRegTable_rF5 :: Int
• pc_OFFSET_StgRegTable_rF6 :: Int
• pc_OFFSET_StgRegTable_rD1 :: Int
• pc_OFFSET_StgRegTable_rD2 :: Int
• pc_OFFSET_StgRegTable_rD3 :: Int
• pc_OFFSET_StgRegTable_rD4 :: Int
• pc_OFFSET_StgRegTable_rD5 :: Int
• pc_OFFSET_StgRegTable_rD6 :: Int
• pc_OFFSET_StgRegTable_rXMM1 :: Int
• pc_OFFSET_StgRegTable_rXMM2 :: Int
• pc_OFFSET_StgRegTable_rXMM3 :: Int
• pc_OFFSET_StgRegTable_rXMM4 :: Int
• pc_OFFSET_StgRegTable_rXMM5 :: Int
• pc_OFFSET_StgRegTable_rXMM6 :: Int
• pc_OFFSET_StgRegTable_rYMM1 :: Int
• pc_OFFSET_StgRegTable_rYMM2 :: Int
• pc_OFFSET_StgRegTable_rYMM3 :: Int
• pc_OFFSET_StgRegTable_rYMM4 :: Int
• pc_OFFSET_StgRegTable_rYMM5 :: Int
• pc_OFFSET_StgRegTable_rYMM6 :: Int
• pc_OFFSET_StgRegTable_rZMM1 :: Int
• pc_OFFSET_StgRegTable_rZMM2 :: Int
• pc_OFFSET_StgRegTable_rZMM3 :: Int
• pc_OFFSET_StgRegTable_rZMM4 :: Int
• pc_OFFSET_StgRegTable_rZMM5 :: Int
• pc_OFFSET_StgRegTable_rZMM6 :: Int
• pc_OFFSET_StgRegTable_rL1 :: Int
• pc_OFFSET_StgRegTable_rSp :: Int
• pc_OFFSET_StgRegTable_rSpLim :: Int
• pc_OFFSET_StgRegTable_rHp :: Int
• pc_OFFSET_StgRegTable_rHpLim :: Int
• pc_OFFSET_StgRegTable_rCCCS :: Int
• pc_OFFSET_StgRegTable_rCurrentTSO :: Int
• pc_OFFSET_StgRegTable_rCurrentNursery :: Int
• pc_OFFSET_StgRegTable_rHpAlloc :: Int
• pc_OFFSET_stgEagerBlackholeInfo :: Int
• pc_OFFSET_stgGCEnter1 :: Int
• pc_OFFSET_stgGCFun :: Int
• pc_OFFSET_Capability_r :: Int
• pc_OFFSET_bdescr_start :: Int
• pc_OFFSET_bdescr_free :: Int
• pc_OFFSET_bdescr_blocks :: Int
• pc_OFFSET_bdescr_flags :: Int
• pc_SIZEOF_CostCentreStack :: Int
• pc_OFFSET_CostCentreStack_mem_alloc :: Int
• pc_REP_CostCentreStack_mem_alloc :: Int
• pc_OFFSET_CostCentreStack_scc_count :: Int
• pc_REP_CostCentreStack_scc_count :: Int
• pc_OFFSET_StgHeader_ccs :: Int
• pc_OFFSET_StgHeader_ldvw :: Int
• pc_SIZEOF_StgSMPThunkHeader :: Int
• pc_OFFSET_StgEntCounter_allocs :: Int
• pc_REP_StgEntCounter_allocs :: Int
• pc_OFFSET_StgEntCounter_allocd :: Int
• pc_REP_StgEntCounter_allocd :: Int
• pc_OFFSET_StgEntCounter_registeredp :: Int
• pc_OFFSET_StgEntCounter_link :: Int
• pc_OFFSET_StgEntCounter_entry_count :: Int
• pc_SIZEOF_StgUpdateFrame_NoHdr :: Int
• pc_SIZEOF_StgMutArrPtrs_NoHdr :: Int
• pc_OFFSET_StgMutArrPtrs_ptrs :: Int
• pc_OFFSET_StgMutArrPtrs_size :: Int
• pc_SIZEOF_StgSmallMutArrPtrs_NoHdr :: Int
• pc_OFFSET_StgSmallMutArrPtrs_ptrs :: Int
• pc_SIZEOF_StgArrBytes_NoHdr :: Int
• pc_OFFSET_StgArrBytes_bytes :: Int
• pc_OFFSET_StgTSO_alloc_limit :: Int
• pc_OFFSET_StgTSO_cccs :: Int
• pc_OFFSET_StgTSO_stackobj :: Int
• pc_OFFSET_StgStack_sp :: Int
• pc_OFFSET_StgStack_stack :: Int
• pc_OFFSET_StgUpdateFrame_updatee :: Int
• pc_OFFSET_StgFunInfoExtraFwd_arity :: Int
• pc_REP_StgFunInfoExtraFwd_arity :: Int
• pc_SIZEOF_StgFunInfoExtraRev :: Int
• pc_OFFSET_StgFunInfoExtraRev_arity :: Int
• pc_REP_StgFunInfoExtraRev_arity :: Int
• pc_MAX_SPEC_SELECTEE_SIZE :: Int
• pc_MAX_SPEC_AP_SIZE :: Int
• pc_MIN_PAYLOAD_SIZE :: Int
• pc_MIN_INTLIKE :: Int
• pc_MAX_INTLIKE :: Int
• pc_MIN_CHARLIKE :: Int
• pc_MAX_CHARLIKE :: Int
• pc_MUT_ARR_PTRS_CARD_BITS :: Int
• pc_MAX_Vanilla_REG :: Int
• pc_MAX_Float_REG :: Int
• pc_MAX_Double_REG :: Int
• pc_MAX_Long_REG :: Int
• pc_MAX_XMM_REG :: Int
• pc_MAX_Real_Vanilla_REG :: Int
• pc_MAX_Real_Float_REG :: Int
• pc_MAX_Real_Double_REG :: Int
• pc_MAX_Real_XMM_REG :: Int
• pc_MAX_Real_Long_REG :: Int
• pc_RESERVED_C_STACK_BYTES :: Int
• pc_RESERVED_STACK_WORDS :: Int
• pc_AP_STACK_SPLIM :: Int
• pc_WORD_SIZE :: Int
• pc_DOUBLE_SIZE :: Int
• pc_CINT_SIZE :: Int
• pc_CLONG_SIZE :: Int
• pc_CLONG_LONG_SIZE :: Int
• pc_BITMAP_BITS_SHIFT :: Int
• pc_TAG_BITS :: Int
• pc_WORDS_BIGENDIAN :: Bool
• pc_DYNAMIC_BY_DEFAULT :: Bool
• pc_LDV_SHIFT :: Int
• pc_ILDV_CREATE_MASK :: Integer
• pc_ILDV_STATE_CREATE :: Integer
• pc_ILDV_STATE_USE :: Integer

Instances

Read PlatformConstants

Defined in PlatformConstants

Methods

readsPrec :: Int -> ReadS PlatformConstants

readList :: ReadS [PlatformConstants]

readPrec :: ReadPrec PlatformConstants

readListPrec :: ReadPrec [PlatformConstants]

withSignalHandlers :: (ExceptionMonad m, MonadIO m) => m a -> m a

Temporarily install standard signal handlers for catching ^C, which just throw an exception in the current thread.

showGhcException :: GhcException -> ShowS

Append a description of the given exception to this string.

Note that this uses unsafeGlobalDynFlags, which may have some uninitialized fields if invoked before initGhcMonad has been called. If the error message to be printed includes a pretty-printer document which forces one of these fields this call may bottom.

data GhcException

GHC's own exception type error messages all take the form:

     location: error
 

If the location is on the command line, or in GHC itself, then location="ghc". All of the error types below correspond to a location of "ghc", except for ProgramError (where the string is assumed to contain a location already, so we don't print one).

Constructors

Signal Int

Some other fatal signal (SIGHUP,SIGTERM)

UsageError String

Prints the short usage msg after the error

CmdLineError String

A problem with the command line arguments, but don't print usage.

Panic String

The impossible happened.

PprPanic String SDoc

Sorry String

The user tickled something that's known not to work yet, but we're not counting it as a bug.

PprSorry String SDoc

InstallationError String

An installation problem.

ProgramError String

An error in the user's code, probably.

PprProgramError String SDoc

Instances

Show GhcException

Defined in Panic

Methods

showsPrec :: Int -> GhcException -> ShowS

show :: GhcException -> String

showList :: [GhcException] -> ShowS

Exception GhcException

Defined in Panic

Methods

toException :: GhcException -> SomeException

fromException :: SomeException -> Maybe GhcException

displayException :: GhcException -> String

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

Eq OccName

Defined in OccName

Methods

(==) :: OccName -> OccName -> Bool

(/=) :: OccName -> OccName -> Bool

Data OccName

Defined in OccName

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

Ord OccName

Defined in OccName

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

NFData OccName

Defined in OccName

Methods

rnf :: OccName -> ()

HasOccName OccName

Defined in OccName

Methods

occName :: OccName -> OccName

Binary OccName

Defined in OccName

Methods

put_ :: BinHandle -> OccName -> IO ()

put :: BinHandle -> OccName -> IO (Bin OccName)

get :: BinHandle -> IO OccName

Uniquable OccName

Defined in OccName

Methods

getUnique :: OccName -> Unique

Outputable OccName

Defined in OccName

Methods

ppr :: OccName -> SDoc

pprPrec :: Rational -> OccName -> SDoc

OutputableBndr OccName

Defined in OccName

Methods

pprBndr :: BindingSite -> OccName -> SDoc

pprPrefixOcc :: OccName -> SDoc

pprInfixOcc :: OccName -> SDoc

bndrIsJoin_maybe :: OccName -> Maybe Int

data Name

A unique, unambiguous name for something, containing information about where that thing originated.

Instances

Eq Name

The same comments as for Name's Ord instance apply.

Defined in Name

Methods

(==) :: Name -> Name -> Bool

(/=) :: Name -> Name -> Bool

Data Name

Defined in Name

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Name -> c Name

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Name

toConstr :: Name -> Constr

dataTypeOf :: Name -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Name)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)

gmapT :: (forall b. Data b => b -> b) -> Name -> Name

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r

gmapQr :: 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

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.

Defined in Name

Methods

compare :: Name -> Name -> Ordering

(<) :: Name -> Name -> Bool

(<=) :: Name -> Name -> Bool

(>) :: Name -> Name -> Bool

(>=) :: Name -> Name -> Bool

max :: Name -> Name -> Name

min :: Name -> Name -> Name

Show Name

Defined in Language.Haskell.Liquid.GHC.Misc

Methods

showsPrec :: Int -> Name -> ShowS

show :: Name -> String

showList :: [Name] -> ShowS

NFData Name

Defined in Name

Methods

rnf :: Name -> ()

NamedThing Name

Defined in Name

Methods

getOccName :: Name -> OccName

getName :: Name -> Name

HasOccName Name

Defined in Name

Methods

occName :: Name -> OccName

Binary Name

Assumes that the Name is a non-binding one. See putIfaceTopBndr and getIfaceTopBndr for serializing binding Names. See UserData for the rationale for this distinction.

Defined in Name

Methods

put_ :: BinHandle -> Name -> IO ()

put :: BinHandle -> Name -> IO (Bin Name)

get :: BinHandle -> IO Name

Uniquable Name

Defined in Name

Methods

getUnique :: Name -> Unique

HasSrcSpan Name

Defined in Name

Methods

composeSrcSpan :: Located (SrcSpanLess Name) -> Name

decomposeSrcSpan :: Name -> Located (SrcSpanLess Name)

Outputable Name

Defined in Name

Methods

ppr :: Name -> SDoc

pprPrec :: Rational -> Name -> SDoc

OutputableBndr Name

Defined in Name

Methods

pprBndr :: BindingSite -> Name -> SDoc

pprPrefixOcc :: Name -> SDoc

pprInfixOcc :: Name -> SDoc

bndrIsJoin_maybe :: Name -> Maybe Int

Symbolic Name

Defined in Language.Haskell.Liquid.GHC.Misc

Methods

symbol :: Name -> Symbol

Fixpoint Name

Defined in Language.Haskell.Liquid.GHC.Misc

Methods

toFix :: Name -> Doc

simplify :: Name -> Name

PPrint Name

Defined in Language.Haskell.Liquid.Types.PrettyPrint

Methods

pprintTidy :: Tidy -> Name -> Doc

pprintPrec :: Int -> Tidy -> Name -> Doc

type SrcSpanLess Name

Defined in Name

type SrcSpanLess Name = Name

showOpt :: Option -> String

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

Eq Option

Defined in CliOption

Methods

(==) :: Option -> Option -> Bool

(/=) :: Option -> Option -> Bool

unsafeGlobalDynFlags :: DynFlags

useUnicodeSyntax :: DynFlags -> Bool

An internal helper to check whether to use unicode syntax for output.

Note: You should very likely be using unicodeSyntax instead of this function.

useStarIsType :: DynFlags -> Bool

shouldUseColor :: DynFlags -> Bool

shouldUseHexWordLiterals :: DynFlags -> Bool

hasPprDebug :: DynFlags -> Bool

hasNoDebugOutput :: DynFlags -> Bool

data DynFlags

Contains not only a collection of GeneralFlags but also a plethora of information relating to the compilation of a single file or GHC session

Constructors

DynFlags

Fields

• ghcMode :: GhcMode
• ghcLink :: GhcLink
• hscTarget :: HscTarget
• ghcNameVersion :: !GhcNameVersion
• fileSettings :: !FileSettings
• targetPlatform :: Platform
• toolSettings :: !ToolSettings
• platformMisc :: !PlatformMisc
• platformConstants :: PlatformConstants
• rawSettings :: [(String, String)]
• integerLibrary :: IntegerLibrary

  IntegerGMP or IntegerSimple. Set at configure time, but may be overriden by GHC-API users. See Note [The integer library] in PrelNames

• llvmConfig :: LlvmConfig

  N.B. It's important that this field is lazy since we load the LLVM configuration lazily. See Note [LLVM Configuration] in SysTools.

• verbosity :: Int

  Verbosity level: see Note [Verbosity levels]

• optLevel :: Int

  Optimisation level

• debugLevel :: Int

  How much debug information to produce

• simplPhases :: Int

  Number of simplifier phases

• maxSimplIterations :: Int

  Max simplifier iterations

• ruleCheck :: Maybe String
• inlineCheck :: Maybe String

  A prefix to report inlining decisions about

• strictnessBefore :: [Int]

  Additional demand analysis

• parMakeCount :: Maybe Int

  The number of modules to compile in parallel in --make mode, where Nothing ==> compile as many in parallel as there are CPUs.

• enableTimeStats :: Bool

  Enable RTS timing statistics?

• ghcHeapSize :: Maybe Int

  The heap size to set.

• maxRelevantBinds :: Maybe Int

  Maximum number of bindings from the type envt to show in type error messages

• maxValidHoleFits :: Maybe Int

  Maximum number of hole fits to show in typed hole error messages

• maxRefHoleFits :: Maybe Int

  Maximum number of refinement hole fits to show in typed hole error messages

• refLevelHoleFits :: Maybe Int

  Maximum level of refinement for refinement hole fits in typed hole error messages

• maxUncoveredPatterns :: Int

  Maximum number of unmatched patterns to show in non-exhaustiveness warnings

• 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

• 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 :: 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 to disable)

• liberateCaseThreshold :: Maybe Int

  Threshold for LiberateCase

• floatLamArgs :: Maybe Int

  Arg count for lambda floating See CoreMonad.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]
• mainModIs :: Module
• mainFunIs :: Maybe String
• reductionDepth :: IntWithInf

  Typechecker maximum stack depth

• solverIterations :: IntWithInf

  Number of iterations in the constraints solver Typically only 1 is needed

• thisInstalledUnitId :: InstalledUnitId
• thisComponentId_ :: Maybe ComponentId
• thisUnitIdInsts_ :: Maybe [(ModuleName, Module)]
• ways :: [Way]

  Way flags from the command line

• buildTag :: String

  The global "way" (e.g. "p" for prof)

• splitInfo :: Maybe (String, Int)
• objectDir :: Maybe String
• dylibInstallName :: Maybe String
• hiDir :: Maybe String
• hieDir :: Maybe String
• stubDir :: Maybe String
• dumpDir :: Maybe String
• objectSuf :: String
• hcSuf :: String
• hiSuf :: String
• hieSuf :: String
• canGenerateDynamicToo :: IORef Bool
• dynObjectSuf :: String
• dynHiSuf :: String
• outputFile :: Maybe String
• dynOutputFile :: Maybe String
• outputHi :: Maybe String
• dynLibLoader :: DynLibLoader
• dumpPrefix :: Maybe FilePath

  This is set by runPipeline based on where its output is going.

• dumpPrefixForce :: Maybe FilePath

  Override the dumpPrefix set by runPipeline. Set by -ddump-file-prefix

• ldInputs :: [Option]
• includePaths :: IncludeSpecs
• libraryPaths :: [String]
• frameworkPaths :: [String]
• cmdlineFrameworks :: [String]
• rtsOpts :: Maybe String
• rtsOptsEnabled :: RtsOptsEnabled
• rtsOptsSuggestions :: Bool
• hpcDir :: String

  Path to store the .mix files

• pluginModNames :: [ModuleName]
• pluginModNameOpts :: [(ModuleName, String)]
• frontendPluginOpts :: [String]

  the -ffrontend-opt flags given on the command line, in *reverse* order that they're specified on the command line.

• cachedPlugins :: [LoadedPlugin]

  plugins dynamically loaded after processing arguments. What will be loaded here is directed by pluginModNames. Arguments are loaded from pluginModNameOpts. The purpose of this field is to cache the plugins so they don't have to be loaded each time they are needed. See initializePlugins.

• staticPlugins :: [StaticPlugin]

  staic 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.

• hooks :: Hooks
• 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 getPackageConfRefs.

• ignorePackageFlags :: [IgnorePackageFlag]

  The -ignore-package flags from the command line. In *reverse* order that they're specified on the command line.

• packageFlags :: [PackageFlag]

  The -package and -hide-package flags from the command-line. In *reverse* order that they're specified on the command line.

• pluginPackageFlags :: [PackageFlag]

  The -plugin-package-id flags from command line. In *reverse* order that they're specified on the command line.

• trustFlags :: [TrustFlag]

  The -trust and -distrust flags. In *reverse* order that they're specified on the command line.

• packageEnv :: Maybe FilePath

  Filepath to the package environment file (if overriding default)

• pkgDatabase :: Maybe [(FilePath, [PackageConfig])]
• pkgState :: PackageState
• filesToClean :: IORef FilesToClean
• dirsToClean :: IORef (Map FilePath FilePath)
• nextTempSuffix :: IORef Int
• generatedDumps :: IORef (Set FilePath)
• dumpFlags :: EnumSet DumpFlag
• generalFlags :: EnumSet GeneralFlag
• warningFlags :: EnumSet WarningFlag
• fatalWarningFlags :: EnumSet WarningFlag
• language :: Maybe Language
• safeHaskell :: SafeHaskellMode

  Safe Haskell mode

• safeInfer :: Bool
• safeInferred :: Bool
• thOnLoc :: SrcSpan
• newDerivOnLoc :: SrcSpan
• overlapInstLoc :: SrcSpan
• incoherentOnLoc :: SrcSpan
• pkgTrustOnLoc :: SrcSpan
• warnSafeOnLoc :: SrcSpan
• warnUnsafeOnLoc :: SrcSpan
• trustworthyOnLoc :: SrcSpan
• extensions :: [OnOff Extension]
• extensionFlags :: EnumSet Extension
• ufCreationThreshold :: Int
• ufUseThreshold :: Int
• ufFunAppDiscount :: Int
• ufDictDiscount :: Int
• ufKeenessFactor :: Float
• ufDearOp :: Int
• ufVeryAggressive :: Bool
• maxWorkerArgs :: Int
• ghciHistSize :: Int
• log_action :: LogAction

  MsgDoc output action: use ErrUtils instead of this if you can

• flushOut :: FlushOut
• flushErr :: FlushErr
• ghcVersionFile :: Maybe FilePath
• haddockOptions :: Maybe String
• ghciScripts :: [String]

  GHCi scripts specified by -ghci-script, in reverse order

• pprUserLength :: Int
• pprCols :: Int
• useUnicode :: Bool
• useColor :: OverridingBool
• canUseColor :: Bool
• colScheme :: Scheme
• profAuto :: ProfAuto

  what kind of {--} to add automatically

• interactivePrint :: Maybe String
• nextWrapperNum :: IORef (ModuleEnv Int)
• sseVersion :: Maybe SseVersion

  Machine dependent flags (-mblah stuff)

• bmiVersion :: Maybe BmiVersion
• avx :: Bool
• avx2 :: Bool
• avx512cd :: Bool
• avx512er :: Bool
• avx512f :: Bool
• avx512pf :: Bool
• rtldInfo :: IORef (Maybe LinkerInfo)

  Run-time linker information (what options we need, etc.)

• rtccInfo :: IORef (Maybe CompilerInfo)

  Run-time compiler information

• maxInlineAllocSize :: Int

  Max size, in bytes, of inline array allocations.

• maxInlineMemcpyInsns :: Int

  Only inline memcpy if it generates no more than this many pseudo (roughly: Cmm) instructions.

• maxInlineMemsetInsns :: Int

  Only inline memset if it generates no more than this many pseudo (roughly: Cmm) instructions.

• reverseErrors :: Bool

  Reverse the order of error messages in GHC/GHCi

• maxErrors :: Maybe Int

  Limit the maximum number of errors to show

• initialUnique :: Int

  Unique supply configuration for testing build determinism

• uniqueIncrement :: Int
• cfgWeightInfo :: CfgWeights

  Temporary: CFG Edge weights for fast iterations

data DumpFlag

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_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_asm_expanded

Opt_D_dump_llvm

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_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_stg

Opt_D_dump_stg_unarised

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_tc

Opt_D_dump_tc_ast

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_vt_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

Instances

Enum DumpFlag

Defined in DynFlags

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]

Eq DumpFlag

Defined in DynFlags

Methods

(==) :: DumpFlag -> DumpFlag -> Bool

(/=) :: DumpFlag -> DumpFlag -> Bool

Show DumpFlag

Defined in DynFlags

Methods

showsPrec :: Int -> DumpFlag -> ShowS

show :: DumpFlag -> String

showList :: [DumpFlag] -> ShowS

data GeneralFlag

Enumerates the simple on-or-off dynamic flags

Constructors

Opt_DumpToFile

Append dump output to files instead of stdout.

Opt_D_faststring_stats

Opt_D_dump_minimal_imports

Opt_DoCoreLinting

Opt_DoStgLinting

Opt_DoCmmLinting

Opt_DoAsmLinting

Opt_DoAnnotationLinting

Opt_NoLlvmMangler

Opt_FastLlvm

Opt_NoTypeableBinds

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_PrintTypecheckerElaboration

Opt_CallArity

Opt_Exitification

Opt_Strictness

Opt_LateDmdAnal

Opt_KillAbsence

Opt_KillOneShot

Opt_FullLaziness

Opt_FloatIn

Opt_LateSpecialise

Opt_Specialise

Opt_SpecialiseAggressively

Opt_CrossModuleSpecialise

Opt_StaticArgumentTransformation

Opt_CSE

Opt_StgCSE

Opt_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_CmmElimCommonBlocks

Opt_AsmShortcutting

Opt_OmitYields

Opt_FunToThunk

Opt_DictsStrict

Opt_DmdTxDictSel

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_SolveConstantDicts

Opt_AlignmentSanitisation

Opt_CatchBottoms

Opt_NumConstantFolding

Opt_SimplPreInlining

Opt_IgnoreInterfacePragmas

Opt_OmitInterfacePragmas

Opt_ExposeAllUnfoldings

Opt_WriteInterface

Opt_WriteHie

Opt_AutoSccsOnIndividualCafs

Opt_ProfCountEntries

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_SccProfilingOn

Opt_Ticky

Opt_Ticky_Allocd

Opt_Ticky_LNE

Opt_Ticky_Dyn_Thunk

Opt_RPath

Opt_RelativeDynlibPaths

Opt_Hpc

Opt_FlatCache

Opt_ExternalInterpreter

Opt_OptimalApplicativeDo

Opt_VersionMacros

Opt_WholeArchiveHsLibs

Opt_SingleLibFolder

Opt_KeepCAFs

Opt_KeepGoing

Opt_ByteCode

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_SuppressVarKinds

Opt_SuppressModulePrefixes

Opt_SuppressTypeApplications

Opt_SuppressIdInfo

Opt_SuppressUnfoldings

Opt_SuppressTypeSignatures

Opt_SuppressUniques

Opt_SuppressStgExts

Opt_SuppressTicks

Opt_SuppressTimestamps

Suppress timestamps in dumps

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_DistrustAllPackages

Opt_PackageTrust

Opt_PluginTrustworthy

Opt_G_NoStateHack

Opt_G_NoOptCoercion

Instances

Enum GeneralFlag

Defined in DynFlags

Methods

succ :: GeneralFlag -> GeneralFlag

pred :: GeneralFlag -> GeneralFlag

toEnum :: Int -> GeneralFlag

fromEnum :: GeneralFlag -> Int

enumFrom :: GeneralFlag -> [GeneralFlag]

enumFromThen :: GeneralFlag -> GeneralFlag -> [GeneralFlag]

enumFromTo :: GeneralFlag -> GeneralFlag -> [GeneralFlag]

enumFromThenTo :: GeneralFlag -> GeneralFlag -> GeneralFlag -> [GeneralFlag]

Eq GeneralFlag

Defined in DynFlags

Methods

(==) :: GeneralFlag -> GeneralFlag -> Bool

(/=) :: GeneralFlag -> GeneralFlag -> Bool

Show GeneralFlag

Defined in DynFlags

Methods

showsPrec :: Int -> GeneralFlag -> ShowS

show :: GeneralFlag -> String

showList :: [GeneralFlag] -> ShowS

gfinally :: ExceptionMonad m => m a -> m b -> m a

Generalised version of finally, allowing an arbitrary exception handling monad instead of just IO.

gcatch :: (ExceptionMonad m, Exception e) => m a -> (e -> m a) -> m a

Generalised version of catch, allowing an arbitrary exception handling monad instead of just IO.

gbracket :: ExceptionMonad m => m a -> (a -> m b) -> (a -> m c) -> m c

Generalised version of bracket, allowing an arbitrary exception handling monad instead of just IO.

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_tmpDir :: String
• fileSettings_systemPackageConfig :: FilePath

data GhcNameVersion

Settings for what GHC this is.

Constructors

GhcNameVersion

Fields

• ghcNameVersion_programName :: String
• ghcNameVersion_projectVersion :: String

type ForeignHValue = ForeignRef HValue

data HValue

Instances

Show HValue

Defined in GHCi.RemoteTypes

Methods

showsPrec :: Int -> HValue -> ShowS

show :: HValue -> String

showList :: [HValue] -> ShowS

data IntegerLibrary

Constructors

IntegerGMP

IntegerSimple

Instances

Eq IntegerLibrary

Defined in GHC.Platform

Methods

(==) :: IntegerLibrary -> IntegerLibrary -> Bool

(/=) :: IntegerLibrary -> IntegerLibrary -> Bool

Read IntegerLibrary

Defined in GHC.Platform

Methods

readsPrec :: Int -> ReadS IntegerLibrary

readList :: ReadS [IntegerLibrary]

readPrec :: ReadPrec IntegerLibrary

readListPrec :: ReadPrec [IntegerLibrary]

Show IntegerLibrary

Defined in GHC.Platform

Methods

showsPrec :: Int -> IntegerLibrary -> ShowS

show :: IntegerLibrary -> String

showList :: [IntegerLibrary] -> ShowS

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_integerLibrary :: String
• platformMisc_integerLibraryType :: IntegerLibrary
• platformMisc_ghcWithInterpreter :: Bool
• platformMisc_ghcWithNativeCodeGen :: Bool
• platformMisc_ghcWithSMP :: Bool
• platformMisc_ghcRTSWays :: String
• platformMisc_tablesNextToCode :: Bool

  Determines whether we will be compiling info tables that reside just before the entry code, or with an indirection to the entry code. See TABLES_NEXT_TO_CODE in includesrtsstorage/InfoTables.h.

• platformMisc_leadingUnderscore :: Bool
• platformMisc_libFFI :: Bool
• platformMisc_ghcThreaded :: Bool
• platformMisc_ghcDebugged :: Bool
• platformMisc_ghcRtsWithLibdw :: Bool
• platformMisc_llvmTarget :: String

data ForeignSrcLang

Foreign formats supported by GHC via TH

Constructors

LangC

C

LangCxx

C++

LangObjc

Objective C

LangObjcxx

Objective C++

LangAsm

Assembly language (.s)

RawObject

Object (.o)

Instances

Eq ForeignSrcLang

Defined in GHC.ForeignSrcLang.Type

Methods

(==) :: ForeignSrcLang -> ForeignSrcLang -> Bool

(/=) :: ForeignSrcLang -> ForeignSrcLang -> Bool

Show ForeignSrcLang

Defined in GHC.ForeignSrcLang.Type

Methods

showsPrec :: Int -> ForeignSrcLang -> ShowS

show :: ForeignSrcLang -> String

showList :: [ForeignSrcLang] -> ShowS

Generic ForeignSrcLang

Defined in GHC.ForeignSrcLang.Type

Associated Types

type Rep ForeignSrcLang :: Type -> Type

Methods

from :: ForeignSrcLang -> Rep ForeignSrcLang x

to :: Rep ForeignSrcLang x -> ForeignSrcLang

type Rep ForeignSrcLang

Defined in GHC.ForeignSrcLang.Type

type Rep ForeignSrcLang = D1 ('MetaData "ForeignSrcLang" "GHC.ForeignSrcLang.Type" "ghc-boot-th-8.10.1" '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 "RawObject" 'PrefixI 'False) (U1 :: Type -> Type))))

coreModule :: DesugaredMod m => m -> ModGuts

tyConRealArity :: TyCon -> Int

NOTE:tyConRealArity

The semantics of tyConArity changed between GHC 8.6.5 and GHC 8.10, mostly due to the Visible Dependent Quantification (VDQ). As a result, given the following:

data family EntityField record :: * -> *

Calling tyConArity on this would yield 2 for 8.6.5 but 1 an 8.10, so we try to backport the old behaviour in 8.10 by "looking" at the Kind of the input TyCon and trying to recursively split the type apart with either splitFunTy_maybe or splitForAllTy_maybe.

NOTE:isEvVarType

For GHC < 8.10.1 isPredTy is effectively the same as the new isEvVarType, which covers the cases for coercion types and "normal" type coercions. The 8.6.5 version of isPredTy had a special case to handle a TyConApp in the case of type equality (i.e. ~ ) which was removed in the implementation for 8.10.1, which essentially calls tcIsConstraintKind straight away.

dataConExTyVars :: DataCon -> [TyVar]