ghcide-0.4.0: The core of an IDE

Safe HaskellNone
LanguageHaskell2010

Development.IDE.GHC.Compat

Description

Attempt at hiding the GHC version differences we can.

Synopsis

Documentation

data HieFile Source #

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

  • a simplified AST

    • nodes are annotated with source positions and types
    • identifiers are annotated with scope information
  • the raw bytes of the initial Haskell source

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

Constructors

HieFile 

Fields

Instances
Show HieFile Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

NFData HieFile Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Methods

rnf :: HieFile -> () #

Binary HieFile Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

newtype NameCacheUpdater #

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

Constructors

NCU 

Fields

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

Construct an HieFile from the outputs of the typechecker.

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

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

addBootSuffixLocnOut :: ModLocation -> ModLocation Source #

Add the -boot suffix to all output file paths associated with the module, not including the input file itself

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

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

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

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

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

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

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

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

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

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

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

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

pattern ValBinds :: LHsBinds p -> [LSig p] -> HsValBindsLR p p Source #

data ModLocation #

Module Location

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

Instances
Show ModLocation 
Instance details

Defined in Module

Outputable ModLocation 
Instance details

Defined in Module

addBootSuffix :: FilePath -> FilePath #

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

class HasSrcSpan a Source #

Minimal complete definition

getLoc

Instances
HasSrcSpan Name Source # 
Instance details

Defined in Development.IDE.GHC.Compat

Methods

getLoc :: Name -> SrcSpan Source #

HasSrcSpan (GenLocated SrcSpan a) Source # 
Instance details

Defined in Development.IDE.GHC.Compat

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.

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

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.

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.

modInfoSafe :: ModuleInfo -> SafeHaskellMode #

Retrieve module safe haskell mode

modInfoInstances :: ModuleInfo -> [ClsInst] #

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

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

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.

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 #

data ParsedModule #

The result of successful parsing.

data DesugaredModule #

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

data CoreModule #

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

Constructors

CoreModule 

Fields

Instances
Show CoreModule Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

NFData CoreModule Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Methods

rnf :: CoreModule -> () #

Outputable CoreModule 
Instance details

Defined in GHC

data ModuleInfo #

Container for information about a Module.

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.

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

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

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

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

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

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

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

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

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

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

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

isDecl :: DynFlags -> String -> Bool #

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

isImport :: DynFlags -> String -> Bool #

Returns True if passed string is an import declaration.

hasImport :: DynFlags -> String -> Bool #

Returns True if passed string has an import declaration.

isStmt :: DynFlags -> String -> Bool #

Returns True if passed string is a statement.

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

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

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

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

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

Returns all names in scope in the current interactive context

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

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

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

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

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

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

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

Set the interactive evaluation context.

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

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

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

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

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

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

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

execStmt #

Arguments

:: GhcMonad m 
=> String

a statement (bind or expression)

-> ExecOptions 
-> m ExecResult 

Run a statement in the current interactive context.

execOptions :: ExecOptions #

default ExecOptions

data GetDocsFailure #

Failure modes for getDocs.

Constructors

NameHasNoModule Name

nameModule_maybe returned Nothing.

NoDocsInIface Module Bool

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

InteractiveName

The Name was defined interactively.

Instances
Outputable GetDocsFailure 
Instance details

Defined in InteractiveEval

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.

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

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

getSessionDynFlags :: GhcMonad m => m DynFlags #

Grabs the DynFlags from the Session

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

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

In short, a GHC monad

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

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

Methods

getSession :: m HscEnv #

setSession :: HscEnv -> m () #

Instances
GhcMonad Ghc 
Instance details

Defined in GhcMonad

ExceptionMonad m => GhcMonad (GhcT m) 
Instance details

Defined in GhcMonad

Methods

getSession :: GhcT m HscEnv #

setSession :: HscEnv -> GhcT m () #

data Ghc a #

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

Instances
Monad Ghc 
Instance details

Defined in GhcMonad

Methods

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

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

return :: a -> Ghc a #

fail :: String -> Ghc a #

Functor Ghc 
Instance details

Defined in GhcMonad

Methods

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

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

MonadFix Ghc 
Instance details

Defined in GhcMonad

Methods

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

Applicative Ghc 
Instance details

Defined in GhcMonad

Methods

pure :: a -> Ghc a #

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

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

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

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

MonadIO Ghc 
Instance details

Defined in GhcMonad

Methods

liftIO :: IO a -> Ghc a #

GhcMonad Ghc 
Instance details

Defined in GhcMonad

HasDynFlags Ghc 
Instance details

Defined in GhcMonad

ExceptionMonad Ghc 
Instance details

Defined in GhcMonad

Methods

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

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

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

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

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

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

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

Instances
Monad m => Monad (GhcT m) 
Instance details

Defined in GhcMonad

Methods

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

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

return :: a -> GhcT m a #

fail :: String -> GhcT m a #

Functor m => Functor (GhcT m) 
Instance details

Defined in GhcMonad

Methods

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

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

Applicative m => Applicative (GhcT m) 
Instance details

Defined in GhcMonad

Methods

pure :: a -> GhcT m a #

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

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

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

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

MonadIO m => MonadIO (GhcT m) 
Instance details

Defined in GhcMonad

Methods

liftIO :: IO a -> GhcT m a #

ExceptionMonad m => GhcMonad (GhcT m) 
Instance details

Defined in GhcMonad

Methods

getSession :: GhcT m HscEnv #

setSession :: HscEnv -> GhcT m () #

MonadIO m => HasDynFlags (GhcT m) 
Instance details

Defined in GhcMonad

ExceptionMonad m => ExceptionMonad (GhcT m) 
Instance details

Defined in GhcMonad

Methods

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

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

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

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

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

A function called to log warnings and errors.

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

Look up a ModSummary in the ModuleGraph

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

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

needsTemplateHaskellOrQQ :: ModuleGraph -> Bool #

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

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

handleSourceError #

Arguments

:: ExceptionMonad m 
=> (SourceError -> m a)

exception handler

-> m a

action to perform

-> m a 

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

data HscEnv #

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

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

data Target #

A compilation target.

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

Constructors

Target 

Fields

Instances
Outputable Target 
Instance details

Defined in HscTypes

Methods

ppr :: Target -> SDoc #

pprPrec :: Rational -> Target -> SDoc #

data TargetId #

Constructors

TargetModule ModuleName

A module name: search for the file

TargetFile FilePath (Maybe Phase)

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

Instances
Eq TargetId 
Instance details

Defined in HscTypes

Outputable TargetId 
Instance details

Defined in HscTypes

data ModIface #

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

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

Constructors

ModIface 

Fields

Instances
Binary ModIface 
Instance details

Defined in HscTypes

data InteractiveImport #

Constructors

IIDecl (ImportDecl GhcPs)

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

IIModule ModuleName

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

Instances
Outputable InteractiveImport 
Instance details

Defined in HscTypes

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

Instances
Show ModSummary Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

NFData ModSummary Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Methods

rnf :: ModSummary -> () #

Outputable ModSummary 
Instance details

Defined in HscTypes

data HsModule pass #

Haskell Module

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

Constructors

HsModule

AnnKeywordIds

Fields

Instances
Data (HsModule GhcPs) 
Instance details

Defined in HsSyn

Methods

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

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

toConstr :: HsModule GhcPs -> Constr #

dataTypeOf :: HsModule GhcPs -> DataType #

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

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

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

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

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

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

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

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

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

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

Data (HsModule GhcRn) 
Instance details

Defined in HsSyn

Methods

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

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

toConstr :: HsModule GhcRn -> Constr #

dataTypeOf :: HsModule GhcRn -> DataType #

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

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

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

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

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

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

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

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

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

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

Data (HsModule GhcTc) 
Instance details

Defined in HsSyn

Methods

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

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

toConstr :: HsModule GhcTc -> Constr #

dataTypeOf :: HsModule GhcTc -> DataType #

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

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

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

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

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

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

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

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

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

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

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsModule p) 
Instance details

Defined in HsSyn

Methods

ppr :: HsModule p -> SDoc #

pprPrec :: Rational -> HsModule p -> SDoc #

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

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

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

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

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

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

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

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

collectHsBindBinders :: HsBindLR idL idR -> [IdP 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.

mkPrefixFunRhs :: Located id -> HsMatchContext id #

Make a prefix, non-strict function HsMatchContext

isInfixFunBind :: HsBindLR id1 id2 -> Bool #

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

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.

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

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

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

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

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

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

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

mkLastStmt :: Located (bodyR (GhcPass idR)) -> StmtLR (GhcPass idL) (GhcPass idR) (Located (bodyR (GhcPass idR))) #

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

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

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

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

mkHsCaseAlt :: LPat (GhcPass p) -> Located (body (GhcPass p)) -> LMatch (GhcPass p) (Located (body (GhcPass p))) #

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

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

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

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

isMonadFailStmtContext :: HsStmtContext id -> Bool #

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

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

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

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

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

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

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

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

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

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

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

isSingletonMatchGroup :: [LMatch id body] -> Bool #

Is there only one RHS in this list of matches?

isInfixMatch :: Match id body -> Bool #

parenthesizeHsExpr :: PprPrec -> LHsExpr (GhcPass p) -> LHsExpr (GhcPass p) #

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

hsExprNeedsParens :: PprPrec -> HsExpr p -> Bool #

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

mkRnSyntaxExpr :: Name -> SyntaxExpr GhcRn #

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

noExpr :: HsExpr (GhcPass p) #

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

type PostTcExpr = HsExpr GhcTc #

Post-Type checking Expression

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

type PostTcTable = [(Name, PostTcExpr)] #

Post-Type checking Table

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

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

Command Syntax Table (for Arrow syntax)

data UnboundVar #

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

Constructors

OutOfScope OccName GlobalRdrEnv

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

TrueExprHole OccName

A "true" expression hole (_ or _x)

Instances
Data UnboundVar 
Instance details

Defined in HsExpr

Methods

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

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

toConstr :: UnboundVar -> Constr #

dataTypeOf :: UnboundVar -> DataType #

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

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

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

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

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

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

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

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

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

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

Outputable UnboundVar 
Instance details

Defined in HsExpr

data RecordConTc #

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

data RecordUpdTc #

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

Instances
Data RecordUpdTc 
Instance details

Defined in HsExpr

Methods

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

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

toConstr :: RecordUpdTc -> Constr #

dataTypeOf :: RecordUpdTc -> DataType #

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

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

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

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

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

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

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

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

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

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

type LHsTupArg id = Located (HsTupArg id) #

Located Haskell Tuple Argument

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

data HsTupArg id #

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

Instances
Data HsArrAppType 
Instance details

Defined in HsExpr

Methods

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

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

toConstr :: HsArrAppType -> Constr #

dataTypeOf :: HsArrAppType -> DataType #

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

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

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

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

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

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

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

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

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

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

type LHsCmdTop p = Located (HsCmdTop p) #

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

Located Haskell Top-level Command

data HsCmdTop p #

Haskell Top-level Command

Constructors

HsCmdTop (XCmdTop p) (LHsCmd p) 
XCmdTop (XXCmdTop p) 
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsCmdTop p) 
Instance details

Defined in HsExpr

Methods

ppr :: HsCmdTop p -> SDoc #

pprPrec :: Rational -> HsCmdTop p -> SDoc #

type HsRecordBinds p = HsRecFields p (LHsExpr p) #

Haskell Record Bindings

data MatchGroupTc #

Constructors

MatchGroupTc 

Fields

Instances
Data MatchGroupTc 
Instance details

Defined in HsExpr

Methods

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

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

toConstr :: MatchGroupTc -> Constr #

dataTypeOf :: MatchGroupTc -> DataType #

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

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

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

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

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

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

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

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

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

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

type LMatch id body = Located (Match id body) #

Located Match

May have AnnKeywordId : AnnSemi when in a list

data Match p body #

Constructors

Match 

Fields

XMatch (XXMatch p body) 
Instances
(idR ~ GhcPass pr, OutputableBndrId idR, Outputable body) => Outputable (Match idR body) 
Instance details

Defined in HsExpr

Methods

ppr :: Match idR body -> SDoc #

pprPrec :: Rational -> Match idR body -> SDoc #

type LGRHS id body = Located (GRHS id body) #

Located Guarded Right-Hand Side

data GRHS p body #

Guarded Right Hand Side.

Constructors

GRHS (XCGRHS p body) [GuardLStmt p] body 
XGRHS (XXGRHS p body) 

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

Located do block Statement

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

Located Statement with separate Left and Right id's

type Stmt id body = StmtLR id id body #

do block Statement

type CmdLStmt id = LStmt id (LHsCmd id) #

Command Located Statement

type CmdStmt id = Stmt id (LHsCmd id) #

Command Statement

type ExprLStmt id = LStmt id (LHsExpr id) #

Expression Located Statement

type ExprStmt id = Stmt id (LHsExpr id) #

Expression Statement

type GuardLStmt id = LStmt id (LHsExpr id) #

Guard Located Statement

type GuardStmt id = Stmt id (LHsExpr id) #

Guard Statement

type GhciLStmt id = LStmt id (LHsExpr id) #

Ghci Located Statement

type GhciStmt id = Stmt id (LHsExpr id) #

Ghci Statement

data StmtLR idL idR body #

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

Constructors

LastStmt (XLastStmt idL idR body) body Bool (SyntaxExpr idR) 
BindStmt (XBindStmt idL idR body) (LPat idL) body (SyntaxExpr idR) (SyntaxExpr idR) 
ApplicativeStmt (XApplicativeStmt idL idR body) [(SyntaxExpr idR, ApplicativeArg idL)] (Maybe (SyntaxExpr idR))

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

For full details, see Note [ApplicativeDo] in RnExpr

BodyStmt (XBodyStmt idL idR body) body (SyntaxExpr idR) (SyntaxExpr idR) 
LetStmt (XLetStmt idL idR body) (LHsLocalBindsLR idL idR)
ParStmt (XParStmt idL idR body) [ParStmtBlock idL idR] (HsExpr idR) (SyntaxExpr idR) 
TransStmt 

Fields

RecStmt

Fields

XStmtLR (XXStmtLR idL idR body) 
Instances
(idL ~ GhcPass pl, idR ~ GhcPass pr, OutputableBndrId idL, OutputableBndrId idR, Outputable body) => Outputable (StmtLR idL idR body) 
Instance details

Defined in HsExpr

Methods

ppr :: StmtLR idL idR body -> SDoc #

pprPrec :: Rational -> StmtLR idL idR body -> SDoc #

data TransForm #

Constructors

ThenForm 
GroupForm 
Instances
Data TransForm 
Instance details

Defined in HsExpr

Methods

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

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

toConstr :: TransForm -> Constr #

dataTypeOf :: TransForm -> DataType #

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

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

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

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

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

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

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

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

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

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

data ParStmtBlock idL idR #

Parenthesised Statement Block

Constructors

ParStmtBlock (XParStmtBlock idL idR) [ExprLStmt idL] [IdP idR] (SyntaxExpr idR) 
XParStmtBlock (XXParStmtBlock idL idR) 
Instances
(Outputable (StmtLR idL idL (LHsExpr idL)), Outputable (XXParStmtBlock idL idR)) => Outputable (ParStmtBlock idL idR) 
Instance details

Defined in HsExpr

Methods

ppr :: ParStmtBlock idL idR -> SDoc #

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

data ApplicativeArg idL #

Applicative Argument

data SpliceDecoration #

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

Constructors

HasParens

$( splice ) or $$( splice )

HasDollar

$splice or $$splice

NoParens

bare splice

Instances
Eq SpliceDecoration 
Instance details

Defined in HsExpr

Data SpliceDecoration 
Instance details

Defined in HsExpr

Methods

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

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

toConstr :: SpliceDecoration -> Constr #

dataTypeOf :: SpliceDecoration -> DataType #

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

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

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

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

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

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

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

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

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

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

Show SpliceDecoration 
Instance details

Defined in HsExpr

Outputable SpliceDecoration 
Instance details

Defined in HsExpr

newtype ThModFinalizers #

Finalizers produced by a splice with addModFinalizer

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

Constructors

ThModFinalizers [ForeignRef (Q ())] 
Instances
Data ThModFinalizers 
Instance details

Defined in HsExpr

Methods

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

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

toConstr :: ThModFinalizers -> Constr #

dataTypeOf :: ThModFinalizers -> DataType #

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

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

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

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

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

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

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

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

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

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

data HsSplicedThing id #

Haskell Spliced Thing

Values that can result from running a splice.

Constructors

HsSplicedExpr (HsExpr id)

Haskell Spliced Expression

HsSplicedTy (HsType id)

Haskell Spliced Type

HsSplicedPat (Pat id)

Haskell Spliced Pattern

Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsSplicedThing p) 
Instance details

Defined in HsExpr

data PendingRnSplice #

Pending Renamer Splice

Instances
Outputable PendingRnSplice 
Instance details

Defined in HsExpr

data UntypedSpliceFlavour #

Instances
Data UntypedSpliceFlavour 
Instance details

Defined in HsExpr

Methods

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

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

toConstr :: UntypedSpliceFlavour -> Constr #

dataTypeOf :: UntypedSpliceFlavour -> DataType #

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

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

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

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

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

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

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

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

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

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

data PendingTcSplice #

Pending Type-checker Splice

Instances
Outputable PendingTcSplice 
Instance details

Defined in HsExpr

data HsBracket p #

Haskell Bracket

Constructors

ExpBr (XExpBr p) (LHsExpr p) 
PatBr (XPatBr p) (LPat p) 
DecBrL (XDecBrL p) [LHsDecl p] 
DecBrG (XDecBrG p) (HsGroup p) 
TypBr (XTypBr p) (LHsType p) 
VarBr (XVarBr p) Bool (IdP p) 
TExpBr (XTExpBr p) (LHsExpr p) 
XBracket (XXBracket p) 
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsBracket p) 
Instance details

Defined in HsExpr

Methods

ppr :: HsBracket p -> SDoc #

pprPrec :: Rational -> HsBracket p -> SDoc #

data ArithSeqInfo id #

Arithmetic Sequence Information

Constructors

From (LHsExpr id) 
FromThen (LHsExpr id) (LHsExpr id) 
FromTo (LHsExpr id) (LHsExpr id) 
FromThenTo (LHsExpr id) (LHsExpr id) (LHsExpr id) 
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (ArithSeqInfo p) 
Instance details

Defined in HsExpr

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

LambdaExpr

Patterns of a lambda

CaseAlt

Patterns and guards on a case alternative

IfAlt

Guards of a multi-way if alternative

ProcExpr

Patterns of a proc

PatBindRhs

A pattern binding eg [y] <- e = e

PatBindGuards

Guards of pattern bindings, e.g., (Just b) | Just _ <- x = e | otherwise = e'

RecUpd

Record update [used only in DsExpr to tell matchWrapper what sort of runtime error message to generate]

StmtCtxt (HsStmtContext id)

Pattern of a do-stmt, list comprehension, pattern guard, etc

ThPatSplice

A Template Haskell pattern splice

ThPatQuote

A Template Haskell pattern quotation [p| (a,b) |]

PatSyn

A pattern synonym declaration

Instances
Functor HsMatchContext 
Instance details

Defined in HsExpr

Methods

fmap :: (a -> b) -> HsMatchContext a -> HsMatchContext b #

(<$) :: a -> HsMatchContext b -> HsMatchContext a #

Data id => Data (HsMatchContext id) 
Instance details

Defined in HsExpr

Methods

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

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

toConstr :: HsMatchContext id -> Constr #

dataTypeOf :: HsMatchContext id -> DataType #

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

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

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

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

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

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

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

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

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

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

OutputableBndr id => Outputable (HsMatchContext id) 
Instance details

Defined in HsExpr

data HsStmtContext id #

Haskell Statement Context. It expects to be parameterised with one of RdrName, Name or Id

Constructors

ListComp 
MonadComp 
DoExpr

do { ... }

MDoExpr

mdo { ... } ie recursive do-expression

ArrowExpr

do-notation in an arrow-command context

GhciStmtCtxt

A command-line Stmt in GHCi pat <- rhs

PatGuard (HsMatchContext id)

Pattern guard for specified thing

ParStmtCtxt (HsStmtContext id)

A branch of a parallel stmt

TransStmtCtxt (HsStmtContext id)

A branch of a transform stmt

Instances
Functor HsStmtContext 
Instance details

Defined in HsExpr

Methods

fmap :: (a -> b) -> HsStmtContext a -> HsStmtContext b #

(<$) :: a -> HsStmtContext b -> HsStmtContext a #

Data id => Data (HsStmtContext id) 
Instance details

Defined in HsExpr

Methods

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

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

toConstr :: HsStmtContext id -> Constr #

dataTypeOf :: HsStmtContext id -> DataType #

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

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

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

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

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

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

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

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

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

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

(Outputable p, Outputable (NameOrRdrName p)) => Outputable (HsStmtContext p) 
Instance details

Defined in HsExpr

derivStrategyName :: DerivStrategy a -> SDoc #

A short description of a DerivStrategy'.

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

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

Maybe return name of the result type variable

famDeclHasCusk #

Arguments

:: Maybe Bool

if associated, does the enclosing class have a CUSK?

-> FamilyDecl pass 
-> Bool 

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

hsDeclHasCusk :: TyClDecl GhcRn -> Bool #

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

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

tcdName :: TyClDecl pass -> IdP pass #

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

isDataFamilyDecl :: TyClDecl pass -> Bool #

data family declaration

isClosedTypeFamilyInfo :: FamilyInfo pass -> Bool #

closed type family info

isOpenTypeFamilyInfo :: FamilyInfo pass -> Bool #

open type family info

isTypeFamilyDecl :: TyClDecl pass -> Bool #

type family declaration

isFamilyDecl :: TyClDecl pass -> Bool #

type/data family declaration

isClassDecl :: TyClDecl pass -> Bool #

type class

isSynDecl :: TyClDecl pass -> Bool #

type or type instance declaration

isDataDecl :: TyClDecl pass -> Bool #

True = argument is a data/newtype declaration.

type LHsDecl p #

Arguments

 = Located (HsDecl p)

When in a list this may have

data HsDecl p #

A Haskell Declaration

Constructors

DefD (XDefD p) (DefaultDecl p)

'default' declaration

WarningD (XWarningD p) (WarnDecls p)

Warning declaration

AnnD (XAnnD p) (AnnDecl p)

Annotation declaration

RuleD (XRuleD p) (RuleDecls p)

Rule declaration

SpliceD (XSpliceD p) (SpliceDecl p)

Splice declaration (Includes quasi-quotes)

DocD (XDocD p) DocDecl

Documentation comment declaration

RoleAnnotD (XRoleAnnotD p) (RoleAnnotDecl p)

Role annotation declaration

XHsDecl (XXHsDecl p) 
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsDecl p) 
Instance details

Defined in HsDecls

Methods

ppr :: HsDecl p -> SDoc #

pprPrec :: Rational -> HsDecl p -> SDoc #

data HsGroup p #

Haskell Group

A HsDecl is categorised into a HsGroup before being fed to the renamer.

Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsGroup p) 
Instance details

Defined in HsDecls

Methods

ppr :: HsGroup p -> SDoc #

pprPrec :: Rational -> HsGroup p -> SDoc #

type LSpliceDecl pass = Located (SpliceDecl pass) #

Located Splice Declaration

data SpliceDecl p #

Splice Declaration

Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (SpliceDecl p) 
Instance details

Defined in HsDecls

Methods

ppr :: SpliceDecl p -> SDoc #

pprPrec :: Rational -> SpliceDecl p -> SDoc #

type LTyClDecl pass = Located (TyClDecl pass) #

Located Declaration of a Type or Class

data TyClDecl pass #

A type or class declaration.

Constructors

FamDecl
type/data family T :: *->*

Fields

SynDecl

type declaration

Fields

DataDecl

data declaration

Fields

ClassDecl

Fields

XTyClDecl (XXTyClDecl pass) 
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (TyClDecl p) 
Instance details

Defined in HsDecls

Methods

ppr :: TyClDecl p -> SDoc #

pprPrec :: Rational -> TyClDecl p -> SDoc #

data DataDeclRn #

Constructors

DataDeclRn 

Fields

Instances
Data DataDeclRn 
Instance details

Defined in HsDecls

Methods

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

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

toConstr :: DataDeclRn -> Constr #

dataTypeOf :: DataDeclRn -> DataType #

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

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

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

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

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

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

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

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

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

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

data TyClGroup pass #

Type or Class Group

Constructors

TyClGroup 
XTyClGroup (XXTyClGroup pass) 
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (TyClGroup p) 
Instance details

Defined in HsDecls

Methods

ppr :: TyClGroup p -> SDoc #

pprPrec :: Rational -> TyClGroup p -> SDoc #

type LFamilyResultSig pass = Located (FamilyResultSig pass) #

Located type Family Result Signature

type LFamilyDecl pass = Located (FamilyDecl pass) #

Located type Family Declaration

data FamilyDecl pass #

type Family Declaration

Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (FamilyDecl p) 
Instance details

Defined in HsDecls

Methods

ppr :: FamilyDecl p -> SDoc #

pprPrec :: Rational -> FamilyDecl p -> SDoc #

type LInjectivityAnn pass = Located (InjectivityAnn pass) #

Located Injectivity Annotation

data InjectivityAnn pass #

If the user supplied an injectivity annotation it is represented using InjectivityAnn. At the moment this is a single injectivity condition - see Note [Injectivity annotation]. `Located name` stores the LHS of injectivity condition. `[Located name]` stores the RHS of injectivity condition. Example:

type family Foo a b c = r | r -> a c where ...

This will be represented as "InjectivityAnn r [a, c]"

data FamilyInfo pass #

Constructors

DataFamily 
OpenTypeFamily 
ClosedTypeFamily (Maybe [LTyFamInstEqn pass])

Nothing if we're in an hs-boot file and the user said "type family Foo x where .."

Instances
Outputable (FamilyInfo pass) 
Instance details

Defined in HsDecls

Methods

ppr :: FamilyInfo pass -> SDoc #

pprPrec :: Rational -> FamilyInfo pass -> SDoc #

data HsDataDefn pass #

Haskell Data type Definition

Constructors

HsDataDefn

Declares a data type or newtype, giving its constructors data/newtype T a = constrs data/newtype instance T [a] = constrs

Fields

XHsDataDefn (XXHsDataDefn pass) 
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsDataDefn p) 
Instance details

Defined in HsDecls

Methods

ppr :: HsDataDefn p -> SDoc #

pprPrec :: Rational -> HsDataDefn p -> SDoc #

type HsDeriving pass #

Arguments

 = Located [LHsDerivingClause pass]

The optional deriving clauses of a data declaration. Clauses is plural because one can specify multiple deriving clauses using the -XDerivingStrategies language extension.

The list of LHsDerivingClauses corresponds to exactly what the user requested to derive, in order. If no deriving clauses were specified, the list is empty.

Haskell Deriving clause

data HsDerivingClause pass #

A single deriving clause of a data declaration.

Constructors

HsDerivingClause 

Fields

XHsDerivingClause (XXHsDerivingClause pass) 
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsDerivingClause p) 
Instance details

Defined in HsDecls

data NewOrData #

Constructors

NewType
newtype Blah ...
DataType
data Blah ...
Instances
Eq NewOrData 
Instance details

Defined in HsDecls

Data NewOrData 
Instance details

Defined in HsDecls

Methods

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

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

toConstr :: NewOrData -> Constr #

dataTypeOf :: NewOrData -> DataType #

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

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

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

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

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

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

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

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

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

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

Outputable NewOrData 
Instance details

Defined in HsDecls

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

data Constructor Declaration

Constructors

ConDeclGADT 

Fields

ConDeclH98 

Fields

XConDecl (XXConDecl pass) 
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (ConDecl p) 
Instance details

Defined in HsDecls

Methods

ppr :: ConDecl p -> SDoc #

pprPrec :: Rational -> ConDecl p -> SDoc #

type HsConDeclDetails pass = HsConDetails (LBangType pass) (Located [LConDeclField pass]) #

Haskell data Constructor Declaration Details

type LTyFamInstEqn pass #

Arguments

 = Located (TyFamInstEqn pass)

May have AnnKeywordId : AnnSemi when in a list

Located Type Family Instance Equation

type LTyFamDefltEqn pass = Located (TyFamDefltEqn pass) #

Located Type Family Default Equation

type HsTyPats pass = [LHsType pass] #

Haskell Type Patterns

type TyFamInstEqn pass = FamInstEqn pass (LHsType pass) #

Type Family Instance Equation

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

Type Family Default Equation

type LTyFamInstDecl pass = Located (TyFamInstDecl pass) #

Located Type Family Instance Declaration

newtype TyFamInstDecl pass #

Type Family Instance Declaration

Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (TyFamInstDecl p) 
Instance details

Defined in HsDecls

type LDataFamInstDecl pass = Located (DataFamInstDecl pass) #

Located Data Family Instance Declaration

newtype DataFamInstDecl pass #

Data Family Instance Declaration

Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (DataFamInstDecl p) 
Instance details

Defined in HsDecls

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

Located Family Instance Equation

type FamInstEqn pass rhs #

Arguments

 = HsImplicitBndrs pass (FamEqn pass (HsTyPats pass) rhs)

Here, the pats are type patterns (with kind and type bndrs). See Note [Family instance declaration binders]

Family Instance Equation

data FamEqn pass pats rhs #

Family Equation

One equation in a type family instance declaration, data family instance declaration, or type family default. See Note [Type family instance declarations in HsSyn] See Note [Family instance declaration binders]

Constructors

FamEqn

Fields

XFamEqn (XXFamEqn pass pats rhs) 

type LClsInstDecl pass = Located (ClsInstDecl pass) #

Located Class Instance Declaration

type LInstDecl pass = Located (InstDecl pass) #

Located Instance Declaration

data InstDecl pass #

Instance Declaration

Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (InstDecl p) 
Instance details

Defined in HsDecls

Methods

ppr :: InstDecl p -> SDoc #

pprPrec :: Rational -> InstDecl p -> SDoc #

type LDerivDecl pass = Located (DerivDecl pass) #

Located Deriving Declaration

data DerivDecl pass #

Deriving Declaration

Constructors

DerivDecl 

Fields

XDerivDecl (XXDerivDecl pass) 
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (DerivDecl p) 
Instance details

Defined in HsDecls

Methods

ppr :: DerivDecl p -> SDoc #

pprPrec :: Rational -> DerivDecl p -> SDoc #

data DerivStrategy pass #

Which technique the user explicitly requested when deriving an instance.

Constructors

StockStrategy

GHC's "standard" strategy, which is to implement a custom instance for the data type. This only works for certain types that GHC knows about (e.g., Eq, Show, Functor when -XDeriveFunctor is enabled, etc.)

AnyclassStrategy
-XDeriveAnyClass
NewtypeStrategy
-XGeneralizedNewtypeDeriving
ViaStrategy (XViaStrategy pass)
-XDerivingVia
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (DerivStrategy p) 
Instance details

Defined in HsDecls

type LDefaultDecl pass = Located (DefaultDecl pass) #

Located Default Declaration

data DefaultDecl pass #

Default Declaration

Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (DefaultDecl p) 
Instance details

Defined in HsDecls

type LForeignDecl pass = Located (ForeignDecl pass) #

Located Foreign Declaration

data ForeignDecl pass #

Foreign Declaration

Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (ForeignDecl p) 
Instance details

Defined in HsDecls

data ForeignImport #

Instances
Data ForeignImport 
Instance details

Defined in HsDecls

Methods

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

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

toConstr :: ForeignImport -> Constr #

dataTypeOf :: ForeignImport -> DataType #

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

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

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

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

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

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

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

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

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

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

Outputable ForeignImport 
Instance details

Defined in HsDecls

data CImportSpec #

Instances
Data CImportSpec 
Instance details

Defined in HsDecls

Methods

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

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

toConstr :: CImportSpec -> Constr #

dataTypeOf :: CImportSpec -> DataType #

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

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

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

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

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

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

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

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

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

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

data ForeignExport #

Instances
Data ForeignExport 
Instance details

Defined in HsDecls

Methods

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

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

toConstr :: ForeignExport -> Constr #

dataTypeOf :: ForeignExport -> DataType #

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

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

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

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

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

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

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

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

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

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

Outputable ForeignExport 
Instance details

Defined in HsDecls

type LRuleDecls pass = Located (RuleDecls pass) #

Located Rule Declarations

data RuleDecls pass #

Rule Declarations

Constructors

HsRules 

Fields

XRuleDecls (XXRuleDecls pass) 
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (RuleDecls p) 
Instance details

Defined in HsDecls

Methods

ppr :: RuleDecls p -> SDoc #

pprPrec :: Rational -> RuleDecls p -> SDoc #

type LRuleDecl pass = Located (RuleDecl pass) #

Located Rule Declaration

data RuleDecl pass #

Rule Declaration

Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (RuleDecl p) 
Instance details

Defined in HsDecls

Methods

ppr :: RuleDecl p -> SDoc #

pprPrec :: Rational -> RuleDecl p -> SDoc #

data HsRuleRn #

Constructors

HsRuleRn NameSet NameSet 
Instances
Data HsRuleRn 
Instance details

Defined in HsDecls

Methods

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

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

toConstr :: HsRuleRn -> Constr #

dataTypeOf :: HsRuleRn -> DataType #

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

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

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

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

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

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

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

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

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

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

type LRuleBndr pass = Located (RuleBndr pass) #

Located Rule Binder

data RuleBndr pass #

Rule Binder

Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (RuleBndr p) 
Instance details

Defined in HsDecls

Methods

ppr :: RuleBndr p -> SDoc #

pprPrec :: Rational -> RuleBndr p -> SDoc #

type LDocDecl = Located DocDecl #

Located Documentation comment Declaration

data DocDecl #

Documentation comment Declaration

Instances
Data DocDecl 
Instance details

Defined in HsDecls

Methods

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

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

toConstr :: DocDecl -> Constr #

dataTypeOf :: DocDecl -> DataType #

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

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

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

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

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

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

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

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

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

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

Outputable DocDecl 
Instance details

Defined in HsDecls

Methods

ppr :: DocDecl -> SDoc #

pprPrec :: Rational -> DocDecl -> SDoc #

type LWarnDecls pass = Located (WarnDecls pass) #

Located Warning Declarations

data WarnDecls pass #

Warning pragma Declarations

Constructors

Warnings 

Fields

XWarnDecls (XXWarnDecls pass) 
Instances
(p ~ GhcPass pass, OutputableBndr (IdP p)) => Outputable (WarnDecls p) 
Instance details

Defined in HsDecls

Methods

ppr :: WarnDecls p -> SDoc #

pprPrec :: Rational -> WarnDecls p -> SDoc #

type LWarnDecl pass = Located (WarnDecl pass) #

Located Warning pragma Declaration

data WarnDecl pass #

Warning pragma Declaration

Constructors

Warning (XWarning pass) [Located (IdP pass)] WarningTxt 
XWarnDecl (XXWarnDecl pass) 
Instances
(p ~ GhcPass pass, OutputableBndr (IdP p)) => Outputable (WarnDecl p) 
Instance details

Defined in HsDecls

Methods

ppr :: WarnDecl p -> SDoc #

pprPrec :: Rational -> WarnDecl p -> SDoc #

type LAnnDecl pass = Located (AnnDecl pass) #

Located Annotation Declaration

data AnnDecl pass #

Annotation Declaration

Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (AnnDecl p) 
Instance details

Defined in HsDecls

Methods

ppr :: AnnDecl p -> SDoc #

pprPrec :: Rational -> AnnDecl p -> SDoc #

data AnnProvenance name #

Annotation Provenance

Instances
Functor AnnProvenance 
Instance details

Defined in HsDecls

Methods

fmap :: (a -> b) -> AnnProvenance a -> AnnProvenance b #

(<$) :: a -> AnnProvenance b -> AnnProvenance a #

Foldable AnnProvenance 
Instance details

Defined in HsDecls

Methods

fold :: Monoid m => AnnProvenance m -> m #

foldMap :: Monoid m => (a -> m) -> AnnProvenance a -> m #

foldr :: (a -> b -> b) -> b -> AnnProvenance a -> b #

foldr' :: (a -> b -> b) -> b -> AnnProvenance a -> b #

foldl :: (b -> a -> b) -> b -> AnnProvenance a -> b #

foldl' :: (b -> a -> b) -> b -> AnnProvenance a -> b #

foldr1 :: (a -> a -> a) -> AnnProvenance a -> a #

foldl1 :: (a -> a -> a) -> AnnProvenance a -> a #

toList :: AnnProvenance a -> [a] #

null :: AnnProvenance a -> Bool #

length :: AnnProvenance a -> Int #

elem :: Eq a => a -> AnnProvenance a -> Bool #

maximum :: Ord a => AnnProvenance a -> a #

minimum :: Ord a => AnnProvenance a -> a #

sum :: Num a => AnnProvenance a -> a #

product :: Num a => AnnProvenance a -> a #

Traversable AnnProvenance 
Instance details

Defined in HsDecls

Methods

traverse :: Applicative f => (a -> f b) -> AnnProvenance a -> f (AnnProvenance b) #

sequenceA :: Applicative f => AnnProvenance (f a) -> f (AnnProvenance a) #

mapM :: Monad m => (a -> m b) -> AnnProvenance a -> m (AnnProvenance b) #

sequence :: Monad m => AnnProvenance (m a) -> m (AnnProvenance a) #

Data pass => Data (AnnProvenance pass) 
Instance details

Defined in HsDecls

Methods

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

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

toConstr :: AnnProvenance pass -> Constr #

dataTypeOf :: AnnProvenance pass -> DataType #

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

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

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

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

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

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

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

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

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

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

type LRoleAnnotDecl pass = Located (RoleAnnotDecl pass) #

Located Role Annotation Declaration

data RoleAnnotDecl pass #

Role Annotation Declaration

Instances
(p ~ GhcPass pass, OutputableBndr (IdP p)) => Outputable (RoleAnnotDecl p) 
Instance details

Defined in HsDecls

parenthesizePat :: PprPrec -> LPat (GhcPass p) -> LPat (GhcPass p) #

parenthesizePat p pat checks if patNeedsParens p pat is true, and if so, surrounds pat with a ParPat. Otherwise, it simply returns pat.

patNeedsParens :: PprPrec -> Pat p -> Bool #

patNeedsParens p pat returns True if the pattern pat needs parentheses under precedence p.

hsRecFieldsArgs :: HsRecFields p arg -> [arg] #

type InPat p = LPat p #

type OutPat p = LPat p #

type HsConPatDetails p = HsConDetails (LPat p) (HsRecFields p (LPat p)) #

Haskell Constructor Pattern Details

data HsRecFields p arg #

Haskell Record Fields

HsRecFields is used only for patterns and expressions (not data type declarations)

Constructors

HsRecFields 

Fields

Instances
Functor (HsRecFields p) 
Instance details

Defined in HsPat

Methods

fmap :: (a -> b) -> HsRecFields p a -> HsRecFields p b #

(<$) :: a -> HsRecFields p b -> HsRecFields p a #

Foldable (HsRecFields p) 
Instance details

Defined in HsPat

Methods

fold :: Monoid m => HsRecFields p m -> m #

foldMap :: Monoid m => (a -> m) -> HsRecFields p a -> m #

foldr :: (a -> b -> b) -> b -> HsRecFields p a -> b #

foldr' :: (a -> b -> b) -> b -> HsRecFields p a -> b #

foldl :: (b -> a -> b) -> b -> HsRecFields p a -> b #

foldl' :: (b -> a -> b) -> b -> HsRecFields p a -> b #

foldr1 :: (a -> a -> a) -> HsRecFields p a -> a #

foldl1 :: (a -> a -> a) -> HsRecFields p a -> a #

toList :: HsRecFields p a -> [a] #

null :: HsRecFields p a -> Bool #

length :: HsRecFields p a -> Int #

elem :: Eq a => a -> HsRecFields p a -> Bool #

maximum :: Ord a => HsRecFields p a -> a #

minimum :: Ord a => HsRecFields p a -> a #

sum :: Num a => HsRecFields p a -> a #

product :: Num a => HsRecFields p a -> a #

Traversable (HsRecFields p) 
Instance details

Defined in HsPat

Methods

traverse :: Applicative f => (a -> f b) -> HsRecFields p a -> f (HsRecFields p b) #

sequenceA :: Applicative f => HsRecFields p (f a) -> f (HsRecFields p a) #

mapM :: Monad m => (a -> m b) -> HsRecFields p a -> m (HsRecFields p b) #

sequence :: Monad m => HsRecFields p (m a) -> m (HsRecFields p a) #

Outputable arg => Outputable (HsRecFields p arg) 
Instance details

Defined in HsPat

Methods

ppr :: HsRecFields p arg -> SDoc #

pprPrec :: Rational -> HsRecFields p arg -> SDoc #

type LHsRecField' p arg = Located (HsRecField' p arg) #

Located Haskell Record Field

type LHsRecField p arg = Located (HsRecField p arg) #

Located Haskell Record Field

type LHsRecUpdField p = Located (HsRecUpdField p) #

Located Haskell Record Update Field

type HsRecField p arg = HsRecField' (FieldOcc p) arg #

Haskell Record Field

type HsRecUpdField p = HsRecField' (AmbiguousFieldOcc p) (LHsExpr p) #

Haskell Record Update Field

data HsRecField' id arg #

Haskell Record Field

For details on above see note [Api annotations] in ApiAnnotation

Constructors

HsRecField 

Fields

Instances
Functor (HsRecField' id) 
Instance details

Defined in HsPat

Methods

fmap :: (a -> b) -> HsRecField' id a -> HsRecField' id b #

(<$) :: a -> HsRecField' id b -> HsRecField' id a #

Foldable (HsRecField' id) 
Instance details

Defined in HsPat

Methods

fold :: Monoid m => HsRecField' id m -> m #

foldMap :: Monoid m => (a -> m) -> HsRecField' id a -> m #

foldr :: (a -> b -> b) -> b -> HsRecField' id a -> b #

foldr' :: (a -> b -> b) -> b -> HsRecField' id a -> b #

foldl :: (b -> a -> b) -> b -> HsRecField' id a -> b #

foldl' :: (b -> a -> b) -> b -> HsRecField' id a -> b #

foldr1 :: (a -> a -> a) -> HsRecField' id a -> a #

foldl1 :: (a -> a -> a) -> HsRecField' id a -> a #

toList :: HsRecField' id a -> [a] #

null :: HsRecField' id a -> Bool #

length :: HsRecField' id a -> Int #

elem :: Eq a => a -> HsRecField' id a -> Bool #

maximum :: Ord a => HsRecField' id a -> a #

minimum :: Ord a => HsRecField' id a -> a #

sum :: Num a => HsRecField' id a -> a #

product :: Num a => HsRecField' id a -> a #

Traversable (HsRecField' id) 
Instance details

Defined in HsPat

Methods

traverse :: Applicative f => (a -> f b) -> HsRecField' id a -> f (HsRecField' id b) #

sequenceA :: Applicative f => HsRecField' id (f a) -> f (HsRecField' id a) #

mapM :: Monad m => (a -> m b) -> HsRecField' id a -> m (HsRecField' id b) #

sequence :: Monad m => HsRecField' id (m a) -> m (HsRecField' id a) #

(Data id, Data arg) => Data (HsRecField' id arg) 
Instance details

Defined in HsPat

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsRecField' id arg -> c (HsRecField' id arg) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsRecField' id arg) #

toConstr :: HsRecField' id arg -> Constr #

dataTypeOf :: HsRecField' id arg -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (HsRecField' id arg)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HsRecField' id arg)) #

gmapT :: (forall b. Data b => b -> b) -> HsRecField' id arg -> HsRecField' id arg #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsRecField' id arg -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsRecField' id arg -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsRecField' id arg -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsRecField' id arg -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsRecField' id arg -> m (HsRecField' id arg) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsRecField' id arg -> m (HsRecField' id arg) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsRecField' id arg -> m (HsRecField' id arg) #

(Outputable p, Outputable arg) => Outputable (HsRecField' p arg) 
Instance details

Defined in HsPat

Methods

ppr :: HsRecField' p arg -> SDoc #

pprPrec :: Rational -> HsRecField' p arg -> SDoc #

pprVarSig :: OutputableBndr id => [id] -> SDoc -> SDoc #

pragSrcBrackets :: SourceText -> String -> SDoc -> SDoc #

Using SourceText in case the pragma was spelled differently or used mixed case

hsSigDoc :: Sig name -> SDoc #

isSCCFunSig :: LSig name -> Bool #

isInlineLSig :: LSig name -> Bool #

isPragLSig :: LSig name -> Bool #

isSpecLSig :: LSig name -> Bool #

isTypeLSig :: LSig name -> Bool #

isFixityLSig :: LSig name -> Bool #

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

HsIPBinds (XHsIPBinds idL idR) (HsIPBinds idR)

Haskell Implicit Parameter Bindings

EmptyLocalBinds (XEmptyLocalBinds idL idR)

Empty Local Bindings

XHsLocalBindsLR (XXHsLocalBindsLR idL idR) 
Instances
(idL ~ GhcPass pl, idR ~ GhcPass pr, OutputableBndrId idL, OutputableBndrId idR) => Outputable (HsLocalBindsLR idL idR) 
Instance details

Defined in HsBinds

Methods

ppr :: HsLocalBindsLR idL idR -> SDoc #

pprPrec :: Rational -> HsLocalBindsLR idL idR -> SDoc #

type LHsLocalBindsLR idL idR = Located (HsLocalBindsLR idL idR) #

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

XValBindsLR (XXValBindsLR idL idR)

Value Bindings Out

After renaming RHS; idR can be Name or Id Dependency analysed, later bindings in the list may depend on earlier ones.

Instances
(idL ~ GhcPass pl, idR ~ GhcPass pr, OutputableBndrId idL, OutputableBndrId idR) => Outputable (HsValBindsLR idL idR) 
Instance details

Defined in HsBinds

Methods

ppr :: HsValBindsLR idL idR -> SDoc #

pprPrec :: Rational -> HsValBindsLR idL idR -> SDoc #

data NHsValBindsLR idL #

Constructors

NValBinds [(RecFlag, LHsBinds idL)] [LSig GhcRn] 

type LHsBind id = LHsBindLR id id #

Located Haskell Binding

type LHsBinds id = LHsBindsLR id id #

Located Haskell Bindings

type HsBind id = HsBindLR id id #

Haskell Binding

type LHsBindsLR idL idR = Bag (LHsBindLR idL idR) #

Located Haskell Bindings with separate Left and Right identifier types

type LHsBindLR idL idR = Located (HsBindLR idL idR) #

Located Haskell Binding with separate Left and Right identifier types

data HsBindLR idL idR #

Haskell Binding with separate Left and Right id's

Constructors

FunBind

Function-like Binding

FunBind is used for both functions f x = e and variables f = x -> e and strict variables !x = x + 1

Reason 1: Special case for type inference: see tcMonoBinds.

Reason 2: Instance decls can only have FunBinds, which is convenient. If you change this, you'll need to change e.g. rnMethodBinds

But note that the form f :: a->a = ... parses as a pattern binding, just like (f :: a -> a) = ...

Strict bindings have their strictness recorded in the SrcStrictness of their MatchContext. See Note [FunBind vs PatBind] for details about the relationship between FunBind and PatBind.

AnnKeywordIds

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

VarBind

Variable Binding

Dictionary binding and suchlike. All VarBinds are introduced by the type checker

Fields

AbsBinds

Abstraction Bindings

Fields

XHsBindsLR (XXHsBindsLR idL idR) 
Instances
(idL ~ GhcPass pl, idR ~ GhcPass pr, OutputableBndrId idL, OutputableBndrId idR) => Outputable (HsBindLR idL idR) 
Instance details

Defined in HsBinds

Methods

ppr :: HsBindLR idL idR -> SDoc #

pprPrec :: Rational -> HsBindLR idL idR -> SDoc #

data NPatBindTc #

Constructors

NPatBindTc 

Fields

Instances
Data NPatBindTc 
Instance details

Defined in HsBinds

Methods

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

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

toConstr :: NPatBindTc -> Constr #

dataTypeOf :: NPatBindTc -> DataType #

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

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

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

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

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

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

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

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

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

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

data ABExport p #

Abtraction Bindings Export

Constructors

ABE 

Fields

XABExport (XXABExport p) 
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (ABExport p) 
Instance details

Defined in HsBinds

Methods

ppr :: ABExport p -> SDoc #

pprPrec :: Rational -> ABExport p -> SDoc #

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

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

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

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

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

Name of the pattern synonym

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

Formal parameter names

psb_def :: PatSynBind idL idR -> LPat idR #

Right-hand side

psb_dir :: PatSynBind idL idR -> HsPatSynDir idR #

Directionality

data HsIPBinds id #

Haskell Implicit Parameter Bindings

Constructors

IPBinds (XIPBinds id) [LIPBind id] 
XHsIPBinds (XXHsIPBinds id) 
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsIPBinds p) 
Instance details

Defined in HsBinds

Methods

ppr :: HsIPBinds p -> SDoc #

pprPrec :: Rational -> HsIPBinds p -> SDoc #

type LIPBind id = Located (IPBind id) #

Located Implicit Parameter Binding

May have AnnKeywordId : AnnSemi when in a list

data IPBind id #

Implicit parameter bindings.

These bindings start off as (Left "x") in the parser and stay that way until after type-checking when they are replaced with (Right d), where "d" is the name of the dictionary holding the evidence for the implicit parameter.

Constructors

IPBind (XCIPBind id) (Either (Located HsIPName) (IdP id)) (LHsExpr id) 
XIPBind (XXIPBind id) 
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (IPBind p) 
Instance details

Defined in HsBinds

Methods

ppr :: IPBind p -> SDoc #

pprPrec :: Rational -> IPBind p -> SDoc #

type LSig pass = Located (Sig pass) #

Located Signature

data Sig pass #

Signatures and pragmas

Constructors

PatSynSig (XPatSynSig pass) [Located (IdP pass)] (LHsSigType pass)

A pattern synonym type signature

pattern Single :: () => (Show a) => a -> [a]
IdSig (XIdSig pass) Id

A type signature in generated code, notably the code generated for record selectors. We simply record the desired Id itself, replete with its name, type and IdDetails. Otherwise it's just like a type signature: there should be an accompanying binding

FixSig (XFixSig pass) (FixitySig pass)

An ordinary fixity declaration

    infixl 8 ***
InlineSig (XInlineSig pass) (Located (IdP pass)) InlinePragma

An inline pragma

{#- INLINE f #-}
SpecSig (XSpecSig pass) (Located (IdP pass)) [LHsSigType pass] InlinePragma

A specialisation pragma

{-# SPECIALISE f :: Int -> Int #-}
SpecInstSig (XSpecInstSig pass) SourceText (LHsSigType pass)

A specialisation pragma for instance declarations only

{-# SPECIALISE instance Eq [Int] #-}

(Class tys); should be a specialisation of the current instance declaration

MinimalSig (XMinimalSig pass) SourceText (LBooleanFormula (Located (IdP pass)))

A minimal complete definition pragma

{-# MINIMAL a | (b, c | (d | e)) #-}
SCCFunSig (XSCCFunSig pass) SourceText (Located (IdP pass)) (Maybe (Located StringLiteral))

A "set cost centre" pragma for declarations

{-# SCC funName #-}

or

{-# SCC funName "cost_centre_name" #-}
CompleteMatchSig (XCompleteMatchSig pass) SourceText (Located [Located (IdP pass)]) (Maybe (Located (IdP pass)))

A complete match pragma

{-# COMPLETE C, D [:: T] #-}

Used to inform the pattern match checker about additional complete matchings which, for example, arise from pattern synonym definitions.

XSig (XXSig pass) 
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (Sig p) 
Instance details

Defined in HsBinds

Methods

ppr :: Sig p -> SDoc #

pprPrec :: Rational -> Sig p -> SDoc #

type LFixitySig pass = Located (FixitySig pass) #

Located Fixity Signature

data FixitySig pass #

Fixity Signature

Constructors

FixitySig (XFixitySig pass) [Located (IdP pass)] Fixity 
XFixitySig (XXFixitySig pass) 
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (FixitySig p) 
Instance details

Defined in HsBinds

Methods

ppr :: FixitySig p -> SDoc #

pprPrec :: Rational -> FixitySig p -> SDoc #

data TcSpecPrags #

Type checker Specialisation Pragmas

TcSpecPrags conveys SPECIALISE pragmas from the type checker to the desugarer

Constructors

IsDefaultMethod

Super-specialised: a default method should be macro-expanded at every call site

SpecPrags [LTcSpecPrag] 
Instances
Data TcSpecPrags 
Instance details

Defined in HsBinds

Methods

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

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

toConstr :: TcSpecPrags -> Constr #

dataTypeOf :: TcSpecPrags -> DataType #

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

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

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

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

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

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

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

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

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

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

type LTcSpecPrag = Located TcSpecPrag #

Located Type checker Specification Pragmas

data TcSpecPrag #

Type checker Specification Pragma

Constructors

SpecPrag Id HsWrapper InlinePragma

The Id to be specialised, a wrapper that specialises the polymorphic function, and inlining spec for the specialised function

Instances
Data TcSpecPrag 
Instance details

Defined in HsBinds

Methods

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

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

toConstr :: TcSpecPrag -> Constr #

dataTypeOf :: TcSpecPrag -> DataType #

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

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

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

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

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

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

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

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

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

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

Outputable TcSpecPrag 
Instance details

Defined in HsBinds

type HsPatSynDetails arg = HsConDetails arg [RecordPatSynField arg] #

Haskell Pattern Synonym Details

data RecordPatSynField a #

Record Pattern Synonym Field

Instances
Functor RecordPatSynField 
Instance details

Defined in HsBinds

Foldable RecordPatSynField 
Instance details

Defined in HsBinds

Methods

fold :: Monoid m => RecordPatSynField m -> m #

foldMap :: Monoid m => (a -> m) -> RecordPatSynField a -> m #

foldr :: (a -> b -> b) -> b -> RecordPatSynField a -> b #

foldr' :: (a -> b -> b) -> b -> RecordPatSynField a -> b #

foldl :: (b -> a -> b) -> b -> RecordPatSynField a -> b #

foldl' :: (b -> a -> b) -> b -> RecordPatSynField a -> b #

foldr1 :: (a -> a -> a) -> RecordPatSynField a -> a #

foldl1 :: (a -> a -> a) -> RecordPatSynField a -> a #

toList :: RecordPatSynField a -> [a] #

null :: RecordPatSynField a -> Bool #

length :: RecordPatSynField a -> Int #

elem :: Eq a => a -> RecordPatSynField a -> Bool #

maximum :: Ord a => RecordPatSynField a -> a #

minimum :: Ord a => RecordPatSynField a -> a #

sum :: Num a => RecordPatSynField a -> a #

product :: Num a => RecordPatSynField a -> a #

Traversable RecordPatSynField 
Instance details

Defined in HsBinds

Methods

traverse :: Applicative f => (a -> f b) -> RecordPatSynField a -> f (RecordPatSynField b) #

sequenceA :: Applicative f => RecordPatSynField (f a) -> f (RecordPatSynField a) #

mapM :: Monad m => (a -> m b) -> RecordPatSynField a -> m (RecordPatSynField b) #

sequence :: Monad m => RecordPatSynField (m a) -> m (RecordPatSynField a) #

Data a => Data (RecordPatSynField a) 
Instance details

Defined in HsBinds

Methods

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

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

toConstr :: RecordPatSynField a -> Constr #

dataTypeOf :: RecordPatSynField a -> DataType #

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

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

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

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

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

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

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

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

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

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

Outputable a => Outputable (RecordPatSynField a) 
Instance details

Defined in HsBinds

data HsPatSynDir id #

Haskell Pattern Synonym Direction

data ClsInst #

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

Instances
Data ClsInst 
Instance details

Defined in InstEnv

Methods

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

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

toConstr :: ClsInst -> Constr #

dataTypeOf :: ClsInst -> DataType #

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

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

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

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

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

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

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

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

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

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

NamedThing ClsInst 
Instance details

Defined in InstEnv

Outputable ClsInst 
Instance details

Defined in InstEnv

Methods

ppr :: ClsInst -> SDoc #

pprPrec :: Rational -> ClsInst -> SDoc #

data FamInst #

Instances
NamedThing FamInst 
Instance details

Defined in FamInstEnv

Outputable FamInst 
Instance details

Defined in FamInstEnv

Methods

ppr :: FamInst -> SDoc #

pprPrec :: Rational -> FamInst -> SDoc #

type BreakIndex = Int #

Breakpoint index

data ModBreaks #

All the information about the breakpoints for a module

Constructors

ModBreaks 

Fields

parenthesizeHsType :: PprPrec -> LHsType (GhcPass p) -> LHsType (GhcPass p) #

parenthesizeHsType p ty checks if hsTypeNeedsParens p ty is true, and if so, surrounds ty with an HsParTy. Otherwise, it simply returns ty.

hsTypeNeedsParens :: PprPrec -> HsType pass -> Bool #

hsTypeNeedsParens p t returns True if the type t needs parentheses under precedence p.

pprHsForAllExtra :: OutputableBndrId (GhcPass p) => Maybe SrcSpan -> [LHsTyVarBndr (GhcPass p)] -> LHsContext (GhcPass p) -> SDoc #

Version of pprHsForAll that can also print an extra-constraints wildcard, e.g. _ => a -> Bool or (Show a, _) => a -> String. This underscore will be printed when the 'Maybe SrcSpan' argument is a Just containing the location of the extra-constraints wildcard. A special function for this is needed, as the extra-constraints wildcard is removed from the actual context and type, and stored in a separate field, thus just printing the type will not print the extra-constraints wildcard.

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

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

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

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

ignoreParens :: LHsType pass -> LHsType pass #

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

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

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

Convert a LHsTyVarBndr to an equivalent LHsType.

hsLTyVarName :: LHsTyVarBndr pass -> IdP pass #

hsTyVarName :: HsTyVarBndr pass -> IdP pass #

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?

hsSigType :: LHsSigType pass -> LHsType pass #

hsImplicitBody :: HsImplicitBndrs pass thing -> thing #

type LBangType pass = Located (BangType pass) #

Located Bang Type

type BangType pass = HsType pass #

Bang Type

type LHsContext pass #

Arguments

 = Located (HsContext pass)

AnnKeywordId : AnnUnit

Located Haskell Context

type HsContext pass = [LHsType pass] #

Haskell Context

type LHsType pass #

Arguments

 = Located (HsType pass)

May have AnnKeywordId : AnnComma when in a list

Located Haskell Type

type HsKind pass = HsType pass #

Haskell Kind

type LHsKind pass #

Arguments

 = Located (HsKind pass)

AnnKeywordId : AnnDcolon

Located Haskell Kind

type LHsTyVarBndr pass = Located (HsTyVarBndr pass) #

Located Haskell Type Variable Binder

data LHsQTyVars pass #

Located Haskell Quantified Type Variables

Constructors

HsQTvs 

Fields

XLHsQTyVars (XXLHsQTyVars pass) 
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (LHsQTyVars p) 
Instance details

Defined in HsTypes

Methods

ppr :: LHsQTyVars p -> SDoc #

pprPrec :: Rational -> LHsQTyVars p -> SDoc #

data HsQTvsRn #

Constructors

HsQTvsRn 
Instances
Data HsQTvsRn 
Instance details

Defined in HsTypes

Methods

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

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

toConstr :: HsQTvsRn -> Constr #

dataTypeOf :: HsQTvsRn -> DataType #

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

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

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

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

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

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

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

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

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

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

data HsImplicitBndrs pass thing #

Haskell Implicit Binders

Constructors

HsIB 

Fields

XHsImplicitBndrs (XXHsImplicitBndrs pass thing) 
Instances
(p ~ GhcPass pass, Outputable thing) => Outputable (HsImplicitBndrs p thing) 
Instance details

Defined in HsTypes

Methods

ppr :: HsImplicitBndrs p thing -> SDoc #

pprPrec :: Rational -> HsImplicitBndrs p thing -> SDoc #

data HsIBRn #

Constructors

HsIBRn 

Fields

Instances
Data HsIBRn 
Instance details

Defined in HsTypes

Methods

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

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

toConstr :: HsIBRn -> Constr #

dataTypeOf :: HsIBRn -> DataType #

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

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

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

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

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

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

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

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

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

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

data HsWildCardBndrs pass thing #

Haskell Wildcard Binders

Constructors

HsWC 

Fields

XHsWildCardBndrs (XXHsWildCardBndrs pass thing) 
Instances
(p ~ GhcPass pass, Outputable thing) => Outputable (HsWildCardBndrs p thing) 
Instance details

Defined in HsTypes

Methods

ppr :: HsWildCardBndrs p thing -> SDoc #

pprPrec :: Rational -> HsWildCardBndrs p thing -> SDoc #

type LHsSigType pass = HsImplicitBndrs pass (LHsType pass) #

Located Haskell Signature Type

type LHsWcType pass = HsWildCardBndrs pass (LHsType pass) #

Located Haskell Wildcard Type

type LHsSigWcType pass = HsWildCardBndrs pass (LHsSigType pass) #

Located Haskell Signature Wildcard Type

newtype HsIPName #

These names are used early on to store the names of implicit parameters. They completely disappear after type-checking.

Constructors

HsIPName FastString 
Instances
Eq HsIPName 
Instance details

Defined in HsTypes

Data HsIPName 
Instance details

Defined in HsTypes

Methods

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

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

toConstr :: HsIPName -> Constr #

dataTypeOf :: HsIPName -> DataType #

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

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

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

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

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

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

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

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

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

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

Outputable HsIPName 
Instance details

Defined in HsTypes

OutputableBndr HsIPName 
Instance details

Defined in HsTypes

data HsTyVarBndr pass #

Haskell Type Variable Binder

Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsTyVarBndr p) 
Instance details

Defined in HsTypes

data HsType pass #

Haskell Type

Constructors

HsForAllTy

Fields

HsQualTy 

Fields

HsTyVar (XTyVar pass) Promoted (Located (IdP pass))
HsAppTy (XAppTy pass) (LHsType pass) (LHsType pass)
HsFunTy (XFunTy pass) (LHsType pass) (LHsType pass)
HsListTy (XListTy pass) (LHsType pass)
HsTupleTy (XTupleTy pass) HsTupleSort [LHsType pass]
HsSumTy (XSumTy pass) [LHsType pass]
HsOpTy (XOpTy pass) (LHsType pass) (Located (IdP pass)) (LHsType pass)
HsParTy (XParTy pass) (LHsType pass)
HsIParamTy (XIParamTy pass) (Located HsIPName) (LHsType pass)
(?x :: ty)
HsStarTy (XStarTy pass) Bool
HsKindSig (XKindSig pass) (LHsType pass) (LHsKind pass)
(ty :: kind)
HsSpliceTy (XSpliceTy pass) (HsSplice pass)
HsDocTy (XDocTy pass) (LHsType pass) LHsDocString
HsBangTy (XBangTy pass) HsSrcBang (LHsType pass)
HsRecTy (XRecTy pass) [LConDeclField pass]
HsExplicitListTy (XExplicitListTy pass) Promoted [LHsType pass]
HsExplicitTupleTy (XExplicitTupleTy pass) [LHsType pass]
HsTyLit (XTyLit pass) HsTyLit
HsWildCardTy (XWildCardTy pass)
XHsType (XXType pass) 
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsType p) 
Instance details

Defined in HsTypes

Methods

ppr :: HsType p -> SDoc #

pprPrec :: Rational -> HsType p -> SDoc #

data NewHsTypeX #

Constructors

NHsCoreTy Type 
Instances
Data NewHsTypeX
Instance details

Defined in HsTypes

Methods

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

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

toConstr :: NewHsTypeX -> Constr #

dataTypeOf :: NewHsTypeX -> DataType #

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

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

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

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

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

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

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

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

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

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

Outputable NewHsTypeX 
Instance details

Defined in HsTypes

data HsTyLit #

Haskell Type Literal

Instances
Data HsTyLit 
Instance details

Defined in HsTypes

Methods

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

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

toConstr :: HsTyLit -> Constr #

dataTypeOf :: HsTyLit -> DataType #

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

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

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

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

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

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

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

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

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

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

Outputable HsTyLit 
Instance details

Defined in HsTypes

Methods

ppr :: HsTyLit -> SDoc #

pprPrec :: Rational -> HsTyLit -> SDoc #

newtype HsWildCardInfo #

Constructors

AnonWildCard (Located Name) 
Instances
Data HsWildCardInfo 
Instance details

Defined in HsTypes

Methods

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

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

toConstr :: HsWildCardInfo -> Constr #

dataTypeOf :: HsWildCardInfo -> DataType #

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

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

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

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

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

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

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

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

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

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

Outputable HsWildCardInfo 
Instance details

Defined in HsTypes

data HsTupleSort #

Haskell Tuple Sort

Instances
Data HsTupleSort 
Instance details

Defined in HsTypes

Methods

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

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

toConstr :: HsTupleSort -> Constr #

dataTypeOf :: HsTupleSort -> DataType #

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

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

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

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

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

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

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

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

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

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

data Promoted #

Promoted data types.

Constructors

Promoted 
NotPromoted 
Instances
Eq Promoted 
Instance details

Defined in HsTypes

Data Promoted 
Instance details

Defined in HsTypes

Methods

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

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

toConstr :: Promoted -> Constr #

dataTypeOf :: Promoted -> DataType #

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

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

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

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

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

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

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

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

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

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

Show Promoted 
Instance details

Defined in HsTypes

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

Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (ConDeclField p) 
Instance details

Defined in HsTypes

data HsConDetails arg rec #

Haskell Constructor Details

Constructors

PrefixCon [arg] 
RecCon rec 
InfixCon arg arg 
Instances
(Data arg, Data rec) => Data (HsConDetails arg rec) 
Instance details

Defined in HsTypes

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsConDetails arg rec -> c (HsConDetails arg rec) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HsConDetails arg rec) #

toConstr :: HsConDetails arg rec -> Constr #

dataTypeOf :: HsConDetails arg rec -> DataType #

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

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

gmapT :: (forall b. Data b => b -> b) -> HsConDetails arg rec -> HsConDetails arg rec #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsConDetails arg rec -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsConDetails arg rec -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsConDetails arg rec -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsConDetails arg rec -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsConDetails arg rec -> m (HsConDetails arg rec) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDetails arg rec -> m (HsConDetails arg rec) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsConDetails arg rec -> m (HsConDetails arg rec) #

(Outputable arg, Outputable rec) => Outputable (HsConDetails arg rec) 
Instance details

Defined in HsTypes

Methods

ppr :: HsConDetails arg rec -> SDoc #

pprPrec :: Rational -> HsConDetails arg rec -> SDoc #

type LFieldOcc pass = Located (FieldOcc pass) #

Located Field Occurrence

data FieldOcc pass #

Field Occurrence

Represents an *occurrence* of an unambiguous field. We store both the RdrName the user originally wrote, and after the renamer, the selector function.

Constructors

FieldOcc 

Fields

XFieldOcc (XXFieldOcc pass) 
Instances
(p ~ GhcPass pass, Eq (XCFieldOcc p)) => Eq (FieldOcc p) 
Instance details

Defined in HsTypes

Methods

(==) :: FieldOcc p -> FieldOcc p -> Bool #

(/=) :: FieldOcc p -> FieldOcc p -> Bool #

(p ~ GhcPass pass, Ord (XCFieldOcc p)) => Ord (FieldOcc p) 
Instance details

Defined in HsTypes

Methods

compare :: FieldOcc p -> FieldOcc p -> Ordering #

(<) :: FieldOcc p -> FieldOcc p -> Bool #

(<=) :: FieldOcc p -> FieldOcc p -> Bool #

(>) :: FieldOcc p -> FieldOcc p -> Bool #

(>=) :: FieldOcc p -> FieldOcc p -> Bool #

max :: FieldOcc p -> FieldOcc p -> FieldOcc p #

min :: FieldOcc p -> FieldOcc p -> FieldOcc p #

Outputable (FieldOcc pass) 
Instance details

Defined in HsTypes

Methods

ppr :: FieldOcc pass -> SDoc #

pprPrec :: Rational -> FieldOcc pass -> SDoc #

data AmbiguousFieldOcc pass #

Ambiguous Field Occurrence

Represents an *occurrence* of a field that is potentially ambiguous after the renamer, with the ambiguity resolved by the typechecker. We always store the RdrName that the user originally wrote, and store the selector function after the renamer (for unambiguous occurrences) or the typechecker (for ambiguous occurrences).

See Note [HsRecField and HsRecUpdField] in HsPat and Note [Disambiguating record fields] in TcExpr. See Note [Located RdrNames] in HsExpr

data ExecOptions #

Constructors

ExecOptions 

Fields

data History #

isBottomingId :: Var -> Bool #

Returns true if an application to n args would diverge

isImplicitId :: Id -> Bool #

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

idDataCon :: Id -> DataCon #

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

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

recordSelectorTyCon :: Id -> RecSelParent #

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

idType :: Id -> Kind #

isVanillaDataCon :: DataCon -> Bool #

Vanilla DataCons are those that are nice boring Haskell 98 constructors

dataConUserType :: DataCon -> Type #

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

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

rather than:

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

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

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

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

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

1) The result of dataConUnivAndExTyVars,

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

3) The type arguments to the constructor

4) The original result type of the DataCon

dataConSrcBangs :: DataCon -> [HsSrcBang] #

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

dataConIsInfix :: DataCon -> Bool #

Should the DataCon be presented infix?

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)

Instances
Data HsSrcBang 
Instance details

Defined in DataCon

Methods

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

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

toConstr :: HsSrcBang -> Constr #

dataTypeOf :: HsSrcBang -> DataType #

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

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

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

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

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

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

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

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

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

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

Outputable HsSrcBang 
Instance details

Defined in DataCon

data HsImplBang #

Haskell Implementation Bang

Bangs of data constructor arguments as generated by the compiler after consulting HsSrcBang, flags, etc.

Constructors

HsLazy

Lazy field, or one with an unlifted type

HsStrict

Strict but not unpacked field

HsUnpack (Maybe Coercion)

Strict and unpacked field co :: arg-ty ~ product-ty HsBang

Instances
Data HsImplBang 
Instance details

Defined in DataCon

Methods

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

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

toConstr :: HsImplBang -> Constr #

dataTypeOf :: HsImplBang -> DataType #

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

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

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

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

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

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

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

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

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

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

Outputable HsImplBang 
Instance details

Defined in DataCon

data SrcStrictness #

Source Strictness

What strictness annotation the user wrote

Constructors

SrcLazy

Lazy, ie '~'

SrcStrict

Strict, ie !

NoSrcStrict

no strictness annotation

Instances
Eq SrcStrictness 
Instance details

Defined in DataCon

Data SrcStrictness 
Instance details

Defined in DataCon

Methods

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

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

toConstr :: SrcStrictness -> Constr #

dataTypeOf :: SrcStrictness -> DataType #

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

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

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

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

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

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

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

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

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

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

Binary SrcStrictness 
Instance details

Defined in DataCon

Outputable SrcStrictness 
Instance details

Defined in DataCon

data SrcUnpackedness #

Source Unpackedness

What unpackedness the user requested

Constructors

SrcUnpack

{--} specified

SrcNoUnpack

{--} specified

NoSrcUnpack

no unpack pragma

Instances
Eq SrcUnpackedness 
Instance details

Defined in DataCon

Data SrcUnpackedness 
Instance details

Defined in DataCon

Methods

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

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

toConstr :: SrcUnpackedness -> Constr #

dataTypeOf :: SrcUnpackedness -> DataType #

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

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

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

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

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

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

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

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

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

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

Binary SrcUnpackedness 
Instance details

Defined in DataCon

Outputable SrcUnpackedness 
Instance details

Defined in DataCon

data StrictnessMark #

Instances
Outputable StrictnessMark 
Instance details

Defined in DataCon

hsOverLitNeedsParens :: PprPrec -> HsOverLit x -> Bool #

hsOverLitNeedsParens p ol returns True if an overloaded literal ol needs to be parenthesized under precedence p.

hsLitNeedsParens :: PprPrec -> HsLit x -> Bool #

hsLitNeedsParens p l returns True if a literal l needs to be parenthesized under precedence p.

pmPprHsLit :: HsLit (GhcPass x) -> SDoc #

pmPprHsLit pretty prints literals and is used when pretty printing pattern match warnings. All are printed the same (i.e., without hashes if they are primitive and not wrapped in constructors if they are boxed). This happens mainly for too reasons: * We do not want to expose their internal representation * The warnings become too messy

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

data HsLit x #

Haskell Literal

Constructors

HsChar (XHsChar x) Char

Character

HsCharPrim (XHsCharPrim x) Char

Unboxed character

HsString (XHsString x) FastString

String

HsStringPrim (XHsStringPrim x) ByteString

Packed bytes

HsInt (XHsInt x) IntegralLit

Genuinely an Int; arises from TcGenDeriv, and from TRANSLATION

HsIntPrim (XHsIntPrim x) Integer

literal Int#

HsWordPrim (XHsWordPrim x) Integer

literal Word#

HsInt64Prim (XHsInt64Prim x) Integer

literal Int64#

HsWord64Prim (XHsWord64Prim x) Integer

literal Word64#

HsInteger (XHsInteger x) Integer Type

Genuinely an integer; arises only from TRANSLATION (overloaded literals are done with HsOverLit)

HsRat (XHsRat x) FractionalLit Type

Genuinely a rational; arises only from TRANSLATION (overloaded literals are done with HsOverLit)

HsFloatPrim (XHsFloatPrim x) FractionalLit

Unboxed Float

HsDoublePrim (XHsDoublePrim x) FractionalLit

Unboxed Double

XLit (XXLit x) 
Instances
Eq (HsLit x) 
Instance details

Defined in HsLit

Methods

(==) :: HsLit x -> HsLit x -> Bool #

(/=) :: HsLit x -> HsLit x -> Bool #

p ~ GhcPass pass => Outputable (HsLit p) 
Instance details

Defined in HsLit

Methods

ppr :: HsLit p -> SDoc #

pprPrec :: Rational -> HsLit p -> SDoc #

data HsOverLit p #

Haskell Overloaded Literal

Constructors

OverLit 
XOverLit (XXOverLit p) 
Instances
Eq (XXOverLit p) => Eq (HsOverLit p) 
Instance details

Defined in HsLit

Methods

(==) :: HsOverLit p -> HsOverLit p -> Bool #

(/=) :: HsOverLit p -> HsOverLit p -> Bool #

Ord (XXOverLit p) => Ord (HsOverLit p) 
Instance details

Defined in HsLit

(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsOverLit p) 
Instance details

Defined in HsLit

Methods

ppr :: HsOverLit p -> SDoc #

pprPrec :: Rational -> HsOverLit p -> SDoc #

data OverLitTc #

Constructors

OverLitTc 
Instances
Data OverLitTc 
Instance details

Defined in HsLit

Methods

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

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

toConstr :: OverLitTc -> Constr #

dataTypeOf :: OverLitTc -> DataType #

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

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

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

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

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

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

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

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

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

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

data OverLitVal #

Overloaded Literal Value

Constructors

HsIntegral !IntegralLit

Integer-looking literals;

HsFractional !FractionalLit

Frac-looking literals

HsIsString !SourceText !FastString

String-looking literals

Instances
Eq OverLitVal 
Instance details

Defined in HsLit

Data OverLitVal 
Instance details

Defined in HsLit

Methods

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

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

toConstr :: OverLitVal -> Constr #

dataTypeOf :: OverLitVal -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord OverLitVal 
Instance details

Defined in HsLit

Outputable OverLitVal 
Instance details

Defined in HsLit

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

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

funResultTy :: Type -> Type #

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

tyConClass_maybe :: TyCon -> Maybe Class #

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

isClassTyCon :: TyCon -> Bool #

Is this TyCon that for a class instance?

synTyConRhs_maybe :: TyCon -> Maybe Type #

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

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

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

tyConDataCons :: TyCon -> [DataCon] #

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

isOpenTypeFamilyTyCon :: TyCon -> Bool #

Is this an open type family TyCon?

isTypeFamilyTyCon :: TyCon -> Bool #

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

isOpenFamilyTyCon :: TyCon -> Bool #

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

isFamilyTyCon :: TyCon -> Bool #

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

isTypeSynonymTyCon :: TyCon -> Bool #

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

isNewTyCon :: TyCon -> Bool #

Is this TyCon that for a newtype

isPrimTyCon :: TyCon -> Bool #

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

data Class #

Instances
Eq Class 
Instance details

Defined in Class

Methods

(==) :: Class -> Class -> Bool #

(/=) :: Class -> Class -> Bool #

Data Class 
Instance details

Defined in Class

Methods

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

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

toConstr :: Class -> Constr #

dataTypeOf :: Class -> DataType #

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

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

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

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

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

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

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

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

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

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

NamedThing Class 
Instance details

Defined in Class

Uniquable Class 
Instance details

Defined in Class

Methods

getUnique :: Class -> Unique #

Outputable Class 
Instance details

Defined in Class

Methods

ppr :: Class -> SDoc #

pprPrec :: Rational -> Class -> SDoc #

dataConTyCon :: DataCon -> TyCon #

The type constructor that we are building via this data constructor

dataConFieldLabels :: DataCon -> [FieldLabel] #

The labels for the fields of this particular DataCon

data DataCon #

A data constructor

Instances
Eq DataCon 
Instance details

Defined in DataCon

Methods

(==) :: DataCon -> DataCon -> Bool #

(/=) :: DataCon -> DataCon -> Bool #

Data DataCon 
Instance details

Defined in DataCon

Methods

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

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

toConstr :: DataCon -> Constr #

dataTypeOf :: DataCon -> DataType #

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

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

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

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

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

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

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

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

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

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

NamedThing DataCon 
Instance details

Defined in DataCon

Uniquable DataCon 
Instance details

Defined in DataCon

Methods

getUnique :: DataCon -> Unique #

Outputable DataCon 
Instance details

Defined in DataCon

Methods

ppr :: DataCon -> SDoc #

pprPrec :: Rational -> DataCon -> SDoc #

OutputableBndr DataCon 
Instance details

Defined in DataCon

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

HsLamCase (XLamCase p) (MatchGroup p (LHsExpr p))

Lambda-case

HsApp (XApp p) (LHsExpr p) (LHsExpr p)

Application

HsAppType (XAppTypeE p) (LHsExpr p)

Visible type application

Explicit type argument; e.g f @Int x y NB: Has wildcards, but no implicit quantification

OpApp (XOpApp p) (LHsExpr p) (LHsExpr p) (LHsExpr p)

Operator applications: NB Bracketed ops such as (+) come out as Vars.

NegApp (XNegApp p) (LHsExpr p) (SyntaxExpr p)

Negation operator. Contains the negated expression and the name of negate

HsPar (XPar p) (LHsExpr p)

Parenthesised expr; see Note [Parens in HsSyn]

SectionL (XSectionL p) (LHsExpr p) (LHsExpr p) 
SectionR (XSectionR p) (LHsExpr p) (LHsExpr p) 
ExplicitTuple (XExplicitTuple p) [LHsTupArg p] Boxity

Used for explicit tuples and sections thereof

ExplicitSum (XExplicitSum p) ConTag Arity (LHsExpr p)

Used for unboxed sum types

There will be multiple AnnVbar, (1 - alternative) before the expression, (arity - alternative) after it

HsCase (XCase p) (LHsExpr p) (MatchGroup p (LHsExpr p))
HsIf (XIf p) (Maybe (SyntaxExpr p)) (LHsExpr p) (LHsExpr p) (LHsExpr p)
HsMultiIf (XMultiIf p) [LGRHS p (LHsExpr p)]

Multi-way if

HsLet (XLet p) (LHsLocalBinds p) (LHsExpr p)

let(rec)

HsDo (XDo p) (HsStmtContext Name) (Located [ExprLStmt p])
ExplicitList (XExplicitList p) (Maybe (SyntaxExpr p)) [LHsExpr p]

Syntactic list: [a,b,c,...]

RecordCon

Record construction

RecordUpd

Record update

ExprWithTySig (XExprWithTySig p) (LHsExpr p)

Expression with an explicit type signature. e :: type

ArithSeq (XArithSeq p) (Maybe (SyntaxExpr p)) (ArithSeqInfo p)

Arithmetic sequence

HsSCC (XSCC p) SourceText StringLiteral (LHsExpr p) 
HsCoreAnn (XCoreAnn p) SourceText StringLiteral (LHsExpr p)
HsBracket (XBracket p) (HsBracket p)
HsRnBracketOut (XRnBracketOut p) (HsBracket GhcRn) [PendingRnSplice] 
HsTcBracketOut (XTcBracketOut p) (HsBracket GhcRn) [PendingTcSplice] 
HsSpliceE (XSpliceE p) (HsSplice p)
HsProc (XProc p) (LPat p) (LHsCmdTop p)

proc notation for Arrows

HsStatic (XStatic p) (LHsExpr p)
HsArrApp (XArrApp p) (LHsExpr p) (LHsExpr p) HsArrAppType Bool
HsArrForm (XArrForm p) (LHsExpr p) (Maybe Fixity) [LHsCmdTop p]
HsTick (XTick p) (Tickish (IdP p)) (LHsExpr p) 
HsBinTick (XBinTick p) Int Int (LHsExpr p) 
HsTickPragma (XTickPragma p) SourceText (StringLiteral, (Int, Int), (Int, Int)) ((SourceText, SourceText), (SourceText, SourceText)) (LHsExpr p)
EWildPat (XEWildPat p) 
EAsPat (XEAsPat p) (Located (IdP p)) (LHsExpr p)
EViewPat (XEViewPat p) (LHsExpr p) (LHsExpr p)
ELazyPat (XELazyPat p) (LHsExpr p)
HsWrap (XWrap p) HsWrapper (HsExpr p) 
XExpr (XXExpr p) 
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsExpr p) 
Instance details

Defined in HsExpr

Methods

ppr :: HsExpr p -> SDoc #

pprPrec :: Rational -> HsExpr p -> SDoc #

data HsSplice id #

Haskell Splice

Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (HsSplice p) 
Instance details

Defined in HsExpr

Methods

ppr :: HsSplice p -> SDoc #

pprPrec :: Rational -> HsSplice p -> SDoc #

data MatchGroup p body #

Constructors

MG 

Fields

XMatchGroup (XXMatchGroup p body) 

data GRHSs p body #

Guarded Right-Hand Sides

GRHSs are used both for pattern bindings and for Matches

Constructors

GRHSs 

Fields

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

Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (SyntaxExpr p) 
Instance details

Defined in HsExpr

Methods

ppr :: SyntaxExpr p -> SDoc #

pprPrec :: Rational -> SyntaxExpr p -> SDoc #

type LHsExpr p #

Arguments

 = Located (HsExpr p)

May have AnnKeywordId : AnnComma when in a list

Located Haskell Expression

pprImpExp :: (HasOccName name, OutputableBndr name) => name -> SDoc #

replaceWrappedName :: IEWrappedName name1 -> name2 -> IEWrappedName name2 #

ieWrappedName :: IEWrappedName name -> name #

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

ieName :: IE pass -> IdP pass #

type LImportDecl pass #

Arguments

 = Located (ImportDecl pass)

When in a list this may have

Located Import Declaration

data ImportDecl pass #

Import Declaration

A single Haskell import declaration.

Constructors

ImportDecl 

Fields

XImportDecl (XXImportDecl pass)

AnnKeywordIds

Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (ImportDecl p) 
Instance details

Defined in HsImpExp

Methods

ppr :: ImportDecl p -> SDoc #

pprPrec :: Rational -> ImportDecl p -> SDoc #

data IEWrappedName name #

A name in an import or export specification which may have adornments. Used primarily for accurate pretty printing of ParsedSource, and API Annotation placement.

Constructors

IEName (Located name)

no extra

IEPattern (Located name)

pattern X

IEType (Located name)

type (:+:)

Instances
Eq name => Eq (IEWrappedName name) 
Instance details

Defined in HsImpExp

Methods

(==) :: IEWrappedName name -> IEWrappedName name -> Bool #

(/=) :: IEWrappedName name -> IEWrappedName name -> Bool #

Data name => Data (IEWrappedName name) 
Instance details

Defined in HsImpExp

Methods

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

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

toConstr :: IEWrappedName name -> Constr #

dataTypeOf :: IEWrappedName name -> DataType #

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

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

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

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

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

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

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

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

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

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

HasOccName name => HasOccName (IEWrappedName name) 
Instance details

Defined in HsImpExp

Methods

occName :: IEWrappedName name -> OccName #

OutputableBndr name => Outputable (IEWrappedName name) 
Instance details

Defined in HsImpExp

Methods

ppr :: IEWrappedName name -> SDoc #

pprPrec :: Rational -> IEWrappedName name -> SDoc #

OutputableBndr name => OutputableBndr (IEWrappedName name) 
Instance details

Defined in HsImpExp

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

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

IEModuleContents (XIEModuleContents pass) (Located ModuleName)

Imported or exported module contents

(Export Only)

IEGroup (XIEGroup pass) Int HsDocString

Doc section heading

IEDoc (XIEDoc pass) HsDocString

Some documentation

IEDocNamed (XIEDocNamed pass) String

Reference to named doc

XIE (XXIE pass) 
Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (IE p) 
Instance details

Defined in HsImpExp

Methods

ppr :: IE p -> SDoc #

pprPrec :: Rational -> IE p -> SDoc #

data IEWildcard #

Imported or Exported Wildcard

Constructors

NoIEWildcard 
IEWildcard Int 
Instances
Eq IEWildcard 
Instance details

Defined in HsImpExp

Data IEWildcard 
Instance details

Defined in HsImpExp

Methods

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

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

toConstr :: IEWildcard -> Constr #

dataTypeOf :: IEWildcard -> DataType #

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

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

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

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

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

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

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

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

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

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

data Pat p #

Constructors

WildPat (XWildPat p)

Wildcard Pattern The sole reason for a type on a WildPat is to support hsPatType :: Pat Id -> Type

LazyPat (XLazyPat p) (LPat p)

Lazy Pattern ^ - AnnKeywordId : AnnTilde

AsPat (XAsPat p) (Located (IdP p)) (LPat p)

As pattern ^ - AnnKeywordId : AnnAt

ParPat (XParPat p) (LPat p)

Parenthesised pattern See Note [Parens in HsSyn] in HsExpr ^ - AnnKeywordId : AnnOpen '(', AnnClose ')'

BangPat (XBangPat p) (LPat p)

Bang pattern ^ - AnnKeywordId : AnnBang

ListPat (XListPat p) [LPat p]

Syntactic List

TuplePat (XTuplePat p) [LPat p] Boxity

Tuple sub-patterns

SumPat (XSumPat p) (LPat p) ConTag Arity

Anonymous sum pattern

ConPatIn (Located (IdP p)) (HsConPatDetails p)

Constructor Pattern In

ConPatOut

Constructor Pattern Out

ViewPat (XViewPat p) (LHsExpr p) (LPat p)

View Pattern

SplicePat (XSplicePat p) (HsSplice p)

Splice Pattern (Includes quasi-quotes)

LitPat (XLitPat p) (HsLit p)

Literal Pattern Used for *non-overloaded* literal patterns: Int, Int, Char, String, etc.

NPat (XNPat p) (Located (HsOverLit p)) (Maybe (SyntaxExpr p)) (SyntaxExpr p)

Natural Pattern

NPlusKPat (XNPlusKPat p) (Located (IdP p)) (Located (HsOverLit p)) (HsOverLit p) (SyntaxExpr p) (SyntaxExpr p)

n+k pattern

SigPat (XSigPat p) (LPat p)

Pattern with a type signature

CoPat (XCoPat p) HsWrapper (Pat p) Type

Coercion Pattern

XPat (XXPat p)

Trees that Grow extension point for new constructors

Instances
(p ~ GhcPass pass, OutputableBndrId p) => Outputable (Pat p) 
Instance details

Defined in HsPat

Methods

ppr :: Pat p -> SDoc #

pprPrec :: Rational -> Pat p -> SDoc #

type LPat p = Located (Pat p) #

noExt :: NoExt #

Used when constructing a term with an unused extension point.

data NoExt #

used as place holder in TTG values

Constructors

NoExt 
Instances
Eq NoExt 
Instance details

Defined in HsExtension

Methods

(==) :: NoExt -> NoExt -> Bool #

(/=) :: NoExt -> NoExt -> Bool #

Data NoExt 
Instance details

Defined in HsExtension

Methods

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

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

toConstr :: NoExt -> Constr #

dataTypeOf :: NoExt -> DataType #

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

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

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

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

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

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

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

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

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

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

Ord NoExt 
Instance details

Defined in HsExtension

Methods

compare :: NoExt -> NoExt -> Ordering #

(<) :: NoExt -> NoExt -> Bool #

(<=) :: NoExt -> NoExt -> Bool #

(>) :: NoExt -> NoExt -> Bool #

(>=) :: NoExt -> NoExt -> Bool #

max :: NoExt -> NoExt -> NoExt #

min :: NoExt -> NoExt -> NoExt #

Outputable NoExt 
Instance details

Defined in HsExtension

Methods

ppr :: NoExt -> SDoc #

pprPrec :: Rational -> NoExt -> SDoc #

data GhcPass (c :: Pass) #

Used as a data type index for the hsSyn AST

Instances
Eq (GhcPass c) 
Instance details

Defined in HsExtension

Methods

(==) :: GhcPass c -> GhcPass c -> Bool #

(/=) :: GhcPass c -> GhcPass c -> Bool #

Data (HsModule GhcPs) 
Instance details

Defined in HsSyn

Methods

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

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

toConstr :: HsModule GhcPs -> Constr #

dataTypeOf :: HsModule GhcPs -> DataType #

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

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

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

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

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

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

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

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

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

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

Data (HsModule GhcRn) 
Instance details

Defined in HsSyn

Methods

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

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

toConstr :: HsModule GhcRn -> Constr #

dataTypeOf :: HsModule GhcRn -> DataType #

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

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

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

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

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

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

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

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

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

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

Data (HsModule GhcTc) 
Instance details

Defined in HsSyn

Methods

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

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

toConstr :: HsModule GhcTc -> Constr #

dataTypeOf :: HsModule GhcTc -> DataType #

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

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

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

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

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

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

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

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

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

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

Typeable c => Data (GhcPass c) 
Instance details

Defined in HsExtension

Methods

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

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

toConstr :: GhcPass c -> Constr #

dataTypeOf :: GhcPass c -> DataType #

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

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

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

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

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

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

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

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

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

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

OutputableBndrId (GhcPass a) => Outputable (InstInfo (GhcPass a)) 
Instance details

Defined in TcEnv

Methods

ppr :: InstInfo (GhcPass a) -> SDoc #

pprPrec :: Rational -> InstInfo (GhcPass a) -> SDoc #

type IdP GhcPs 
Instance details

Defined in HsExtension

type IdP GhcRn 
Instance details

Defined in HsExtension

type IdP GhcRn = Name
type IdP GhcTc 
Instance details

Defined in HsExtension

type IdP GhcTc = Id
type XIPBinds GhcPs 
Instance details

Defined in HsBinds

type XIPBinds GhcRn 
Instance details

Defined in HsBinds

type XIPBinds GhcTc 
Instance details

Defined in HsBinds

type XSynDecl GhcPs 
Instance details

Defined in HsDecls

type XSynDecl GhcRn 
Instance details

Defined in HsDecls

type XSynDecl GhcTc 
Instance details

Defined in HsDecls

type XDataDecl GhcPs 
Instance details

Defined in HsDecls

type XDataDecl GhcRn 
Instance details

Defined in HsDecls

type XDataDecl GhcTc 
Instance details

Defined in HsDecls

type XClassDecl GhcPs 
Instance details

Defined in HsDecls

type XClassDecl GhcRn 
Instance details

Defined in HsDecls

type XClassDecl GhcTc 
Instance details

Defined in HsDecls

type XViaStrategy GhcPs 
Instance details

Defined in HsDecls

type XViaStrategy GhcRn 
Instance details

Defined in HsDecls

type XViaStrategy GhcTc 
Instance details

Defined in HsDecls

type XForeignImport GhcPs 
Instance details

Defined in HsDecls

type XForeignImport GhcRn 
Instance details

Defined in HsDecls

type XForeignImport GhcTc 
Instance details

Defined in HsDecls

type XForeignExport GhcPs 
Instance details

Defined in HsDecls

type XForeignExport GhcRn 
Instance details

Defined in HsDecls

type XForeignExport GhcTc 
Instance details

Defined in HsDecls

type XHsRule GhcPs 
Instance details

Defined in HsDecls

type XHsRule GhcRn 
Instance details

Defined in HsDecls

type XHsRule GhcTc 
Instance details

Defined in HsDecls

type XAppTypeE GhcPs 
Instance details

Defined in HsExpr

type XAppTypeE GhcRn 
Instance details

Defined in HsExpr

type XAppTypeE GhcTc 
Instance details

Defined in HsExpr

type XOpApp GhcPs 
Instance details

Defined in HsExpr

type XOpApp GhcRn 
Instance details

Defined in HsExpr

type XOpApp GhcTc 
Instance details

Defined in HsExpr

type XExplicitSum GhcPs 
Instance details

Defined in HsExpr

type XExplicitSum GhcRn 
Instance details

Defined in HsExpr

type XExplicitSum GhcTc 
Instance details

Defined in HsExpr

type XMultiIf GhcPs 
Instance details

Defined in HsExpr

type XMultiIf GhcRn 
Instance details

Defined in HsExpr

type XMultiIf GhcTc 
Instance details

Defined in HsExpr

type XDo GhcPs 
Instance details

Defined in HsExpr

type XDo GhcPs = NoExt
type XDo GhcRn 
Instance details

Defined in HsExpr

type XDo GhcRn = NoExt
type XDo GhcTc 
Instance details

Defined in HsExpr

type XDo GhcTc = Type
type XExplicitList GhcPs 
Instance details

Defined in HsExpr

type XExplicitList GhcRn 
Instance details

Defined in HsExpr

type XExplicitList GhcTc 
Instance details

Defined in HsExpr

type XRecordCon GhcPs 
Instance details

Defined in HsExpr

type XRecordCon GhcRn 
Instance details

Defined in HsExpr

type XRecordCon GhcTc 
Instance details

Defined in HsExpr

type XRecordUpd GhcPs 
Instance details

Defined in HsExpr

type XRecordUpd GhcRn 
Instance details

Defined in HsExpr

type XRecordUpd GhcTc 
Instance details

Defined in HsExpr

type XExprWithTySig GhcPs 
Instance details

Defined in HsExpr

type XExprWithTySig GhcRn 
Instance details

Defined in HsExpr

type XExprWithTySig GhcTc 
Instance details

Defined in HsExpr

type XArithSeq GhcPs 
Instance details

Defined in HsExpr

type XArithSeq GhcRn 
Instance details

Defined in HsExpr

type XArithSeq GhcTc 
Instance details

Defined in HsExpr

type XStatic GhcPs 
Instance details

Defined in HsExpr

type XStatic GhcRn 
Instance details

Defined in HsExpr

type XStatic GhcTc 
Instance details

Defined in HsExpr

type XArrApp GhcPs 
Instance details

Defined in HsExpr

type XArrApp GhcRn 
Instance details

Defined in HsExpr

type XArrApp GhcTc 
Instance details

Defined in HsExpr

type XUnambiguous GhcPs 
Instance details

Defined in HsTypes

type XUnambiguous GhcRn 
Instance details

Defined in HsTypes

type XUnambiguous GhcTc 
Instance details

Defined in HsTypes

type XAmbiguous GhcPs 
Instance details

Defined in HsTypes

type XAmbiguous GhcRn 
Instance details

Defined in HsTypes

type XAmbiguous GhcTc 
Instance details

Defined in HsTypes

type XMissing GhcPs 
Instance details

Defined in HsExpr

type XMissing GhcRn 
Instance details

Defined in HsExpr

type XMissing GhcTc 
Instance details

Defined in HsExpr

type XCmdTop GhcPs 
Instance details

Defined in HsExpr

type XCmdTop GhcRn 
Instance details

Defined in HsExpr

type XCmdTop GhcTc 
Instance details

Defined in HsExpr

type XCmdArrApp GhcPs 
Instance details

Defined in HsExpr

type XCmdArrApp GhcRn 
Instance details

Defined in HsExpr

type XCmdArrApp GhcTc 
Instance details

Defined in HsExpr

type XCmdDo GhcPs 
Instance details

Defined in HsExpr

type XCmdDo GhcRn 
Instance details

Defined in HsExpr

type XCmdDo GhcTc 
Instance details

Defined in HsExpr

type XOverLit GhcPs 
Instance details

Defined in HsLit

type XOverLit GhcRn 
Instance details

Defined in HsLit

type XOverLit GhcTc 
Instance details

Defined in HsLit

type XWildPat GhcPs 
Instance details

Defined in HsPat

type XWildPat GhcRn 
Instance details

Defined in HsPat

type XWildPat GhcTc 
Instance details

Defined in HsPat

type XListPat GhcPs 
Instance details

Defined in HsPat

type XListPat GhcRn 
Instance details

Defined in HsPat

type XListPat GhcTc 
Instance details

Defined in HsPat

type XTuplePat GhcPs 
Instance details

Defined in HsPat

type XTuplePat GhcRn 
Instance details

Defined in HsPat

type XTuplePat GhcTc 
Instance details

Defined in HsPat

type XSumPat GhcPs 
Instance details

Defined in HsPat

type XSumPat GhcRn 
Instance details

Defined in HsPat

type XSumPat GhcTc 
Instance details

Defined in HsPat

type XSumPat GhcTc = [Type]
type XViewPat GhcPs 
Instance details

Defined in HsPat

type XViewPat GhcRn 
Instance details

Defined in HsPat

type XViewPat GhcTc 
Instance details

Defined in HsPat

type XNPat GhcPs 
Instance details

Defined in HsPat

type XNPat GhcRn 
Instance details

Defined in HsPat

type XNPat GhcTc 
Instance details

Defined in HsPat

type XNPlusKPat GhcPs 
Instance details

Defined in HsPat

type XNPlusKPat GhcRn 
Instance details

Defined in HsPat

type XNPlusKPat GhcTc 
Instance details

Defined in HsPat

type XSigPat GhcPs 
Instance details

Defined in HsPat

type XSigPat GhcRn 
Instance details

Defined in HsPat

type XSigPat GhcTc 
Instance details

Defined in HsPat

type XHsQTvs GhcPs 
Instance details

Defined in HsTypes

type XHsQTvs GhcRn 
Instance details

Defined in HsTypes

type XHsQTvs GhcTc 
Instance details

Defined in HsTypes

type XSpliceTy GhcPs 
Instance details

Defined in HsTypes

type XSpliceTy GhcRn 
Instance details

Defined in HsTypes

type XSpliceTy GhcTc 
Instance details

Defined in HsTypes

type XExplicitListTy GhcPs 
Instance details

Defined in HsTypes

type XExplicitListTy GhcRn 
Instance details

Defined in HsTypes

type XExplicitListTy GhcTc 
Instance details

Defined in HsTypes

type XExplicitTupleTy GhcPs 
Instance details

Defined in HsTypes

type XExplicitTupleTy GhcRn 
Instance details

Defined in HsTypes

type XExplicitTupleTy GhcTc 
Instance details

Defined in HsTypes

type XWildCardTy GhcPs 
Instance details

Defined in HsTypes

type XWildCardTy GhcRn 
Instance details

Defined in HsTypes

type XWildCardTy GhcTc 
Instance details

Defined in HsTypes

type XCFieldOcc GhcPs 
Instance details

Defined in HsTypes

type XCFieldOcc GhcRn 
Instance details

Defined in HsTypes

type XCFieldOcc GhcTc 
Instance details

Defined in HsTypes

type XMG GhcPs b 
Instance details

Defined in HsExpr

type XMG GhcPs b = NoExt
type XMG GhcRn b 
Instance details

Defined in HsExpr

type XMG GhcRn b = NoExt
type XMG GhcTc b 
Instance details

Defined in HsExpr

type XHsIB GhcPs _ 
Instance details

Defined in HsTypes

type XHsIB GhcPs _ = NoExt
type XHsIB GhcRn _ 
Instance details

Defined in HsTypes

type XHsIB GhcRn _ = HsIBRn
type XHsIB GhcTc _ 
Instance details

Defined in HsTypes

type XHsIB GhcTc _ = HsIBRn
type XHsWC GhcPs b 
Instance details

Defined in HsTypes

type XHsWC GhcPs b = NoExt
type XHsWC GhcRn b 
Instance details

Defined in HsTypes

type XHsWC GhcRn b = [Name]
type XHsWC GhcTc b 
Instance details

Defined in HsTypes

type XHsWC GhcTc b = [Name]
type XPatBind GhcPs (GhcPass pR) 
Instance details

Defined in HsBinds

type XPatBind GhcRn (GhcPass pR) 
Instance details

Defined in HsBinds

type XPatBind GhcTc (GhcPass pR) 
Instance details

Defined in HsBinds

type XABE (GhcPass p) 
Instance details

Defined in HsBinds

type XABE (GhcPass p) = NoExt
type XXABExport (GhcPass p) 
Instance details

Defined in HsBinds

type XXHsIPBinds (GhcPass p) 
Instance details

Defined in HsBinds

type XCIPBind (GhcPass p) 
Instance details

Defined in HsBinds

type XXIPBind (GhcPass p) 
Instance details

Defined in HsBinds

type XTypeSig (GhcPass p) 
Instance details

Defined in HsBinds

type XPatSynSig (GhcPass p) 
Instance details

Defined in HsBinds

type XClassOpSig (GhcPass p) 
Instance details

Defined in HsBinds

type XIdSig (GhcPass p) 
Instance details

Defined in HsBinds

type XIdSig (GhcPass p) = NoExt
type XFixSig (GhcPass p) 
Instance details

Defined in HsBinds

type XFixSig (GhcPass p) = NoExt
type XInlineSig (GhcPass p) 
Instance details

Defined in HsBinds

type XSpecSig (GhcPass p) 
Instance details

Defined in HsBinds

type XSpecInstSig (GhcPass p) 
Instance details

Defined in HsBinds

type XMinimalSig (GhcPass p) 
Instance details

Defined in HsBinds

type XSCCFunSig (GhcPass p) 
Instance details

Defined in HsBinds

type XCompleteMatchSig (GhcPass p) 
Instance details

Defined in HsBinds

type XXSig (GhcPass p) 
Instance details

Defined in HsBinds

type XXSig (GhcPass p) = NoExt
type XFixitySig (GhcPass p) 
Instance details

Defined in HsBinds

type XXFixitySig (GhcPass p) 
Instance details

Defined in HsBinds

type XTyClD (GhcPass _) 
Instance details

Defined in HsDecls

type XTyClD (GhcPass _) = NoExt
type XInstD (GhcPass _) 
Instance details

Defined in HsDecls

type XInstD (GhcPass _) = NoExt
type XDerivD (GhcPass _) 
Instance details

Defined in HsDecls

type XDerivD (GhcPass _) = NoExt
type XValD (GhcPass _) 
Instance details

Defined in HsDecls

type XValD (GhcPass _) = NoExt
type XSigD (GhcPass _) 
Instance details

Defined in HsDecls

type XSigD (GhcPass _) = NoExt
type XDefD (GhcPass _) 
Instance details

Defined in HsDecls

type XDefD (GhcPass _) = NoExt
type XForD (GhcPass _) 
Instance details

Defined in HsDecls

type XForD (GhcPass _) = NoExt
type XWarningD (GhcPass _) 
Instance details

Defined in HsDecls

type XAnnD (GhcPass _) 
Instance details

Defined in HsDecls

type XAnnD (GhcPass _) = NoExt
type XRuleD (GhcPass _) 
Instance details

Defined in HsDecls

type XRuleD (GhcPass _) = NoExt
type XSpliceD (GhcPass _) 
Instance details

Defined in HsDecls

type XDocD (GhcPass _) 
Instance details

Defined in HsDecls

type XDocD (GhcPass _) = NoExt
type XRoleAnnotD (GhcPass _) 
Instance details

Defined in HsDecls

type XXHsDecl (GhcPass _) 
Instance details

Defined in HsDecls

type XCHsGroup (GhcPass _) 
Instance details

Defined in HsDecls

type XXHsGroup (GhcPass _) 
Instance details

Defined in HsDecls

type XSpliceDecl (GhcPass _) 
Instance details

Defined in HsDecls

type XXSpliceDecl (GhcPass _) 
Instance details

Defined in HsDecls

type XFamDecl (GhcPass _) 
Instance details

Defined in HsDecls

type XXTyClDecl (GhcPass _) 
Instance details

Defined in HsDecls

type XCTyClGroup (GhcPass _) 
Instance details

Defined in HsDecls

type XXTyClGroup (GhcPass _) 
Instance details

Defined in HsDecls

type XNoSig (GhcPass _) 
Instance details

Defined in HsDecls

type XNoSig (GhcPass _) = NoExt
type XCKindSig (GhcPass _) 
Instance details

Defined in HsDecls

type XTyVarSig (GhcPass _) 
Instance details

Defined in HsDecls

type XXFamilyResultSig (GhcPass _) 
Instance details

Defined in HsDecls

type XCFamilyDecl (GhcPass _) 
Instance details

Defined in HsDecls

type XXFamilyDecl (GhcPass _) 
Instance details

Defined in HsDecls

type XCHsDataDefn (GhcPass _) 
Instance details

Defined in HsDecls

type XXHsDataDefn (GhcPass _) 
Instance details

Defined in HsDecls

type XCHsDerivingClause (GhcPass _) 
Instance details

Defined in HsDecls

type XXHsDerivingClause (GhcPass _) 
Instance details

Defined in HsDecls

type XConDeclGADT (GhcPass _) 
Instance details

Defined in HsDecls

type XConDeclH98 (GhcPass _) 
Instance details

Defined in HsDecls

type XXConDecl (GhcPass _) 
Instance details

Defined in HsDecls

type XCClsInstDecl (GhcPass _) 
Instance details

Defined in HsDecls

type XXClsInstDecl (GhcPass _) 
Instance details

Defined in HsDecls

type XClsInstD (GhcPass _) 
Instance details

Defined in HsDecls

type XDataFamInstD (GhcPass _) 
Instance details

Defined in HsDecls

type XTyFamInstD (GhcPass _) 
Instance details

Defined in HsDecls

type XXInstDecl (GhcPass _) 
Instance details

Defined in HsDecls

type XCDerivDecl (GhcPass _) 
Instance details

Defined in HsDecls

type XXDerivDecl (GhcPass _) 
Instance details

Defined in HsDecls

type XCDefaultDecl (GhcPass _) 
Instance details

Defined in HsDecls

type XXDefaultDecl (GhcPass _) 
Instance details

Defined in HsDecls

type XXForeignDecl (GhcPass _) 
Instance details

Defined in HsDecls

type XCRuleDecls (GhcPass _) 
Instance details

Defined in HsDecls

type XXRuleDecls (GhcPass _) 
Instance details

Defined in HsDecls

type XXRuleDecl (GhcPass _) 
Instance details

Defined in HsDecls

type XCRuleBndr (GhcPass _) 
Instance details

Defined in HsDecls

type XRuleBndrSig (GhcPass _) 
Instance details

Defined in HsDecls

type XXRuleBndr (GhcPass _) 
Instance details

Defined in HsDecls

type XWarnings (GhcPass _) 
Instance details

Defined in HsDecls

type XXWarnDecls (GhcPass _) 
Instance details

Defined in HsDecls

type XWarning (GhcPass _) 
Instance details

Defined in HsDecls

type XXWarnDecl (GhcPass _) 
Instance details

Defined in HsDecls

type XHsAnnotation (GhcPass _) 
Instance details

Defined in HsDecls

type XXAnnDecl (GhcPass _) 
Instance details

Defined in HsDecls

type XCRoleAnnotDecl (GhcPass _) 
Instance details

Defined in HsDecls

type XXRoleAnnotDecl (GhcPass _) 
Instance details

Defined in HsDecls

type XVar (GhcPass _) 
Instance details

Defined in HsExpr

type XVar (GhcPass _) = NoExt
type XUnboundVar (GhcPass _) 
Instance details

Defined in HsExpr

type XConLikeOut (GhcPass _) 
Instance details

Defined in HsExpr

type XRecFld (GhcPass _) 
Instance details

Defined in HsExpr

type XRecFld (GhcPass _) = NoExt
type XOverLabel (GhcPass _) 
Instance details

Defined in HsExpr

type XIPVar (GhcPass _) 
Instance details

Defined in HsExpr

type XIPVar (GhcPass _) = NoExt
type XOverLitE (GhcPass _) 
Instance details

Defined in HsExpr

type XLitE (GhcPass _) 
Instance details

Defined in HsExpr

type XLitE (GhcPass _) = NoExt
type XLam (GhcPass _) 
Instance details

Defined in HsExpr

type XLam (GhcPass _) = NoExt
type XLamCase (GhcPass _) 
Instance details

Defined in HsExpr

type XApp (GhcPass _) 
Instance details

Defined in HsExpr

type XApp (GhcPass _) = NoExt
type XNegApp (GhcPass _) 
Instance details

Defined in HsExpr

type XNegApp (GhcPass _) = NoExt
type XPar (GhcPass _) 
Instance details

Defined in HsExpr

type XPar (GhcPass _) = NoExt
type XSectionL (GhcPass _) 
Instance details

Defined in HsExpr

type XSectionR (GhcPass _) 
Instance details

Defined in HsExpr

type XExplicitTuple (GhcPass _) 
Instance details

Defined in HsExpr

type XCase (GhcPass _) 
Instance details

Defined in HsExpr

type XCase (GhcPass _) = NoExt
type XIf (GhcPass _) 
Instance details

Defined in HsExpr

type XIf (GhcPass _) = NoExt
type XLet (GhcPass _) 
Instance details

Defined in HsExpr

type XLet (GhcPass _) = NoExt
type XSCC (GhcPass _) 
Instance details

Defined in HsExpr

type XSCC (GhcPass _) = NoExt
type XCoreAnn (GhcPass _) 
Instance details

Defined in HsExpr

type XBracket (GhcPass _) 
Instance details

Defined in HsExpr

type XRnBracketOut (GhcPass _) 
Instance details

Defined in HsExpr

type XTcBracketOut (GhcPass _) 
Instance details

Defined in HsExpr

type XSpliceE (GhcPass _) 
Instance details

Defined in HsExpr

type XProc (GhcPass _) 
Instance details

Defined in HsExpr

type XProc (GhcPass _) = NoExt
type XArrForm (GhcPass _) 
Instance details

Defined in HsExpr

type XTick (GhcPass _) 
Instance details

Defined in HsExpr

type XTick (GhcPass _) = NoExt
type XBinTick (GhcPass _) 
Instance details

Defined in HsExpr

type XTickPragma (GhcPass _) 
Instance details

Defined in HsExpr

type XEWildPat (GhcPass _) 
Instance details

Defined in HsExpr

type XEAsPat (GhcPass _) 
Instance details

Defined in HsExpr

type XEAsPat (GhcPass _) = NoExt
type XEViewPat (GhcPass _) 
Instance details

Defined in HsExpr

type XELazyPat (GhcPass _) 
Instance details

Defined in HsExpr

type XWrap (GhcPass _) 
Instance details

Defined in HsExpr

type XWrap (GhcPass _) = NoExt
type XXExpr (GhcPass _) 
Instance details

Defined in HsExpr

type XXExpr (GhcPass _) = NoExt
type XXAmbiguousFieldOcc (GhcPass _) 
Instance details

Defined in HsTypes

type XPresent (GhcPass _) 
Instance details

Defined in HsExpr

type XXTupArg (GhcPass _) 
Instance details

Defined in HsExpr

type XTypedSplice (GhcPass _) 
Instance details

Defined in HsExpr

type XUntypedSplice (GhcPass _) 
Instance details

Defined in HsExpr

type XQuasiQuote (GhcPass _) 
Instance details

Defined in HsExpr

type XSpliced (GhcPass _) 
Instance details

Defined in HsExpr

type XXSplice (GhcPass _) 
Instance details

Defined in HsExpr

type XExpBr (GhcPass _) 
Instance details

Defined in HsExpr

type XExpBr (GhcPass _) = NoExt
type XPatBr (GhcPass _) 
Instance details

Defined in HsExpr

type XPatBr (GhcPass _) = NoExt
type XDecBrL (GhcPass _) 
Instance details

Defined in HsExpr

type XDecBrL (GhcPass _) = NoExt
type XDecBrG (GhcPass _) 
Instance details

Defined in HsExpr

type XDecBrG (GhcPass _) = NoExt
type XTypBr (GhcPass _) 
Instance details

Defined in HsExpr

type XTypBr (GhcPass _) = NoExt
type XVarBr (GhcPass _) 
Instance details

Defined in HsExpr

type XVarBr (GhcPass _) = NoExt
type XTExpBr (GhcPass _) 
Instance details

Defined in HsExpr

type XTExpBr (GhcPass _) = NoExt
type XXBracket (GhcPass _) 
Instance details

Defined in HsExpr

type XXCmdTop (GhcPass _) 
Instance details

Defined in HsExpr

type XCmdArrForm (GhcPass _) 
Instance details

Defined in HsExpr

type XCmdApp (GhcPass _) 
Instance details

Defined in HsExpr

type XCmdApp (GhcPass _) = NoExt
type XCmdLam (GhcPass _) 
Instance details

Defined in HsExpr

type XCmdLam (GhcPass _) = NoExt
type XCmdPar (GhcPass _) 
Instance details

Defined in HsExpr

type XCmdPar (GhcPass _) = NoExt
type XCmdCase (GhcPass _) 
Instance details

Defined in HsExpr

type XCmdIf (GhcPass _) 
Instance details

Defined in HsExpr

type XCmdIf (GhcPass _) = NoExt
type XCmdLet (GhcPass _) 
Instance details

Defined in HsExpr

type XCmdLet (GhcPass _) = NoExt
type XCmdWrap (GhcPass _) 
Instance details

Defined in HsExpr

type XXCmd (GhcPass _) 
Instance details

Defined in HsExpr

type XXCmd (GhcPass _) = NoExt
type XApplicativeArgOne (GhcPass _) 
Instance details

Defined in HsExpr

type XApplicativeArgMany (GhcPass _) 
Instance details

Defined in HsExpr

type XXApplicativeArg (GhcPass _) 
Instance details

Defined in HsExpr

type XHsChar (GhcPass _) 
Instance details

Defined in HsLit

type XHsCharPrim (GhcPass _) 
Instance details

Defined in HsLit

type XHsString (GhcPass _) 
Instance details

Defined in HsLit

type XHsStringPrim (GhcPass _) 
Instance details

Defined in HsLit

type XHsInt (GhcPass _) 
Instance details

Defined in HsLit

type XHsInt (GhcPass _) = NoExt
type XHsIntPrim (GhcPass _) 
Instance details

Defined in HsLit

type XHsWordPrim (GhcPass _) 
Instance details

Defined in HsLit

type XHsInt64Prim (GhcPass _) 
Instance details

Defined in HsLit

type XHsWord64Prim (GhcPass _) 
Instance details

Defined in HsLit

type XHsInteger (GhcPass _) 
Instance details

Defined in HsLit

type XHsRat (GhcPass _) 
Instance details

Defined in HsLit

type XHsRat (GhcPass _) = NoExt
type XHsFloatPrim (GhcPass _) 
Instance details

Defined in HsLit

type XHsDoublePrim (GhcPass _) 
Instance details

Defined in HsLit

type XXLit (GhcPass _) 
Instance details

Defined in HsLit

type XXLit (GhcPass _) = NoExt
type XXOverLit (GhcPass _) 
Instance details

Defined in HsLit

type XVarPat (GhcPass _) 
Instance details

Defined in HsPat

type XVarPat (GhcPass _) = NoExt
type XLazyPat (GhcPass _) 
Instance details

Defined in HsPat

type XAsPat (GhcPass _) 
Instance details

Defined in HsPat

type XAsPat (GhcPass _) = NoExt
type XParPat (GhcPass _) 
Instance details

Defined in HsPat

type XParPat (GhcPass _) = NoExt
type XBangPat (GhcPass _) 
Instance details

Defined in HsPat

type XSplicePat (GhcPass _) 
Instance details

Defined in HsPat

type XLitPat (GhcPass _) 
Instance details

Defined in HsPat

type XLitPat (GhcPass _) = NoExt
type XCoPat (GhcPass _) 
Instance details

Defined in HsPat

type XCoPat (GhcPass _) = NoExt
type XXPat (GhcPass _) 
Instance details

Defined in HsPat

type XXPat (GhcPass _) = NoExt
type XXLHsQTyVars (GhcPass _) 
Instance details

Defined in HsTypes

type XForAllTy (GhcPass _) 
Instance details

Defined in HsTypes

type XQualTy (GhcPass _) 
Instance details

Defined in HsTypes

type XQualTy (GhcPass _) = NoExt
type XTyVar (GhcPass _) 
Instance details

Defined in HsTypes

type XTyVar (GhcPass _) = NoExt
type XAppTy (GhcPass _) 
Instance details

Defined in HsTypes

type XAppTy (GhcPass _) = NoExt
type XFunTy (GhcPass _) 
Instance details

Defined in HsTypes

type XFunTy (GhcPass _) = NoExt
type XListTy (GhcPass _) 
Instance details

Defined in HsTypes

type XListTy (GhcPass _) = NoExt
type XTupleTy (GhcPass _) 
Instance details

Defined in HsTypes

type XSumTy (GhcPass _) 
Instance details

Defined in HsTypes

type XSumTy (GhcPass _) = NoExt
type XOpTy (GhcPass _) 
Instance details

Defined in HsTypes

type XOpTy (GhcPass _) = NoExt
type XParTy (GhcPass _) 
Instance details

Defined in HsTypes

type XParTy (GhcPass _) = NoExt
type XIParamTy (GhcPass _) 
Instance details

Defined in HsTypes

type XStarTy (GhcPass _) 
Instance details

Defined in HsTypes

type XStarTy (GhcPass _) = NoExt
type XKindSig (GhcPass _) 
Instance details

Defined in HsTypes

type XDocTy (GhcPass _) 
Instance details

Defined in HsTypes

type XDocTy (GhcPass _) = NoExt
type XBangTy (GhcPass _) 
Instance details

Defined in HsTypes

type XBangTy (GhcPass _) = NoExt
type XRecTy (GhcPass _) 
Instance details

Defined in HsTypes

type XRecTy (GhcPass _) = NoExt
type XTyLit (GhcPass _) 
Instance details

Defined in HsTypes

type XTyLit (GhcPass _) = NoExt
type XXType (GhcPass _) 
Instance details

Defined in HsTypes

type XUserTyVar (GhcPass _) 
Instance details

Defined in HsTypes

type XKindedTyVar (GhcPass _) 
Instance details

Defined in HsTypes

type XXTyVarBndr (GhcPass _) 
Instance details

Defined in HsTypes

type XConDeclField (GhcPass _) 
Instance details

Defined in HsTypes

type XXConDeclField (GhcPass _) 
Instance details

Defined in HsTypes

type XXFieldOcc (GhcPass _) 
Instance details

Defined in HsTypes

type XCImportDecl (GhcPass _) 
Instance details

Defined in HsImpExp

type XXImportDecl (GhcPass _) 
Instance details

Defined in HsImpExp

type XIEVar (GhcPass _) 
Instance details

Defined in HsImpExp

type XIEVar (GhcPass _) = NoExt
type XIEThingAbs (GhcPass _) 
Instance details

Defined in HsImpExp

type XIEThingAll (GhcPass _) 
Instance details

Defined in HsImpExp

type XIEThingWith (GhcPass _) 
Instance details

Defined in HsImpExp

type XIEModuleContents (GhcPass _) 
Instance details

Defined in HsImpExp

type XIEGroup (GhcPass _) 
Instance details

Defined in HsImpExp

type XIEDoc (GhcPass _) 
Instance details

Defined in HsImpExp

type XIEDoc (GhcPass _) = NoExt
type XIEDocNamed (GhcPass _) 
Instance details

Defined in HsImpExp

type XXIE (GhcPass _) 
Instance details

Defined in HsImpExp

type XXIE (GhcPass _) = NoExt
type XFunBind (GhcPass pL) GhcTc 
Instance details

Defined in HsBinds

type XFunBind (GhcPass pL) GhcRn 
Instance details

Defined in HsBinds

type XFunBind (GhcPass pL) GhcPs 
Instance details

Defined in HsBinds

type XPSB (GhcPass idL) GhcTc 
Instance details

Defined in HsBinds

type XPSB (GhcPass idL) GhcTc = NameSet
type XPSB (GhcPass idL) GhcRn 
Instance details

Defined in HsBinds

type XPSB (GhcPass idL) GhcRn = NameSet
type XPSB (GhcPass idL) GhcPs 
Instance details

Defined in HsBinds

type XPSB (GhcPass idL) GhcPs = NoExt
type XXMatchGroup (GhcPass _) b 
Instance details

Defined in HsExpr

type XCMatch (GhcPass _) b 
Instance details

Defined in HsExpr

type XCMatch (GhcPass _) b = NoExt
type XXMatch (GhcPass _) b 
Instance details

Defined in HsExpr

type XXMatch (GhcPass _) b = NoExt
type XCGRHSs (GhcPass _) b 
Instance details

Defined in HsExpr

type XCGRHSs (GhcPass _) b = NoExt
type XXGRHSs (GhcPass _) b 
Instance details

Defined in HsExpr

type XXGRHSs (GhcPass _) b = NoExt
type XCGRHS (GhcPass _) b 
Instance details

Defined in HsExpr

type XCGRHS (GhcPass _) b = NoExt
type XXGRHS (GhcPass _) b 
Instance details

Defined in HsExpr

type XXGRHS (GhcPass _) b = NoExt
type XXHsImplicitBndrs (GhcPass _1) _2 
Instance details

Defined in HsTypes

type XXHsWildCardBndrs (GhcPass _) b 
Instance details

Defined in HsTypes

type XCFamEqn (GhcPass _) p r 
Instance details

Defined in HsDecls

type XCFamEqn (GhcPass _) p r = NoExt
type XXFamEqn (GhcPass _) p r 
Instance details

Defined in HsDecls

type XXFamEqn (GhcPass _) p r = NoExt
type XBindStmt (GhcPass _) GhcTc b 
Instance details

Defined in HsExpr

type XBindStmt (GhcPass _) GhcRn b 
Instance details

Defined in HsExpr

type XBindStmt (GhcPass _) GhcPs b 
Instance details

Defined in HsExpr

type XApplicativeStmt (GhcPass _) GhcTc b 
Instance details

Defined in HsExpr

type XApplicativeStmt (GhcPass _) GhcRn b 
Instance details

Defined in HsExpr

type XApplicativeStmt (GhcPass _) GhcPs b 
Instance details

Defined in HsExpr

type XBodyStmt (GhcPass _) GhcTc b 
Instance details

Defined in HsExpr

type XBodyStmt (GhcPass _) GhcRn b 
Instance details

Defined in HsExpr

type XBodyStmt (GhcPass _) GhcPs b 
Instance details

Defined in HsExpr

type XParStmt (GhcPass _) GhcTc b 
Instance details

Defined in HsExpr

type XParStmt (GhcPass _) GhcTc b = Type
type XParStmt (GhcPass _) GhcRn b 
Instance details

Defined in HsExpr

type XParStmt (GhcPass _) GhcPs b 
Instance details

Defined in HsExpr

type XTransStmt (GhcPass _) GhcTc b 
Instance details

Defined in HsExpr

type XTransStmt (GhcPass _) GhcRn b 
Instance details

Defined in HsExpr

type XTransStmt (GhcPass _) GhcPs b 
Instance details

Defined in HsExpr

type XRecStmt (GhcPass _) GhcRn b 
Instance details

Defined in HsExpr

type XRecStmt (GhcPass _) GhcPs b 
Instance details

Defined in HsExpr

type XRecStmt (GhcPass _) GhcTc b 
Instance details

Defined in HsExpr

type XHsValBinds (GhcPass pL) (GhcPass pR) 
Instance details

Defined in HsBinds

type XHsValBinds (GhcPass pL) (GhcPass pR) = NoExt
type XHsIPBinds (GhcPass pL) (GhcPass pR) 
Instance details

Defined in HsBinds

type XHsIPBinds (GhcPass pL) (GhcPass pR) = NoExt
type XEmptyLocalBinds (GhcPass pL) (GhcPass pR) 
Instance details

Defined in HsBinds

type XXHsLocalBindsLR (GhcPass pL) (GhcPass pR) 
Instance details

Defined in HsBinds

type XValBinds (GhcPass pL) (GhcPass pR) 
Instance details

Defined in HsBinds

type XValBinds (GhcPass pL) (GhcPass pR) = NoExt
type XXValBindsLR (GhcPass pL) (GhcPass pR) 
Instance details

Defined in HsBinds

type XVarBind (GhcPass pL) (GhcPass pR) 
Instance details

Defined in HsBinds

type XVarBind (GhcPass pL) (GhcPass pR) = NoExt
type XAbsBinds (GhcPass pL) (GhcPass pR) 
Instance details

Defined in HsBinds

type XAbsBinds (GhcPass pL) (GhcPass pR) = NoExt
type XPatSynBind (GhcPass pL) (GhcPass pR) 
Instance details

Defined in HsBinds

type XPatSynBind (GhcPass pL) (GhcPass pR) = NoExt
type XXHsBindsLR (GhcPass pL) (GhcPass pR) 
Instance details

Defined in HsBinds

type XXHsBindsLR (GhcPass pL) (GhcPass pR) = NoExt
type XXPatSynBind (GhcPass idL) (GhcPass idR) 
Instance details

Defined in HsBinds

type XXPatSynBind (GhcPass idL) (GhcPass idR) = NoExt
type XParStmtBlock (GhcPass pL) (GhcPass pR) 
Instance details

Defined in HsExpr

type XXParStmtBlock (GhcPass pL) (GhcPass pR) 
Instance details

Defined in HsExpr

type XLastStmt (GhcPass _1) (GhcPass _2) b 
Instance details

Defined in HsExpr

type XLastStmt (GhcPass _1) (GhcPass _2) b = NoExt
type XLetStmt (GhcPass _1) (GhcPass _2) b 
Instance details

Defined in HsExpr

type XLetStmt (GhcPass _1) (GhcPass _2) b = NoExt
type XXStmtLR (GhcPass _1) (GhcPass _2) b 
Instance details

Defined in HsExpr

type XXStmtLR (GhcPass _1) (GhcPass _2) b = NoExt

data Pass #

Constructors

Parsed 
Renamed 
Typechecked 
Instances
Data Pass 
Instance details

Defined in HsExtension

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Pass -> c Pass #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Pass #

toConstr :: Pass -> Constr #

dataTypeOf :: Pass -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Pass) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pass) #

gmapT :: (forall b. Data b => b -> b) -> Pass -> Pass #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pass -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pass -> r #

gmapQ :: (forall d. Data d => d -> u) -> Pass -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Pass -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Pass -> m Pass #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Pass -> m Pass #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Pass -> m Pass #

type GhcTcId = GhcTc #

type family IdP p :: Type #

Maps the "normal" id type for a given pass

Instances
type IdP GhcPs 
Instance details

Defined in HsExtension

type IdP GhcRn 
Instance details

Defined in HsExtension

type IdP GhcRn = Name
type IdP GhcTc 
Instance details

Defined in HsExtension

type IdP GhcTc = Id

type LIdP p = Located (IdP p) #

type family XHsValBinds x x' :: Type #

Instances
type XHsValBinds (GhcPass pL) (GhcPass pR) 
Instance details

Defined in HsBinds

type XHsValBinds (GhcPass pL) (GhcPass pR) = NoExt

type family XHsIPBinds x x' :: Type #

Instances
type XHsIPBinds (GhcPass pL) (GhcPass pR) 
Instance details

Defined in HsBinds

type XHsIPBinds (GhcPass pL) (GhcPass pR) = NoExt

type family XEmptyLocalBinds x x' :: Type #

Instances
type XEmptyLocalBinds (GhcPass pL) (GhcPass pR) 
Instance details

Defined in HsBinds

type family XXHsLocalBindsLR x x' :: Type #

Instances
type XXHsLocalBindsLR (GhcPass pL) (GhcPass pR) 
Instance details

Defined in HsBinds

type ForallXHsLocalBindsLR (c :: Type -> Constraint) x x' = (c (XHsValBinds x x'), c (XHsIPBinds x x'), c (XEmptyLocalBinds x x'), c (XXHsLocalBindsLR x x')) #

type family XValBinds x x' :: Type #

Instances
type XValBinds (GhcPass pL) (GhcPass pR) 
Instance details

Defined in HsBinds

type XValBinds (GhcPass pL) (GhcPass pR) = NoExt

type family XXValBindsLR x x' :: Type #

Instances
type XXValBindsLR (GhcPass pL) (GhcPass pR) 
Instance details

Defined in HsBinds

type ForallXValBindsLR (c :: Type -> Constraint) x x' = (c (XValBinds x x'), c (XXValBindsLR x x')) #

type family XFunBind x x' :: Type #

Instances
type XFunBind (GhcPass pL) GhcTc 
Instance details

Defined in HsBinds

type XFunBind (GhcPass pL) GhcRn 
Instance details

Defined in HsBinds

type XFunBind (GhcPass pL) GhcPs 
Instance details

Defined in HsBinds

type family XPatBind x x' :: Type #

Instances
type XPatBind GhcPs (GhcPass pR) 
Instance details

Defined in HsBinds

type XPatBind GhcRn (GhcPass pR) 
Instance details

Defined in HsBinds

type XPatBind GhcTc (GhcPass pR) 
Instance details

Defined in HsBinds

type family XVarBind x x' :: Type #

Instances
type XVarBind (GhcPass pL) (GhcPass pR) 
Instance details

Defined in HsBinds

type XVarBind (GhcPass pL) (GhcPass pR) = NoExt

type family XAbsBinds x x' :: Type #

Instances
type XAbsBinds (GhcPass pL) (GhcPass pR) 
Instance details

Defined in HsBinds

type XAbsBinds (GhcPass pL) (GhcPass pR) = NoExt

type family XPatSynBind x x' :: Type #

Instances
type XPatSynBind (GhcPass pL) (GhcPass pR) 
Instance details

Defined in HsBinds

type XPatSynBind (GhcPass pL) (GhcPass pR) = NoExt

type family XXHsBindsLR x x' :: Type #

Instances
type XXHsBindsLR (GhcPass pL) (GhcPass pR) 
Instance details

Defined in HsBinds

type XXHsBindsLR (GhcPass pL) (GhcPass pR) = NoExt

type ForallXHsBindsLR (c :: Type -> Constraint) x x' = (c (XFunBind x x'), c (XPatBind x x'), c (XVarBind x x'), c (XAbsBinds x x'), c (XPatSynBind x x'), c (XXHsBindsLR x x')) #

type family XABE x :: Type #

Instances
type XABE (GhcPass p) 
Instance details

Defined in HsBinds

type XABE (GhcPass p) = NoExt

type family XXABExport x :: Type #

Instances
type XXABExport (GhcPass p) 
Instance details

Defined in HsBinds

type ForallXABExport (c :: Type -> Constraint) x = (c (XABE x), c (XXABExport x)) #

type family XPSB x x' :: Type #

Instances
type XPSB (GhcPass idL) GhcTc 
Instance details

Defined in HsBinds

type XPSB (GhcPass idL) GhcTc = NameSet
type XPSB (GhcPass idL) GhcRn 
Instance details

Defined in HsBinds

type XPSB (GhcPass idL) GhcRn = NameSet
type XPSB (GhcPass idL) GhcPs 
Instance details

Defined in HsBinds

type XPSB (GhcPass idL) GhcPs = NoExt

type family XXPatSynBind x x' :: Type #

Instances
type XXPatSynBind (GhcPass idL) (GhcPass idR) 
Instance details

Defined in HsBinds

type XXPatSynBind (GhcPass idL) (GhcPass idR) = NoExt

type ForallXPatSynBind (c :: Type -> Constraint) x x' = (c (XPSB x x'), c (XXPatSynBind x x')) #

type family XIPBinds x :: Type #

Instances
type XIPBinds GhcPs 
Instance details

Defined in HsBinds

type XIPBinds GhcRn 
Instance details

Defined in HsBinds

type XIPBinds GhcTc 
Instance details

Defined in HsBinds

type family XXHsIPBinds x :: Type #

Instances
type XXHsIPBinds (GhcPass p) 
Instance details

Defined in HsBinds

type ForallXHsIPBinds (c :: Type -> Constraint) x = (c (XIPBinds x), c (XXHsIPBinds x)) #

type family XCIPBind x :: Type #

Instances
type XCIPBind (GhcPass p) 
Instance details

Defined in HsBinds

type family XXIPBind x :: Type #

Instances
type XXIPBind (GhcPass p) 
Instance details

Defined in HsBinds

type ForallXIPBind (c :: Type -> Constraint) x = (c (XCIPBind x), c (XXIPBind x)) #

type family XTypeSig x :: Type #

Instances
type XTypeSig (GhcPass p) 
Instance details

Defined in HsBinds

type family XPatSynSig x :: Type #

Instances
type XPatSynSig (GhcPass p) 
Instance details

Defined in HsBinds

type family XClassOpSig x :: Type #

Instances
type XClassOpSig (GhcPass p) 
Instance details

Defined in HsBinds

type family XIdSig x :: Type #

Instances
type XIdSig (GhcPass p) 
Instance details

Defined in HsBinds

type XIdSig (GhcPass p) = NoExt

type family XFixSig x :: Type #

Instances
type XFixSig (GhcPass p) 
Instance details

Defined in HsBinds

type XFixSig (GhcPass p) = NoExt

type family XInlineSig x :: Type #

Instances
type XInlineSig (GhcPass p) 
Instance details

Defined in HsBinds

type family XSpecSig x :: Type #

Instances
type XSpecSig (GhcPass p) 
Instance details

Defined in HsBinds

type family XSpecInstSig x :: Type #

Instances
type XSpecInstSig (GhcPass p) 
Instance details

Defined in HsBinds

type family XMinimalSig x :: Type #

Instances
type XMinimalSig (GhcPass p) 
Instance details

Defined in HsBinds

type family XSCCFunSig x :: Type #

Instances
type XSCCFunSig (GhcPass p) 
Instance details

Defined in HsBinds

type family XCompleteMatchSig x :: Type #

Instances
type XCompleteMatchSig (GhcPass p) 
Instance details

Defined in HsBinds

type family XXSig x :: Type #

Instances
type XXSig (GhcPass p) 
Instance details

Defined in HsBinds

type XXSig (GhcPass p) = NoExt

type ForallXSig (c :: Type -> Constraint) x = (c (XTypeSig x), c (XPatSynSig x), c (XClassOpSig x), c (XIdSig x), c (XFixSig x), c (XInlineSig x), c (XSpecSig x), c (XSpecInstSig x), c (XMinimalSig x), c (XSCCFunSig x), c (XCompleteMatchSig x), c (XXSig x)) #

type family XFixitySig x :: Type #

Instances
type XFixitySig (GhcPass p) 
Instance details

Defined in HsBinds

type family XXFixitySig x :: Type #

Instances
type XXFixitySig (GhcPass p) 
Instance details

Defined in HsBinds

type ForallXFixitySig (c :: Type -> Constraint) x = (c (XFixitySig x), c (XXFixitySig x)) #

type family XTyClD x :: Type #

Instances
type XTyClD (GhcPass _) 
Instance details

Defined in HsDecls

type XTyClD (GhcPass _) = NoExt

type family XInstD x :: Type #

Instances
type XInstD (GhcPass _) 
Instance details

Defined in HsDecls

type XInstD (GhcPass _) = NoExt

type family XDerivD x :: Type #

Instances
type XDerivD (GhcPass _) 
Instance details

Defined in HsDecls

type XDerivD (GhcPass _) = NoExt

type family XValD x :: Type #

Instances
type XValD (GhcPass _) 
Instance details

Defined in HsDecls

type XValD (GhcPass _) = NoExt

type family XSigD x :: Type #

Instances
type XSigD (GhcPass _) 
Instance details

Defined in HsDecls

type XSigD (GhcPass _) = NoExt

type family XDefD x :: Type #

Instances
type XDefD (GhcPass _) 
Instance details

Defined in HsDecls

type XDefD (GhcPass _) = NoExt

type family XForD x :: Type #

Instances
type XForD (GhcPass _) 
Instance details

Defined in HsDecls

type XForD (GhcPass _) = NoExt

type family XWarningD x :: Type #

Instances
type XWarningD (GhcPass _) 
Instance details

Defined in HsDecls

type family XAnnD x :: Type #

Instances
type XAnnD (GhcPass _) 
Instance details

Defined in HsDecls

type XAnnD (GhcPass _) = NoExt

type family XRuleD x :: Type #

Instances
type XRuleD (GhcPass _) 
Instance details

Defined in HsDecls

type XRuleD (GhcPass _) = NoExt

type family XSpliceD x :: Type #

Instances
type XSpliceD (GhcPass _) 
Instance details

Defined in HsDecls

type family XDocD x :: Type #

Instances
type XDocD (GhcPass _) 
Instance details

Defined in HsDecls

type XDocD (GhcPass _) = NoExt

type family XRoleAnnotD x :: Type #

Instances
type XRoleAnnotD (GhcPass _) 
Instance details

Defined in HsDecls

type family XXHsDecl x :: Type #

Instances
type XXHsDecl (GhcPass _) 
Instance details

Defined in HsDecls

type ForallXHsDecl (c :: Type -> Constraint) x = (c (XTyClD x), c (XInstD x), c (XDerivD x), c (XValD x), c (XSigD x), c (XDefD x), c (XForD x), c (XWarningD x), c (XAnnD x), c (XRuleD x), c (XSpliceD x), c (XDocD x), c (XRoleAnnotD x), c (XXHsDecl x)) #

type family XCHsGroup x :: Type #

Instances
type XCHsGroup (GhcPass _) 
Instance details

Defined in HsDecls

type family XXHsGroup x :: Type #

Instances
type XXHsGroup (GhcPass _) 
Instance details

Defined in HsDecls

type ForallXHsGroup (c :: Type -> Constraint) x = (c (XCHsGroup x), c (XXHsGroup x)) #

type family XSpliceDecl x :: Type #

Instances
type XSpliceDecl (GhcPass _) 
Instance details

Defined in HsDecls

type family XXSpliceDecl x :: Type #

Instances
type XXSpliceDecl (GhcPass _) 
Instance details

Defined in HsDecls

type ForallXSpliceDecl (c :: Type -> Constraint) x = (c (XSpliceDecl x), c (XXSpliceDecl x)) #

type family XFamDecl x :: Type #

Instances
type XFamDecl (GhcPass _) 
Instance details

Defined in HsDecls

type family XSynDecl x :: Type #

Instances
type XSynDecl GhcPs 
Instance details

Defined in HsDecls

type XSynDecl GhcRn 
Instance details

Defined in HsDecls

type XSynDecl GhcTc 
Instance details

Defined in HsDecls

type family XDataDecl x :: Type #

Instances
type XDataDecl GhcPs 
Instance details

Defined in HsDecls

type XDataDecl GhcRn 
Instance details

Defined in HsDecls

type XDataDecl GhcTc 
Instance details

Defined in HsDecls

type family XClassDecl x :: Type #

Instances
type XClassDecl GhcPs 
Instance details

Defined in HsDecls

type XClassDecl GhcRn 
Instance details

Defined in HsDecls

type XClassDecl GhcTc 
Instance details

Defined in HsDecls

type family XXTyClDecl x :: Type #

Instances
type XXTyClDecl (GhcPass _) 
Instance details

Defined in HsDecls

type ForallXTyClDecl (c :: Type -> Constraint) x = (c (XFamDecl x), c (XSynDecl x), c (XDataDecl x), c (XClassDecl x), c (XXTyClDecl x)) #

type family XCTyClGroup x :: Type #

Instances
type XCTyClGroup (GhcPass _) 
Instance details

Defined in HsDecls

type family XXTyClGroup x :: Type #

Instances
type XXTyClGroup (GhcPass _) 
Instance details

Defined in HsDecls

type ForallXTyClGroup (c :: Type -> Constraint) x = (c (XCTyClGroup x), c (XXTyClGroup x)) #

type family XNoSig x :: Type #

Instances
type XNoSig (GhcPass _) 
Instance details

Defined in HsDecls

type XNoSig (GhcPass _) = NoExt

type family XCKindSig x :: Type #

Instances
type XCKindSig (GhcPass _) 
Instance details

Defined in HsDecls

type family XTyVarSig x :: Type #

Instances
type XTyVarSig (GhcPass _) 
Instance details

Defined in HsDecls

type family XXFamilyResultSig x :: Type #

Instances
type XXFamilyResultSig (GhcPass _) 
Instance details

Defined in HsDecls

type ForallXFamilyResultSig (c :: Type -> Constraint) x = (c (XNoSig x), c (XCKindSig x), c (XTyVarSig x), c (XXFamilyResultSig x)) #

type family XCFamilyDecl x :: Type #

Instances
type XCFamilyDecl (GhcPass _) 
Instance details

Defined in HsDecls

type family XXFamilyDecl x :: Type #

Instances
type XXFamilyDecl (GhcPass _) 
Instance details

Defined in HsDecls

type ForallXFamilyDecl (c :: Type -> Constraint) x = (c (XCFamilyDecl x), c (XXFamilyDecl x)) #

type family XCHsDataDefn x :: Type #

Instances
type XCHsDataDefn (GhcPass _) 
Instance details

Defined in HsDecls

type family XXHsDataDefn x :: Type #

Instances
type XXHsDataDefn (GhcPass _) 
Instance details

Defined in HsDecls

type ForallXHsDataDefn (c :: Type -> Constraint) x = (c (XCHsDataDefn x), c (XXHsDataDefn x)) #

type family XCHsDerivingClause x :: Type #

Instances
type XCHsDerivingClause (GhcPass _) 
Instance details

Defined in HsDecls

type family XXHsDerivingClause x :: Type #

Instances
type XXHsDerivingClause (GhcPass _) 
Instance details

Defined in HsDecls

type family XConDeclGADT x :: Type #

Instances
type XConDeclGADT (GhcPass _) 
Instance details

Defined in HsDecls

type family XConDeclH98 x :: Type #

Instances
type XConDeclH98 (GhcPass _) 
Instance details

Defined in HsDecls

type family XXConDecl x :: Type #

Instances
type XXConDecl (GhcPass _) 
Instance details

Defined in HsDecls

type ForallXConDecl (c :: Type -> Constraint) x = (c (XConDeclGADT x), c (XConDeclH98 x), c (XXConDecl x)) #

type family XCFamEqn x p r :: Type #

Instances
type XCFamEqn (GhcPass _) p r 
Instance details

Defined in HsDecls

type XCFamEqn (GhcPass _) p r = NoExt

type family XXFamEqn x p r :: Type #

Instances
type XXFamEqn (GhcPass _) p r 
Instance details

Defined in HsDecls

type XXFamEqn (GhcPass _) p r = NoExt

type ForallXFamEqn (c :: Type -> Constraint) x p r = (c (XCFamEqn x p r), c (XXFamEqn x p r)) #

type family XCClsInstDecl x :: Type #

Instances
type XCClsInstDecl (GhcPass _) 
Instance details

Defined in HsDecls

type family XXClsInstDecl x :: Type #

Instances
type XXClsInstDecl (GhcPass _) 
Instance details

Defined in HsDecls

type family XClsInstD x :: Type #

Instances
type XClsInstD (GhcPass _) 
Instance details

Defined in HsDecls

type family XDataFamInstD x :: Type #

Instances
type XDataFamInstD (GhcPass _) 
Instance details

Defined in HsDecls

type family XTyFamInstD x :: Type #

Instances
type XTyFamInstD (GhcPass _) 
Instance details

Defined in HsDecls

type family XXInstDecl x :: Type #

Instances
type XXInstDecl (GhcPass _) 
Instance details

Defined in HsDecls

type ForallXInstDecl (c :: Type -> Constraint) x = (c (XClsInstD x), c (XDataFamInstD x), c (XTyFamInstD x), c (XXInstDecl x)) #

type family XCDerivDecl x :: Type #

Instances
type XCDerivDecl (GhcPass _) 
Instance details

Defined in HsDecls

type family XXDerivDecl x :: Type #

Instances
type XXDerivDecl (GhcPass _) 
Instance details

Defined in HsDecls

type ForallXDerivDecl (c :: Type -> Constraint) x = (c (XCDerivDecl x), c (XXDerivDecl x)) #

type family XViaStrategy x :: Type #

Instances
type XViaStrategy GhcPs 
Instance details

Defined in HsDecls

type XViaStrategy GhcRn 
Instance details

Defined in HsDecls

type XViaStrategy GhcTc 
Instance details

Defined in HsDecls

type family XCDefaultDecl x :: Type #

Instances
type XCDefaultDecl (GhcPass _) 
Instance details

Defined in HsDecls

type family XXDefaultDecl x :: Type #

Instances
type XXDefaultDecl (GhcPass _) 
Instance details

Defined in HsDecls

type family XForeignImport x :: Type #

Instances
type XForeignImport GhcPs 
Instance details

Defined in HsDecls

type XForeignImport GhcRn 
Instance details

Defined in HsDecls

type XForeignImport GhcTc 
Instance details

Defined in HsDecls

type family XForeignExport x :: Type #

Instances
type XForeignExport GhcPs 
Instance details

Defined in HsDecls

type XForeignExport GhcRn 
Instance details

Defined in HsDecls

type XForeignExport GhcTc 
Instance details

Defined in HsDecls

type family XXForeignDecl x :: Type #

Instances
type XXForeignDecl (GhcPass _) 
Instance details

Defined in HsDecls

type family XCRuleDecls x :: Type #

Instances
type XCRuleDecls (GhcPass _) 
Instance details

Defined in HsDecls

type family XXRuleDecls x :: Type #

Instances
type XXRuleDecls (GhcPass _) 
Instance details

Defined in HsDecls

type ForallXRuleDecls (c :: Type -> Constraint) x = (c (XCRuleDecls x), c (XXRuleDecls x)) #

type family XHsRule x :: Type #

Instances
type XHsRule GhcPs 
Instance details

Defined in HsDecls

type XHsRule GhcRn 
Instance details

Defined in HsDecls

type XHsRule GhcTc 
Instance details

Defined in HsDecls

type family XXRuleDecl x :: Type #

Instances
type XXRuleDecl (GhcPass _) 
Instance details

Defined in HsDecls

type ForallXRuleDecl (c :: Type -> Constraint) x = (c (XHsRule x), c (XXRuleDecl x)) #

type family XCRuleBndr x :: Type #

Instances
type XCRuleBndr (GhcPass _) 
Instance details

Defined in HsDecls

type family XRuleBndrSig x :: Type #

Instances
type XRuleBndrSig (GhcPass _) 
Instance details

Defined in HsDecls

type family XXRuleBndr x :: Type #

Instances
type XXRuleBndr (GhcPass _) 
Instance details

Defined in HsDecls

type ForallXRuleBndr (c :: Type -> Constraint) x = (c (XCRuleBndr x), c (XRuleBndrSig x), c (XXRuleBndr x)) #

type family XWarnings x :: Type #

Instances
type XWarnings (GhcPass _) 
Instance details

Defined in HsDecls

type family XXWarnDecls x :: Type #

Instances
type XXWarnDecls (GhcPass _) 
Instance details

Defined in HsDecls

type ForallXWarnDecls (c :: Type -> Constraint) x = (c (XWarnings x), c (XXWarnDecls x)) #

type family XWarning x :: Type #

Instances
type XWarning (GhcPass _) 
Instance details

Defined in HsDecls

type family XXWarnDecl x :: Type #

Instances
type XXWarnDecl (GhcPass _) 
Instance details

Defined in HsDecls

type ForallXWarnDecl (c :: Type -> Constraint) x = (c (XWarning x), c (XXWarnDecl x)) #

type family XHsAnnotation x :: Type #

Instances
type XHsAnnotation (GhcPass _) 
Instance details

Defined in HsDecls

type family XXAnnDecl x :: Type #

Instances
type XXAnnDecl (GhcPass _) 
Instance details

Defined in HsDecls

type ForallXAnnDecl (c :: Type -> Constraint) x = (c (XHsAnnotation x), c (XXAnnDecl x)) #

type family XCRoleAnnotDecl x :: Type #

Instances
type XCRoleAnnotDecl (GhcPass _) 
Instance details

Defined in HsDecls

type family XXRoleAnnotDecl x :: Type #

Instances
type XXRoleAnnotDecl (GhcPass _) 
Instance details

Defined in HsDecls

type family XVar x :: Type #

Instances
type XVar (GhcPass _) 
Instance details

Defined in HsExpr

type XVar (GhcPass _) = NoExt

type family XUnboundVar x :: Type #

Instances
type XUnboundVar (GhcPass _) 
Instance details

Defined in HsExpr

type family XConLikeOut x :: Type #

Instances
type XConLikeOut (GhcPass _) 
Instance details

Defined in HsExpr

type family XRecFld x :: Type #

Instances
type XRecFld (GhcPass _) 
Instance details

Defined in HsExpr

type XRecFld (GhcPass _) = NoExt

type family XOverLabel x :: Type #

Instances
type XOverLabel (GhcPass _) 
Instance details

Defined in HsExpr

type family XIPVar x :: Type #

Instances
type XIPVar (GhcPass _) 
Instance details

Defined in HsExpr

type XIPVar (GhcPass _) = NoExt

type family XOverLitE x :: Type #

Instances
type XOverLitE (GhcPass _) 
Instance details

Defined in HsExpr

type family XLitE x :: Type #

Instances
type XLitE (GhcPass _) 
Instance details

Defined in HsExpr

type XLitE (GhcPass _) = NoExt

type family XLam x :: Type #

Instances
type XLam (GhcPass _) 
Instance details

Defined in HsExpr

type XLam (GhcPass _) = NoExt

type family XLamCase x :: Type #

Instances
type XLamCase (GhcPass _) 
Instance details

Defined in HsExpr

type family XApp x :: Type #

Instances
type XApp (GhcPass _) 
Instance details

Defined in HsExpr

type XApp (GhcPass _) = NoExt

type family XAppTypeE x :: Type #

Instances
type XAppTypeE GhcPs 
Instance details

Defined in HsExpr

type XAppTypeE GhcRn 
Instance details

Defined in HsExpr

type XAppTypeE GhcTc 
Instance details

Defined in HsExpr

type family XOpApp x :: Type #

Instances
type XOpApp GhcPs 
Instance details

Defined in HsExpr

type XOpApp GhcRn 
Instance details

Defined in HsExpr

type XOpApp GhcTc 
Instance details

Defined in HsExpr

type family XNegApp x :: Type #

Instances
type XNegApp (GhcPass _) 
Instance details

Defined in HsExpr

type XNegApp (GhcPass _) = NoExt

type family XPar x :: Type #

Instances
type XPar (GhcPass _) 
Instance details

Defined in HsExpr

type XPar (GhcPass _) = NoExt

type family XSectionL x :: Type #

Instances
type XSectionL (GhcPass _) 
Instance details

Defined in HsExpr

type family XSectionR x :: Type #

Instances
type XSectionR (GhcPass _) 
Instance details

Defined in HsExpr

type family XExplicitTuple x :: Type #

Instances
type XExplicitTuple (GhcPass _) 
Instance details

Defined in HsExpr

type family XExplicitSum x :: Type #

Instances
type XExplicitSum GhcPs 
Instance details

Defined in HsExpr

type XExplicitSum GhcRn 
Instance details

Defined in HsExpr

type XExplicitSum GhcTc 
Instance details

Defined in HsExpr

type family XCase x :: Type #

Instances
type XCase (GhcPass _) 
Instance details

Defined in HsExpr

type XCase (GhcPass _) = NoExt

type family XIf x :: Type #

Instances
type XIf (GhcPass _) 
Instance details

Defined in HsExpr

type XIf (GhcPass _) = NoExt

type family XMultiIf x :: Type #

Instances
type XMultiIf GhcPs 
Instance details

Defined in HsExpr

type XMultiIf GhcRn 
Instance details

Defined in HsExpr

type XMultiIf GhcTc 
Instance details

Defined in HsExpr

type family XLet x :: Type #

Instances
type XLet (GhcPass _) 
Instance details

Defined in HsExpr

type XLet (GhcPass _) = NoExt

type family XDo x :: Type #

Instances
type XDo GhcPs 
Instance details

Defined in HsExpr

type XDo GhcPs = NoExt
type XDo GhcRn 
Instance details

Defined in HsExpr

type XDo GhcRn = NoExt
type XDo GhcTc 
Instance details

Defined in HsExpr

type XDo GhcTc = Type

type family XExplicitList x :: Type #

Instances
type XExplicitList GhcPs 
Instance details

Defined in HsExpr

type XExplicitList GhcRn 
Instance details

Defined in HsExpr

type XExplicitList GhcTc 
Instance details

Defined in HsExpr

type family XRecordCon x :: Type #

Instances
type XRecordCon GhcPs 
Instance details

Defined in HsExpr

type XRecordCon GhcRn 
Instance details

Defined in HsExpr

type XRecordCon GhcTc 
Instance details

Defined in HsExpr

type family XRecordUpd x :: Type #

Instances
type XRecordUpd GhcPs 
Instance details

Defined in HsExpr

type XRecordUpd GhcRn 
Instance details

Defined in HsExpr

type XRecordUpd GhcTc 
Instance details

Defined in HsExpr

type family XExprWithTySig x :: Type #

Instances
type XExprWithTySig GhcPs 
Instance details

Defined in HsExpr

type XExprWithTySig GhcRn 
Instance details

Defined in HsExpr

type XExprWithTySig GhcTc 
Instance details

Defined in HsExpr

type family XArithSeq x :: Type #

Instances
type XArithSeq GhcPs 
Instance details

Defined in HsExpr

type XArithSeq GhcRn 
Instance details

Defined in HsExpr

type XArithSeq GhcTc 
Instance details

Defined in HsExpr

type family XSCC x :: Type #

Instances
type XSCC (GhcPass _) 
Instance details

Defined in HsExpr

type XSCC (GhcPass _) = NoExt

type family XCoreAnn x :: Type #

Instances
type XCoreAnn (GhcPass _) 
Instance details

Defined in HsExpr

type family XBracket x :: Type #

Instances
type XBracket (GhcPass _) 
Instance details

Defined in HsExpr

type family XRnBracketOut x :: Type #

Instances
type XRnBracketOut (GhcPass _) 
Instance details

Defined in HsExpr

type family XTcBracketOut x :: Type #

Instances
type XTcBracketOut (GhcPass _) 
Instance details

Defined in HsExpr

type family XSpliceE x :: Type #

Instances
type XSpliceE (GhcPass _) 
Instance details

Defined in HsExpr

type family XProc x :: Type #

Instances
type XProc (GhcPass _) 
Instance details

Defined in HsExpr

type XProc (GhcPass _) = NoExt

type family XStatic x :: Type #

Instances
type XStatic GhcPs 
Instance details

Defined in HsExpr

type XStatic GhcRn 
Instance details

Defined in HsExpr

type XStatic GhcTc 
Instance details

Defined in HsExpr

type family XArrApp x :: Type #

Instances
type XArrApp GhcPs 
Instance details

Defined in HsExpr

type XArrApp GhcRn 
Instance details

Defined in HsExpr

type XArrApp GhcTc 
Instance details

Defined in HsExpr

type family XArrForm x :: Type #

Instances
type XArrForm (GhcPass _) 
Instance details

Defined in HsExpr

type family XTick x :: Type #

Instances
type XTick (GhcPass _) 
Instance details

Defined in HsExpr

type XTick (GhcPass _) = NoExt

type family XBinTick x :: Type #

Instances
type XBinTick (GhcPass _) 
Instance details

Defined in HsExpr

type family XTickPragma x :: Type #

Instances
type XTickPragma (GhcPass _) 
Instance details

Defined in HsExpr

type family XEWildPat x :: Type #

Instances
type XEWildPat (GhcPass _) 
Instance details

Defined in HsExpr

type family XEAsPat x :: Type #

Instances
type XEAsPat (GhcPass _) 
Instance details

Defined in HsExpr

type XEAsPat (GhcPass _) = NoExt

type family XEViewPat x :: Type #

Instances
type XEViewPat (GhcPass _) 
Instance details

Defined in HsExpr

type family XELazyPat x :: Type #

Instances
type XELazyPat (GhcPass _) 
Instance details

Defined in HsExpr

type family XWrap x :: Type #

Instances
type XWrap (GhcPass _) 
Instance details

Defined in HsExpr

type XWrap (GhcPass _) = NoExt

type family XXExpr x :: Type #

Instances
type XXExpr (GhcPass _) 
Instance details

Defined in HsExpr

type XXExpr (GhcPass _) = NoExt

type ForallXExpr (c :: Type -> Constraint) x = (c (XVar x), c (XUnboundVar x), c (XConLikeOut x), c (XRecFld x), c (XOverLabel x), c (XIPVar x), c (XOverLitE x), c (XLitE x), c (XLam x), c (XLamCase x), c (XApp x), c (XAppTypeE x), c (XOpApp x), c (XNegApp x), c (XPar x), c (XSectionL x), c (XSectionR x), c (XExplicitTuple x), c (XExplicitSum x), c (XCase x), c (XIf x), c (XMultiIf x), c (XLet x), c (XDo x), c (XExplicitList x), c (XRecordCon x), c (XRecordUpd x), c (XExprWithTySig x), c (XArithSeq x), c (XSCC x), c (XCoreAnn x), c (XBracket x), c (XRnBracketOut x), c (XTcBracketOut x), c (XSpliceE x), c (XProc x), c (XStatic x), c (XArrApp x), c (XArrForm x), c (XTick x), c (XBinTick x), c (XTickPragma x), c (XEWildPat x), c (XEAsPat x), c (XEViewPat x), c (XELazyPat x), c (XWrap x), c (XXExpr x)) #

type family XUnambiguous x :: Type #

Instances
type XUnambiguous GhcPs 
Instance details

Defined in HsTypes

type XUnambiguous GhcRn 
Instance details

Defined in HsTypes

type XUnambiguous GhcTc 
Instance details

Defined in HsTypes

type family XAmbiguous x :: Type #

Instances
type XAmbiguous GhcPs 
Instance details

Defined in HsTypes

type XAmbiguous GhcRn 
Instance details

Defined in HsTypes

type XAmbiguous GhcTc 
Instance details

Defined in HsTypes

type family XXAmbiguousFieldOcc x :: Type #

Instances
type XXAmbiguousFieldOcc (GhcPass _) 
Instance details

Defined in HsTypes

type family XPresent x :: Type #

Instances
type XPresent (GhcPass _) 
Instance details

Defined in HsExpr

type family XMissing x :: Type #

Instances
type XMissing GhcPs 
Instance details

Defined in HsExpr

type XMissing GhcRn 
Instance details

Defined in HsExpr

type XMissing GhcTc 
Instance details

Defined in HsExpr

type family XXTupArg x :: Type #

Instances
type XXTupArg (GhcPass _) 
Instance details

Defined in HsExpr

type ForallXTupArg (c :: Type -> Constraint) x = (c (XPresent x), c (XMissing x), c (XXTupArg x)) #

type family XTypedSplice x :: Type #

Instances
type XTypedSplice (GhcPass _) 
Instance details

Defined in HsExpr

type family XUntypedSplice x :: Type #

Instances
type XUntypedSplice (GhcPass _) 
Instance details

Defined in HsExpr

type family XQuasiQuote x :: Type #

Instances
type XQuasiQuote (GhcPass _) 
Instance details

Defined in HsExpr

type family XSpliced x :: Type #

Instances
type XSpliced (GhcPass _) 
Instance details

Defined in HsExpr

type family XXSplice x :: Type #

Instances
type XXSplice (GhcPass _) 
Instance details

Defined in HsExpr

type ForallXSplice (c :: Type -> Constraint) x = (c (XTypedSplice x), c (XUntypedSplice x), c (XQuasiQuote x), c (XSpliced x), c (XXSplice x)) #

type family XExpBr x :: Type #

Instances
type XExpBr (GhcPass _) 
Instance details

Defined in HsExpr

type XExpBr (GhcPass _) = NoExt

type family XPatBr x :: Type #

Instances
type XPatBr (GhcPass _) 
Instance details

Defined in HsExpr

type XPatBr (GhcPass _) = NoExt

type family XDecBrL x :: Type #

Instances
type XDecBrL (GhcPass _) 
Instance details

Defined in HsExpr

type XDecBrL (GhcPass _) = NoExt

type family XDecBrG x :: Type #

Instances
type XDecBrG (GhcPass _) 
Instance details

Defined in HsExpr

type XDecBrG (GhcPass _) = NoExt

type family XTypBr x :: Type #

Instances
type XTypBr (GhcPass _) 
Instance details

Defined in HsExpr

type XTypBr (GhcPass _) = NoExt

type family XVarBr x :: Type #

Instances
type XVarBr (GhcPass _) 
Instance details

Defined in HsExpr

type XVarBr (GhcPass _) = NoExt

type family XTExpBr x :: Type #

Instances
type XTExpBr (GhcPass _) 
Instance details

Defined in HsExpr

type XTExpBr (GhcPass _) = NoExt

type family XXBracket x :: Type #

Instances
type XXBracket (GhcPass _) 
Instance details

Defined in HsExpr

type ForallXBracket (c :: Type -> Constraint) x = (c (XExpBr x), c (XPatBr x), c (XDecBrL x), c (XDecBrG x), c (XTypBr x), c (XVarBr x), c (XTExpBr x), c (XXBracket x)) #

type family XCmdTop x :: Type #

Instances
type XCmdTop GhcPs 
Instance details

Defined in HsExpr

type XCmdTop GhcRn 
Instance details

Defined in HsExpr

type XCmdTop GhcTc 
Instance details

Defined in HsExpr

type family XXCmdTop x :: Type #

Instances
type XXCmdTop (GhcPass _) 
Instance details

Defined in HsExpr

type ForallXCmdTop (c :: Type -> Constraint) x = (c (XCmdTop x), c (XXCmdTop x)) #

type family XMG x b :: Type #

Instances
type XMG GhcPs b 
Instance details

Defined in HsExpr

type XMG GhcPs b = NoExt
type XMG GhcRn b 
Instance details

Defined in HsExpr

type XMG GhcRn b = NoExt
type XMG GhcTc b 
Instance details

Defined in HsExpr

type family XXMatchGroup x b :: Type #

Instances
type XXMatchGroup (GhcPass _) b 
Instance details

Defined in HsExpr

type ForallXMatchGroup (c :: Type -> Constraint) x b = (c (XMG x b), c (XXMatchGroup x b)) #

type family XCMatch x b :: Type #

Instances
type XCMatch (GhcPass _) b 
Instance details

Defined in HsExpr

type XCMatch (GhcPass _) b = NoExt

type family XXMatch x b :: Type #

Instances
type XXMatch (GhcPass _) b 
Instance details

Defined in HsExpr

type XXMatch (GhcPass _) b = NoExt

type ForallXMatch (c :: Type -> Constraint) x b = (c (XCMatch x b), c (XXMatch x b)) #

type family XCGRHSs x b :: Type #

Instances
type XCGRHSs (GhcPass _) b 
Instance details

Defined in HsExpr

type XCGRHSs (GhcPass _) b = NoExt

type family XXGRHSs x b :: Type #

Instances
type XXGRHSs (GhcPass _) b 
Instance details

Defined in HsExpr

type XXGRHSs (GhcPass _) b = NoExt

type ForallXGRHSs (c :: Type -> Constraint) x b = (c (XCGRHSs x b), c (XXGRHSs x b)) #

type family XCGRHS x b :: Type #

Instances
type XCGRHS (GhcPass _) b 
Instance details

Defined in HsExpr

type XCGRHS (GhcPass _) b = NoExt

type family XXGRHS x b :: Type #

Instances
type XXGRHS (GhcPass _) b 
Instance details

Defined in HsExpr

type XXGRHS (GhcPass _) b = NoExt

type ForallXGRHS (c :: Type -> Constraint) x b = (c (XCGRHS x b), c (XXGRHS x b)) #

type family XLastStmt x x' b :: Type #

Instances
type XLastStmt (GhcPass _1) (GhcPass _2) b 
Instance details

Defined in HsExpr

type XLastStmt (GhcPass _1) (GhcPass _2) b = NoExt

type family XBindStmt x x' b :: Type #

Instances
type XBindStmt (GhcPass _) GhcTc b 
Instance details

Defined in HsExpr

type XBindStmt (GhcPass _) GhcRn b 
Instance details

Defined in HsExpr

type XBindStmt (GhcPass _) GhcPs b 
Instance details

Defined in HsExpr

type family XApplicativeStmt x x' b :: Type #

Instances
type XApplicativeStmt (GhcPass _) GhcTc b 
Instance details

Defined in HsExpr

type XApplicativeStmt (GhcPass _) GhcRn b 
Instance details

Defined in HsExpr

type XApplicativeStmt (GhcPass _) GhcPs b 
Instance details

Defined in HsExpr

type family XBodyStmt x x' b :: Type #

Instances
type XBodyStmt (GhcPass _) GhcTc b 
Instance details

Defined in HsExpr

type XBodyStmt (GhcPass _) GhcRn b 
Instance details

Defined in HsExpr

type XBodyStmt (GhcPass _) GhcPs b 
Instance details

Defined in HsExpr

type family XLetStmt x x' b :: Type #

Instances
type XLetStmt (GhcPass _1) (GhcPass _2) b 
Instance details

Defined in HsExpr

type XLetStmt (GhcPass _1) (GhcPass _2) b = NoExt

type family XParStmt x x' b :: Type #

Instances
type XParStmt (GhcPass _) GhcTc b 
Instance details

Defined in HsExpr

type XParStmt (GhcPass _) GhcTc b = Type
type XParStmt (GhcPass _) GhcRn b 
Instance details

Defined in HsExpr

type XParStmt (GhcPass _) GhcPs b 
Instance details

Defined in HsExpr

type family XTransStmt x x' b :: Type #

Instances
type XTransStmt (GhcPass _) GhcTc b 
Instance details

Defined in HsExpr

type XTransStmt (GhcPass _) GhcRn b 
Instance details

Defined in HsExpr

type XTransStmt (GhcPass _) GhcPs b 
Instance details

Defined in HsExpr

type family XRecStmt x x' b :: Type #

Instances
type XRecStmt (GhcPass _) GhcRn b 
Instance details

Defined in HsExpr

type XRecStmt (GhcPass _) GhcPs b 
Instance details

Defined in HsExpr

type XRecStmt (GhcPass _) GhcTc b 
Instance details

Defined in HsExpr

type family XXStmtLR x x' b :: Type #

Instances
type XXStmtLR (GhcPass _1) (GhcPass _2) b 
Instance details

Defined in HsExpr

type XXStmtLR (GhcPass _1) (GhcPass _2) b = NoExt

type ForallXStmtLR (c :: Type -> Constraint) x x' b = (c (XLastStmt x x' b), c (XBindStmt x x' b), c (XApplicativeStmt x x' b), c (XBodyStmt x x' b), c (XLetStmt x x' b), c (XParStmt x x' b), c (XTransStmt x x' b), c (XRecStmt x x' b), c (XXStmtLR x x' b)) #

type family XCmdArrApp x :: Type #

Instances
type XCmdArrApp GhcPs 
Instance details

Defined in HsExpr

type XCmdArrApp GhcRn 
Instance details

Defined in HsExpr

type XCmdArrApp GhcTc 
Instance details

Defined in HsExpr

type family XCmdArrForm x :: Type #

Instances
type XCmdArrForm (GhcPass _) 
Instance details

Defined in HsExpr

type family XCmdApp x :: Type #

Instances
type XCmdApp (GhcPass _) 
Instance details

Defined in HsExpr

type XCmdApp (GhcPass _) = NoExt

type family XCmdLam x :: Type #

Instances
type XCmdLam (GhcPass _) 
Instance details

Defined in HsExpr

type XCmdLam (GhcPass _) = NoExt

type family XCmdPar x :: Type #

Instances
type XCmdPar (GhcPass _) 
Instance details

Defined in HsExpr

type XCmdPar (GhcPass _) = NoExt

type family XCmdCase x :: Type #

Instances
type XCmdCase (GhcPass _) 
Instance details

Defined in HsExpr

type family XCmdIf x :: Type #

Instances
type XCmdIf (GhcPass _) 
Instance details

Defined in HsExpr

type XCmdIf (GhcPass _) = NoExt

type family XCmdLet x :: Type #

Instances
type XCmdLet (GhcPass _) 
Instance details

Defined in HsExpr

type XCmdLet (GhcPass _) = NoExt

type family XCmdDo x :: Type #

Instances
type XCmdDo GhcPs 
Instance details

Defined in HsExpr

type XCmdDo GhcRn 
Instance details

Defined in HsExpr

type XCmdDo GhcTc 
Instance details

Defined in HsExpr

type family XCmdWrap x :: Type #

Instances
type XCmdWrap (GhcPass _) 
Instance details

Defined in HsExpr

type family XXCmd x :: Type #

Instances
type XXCmd (GhcPass _) 
Instance details

Defined in HsExpr

type XXCmd (GhcPass _) = NoExt

type ForallXCmd (c :: Type -> Constraint) x = (c (XCmdArrApp x), c (XCmdArrForm x), c (XCmdApp x), c (XCmdLam x), c (XCmdPar x), c (XCmdCase x), c (XCmdIf x), c (XCmdLet x), c (XCmdDo x), c (XCmdWrap x), c (XXCmd x)) #

type family XParStmtBlock x x' :: Type #

Instances
type XParStmtBlock (GhcPass pL) (GhcPass pR) 
Instance details

Defined in HsExpr

type family XXParStmtBlock x x' :: Type #

Instances
type XXParStmtBlock (GhcPass pL) (GhcPass pR) 
Instance details

Defined in HsExpr

type ForallXParStmtBlock (c :: Type -> Constraint) x x' = (c (XParStmtBlock x x'), c (XXParStmtBlock x x')) #

type family XApplicativeArgOne x :: Type #

Instances
type XApplicativeArgOne (GhcPass _) 
Instance details

Defined in HsExpr

type family XApplicativeArgMany x :: Type #

Instances
type XApplicativeArgMany (GhcPass _) 
Instance details

Defined in HsExpr

type family XXApplicativeArg x :: Type #

Instances
type XXApplicativeArg (GhcPass _) 
Instance details

Defined in HsExpr

type family XHsChar x :: Type #

Instances
type XHsChar (GhcPass _) 
Instance details

Defined in HsLit

type family XHsCharPrim x :: Type #

Instances
type XHsCharPrim (GhcPass _) 
Instance details

Defined in HsLit

type family XHsString x :: Type #

Instances
type XHsString (GhcPass _) 
Instance details

Defined in HsLit

type family XHsStringPrim x :: Type #

Instances
type XHsStringPrim (GhcPass _) 
Instance details

Defined in HsLit

type family XHsInt x :: Type #

Instances
type XHsInt (GhcPass _) 
Instance details

Defined in HsLit

type XHsInt (GhcPass _) = NoExt

type family XHsIntPrim x :: Type #

Instances
type XHsIntPrim (GhcPass _) 
Instance details

Defined in HsLit

type family XHsWordPrim x :: Type #

Instances
type XHsWordPrim (GhcPass _) 
Instance details

Defined in HsLit

type family XHsInt64Prim x :: Type #

Instances
type XHsInt64Prim (GhcPass _) 
Instance details

Defined in HsLit

type family XHsWord64Prim x :: Type #

Instances
type XHsWord64Prim (GhcPass _) 
Instance details

Defined in HsLit

type family XHsInteger x :: Type #

Instances
type XHsInteger (GhcPass _) 
Instance details

Defined in HsLit

type family XHsRat x :: Type #

Instances
type XHsRat (GhcPass _) 
Instance details

Defined in HsLit

type XHsRat (GhcPass _) = NoExt

type family XHsFloatPrim x :: Type #

Instances
type XHsFloatPrim (GhcPass _) 
Instance details

Defined in HsLit

type family XHsDoublePrim x :: Type #

Instances
type XHsDoublePrim (GhcPass _) 
Instance details

Defined in HsLit

type family XXLit x :: Type #

Instances
type XXLit (GhcPass _) 
Instance details

Defined in HsLit

type XXLit (GhcPass _) = NoExt

type ForallXHsLit (c :: Type -> Constraint) x = (c (XHsChar x), c (XHsCharPrim x), c (XHsDoublePrim x), c (XHsFloatPrim x), c (XHsInt x), c (XHsInt64Prim x), c (XHsIntPrim x), c (XHsInteger x), c (XHsRat x), c (XHsString x), c (XHsStringPrim x), c (XHsWord64Prim x), c (XHsWordPrim x), c (XXLit x)) #

Helper to apply a constraint to all extension points. It has one entry per extension point type family.

type family XOverLit x :: Type #

Instances
type XOverLit GhcPs 
Instance details

Defined in HsLit

type XOverLit GhcRn 
Instance details

Defined in HsLit

type XOverLit GhcTc 
Instance details

Defined in HsLit

type family XXOverLit x :: Type #

Instances
type XXOverLit (GhcPass _) 
Instance details

Defined in HsLit

type ForallXOverLit (c :: Type -> Constraint) x = (c (XOverLit x), c (XXOverLit x)) #

type family XWildPat x :: Type #

Instances
type XWildPat GhcPs 
Instance details

Defined in HsPat

type XWildPat GhcRn 
Instance details

Defined in HsPat

type XWildPat GhcTc 
Instance details

Defined in HsPat

type family XVarPat x :: Type #

Instances
type XVarPat (GhcPass _) 
Instance details

Defined in HsPat

type XVarPat (GhcPass _) = NoExt

type family XLazyPat x :: Type #

Instances
type XLazyPat (GhcPass _) 
Instance details

Defined in HsPat

type family XAsPat x :: Type #

Instances
type XAsPat (GhcPass _) 
Instance details

Defined in HsPat

type XAsPat (GhcPass _) = NoExt

type family XParPat x :: Type #

Instances
type XParPat (GhcPass _) 
Instance details

Defined in HsPat

type XParPat (GhcPass _) = NoExt

type family XBangPat x :: Type #

Instances
type XBangPat (GhcPass _) 
Instance details

Defined in HsPat

type family XListPat x :: Type #

Instances
type XListPat GhcPs 
Instance details

Defined in HsPat

type XListPat GhcRn 
Instance details

Defined in HsPat

type XListPat GhcTc 
Instance details

Defined in HsPat

type family XTuplePat x :: Type #

Instances
type XTuplePat GhcPs 
Instance details

Defined in HsPat

type XTuplePat GhcRn 
Instance details

Defined in HsPat

type XTuplePat GhcTc 
Instance details

Defined in HsPat

type family XSumPat x :: Type #

Instances
type XSumPat GhcPs 
Instance details

Defined in HsPat

type XSumPat GhcRn 
Instance details

Defined in HsPat

type XSumPat GhcTc 
Instance details

Defined in HsPat

type XSumPat GhcTc = [Type]

type family XConPat x :: Type #

type family XViewPat x :: Type #

Instances
type XViewPat GhcPs 
Instance details

Defined in HsPat

type XViewPat GhcRn 
Instance details

Defined in HsPat

type XViewPat GhcTc 
Instance details

Defined in HsPat

type family XSplicePat x :: Type #

Instances
type XSplicePat (GhcPass _) 
Instance details

Defined in HsPat

type family XLitPat x :: Type #

Instances
type XLitPat (GhcPass _) 
Instance details

Defined in HsPat

type XLitPat (GhcPass _) = NoExt

type family XNPat x :: Type #

Instances
type XNPat GhcPs 
Instance details

Defined in HsPat

type XNPat GhcRn 
Instance details

Defined in HsPat

type XNPat GhcTc 
Instance details

Defined in HsPat

type family XNPlusKPat x :: Type #

Instances
type XNPlusKPat GhcPs 
Instance details

Defined in HsPat

type XNPlusKPat GhcRn 
Instance details

Defined in HsPat

type XNPlusKPat GhcTc 
Instance details

Defined in HsPat

type family XSigPat x :: Type #

Instances
type XSigPat GhcPs 
Instance details

Defined in HsPat

type XSigPat GhcRn 
Instance details

Defined in HsPat

type XSigPat GhcTc 
Instance details

Defined in HsPat

type family XCoPat x :: Type #

Instances
type XCoPat (GhcPass _) 
Instance details

Defined in HsPat

type XCoPat (GhcPass _) = NoExt

type family XXPat x :: Type #

Instances
type XXPat (GhcPass _) 
Instance details

Defined in HsPat

type XXPat (GhcPass _) = NoExt

type ForallXPat (c :: Type -> Constraint) x = (c (XWildPat x), c (XVarPat x), c (XLazyPat x), c (XAsPat x), c (XParPat x), c (XBangPat x), c (XListPat x), c (XTuplePat x), c (XSumPat x), c (XViewPat x), c (XSplicePat x), c (XLitPat x), c (XNPat x), c (XNPlusKPat x), c (XSigPat x), c (XCoPat x), c (XXPat x)) #

type family XHsQTvs x :: Type #

Instances
type XHsQTvs GhcPs 
Instance details

Defined in HsTypes

type XHsQTvs GhcRn 
Instance details

Defined in HsTypes

type XHsQTvs GhcTc 
Instance details

Defined in HsTypes

type family XXLHsQTyVars x :: Type #

Instances
type XXLHsQTyVars (GhcPass _) 
Instance details

Defined in HsTypes

type ForallXLHsQTyVars (c :: Type -> Constraint) x = (c (XHsQTvs x), c (XXLHsQTyVars x)) #

type family XHsIB x b :: Type #

Instances
type XHsIB GhcPs _ 
Instance details

Defined in HsTypes

type XHsIB GhcPs _ = NoExt
type XHsIB GhcRn _ 
Instance details

Defined in HsTypes

type XHsIB GhcRn _ = HsIBRn
type XHsIB GhcTc _ 
Instance details

Defined in HsTypes

type XHsIB GhcTc _ = HsIBRn

type family XXHsImplicitBndrs x b :: Type #

Instances
type XXHsImplicitBndrs (GhcPass _1) _2 
Instance details

Defined in HsTypes

type ForallXHsImplicitBndrs (c :: Type -> Constraint) x b = (c (XHsIB x b), c (XXHsImplicitBndrs x b)) #

type family XHsWC x b :: Type #

Instances
type XHsWC GhcPs b 
Instance details

Defined in HsTypes

type XHsWC GhcPs b = NoExt
type XHsWC GhcRn b 
Instance details

Defined in HsTypes

type XHsWC GhcRn b = [Name]
type XHsWC GhcTc b 
Instance details

Defined in HsTypes

type XHsWC GhcTc b = [Name]

type family XXHsWildCardBndrs x b :: Type #

Instances
type XXHsWildCardBndrs (GhcPass _) b 
Instance details

Defined in HsTypes

type ForallXHsWildCardBndrs (c :: Type -> Constraint) x b = (c (XHsWC x b), c (XXHsWildCardBndrs x b)) #

type family XForAllTy x :: Type #

Instances
type XForAllTy (GhcPass _) 
Instance details

Defined in HsTypes

type family XQualTy x :: Type #

Instances
type XQualTy (GhcPass _) 
Instance details

Defined in HsTypes

type XQualTy (GhcPass _) = NoExt

type family XTyVar x :: Type #

Instances
type XTyVar (GhcPass _) 
Instance details

Defined in HsTypes

type XTyVar (GhcPass _) = NoExt

type family XAppTy x :: Type #

Instances
type XAppTy (GhcPass _) 
Instance details

Defined in HsTypes

type XAppTy (GhcPass _) = NoExt

type family XFunTy x :: Type #

Instances
type XFunTy (GhcPass _) 
Instance details

Defined in HsTypes

type XFunTy (GhcPass _) = NoExt

type family XListTy x :: Type #

Instances
type XListTy (GhcPass _) 
Instance details

Defined in HsTypes

type XListTy (GhcPass _) = NoExt

type family XTupleTy x :: Type #

Instances
type XTupleTy (GhcPass _) 
Instance details

Defined in HsTypes

type family XSumTy x :: Type #

Instances
type XSumTy (GhcPass _) 
Instance details

Defined in HsTypes

type XSumTy (GhcPass _) = NoExt

type family XOpTy x :: Type #

Instances
type XOpTy (GhcPass _) 
Instance details

Defined in HsTypes

type XOpTy (GhcPass _) = NoExt

type family XParTy x :: Type #

Instances
type XParTy (GhcPass _) 
Instance details

Defined in HsTypes

type XParTy (GhcPass _) = NoExt

type family XIParamTy x :: Type #

Instances
type XIParamTy (GhcPass _) 
Instance details

Defined in HsTypes

type family XStarTy x :: Type #

Instances
type XStarTy (GhcPass _) 
Instance details

Defined in HsTypes

type XStarTy (GhcPass _) = NoExt

type family XKindSig x :: Type #

Instances
type XKindSig (GhcPass _) 
Instance details

Defined in HsTypes

type family XSpliceTy x :: Type #

Instances
type XSpliceTy GhcPs 
Instance details

Defined in HsTypes

type XSpliceTy GhcRn 
Instance details

Defined in HsTypes

type XSpliceTy GhcTc 
Instance details

Defined in HsTypes

type family XDocTy x :: Type #

Instances
type XDocTy (GhcPass _) 
Instance details

Defined in HsTypes

type XDocTy (GhcPass _) = NoExt

type family XBangTy x :: Type #

Instances
type XBangTy (GhcPass _) 
Instance details

Defined in HsTypes

type XBangTy (GhcPass _) = NoExt

type family XRecTy x :: Type #

Instances
type XRecTy (GhcPass _) 
Instance details

Defined in HsTypes

type XRecTy (GhcPass _) = NoExt

type family XExplicitListTy x :: Type #

Instances
type XExplicitListTy GhcPs 
Instance details

Defined in HsTypes

type XExplicitListTy GhcRn 
Instance details

Defined in HsTypes

type XExplicitListTy GhcTc 
Instance details

Defined in HsTypes

type family XExplicitTupleTy x :: Type #

Instances
type XExplicitTupleTy GhcPs 
Instance details

Defined in HsTypes

type XExplicitTupleTy GhcRn 
Instance details

Defined in HsTypes

type XExplicitTupleTy GhcTc 
Instance details

Defined in HsTypes

type family XTyLit x :: Type #

Instances
type XTyLit (GhcPass _) 
Instance details

Defined in HsTypes

type XTyLit (GhcPass _) = NoExt

type family XWildCardTy x :: Type #

Instances
type XWildCardTy GhcPs 
Instance details

Defined in HsTypes

type XWildCardTy GhcRn 
Instance details

Defined in HsTypes

type XWildCardTy GhcTc 
Instance details

Defined in HsTypes

type family XXType x :: Type #

Instances
type XXType (GhcPass _) 
Instance details

Defined in HsTypes

type ForallXType (c :: Type -> Constraint) x = (c (XForAllTy x), c (XQualTy x), c (XTyVar x), c (XAppTy x), c (XFunTy x), c (XListTy x), c (XTupleTy x), c (XSumTy x), c (XOpTy x), c (XParTy x), c (XIParamTy x), c (XStarTy x), c (XKindSig x), c (XSpliceTy x), c (XDocTy x), c (XBangTy x), c (XRecTy x), c (XExplicitListTy x), c (XExplicitTupleTy x), c (XTyLit x), c (XWildCardTy x), c (XXType x)) #

Helper to apply a constraint to all extension points. It has one entry per extension point type family.

type family XUserTyVar x :: Type #

Instances
type XUserTyVar (GhcPass _) 
Instance details

Defined in HsTypes

type family XKindedTyVar x :: Type #

Instances
type XKindedTyVar (GhcPass _) 
Instance details

Defined in HsTypes

type family XXTyVarBndr x :: Type #

Instances
type XXTyVarBndr (GhcPass _) 
Instance details

Defined in HsTypes

type ForallXTyVarBndr (c :: Type -> Constraint) x = (c (XUserTyVar x), c (XKindedTyVar x), c (XXTyVarBndr x)) #

type family XConDeclField x :: Type #

Instances
type XConDeclField (GhcPass _) 
Instance details

Defined in HsTypes

type family XXConDeclField x :: Type #

Instances
type XXConDeclField (GhcPass _) 
Instance details

Defined in HsTypes

type family XCFieldOcc x :: Type #

Instances
type XCFieldOcc GhcPs 
Instance details

Defined in HsTypes

type XCFieldOcc GhcRn 
Instance details

Defined in HsTypes

type XCFieldOcc GhcTc 
Instance details

Defined in HsTypes

type family XXFieldOcc x :: Type #

Instances
type XXFieldOcc (GhcPass _) 
Instance details

Defined in HsTypes

type ForallXFieldOcc (c :: Type -> Constraint) x = (c (XCFieldOcc x), c (XXFieldOcc x)) #

type family XCImportDecl x :: Type #

Instances
type XCImportDecl (GhcPass _) 
Instance details

Defined in HsImpExp

type family XXImportDecl x :: Type #

Instances
type XXImportDecl (GhcPass _) 
Instance details

Defined in HsImpExp

type ForallXImportDecl (c :: Type -> Constraint) x = (c (XCImportDecl x), c (XXImportDecl x)) #

type family XIEVar x :: Type #

Instances
type XIEVar (GhcPass _) 
Instance details

Defined in HsImpExp

type XIEVar (GhcPass _) = NoExt

type family XIEThingAbs x :: Type #

Instances
type XIEThingAbs (GhcPass _) 
Instance details

Defined in HsImpExp

type family XIEThingAll x :: Type #

Instances
type XIEThingAll (GhcPass _) 
Instance details

Defined in HsImpExp

type family XIEThingWith x :: Type #

Instances
type XIEThingWith (GhcPass _) 
Instance details

Defined in HsImpExp

type family XIEModuleContents x :: Type #

Instances
type XIEModuleContents (GhcPass _) 
Instance details

Defined in HsImpExp

type family XIEGroup x :: Type #

Instances
type XIEGroup (GhcPass _) 
Instance details

Defined in HsImpExp

type family XIEDoc x :: Type #

Instances
type XIEDoc (GhcPass _) 
Instance details

Defined in HsImpExp

type XIEDoc (GhcPass _) = NoExt

type family XIEDocNamed x :: Type #

Instances
type XIEDocNamed (GhcPass _) 
Instance details

Defined in HsImpExp

type family XXIE x :: Type #

Instances
type XXIE (GhcPass _) 
Instance details

Defined in HsImpExp

type XXIE (GhcPass _) = NoExt

type ForallXIE (c :: Type -> Constraint) x = (c (XIEVar x), c (XIEThingAbs x), c (XIEThingAll x), c (XIEThingWith x), c (XIEModuleContents x), c (XIEGroup x), c (XIEDoc x), c (XIEDocNamed x), c (XXIE x)) #

class Convertable a b | a -> b where #

Conversion of annotations from one type index to another. This is required where the AST is converted from one pass to another, and the extension values need to be brought along if possible. So for example a SourceText is converted via id, but needs a type signature to keep the type checker happy.

Methods

convert :: a -> b #

Instances
Convertable a a 
Instance details

Defined in HsExtension

Methods

convert :: a -> a #

type ConvertIdX a b = (XHsDoublePrim a ~ XHsDoublePrim b, XHsFloatPrim a ~ XHsFloatPrim b, XHsRat a ~ XHsRat b, XHsInteger a ~ XHsInteger b, XHsWord64Prim a ~ XHsWord64Prim b, XHsInt64Prim a ~ XHsInt64Prim b, XHsWordPrim a ~ XHsWordPrim b, XHsIntPrim a ~ XHsIntPrim b, XHsInt a ~ XHsInt b, XHsStringPrim a ~ XHsStringPrim b, XHsString a ~ XHsString b, XHsCharPrim a ~ XHsCharPrim b, XHsChar a ~ XHsChar b, XXLit a ~ XXLit b) #

A constraint capturing all the extension points that can be converted via instance Convertable a a

type OutputableX p = (Outputable (XSigPat p), Outputable (XSigPat GhcRn), Outputable (XIPBinds p), Outputable (XExprWithTySig p), Outputable (XExprWithTySig GhcRn), Outputable (XAppTypeE p), Outputable (XAppTypeE GhcRn), Outputable (XViaStrategy p), Outputable (XViaStrategy GhcRn)) #

Provide a summary constraint that gives all am Outputable constraint to extension points needing one

type OutputableBndrId id = (OutputableBndr (NameOrRdrName (IdP id)), OutputableBndr (IdP id), OutputableX id) #

Constraint type to bundle up the requirement for OutputableBndr on both the id and the NameOrRdrName type for it

type family NameOrRdrName id :: Type where ... #

Follow the id, but never beyond Name. This is used in a HsMatchContext, for printing messages related to a Match

isExportedId :: Var -> Bool #

isExportedIdVar means "don't throw this away"

type Id = Var #

Identifier

type TyVar = Var #

Type or kind Variable

data Token #

Instances
Show Token 
Instance details

Defined in Lexer

Methods

showsPrec :: Int -> Token -> ShowS #

show :: Token -> String #

showList :: [Token] -> ShowS #

Outputable Token 
Instance details

Defined in Lexer

Methods

ppr :: Token -> SDoc #

pprPrec :: Rational -> Token -> SDoc #

unicodeAnn :: AnnKeywordId -> AnnKeywordId #

Convert a normal annotation into its unicode equivalent one

getAndRemoveAnnotationComments :: ApiAnns -> SrcSpan -> ([Located AnnotationComment], ApiAnns) #

Retrieve the comments allocated to the current SrcSpan, and remove them from the annotations

getAnnotationComments :: ApiAnns -> SrcSpan -> [Located AnnotationComment] #

Retrieve the comments allocated to the current SrcSpan

Note: A given SrcSpan may appear in multiple AST elements, beware of duplicates

getAndRemoveAnnotation :: ApiAnns -> SrcSpan -> AnnKeywordId -> ([SrcSpan], ApiAnns) #

Retrieve a list of annotation SrcSpans based on the SrcSpan of the annotated AST element, and the known type of the annotation. The list is removed from the annotations.

getAnnotation :: ApiAnns -> SrcSpan -> AnnKeywordId -> [SrcSpan] #

Retrieve a list of annotation SrcSpans based on the SrcSpan of the annotated AST element, and the known type of the annotation.

data AnnKeywordId #

API Annotations exist so that tools can perform source to source conversions of Haskell code. They are used to keep track of the various syntactic keywords that are not captured in the existing AST.

The annotations, together with original source comments are made available in the pm_annotations field of ParsedModule. Comments are only retained if Opt_KeepRawTokenStream is set in DynFlags before parsing.

The wiki page describing this feature is https://ghc.haskell.org/trac/ghc/wiki/ApiAnnotations

Note: in general the names of these are taken from the corresponding token, unless otherwise noted See note [Api annotations] above for details of the usage

Constructors

AnnAnyclass 
AnnAs 
AnnAt 
AnnBang

!

AnnBackquote

'`'

AnnBy 
AnnCase

case or lambda case

AnnClass 
AnnClose

'#)' or '#-}' etc

AnnCloseB

'|)'

AnnCloseBU

'|)', unicode variant

AnnCloseC

'}'

AnnCloseQ

'|]'

AnnCloseQU

'|]', unicode variant

AnnCloseP

')'

AnnCloseS

']'

AnnColon 
AnnComma

as a list separator

AnnCommaTuple

in a RdrName for a tuple

AnnDarrow

'=>'

AnnDarrowU

'=>', unicode variant

AnnData 
AnnDcolon

'::'

AnnDcolonU

'::', unicode variant

AnnDefault 
AnnDeriving 
AnnDo 
AnnDot

.

AnnDotdot

'..'

AnnElse 
AnnEqual 
AnnExport 
AnnFamily 
AnnForall 
AnnForallU

Unicode variant

AnnForeign 
AnnFunId

for function name in matches where there are multiple equations for the function.

AnnGroup 
AnnHeader

for CType

AnnHiding 
AnnIf 
AnnImport 
AnnIn 
AnnInfix

'infix' or 'infixl' or 'infixr'

AnnInstance 
AnnLam 
AnnLarrow

'<-'

AnnLarrowU

'<-', unicode variant

AnnLet 
AnnMdo 
AnnMinus

-

AnnModule 
AnnNewtype 
AnnName

where a name loses its location in the AST, this carries it

AnnOf 
AnnOpen

'(#' or '{-# LANGUAGE' etc

AnnOpenB

'(|'

AnnOpenBU

'(|', unicode variant

AnnOpenC

'{'

AnnOpenE

'[e|' or '[e||'

AnnOpenEQ

'[|'

AnnOpenEQU

'[|', unicode variant

AnnOpenP

'('

AnnOpenPE

'$('

AnnOpenPTE

'$$('

AnnOpenS

'['

AnnPackageName 
AnnPattern 
AnnProc 
AnnQualified 
AnnRarrow

'->'

AnnRarrowU

'->', unicode variant

AnnRec 
AnnRole 
AnnSafe 
AnnSemi

';'

AnnSimpleQuote

'''

AnnSignature 
AnnStatic

static

AnnStock 
AnnThen 
AnnThIdSplice

$

AnnThIdTySplice

$$

AnnThTyQuote

double '''

AnnTilde

'~'

AnnType 
AnnUnit

'()' for types

AnnUsing 
AnnVal

e.g. INTEGER

AnnValStr

String value, will need quotes when output

AnnVbar

'|'

AnnVia

via

AnnWhere 
Annlarrowtail

-<

AnnlarrowtailU

-<, unicode variant

Annrarrowtail

'->'

AnnrarrowtailU

'->', unicode variant

AnnLarrowtail

-<<

AnnLarrowtailU

-<<, unicode variant

AnnRarrowtail

>>-

AnnRarrowtailU

>>-, unicode variant

AnnEofPos 
Instances
Eq AnnKeywordId 
Instance details

Defined in ApiAnnotation

Data AnnKeywordId 
Instance details

Defined in ApiAnnotation

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnKeywordId -> c AnnKeywordId #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnKeywordId #

toConstr :: AnnKeywordId -> Constr #

dataTypeOf :: AnnKeywordId -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnnKeywordId) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnKeywordId) #

gmapT :: (forall b. Data b => b -> b) -> AnnKeywordId -> AnnKeywordId #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnKeywordId -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnKeywordId -> r #

gmapQ :: (forall d. Data d => d -> u) -> AnnKeywordId -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnKeywordId -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnKeywordId -> m AnnKeywordId #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnKeywordId -> m AnnKeywordId #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnKeywordId -> m AnnKeywordId #

Ord AnnKeywordId 
Instance details

Defined in ApiAnnotation

Show AnnKeywordId 
Instance details

Defined in ApiAnnotation

Outputable AnnKeywordId 
Instance details

Defined in ApiAnnotation

data AnnotationComment #

Constructors

AnnDocCommentNext String

something beginning '-- |'

AnnDocCommentPrev String

something beginning '-- ^'

AnnDocCommentNamed String

something beginning '-- $'

AnnDocSection Int String

a section heading

AnnDocOptions String

doc options (prune, ignore-exports, etc)

AnnLineComment String

comment starting by "--"

AnnBlockComment String

comment in {- -}

Instances
Eq AnnotationComment 
Instance details

Defined in ApiAnnotation

Data AnnotationComment 
Instance details

Defined in ApiAnnotation

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnotationComment -> c AnnotationComment #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnotationComment #

toConstr :: AnnotationComment -> Constr #

dataTypeOf :: AnnotationComment -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnnotationComment) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnotationComment) #

gmapT :: (forall b. Data b => b -> b) -> AnnotationComment -> AnnotationComment #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnotationComment -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnotationComment -> r #

gmapQ :: (forall d. Data d => d -> u) -> AnnotationComment -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnotationComment -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnotationComment -> m AnnotationComment #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnotationComment -> m AnnotationComment #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnotationComment -> m AnnotationComment #

Ord AnnotationComment 
Instance details

Defined in ApiAnnotation

Show AnnotationComment 
Instance details

Defined in ApiAnnotation

Outputable AnnotationComment 
Instance details

Defined in ApiAnnotation

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`
( ~ )

Constructors

Unqual OccName

Unqualified name

Used for ordinary, unqualified occurrences, e.g. x, y or Foo. Create such a RdrName with mkRdrUnqual

Qual ModuleName OccName

Qualified name

A qualified name written by the user in source code. The module isn't necessarily the module where the thing is defined; just the one from which it is imported. Examples are Bar.x, Bar.y or Bar.Foo. Create such a RdrName with mkRdrQual

Instances
Eq RdrName 
Instance details

Defined in RdrName

Methods

(==) :: RdrName -> RdrName -> Bool #

(/=) :: RdrName -> RdrName -> Bool #

Data RdrName 
Instance details

Defined in RdrName

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RdrName -> c RdrName #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RdrName #

toConstr :: RdrName -> Constr #

dataTypeOf :: RdrName -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RdrName) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RdrName) #

gmapT :: (forall b. Data b => b -> b) -> RdrName -> RdrName #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RdrName -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RdrName -> r #

gmapQ :: (forall d. Data d => d -> u) -> RdrName -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> RdrName -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RdrName -> m RdrName #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RdrName -> m RdrName #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RdrName -> m RdrName #

Ord RdrName 
Instance details

Defined in RdrName

HasOccName RdrName 
Instance details

Defined in RdrName

Methods

occName :: RdrName -> OccName #

Outputable RdrName 
Instance details

Defined in RdrName

Methods

ppr :: RdrName -> SDoc #

pprPrec :: Rational -> RdrName -> SDoc #

OutputableBndr RdrName 
Instance details

Defined in RdrName

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.

hsDocStringToByteString :: HsDocString -> ByteString #

Return the contents of a HsDocString as a UTF8-encoded ByteString.

data HsDocString #

Haskell Documentation String

Internally this is a UTF8-Encoded ByteString.

Instances
Eq HsDocString 
Instance details

Defined in HsDoc

Data HsDocString 
Instance details

Defined in HsDoc

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsDocString -> c HsDocString #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsDocString #

toConstr :: HsDocString -> Constr #

dataTypeOf :: HsDocString -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsDocString) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsDocString) #

gmapT :: (forall b. Data b => b -> b) -> HsDocString -> HsDocString #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsDocString -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsDocString -> r #

gmapQ :: (forall d. Data d => d -> u) -> HsDocString -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsDocString -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsDocString -> m HsDocString #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDocString -> m HsDocString #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsDocString -> m HsDocString #

Show HsDocString 
Instance details

Defined in HsDoc

Binary HsDocString 
Instance details

Defined in HsDoc

Outputable HsDocString 
Instance details

Defined in HsDoc

type LHsDocString = Located HsDocString #

Located Haskell Documentation String

newtype DeclDocMap #

Docs for declarations: functions, data types, instances, methods etc.

Constructors

DeclDocMap (Map Name HsDocString) 
Instances
Binary DeclDocMap 
Instance details

Defined in HsDoc

Outputable DeclDocMap 
Instance details

Defined in HsDoc

newtype ArgDocMap #

Docs for arguments. E.g. function arguments, method arguments.

Constructors

ArgDocMap (Map Name (Map Int HsDocString)) 
Instances
Binary ArgDocMap 
Instance details

Defined in HsDoc

Outputable ArgDocMap 
Instance details

Defined in HsDoc

class NamedThing a where #

A class allowing convenient access to the Name of various datatypes

Minimal complete definition

getName

Methods

getOccName :: a -> OccName #

getName :: a -> Name #

Instances
NamedThing ClsInst 
Instance details

Defined in InstEnv

NamedThing FamInst 
Instance details

Defined in FamInstEnv

NamedThing IfaceDecl 
Instance details

Defined in IfaceSyn

NamedThing IfaceClassOp 
Instance details

Defined in IfaceSyn

NamedThing IfaceConDecl 
Instance details

Defined in IfaceSyn

NamedThing Class 
Instance details

Defined in Class

NamedThing ConLike 
Instance details

Defined in ConLike

NamedThing DataCon 
Instance details

Defined in DataCon

NamedThing Var 
Instance details

Defined in Var

Methods

getOccName :: Var -> OccName #

getName :: Var -> Name #

NamedThing TyThing 
Instance details

Defined in TyCoRep

NamedThing TyCon 
Instance details

Defined in TyCon

NamedThing Name 
Instance details

Defined in Name

NamedThing (CoAxiom br) 
Instance details

Defined in CoAxiom

Methods

getOccName :: CoAxiom br -> OccName #

getName :: CoAxiom br -> Name #

NamedThing e => NamedThing (GenLocated l e) 
Instance details

Defined in Name

gopt :: GeneralFlag -> DynFlags -> Bool #

Test whether a GeneralFlag is set

defaultObjectTarget :: Platform -> HscTarget #

The HscTarget value corresponding to the default way to create object files on the current platform.

data SafeHaskellMode #

The various Safe Haskell modes

Instances
Eq SafeHaskellMode 
Instance details

Defined in DynFlags

Show SafeHaskellMode 
Instance details

Defined in DynFlags

NFData SafeHaskellMode Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Methods

rnf :: SafeHaskellMode -> () #

Outputable SafeHaskellMode 
Instance details

Defined in DynFlags

data HscTarget #

The target code type of the compilation (if any).

Whenever you change the target, also make sure to set ghcLink to something sensible.

HscNothing can be used to avoid generating any output, however, note that:

  • If a program uses Template Haskell the typechecker may need to run code from an imported module. To facilitate this, code generation is enabled for modules imported by modules that use template haskell. See Note [-fno-code mode].

Constructors

HscC

Generate C code.

HscAsm

Generate assembly using the native code generator.

HscLlvm

Generate assembly using the llvm code generator.

HscInterpreted

Generate bytecode. (Requires LinkInMemory)

HscNothing

Don't generate any code. See notes above.

Instances
Eq HscTarget 
Instance details

Defined in DynFlags

Show HscTarget 
Instance details

Defined in DynFlags

data GhcMode #

The GhcMode tells us whether we're doing multi-module compilation (controlled via the GHC API) or one-shot (single-module) compilation. This makes a difference primarily to the Finder: in one-shot mode we look for interface files for imported modules, but in multi-module mode we look for source files in order to check whether they need to be recompiled.

Constructors

CompManager

--make, GHCi, etc.

OneShot
ghc -c Foo.hs
MkDepend

ghc -M, see Finder for why we need this

Instances
Eq GhcMode 
Instance details

Defined in DynFlags

Methods

(==) :: GhcMode -> GhcMode -> Bool #

(/=) :: GhcMode -> GhcMode -> Bool #

Outputable GhcMode 
Instance details

Defined in DynFlags

Methods

ppr :: GhcMode -> SDoc #

pprPrec :: Rational -> GhcMode -> SDoc #

data GhcLink #

What to do in the link step, if there is one.

Constructors

NoLink

Don't link at all

LinkBinary

Link object code into a binary

LinkInMemory

Use the in-memory dynamic linker (works for both bytecode and object code).

LinkDynLib

Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)

LinkStaticLib

Link objects into a static lib

data Phase #

Instances
Eq Phase 
Instance details

Defined in DriverPhases

Methods

(==) :: Phase -> Phase -> Bool #

(/=) :: Phase -> Phase -> Bool #

Show Phase 
Instance details

Defined in DriverPhases

Methods

showsPrec :: Int -> Phase -> ShowS #

show :: Phase -> String #

showList :: [Phase] -> ShowS #

Outputable Phase 
Instance details

Defined in DriverPhases

Methods

ppr :: Phase -> SDoc #

pprPrec :: Rational -> Phase -> SDoc #

data Fixity #

Instances
Eq Fixity 
Instance details

Defined in BasicTypes

Methods

(==) :: Fixity -> Fixity -> Bool #

(/=) :: Fixity -> Fixity -> Bool #

Data Fixity 
Instance details

Defined in BasicTypes

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Fixity -> c Fixity #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Fixity #

toConstr :: Fixity -> Constr #

dataTypeOf :: Fixity -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Fixity) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity) #

gmapT :: (forall b. Data b => b -> b) -> Fixity -> Fixity #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r #

gmapQ :: (forall d. Data d => d -> u) -> Fixity -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Fixity -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity #

Binary Fixity 
Instance details

Defined in Binary

Methods

put_ :: BinHandle -> Fixity -> IO () #

put :: BinHandle -> Fixity -> IO (Bin Fixity) #

get :: BinHandle -> IO Fixity #

Outputable Fixity 
Instance details

Defined in BasicTypes

Methods

ppr :: Fixity -> SDoc #

pprPrec :: Rational -> Fixity -> SDoc #

data FixityDirection #

Constructors

InfixL 
InfixR 
InfixN 
Instances
Eq FixityDirection 
Instance details

Defined in BasicTypes

Data FixityDirection 
Instance details

Defined in BasicTypes

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FixityDirection -> c FixityDirection #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FixityDirection #

toConstr :: FixityDirection -> Constr #

dataTypeOf :: FixityDirection -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FixityDirection) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FixityDirection) #

gmapT :: (forall b. Data b => b -> b) -> FixityDirection -> FixityDirection #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r #

gmapQ :: (forall d. Data d => d -> u) -> FixityDirection -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FixityDirection -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection #

Binary FixityDirection 
Instance details

Defined in Binary

Outputable FixityDirection 
Instance details

Defined in BasicTypes

data LexicalFixity #

Captures the fixity of declarations as they are parsed. This is not necessarily the same as the fixity declaration, as the normal fixity may be overridden using parens or backticks.

Constructors

Prefix 
Infix 
Instances
Eq LexicalFixity 
Instance details

Defined in BasicTypes

Data LexicalFixity 
Instance details

Defined in BasicTypes

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LexicalFixity -> c LexicalFixity #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LexicalFixity #

toConstr :: LexicalFixity -> Constr #

dataTypeOf :: LexicalFixity -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c LexicalFixity) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LexicalFixity) #

gmapT :: (forall b. Data b => b -> b) -> LexicalFixity -> LexicalFixity #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LexicalFixity -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LexicalFixity -> r #

gmapQ :: (forall d. Data d => d -> u) -> LexicalFixity -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> LexicalFixity -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> LexicalFixity -> m LexicalFixity #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LexicalFixity -> m LexicalFixity #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LexicalFixity -> m LexicalFixity #

Outputable LexicalFixity 
Instance details

Defined in BasicTypes

data SuccessFlag #

Constructors

Succeeded 
Failed 
Instances
Outputable SuccessFlag 
Instance details

Defined in BasicTypes

data SpliceExplicitFlag #

Constructors

ExplicitSplice

= $(f x y)

ImplicitSplice

= f x y, i.e. a naked top level expression

Instances
Data SpliceExplicitFlag 
Instance details

Defined in BasicTypes

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SpliceExplicitFlag -> c SpliceExplicitFlag #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SpliceExplicitFlag #

toConstr :: SpliceExplicitFlag -> Constr #

dataTypeOf :: SpliceExplicitFlag -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SpliceExplicitFlag) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SpliceExplicitFlag) #

gmapT :: (forall b. Data b => b -> b) -> SpliceExplicitFlag -> SpliceExplicitFlag #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SpliceExplicitFlag -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SpliceExplicitFlag -> r #

gmapQ :: (forall d. Data d => d -> u) -> SpliceExplicitFlag -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SpliceExplicitFlag -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SpliceExplicitFlag -> m SpliceExplicitFlag #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceExplicitFlag -> m SpliceExplicitFlag #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SpliceExplicitFlag -> m SpliceExplicitFlag #

data Severity #

Constructors

SevOutput 
SevFatal 
SevInteractive 
SevDump

Log message intended for compiler developers No filelinecolumn stuff

SevInfo

Log messages intended for end users. No filelinecolumn stuff.

SevWarning 
SevError

SevWarning and SevError are used for warnings and errors o The message has a filelinecolumn heading, plus "warning:" or "error:", added by mkLocMessags o Output is intended for end users

Instances
Show Severity 
Instance details

Defined in ErrUtils

ToJson Severity 
Instance details

Defined in ErrUtils

Methods

json :: Severity -> JsonDoc #

isSubspanOf #

Arguments

:: SrcSpan

The span that may be enclosed by the other

-> SrcSpan

The span it may be enclosed by

-> Bool 

Determines whether a span is enclosed by another one

spans :: SrcSpan -> (Int, Int) -> Bool #

Determines whether a span encloses a given line and column index

leftmost_largest :: SrcSpan -> SrcSpan -> Ordering #

Alternative strategies for ordering SrcSpans

leftmost_smallest :: SrcSpan -> SrcSpan -> Ordering #

Alternative strategies for ordering SrcSpans

rightmost :: SrcSpan -> SrcSpan -> Ordering #

Alternative strategies for ordering SrcSpans

cmpLocated :: Ord a => Located a -> Located a -> Ordering #

Tests the ordering of the two located things

eqLocated :: Eq a => Located a -> Located a -> Bool #

Tests whether the two located things are equal

addCLoc :: Located a -> Located b -> c -> Located c #

Combine locations from two Located things and add them to a third thing

noLoc :: e -> Located e #

unLoc :: GenLocated l e -> e #

srcSpanEnd :: SrcSpan -> SrcLoc #

Returns the location at the end of the SrcSpan or a "bad" SrcSpan if that is unavailable

srcSpanStart :: SrcSpan -> SrcLoc #

Returns the location at the start of the SrcSpan or a "bad" SrcSpan if that is unavailable

isGoodSrcSpan :: SrcSpan -> Bool #

Test if a SrcSpan is "good", i.e. has precise location information

mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan #

Create a SrcSpan between two points in a file

srcLocSpan :: SrcLoc -> SrcSpan #

Create a SrcSpan corresponding to a single point

noSrcSpan :: SrcSpan #

Built-in "bad" SrcSpans for common sources of location uncertainty

srcLocCol :: RealSrcLoc -> Int #

Raises an error when used on a "bad" RealSrcLoc

srcLocLine :: RealSrcLoc -> Int #

Raises an error when used on a "bad" RealSrcLoc

srcLocFile :: RealSrcLoc -> FastString #

Gives the filename of the RealSrcLoc

noSrcLoc :: SrcLoc #

Built-in "bad" RealSrcLoc values for particular locations

data RealSrcLoc #

Real Source Location

Represents a single point within a file

Instances
Eq RealSrcLoc 
Instance details

Defined in SrcLoc

Ord RealSrcLoc 
Instance details

Defined in SrcLoc

Show RealSrcLoc 
Instance details

Defined in SrcLoc

Outputable RealSrcLoc 
Instance details

Defined in SrcLoc

data SrcLoc #

Source Location

Instances
Eq SrcLoc 
Instance details

Defined in SrcLoc

Methods

(==) :: SrcLoc -> SrcLoc -> Bool #

(/=) :: SrcLoc -> SrcLoc -> Bool #

Ord SrcLoc 
Instance details

Defined in SrcLoc

Show SrcLoc 
Instance details

Defined in SrcLoc

Outputable SrcLoc 
Instance details

Defined in SrcLoc

Methods

ppr :: SrcLoc -> SDoc #

pprPrec :: Rational -> SrcLoc -> SDoc #

data RealSrcSpan #

A RealSrcSpan delimits a portion of a text file. It could be represented by a pair of (line,column) coordinates, but in fact we optimise slightly by using more compact representations for single-line and zero-length spans, both of which are quite common.

The end position is defined to be the column after the end of the span. That is, a span of (1,1)-(1,2) is one character long, and a span of (1,1)-(1,1) is zero characters long.

Real Source Span

Instances
Eq RealSrcSpan 
Instance details

Defined in SrcLoc

Data RealSrcSpan 
Instance details

Defined in SrcLoc

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RealSrcSpan -> c RealSrcSpan #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RealSrcSpan #

toConstr :: RealSrcSpan -> Constr #

dataTypeOf :: RealSrcSpan -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RealSrcSpan) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RealSrcSpan) #

gmapT :: (forall b. Data b => b -> b) -> RealSrcSpan -> RealSrcSpan #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RealSrcSpan -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RealSrcSpan -> r #

gmapQ :: (forall d. Data d => d -> u) -> RealSrcSpan -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> RealSrcSpan -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RealSrcSpan -> m RealSrcSpan #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RealSrcSpan -> m RealSrcSpan #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RealSrcSpan -> m RealSrcSpan #

Ord RealSrcSpan 
Instance details

Defined in SrcLoc

Show RealSrcSpan 
Instance details

Defined in SrcLoc

Binary RealSrcSpan Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

ToJson RealSrcSpan 
Instance details

Defined in SrcLoc

Methods

json :: RealSrcSpan -> JsonDoc #

Outputable RealSrcSpan 
Instance details

Defined in SrcLoc

data SrcSpan #

Source Span

A SrcSpan identifies either a specific portion of a text file or a human-readable description of a location.

Instances
Eq SrcSpan 
Instance details

Defined in SrcLoc

Methods

(==) :: SrcSpan -> SrcSpan -> Bool #

(/=) :: SrcSpan -> SrcSpan -> Bool #

Data SrcSpan 
Instance details

Defined in SrcLoc

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcSpan -> c SrcSpan #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SrcSpan #

toConstr :: SrcSpan -> Constr #

dataTypeOf :: SrcSpan -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SrcSpan) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcSpan) #

gmapT :: (forall b. Data b => b -> b) -> SrcSpan -> SrcSpan #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcSpan -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SrcSpan -> r #

gmapQ :: (forall d. Data d => d -> u) -> SrcSpan -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcSpan -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan #

Ord SrcSpan 
Instance details

Defined in SrcLoc

Show SrcSpan 
Instance details

Defined in SrcLoc

NFData SrcSpan 
Instance details

Defined in SrcLoc

Methods

rnf :: SrcSpan -> () #

Binary SrcSpan 
Instance details

Defined in Binary

ToJson SrcSpan 
Instance details

Defined in SrcLoc

Methods

json :: SrcSpan -> JsonDoc #

Outputable SrcSpan 
Instance details

Defined in SrcLoc

Methods

ppr :: SrcSpan -> SDoc #

pprPrec :: Rational -> SrcSpan -> SDoc #

Show (GenLocated SrcSpan ModuleName) Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Binary a => Binary (GenLocated SrcSpan a) 
Instance details

Defined in Binary

HasSrcSpan (GenLocated SrcSpan a) Source # 
Instance details

Defined in Development.IDE.GHC.Compat

data GenLocated l e #

We attach SrcSpans to lots of things, so let's have a datatype for it.

Constructors

L l e 
Instances
Functor (GenLocated l) 
Instance details

Defined in SrcLoc

Methods

fmap :: (a -> b) -> GenLocated l a -> GenLocated l b #

(<$) :: a -> GenLocated l b -> GenLocated l a #

Foldable (GenLocated l) 
Instance details

Defined in SrcLoc

Methods

fold :: Monoid m => GenLocated l m -> m #

foldMap :: Monoid m => (a -> m) -> GenLocated l a -> m #

foldr :: (a -> b -> b) -> b -> GenLocated l a -> b #

foldr' :: (a -> b -> b) -> b -> GenLocated l a -> b #

foldl :: (b -> a -> b) -> b -> GenLocated l a -> b #

foldl' :: (b -> a -> b) -> b -> GenLocated l a -> b #

foldr1 :: (a -> a -> a) -> GenLocated l a -> a #

foldl1 :: (a -> a -> a) -> GenLocated l a -> a #

toList :: GenLocated l a -> [a] #

null :: GenLocated l a -> Bool #

length :: GenLocated l a -> Int #

elem :: Eq a => a -> GenLocated l a -> Bool #

maximum :: Ord a => GenLocated l a -> a #

minimum :: Ord a => GenLocated l a -> a #

sum :: Num a => GenLocated l a -> a #

product :: Num a => GenLocated l a -> a #

Traversable (GenLocated l) 
Instance details

Defined in SrcLoc

Methods

traverse :: Applicative f => (a -> f b) -> GenLocated l a -> f (GenLocated l b) #

sequenceA :: Applicative f => GenLocated l (f a) -> f (GenLocated l a) #

mapM :: Monad m => (a -> m b) -> GenLocated l a -> m (GenLocated l b) #

sequence :: Monad m => GenLocated l (m a) -> m (GenLocated l a) #

(Eq l, Eq e) => Eq (GenLocated l e) 
Instance details

Defined in SrcLoc

Methods

(==) :: GenLocated l e -> GenLocated l e -> Bool #

(/=) :: GenLocated l e -> GenLocated l e -> Bool #

(Data l, Data e) => Data (GenLocated l e) 
Instance details

Defined in SrcLoc

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GenLocated l e -> c (GenLocated l e) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GenLocated l e) #

toConstr :: GenLocated l e -> Constr #

dataTypeOf :: GenLocated l e -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GenLocated l e)) #

dataCast2 :: Typeable t => (forall d e0. (Data d, Data e0) => c (t d e0)) -> Maybe (c (GenLocated l e)) #

gmapT :: (forall b. Data b => b -> b) -> GenLocated l e -> GenLocated l e #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GenLocated l e -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GenLocated l e -> r #

gmapQ :: (forall d. Data d => d -> u) -> GenLocated l e -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> GenLocated l e -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GenLocated l e -> m (GenLocated l e) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GenLocated l e -> m (GenLocated l e) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GenLocated l e -> m (GenLocated l e) #

(Ord l, Ord e) => Ord (GenLocated l e) 
Instance details

Defined in SrcLoc

Methods

compare :: GenLocated l e -> GenLocated l e -> Ordering #

(<) :: GenLocated l e -> GenLocated l e -> Bool #

(<=) :: GenLocated l e -> GenLocated l e -> Bool #

(>) :: GenLocated l e -> GenLocated l e -> Bool #

(>=) :: GenLocated l e -> GenLocated l e -> Bool #

max :: GenLocated l e -> GenLocated l e -> GenLocated l e #

min :: GenLocated l e -> GenLocated l e -> GenLocated l e #

Show (GenLocated SrcSpan ModuleName) Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

(NFData l, NFData e) => NFData (GenLocated l e) Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Methods

rnf :: GenLocated l e -> () #

NamedThing e => NamedThing (GenLocated l e) 
Instance details

Defined in Name

Binary a => Binary (GenLocated SrcSpan a) 
Instance details

Defined in Binary

(Outputable l, Outputable e) => Outputable (GenLocated l e) 
Instance details

Defined in SrcLoc

Methods

ppr :: GenLocated l e -> SDoc #

pprPrec :: Rational -> GenLocated l e -> SDoc #

HasSrcSpan (GenLocated SrcSpan a) Source # 
Instance details

Defined in Development.IDE.GHC.Compat

data Type #

Instances
Data Type 
Instance details

Defined in TyCoRep

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Type -> c Type #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Type #

toConstr :: Type -> Constr #

dataTypeOf :: Type -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Type) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type) #

gmapT :: (forall b. Data b => b -> b) -> Type -> Type #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r #

gmapQ :: (forall d. Data d => d -> u) -> Type -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Type -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Type -> m Type #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Type -> m Type #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Type -> m Type #

Outputable Type 
Instance details

Defined in TyCoRep

Methods

ppr :: Type -> SDoc #

pprPrec :: Rational -> Type -> SDoc #

Eq (DeBruijn Type) 
Instance details

Defined in CoreMap

Methods

(==) :: DeBruijn Type -> DeBruijn Type -> Bool #

(/=) :: DeBruijn Type -> DeBruijn Type -> Bool #

data TyThing #

A global typecheckable-thing, essentially anything that has a name. Not to be confused with a TcTyThing, which is also a typecheckable thing but in the *local* context. See TcEnv for how to retrieve a TyThing given a Name.

Instances
NamedThing TyThing 
Instance details

Defined in TyCoRep

Outputable TyThing 
Instance details

Defined in TyCoRep

Methods

ppr :: TyThing -> SDoc #

pprPrec :: Rational -> TyThing -> SDoc #

type PredType = Type #

A type of the form p of kind Constraint represents a value whose type is the Haskell predicate p, where a predicate is what occurs before the => in a Haskell type.

We use PredType as documentation to mark those types that we guarantee to have this kind.

It can be expanded into its representation, but:

  • The type checker must treat it as opaque
  • The rest of the compiler treats it as transparent

Consider these examples:

f :: (Eq a) => a -> Int
g :: (?x :: Int -> Int) => a -> Int
h :: (r\l) => {r} => {l::Int | r}

Here the Eq a and ?x :: Int -> Int and rl are all called "predicates"

type Kind = Type #

The key type representing kinds in the compiler.

type ThetaType = [PredType] #

A collection of PredTypes

data PrintUnqualified #

When printing code that contains original names, we need to map the original names back to something the user understands. This is the purpose of the triple of functions that gets passed around when rendering SDoc.

data Module #

A Module is a pair of a UnitId and a ModuleName.

Module variables (i.e. H) which can be instantiated to a specific module at some later point in time are represented with moduleUnitId set to holeUnitId (this allows us to avoid having to make moduleUnitId a partial operation.)

Instances
Eq Module 
Instance details

Defined in Module

Methods

(==) :: Module -> Module -> Bool #

(/=) :: Module -> Module -> Bool #

Data Module 
Instance details

Defined in Module

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Module -> c Module #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Module #

toConstr :: Module -> Constr #

dataTypeOf :: Module -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Module) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module) #

gmapT :: (forall b. Data b => b -> b) -> Module -> Module #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r #

gmapQ :: (forall d. Data d => d -> u) -> Module -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Module -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Module -> m Module #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module #

Ord Module 
Instance details

Defined in Module

Show Module Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

NFData Module 
Instance details

Defined in Module

Methods

rnf :: Module -> () #

Binary Module 
Instance details

Defined in Module

Methods

put_ :: BinHandle -> Module -> IO () #

put :: BinHandle -> Module -> IO (Bin Module) #

get :: BinHandle -> IO Module #

Uniquable Module 
Instance details

Defined in Module

Methods

getUnique :: Module -> Unique #

Outputable Module 
Instance details

Defined in Module

Methods

ppr :: Module -> SDoc #

pprPrec :: Rational -> Module -> SDoc #

DbUnitIdModuleRep InstalledUnitId ComponentId UnitId ModuleName Module 
Instance details

Defined in Module

data ModuleName #

A ModuleName is essentially a simple string, e.g. Data.List.

Instances
Eq ModuleName 
Instance details

Defined in Module

Data ModuleName 
Instance details

Defined in Module

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModuleName -> c ModuleName #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ModuleName #

toConstr :: ModuleName -> Constr #

dataTypeOf :: ModuleName -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ModuleName) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleName) #

gmapT :: (forall b. Data b => b -> b) -> ModuleName -> ModuleName #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModuleName -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModuleName -> r #

gmapQ :: (forall d. Data d => d -> u) -> ModuleName -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ModuleName -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModuleName -> m ModuleName #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleName -> m ModuleName #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleName -> m ModuleName #

Ord ModuleName 
Instance details

Defined in Module

Show ModuleName Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Hashable ModuleName Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

NFData ModuleName 
Instance details

Defined in Module

Methods

rnf :: ModuleName -> () #

Binary ModuleName 
Instance details

Defined in Module

Uniquable ModuleName 
Instance details

Defined in Module

Outputable ModuleName 
Instance details

Defined in Module

BinaryStringRep ModuleName 
Instance details

Defined in Module

DbUnitIdModuleRep InstalledUnitId ComponentId UnitId ModuleName Module 
Instance details

Defined in Module

Show (GenLocated SrcSpan ModuleName) Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

data UnitId #

A unit identifier identifies a (possibly partially) instantiated library. It is primarily used as part of Module, which in turn is used in Name, which is used to give names to entities when typechecking.

There are two possible forms for a UnitId. It can be a DefiniteUnitId, in which case we just have a string that uniquely identifies some fully compiled, installed library we have on disk. However, when we are typechecking a library with missing holes, we may need to instantiate a library on the fly (in which case we don't have any on-disk representation.) In that case, you have an IndefiniteUnitId, which explicitly records the instantiation, so that we can substitute over it.

Instances
Eq UnitId 
Instance details

Defined in Module

Methods

(==) :: UnitId -> UnitId -> Bool #

(/=) :: UnitId -> UnitId -> Bool #

Data UnitId 
Instance details

Defined in Module

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UnitId -> c UnitId #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UnitId #

toConstr :: UnitId -> Constr #

dataTypeOf :: UnitId -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UnitId) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnitId) #

gmapT :: (forall b. Data b => b -> b) -> UnitId -> UnitId #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UnitId -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UnitId -> r #

gmapQ :: (forall d. Data d => d -> u) -> UnitId -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UnitId -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UnitId -> m UnitId #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UnitId -> m UnitId #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UnitId -> m UnitId #

Ord UnitId 
Instance details

Defined in Module

Show UnitId 
Instance details

Defined in Module

NFData UnitId 
Instance details

Defined in Module

Methods

rnf :: UnitId -> () #

Binary UnitId 
Instance details

Defined in Module

Methods

put_ :: BinHandle -> UnitId -> IO () #

put :: BinHandle -> UnitId -> IO (Bin UnitId) #

get :: BinHandle -> IO UnitId #

Uniquable UnitId 
Instance details

Defined in Module

Methods

getUnique :: UnitId -> Unique #

Outputable UnitId 
Instance details

Defined in Module

Methods

ppr :: UnitId -> SDoc #

pprPrec :: Rational -> UnitId -> SDoc #

DbUnitIdModuleRep InstalledUnitId ComponentId UnitId ModuleName Module 
Instance details

Defined in Module

data TyCon #

TyCons represent type constructors. Type constructors are introduced by things such as:

1) Data declarations: data Foo = ... creates the Foo type constructor of kind *

2) Type synonyms: type Foo = ... creates the Foo type constructor

3) Newtypes: newtype Foo a = MkFoo ... creates the Foo type constructor of kind * -> *

4) Class declarations: class Foo where creates the Foo type constructor of kind *

This data type also encodes a number of primitive, built in type constructors such as those for function and tuple types.

Instances
Eq TyCon 
Instance details

Defined in TyCon

Methods

(==) :: TyCon -> TyCon -> Bool #

(/=) :: TyCon -> TyCon -> Bool #

Data TyCon 
Instance details

Defined in TyCon

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyCon -> c TyCon #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TyCon #

toConstr :: TyCon -> Constr #

dataTypeOf :: TyCon -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TyCon) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyCon) #

gmapT :: (forall b. Data b => b -> b) -> TyCon -> TyCon #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyCon -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyCon -> r #

gmapQ :: (forall d. Data d => d -> u) -> TyCon -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TyCon -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyCon -> m TyCon #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyCon -> m TyCon #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyCon -> m TyCon #

NamedThing TyCon 
Instance details

Defined in TyCon

Uniquable TyCon 
Instance details

Defined in TyCon

Methods

getUnique :: TyCon -> Unique #

Outputable TyCon 
Instance details

Defined in TyCon

Methods

ppr :: TyCon -> SDoc #

pprPrec :: Rational -> TyCon -> SDoc #

data DynFlags #

Contains not only a collection of GeneralFlags but also a plethora of information relating to the compilation of a single file or GHC session

Constructors

DynFlags 

Fields

data GeneralFlag #

Enumerates the simple on-or-off dynamic flags

Constructors

Opt_DumpToFile

Append dump output to files instead of stdout.

Opt_D_faststring_stats 
Opt_D_dump_minimal_imports 
Opt_DoCoreLinting 
Opt_DoStgLinting 
Opt_DoCmmLinting 
Opt_DoAsmLinting 
Opt_DoAnnotationLinting 
Opt_NoLlvmMangler 
Opt_FastLlvm 
Opt_WarnIsError 
Opt_ShowWarnGroups 
Opt_HideSourcePaths 
Opt_PrintExplicitForalls 
Opt_PrintExplicitKinds 
Opt_PrintExplicitCoercions 
Opt_PrintExplicitRuntimeReps 
Opt_PrintEqualityRelations 
Opt_PrintUnicodeSyntax 
Opt_PrintExpandedSynonyms 
Opt_PrintPotentialInstances 
Opt_PrintTypecheckerElaboration 
Opt_CallArity 
Opt_Exitification 
Opt_Strictness 
Opt_LateDmdAnal 
Opt_KillAbsence 
Opt_KillOneShot 
Opt_FullLaziness 
Opt_FloatIn 
Opt_LateSpecialise 
Opt_Specialise 
Opt_SpecialiseAggressively 
Opt_CrossModuleSpecialise 
Opt_StaticArgumentTransformation 
Opt_CSE 
Opt_StgCSE 
Opt_LiberateCase 
Opt_SpecConstr 
Opt_SpecConstrKeen 
Opt_DoLambdaEtaExpansion 
Opt_IgnoreAsserts 
Opt_DoEtaReduction 
Opt_CaseMerge 
Opt_CaseFolding 
Opt_UnboxStrictFields 
Opt_UnboxSmallStrictFields 
Opt_DictsCheap 
Opt_EnableRewriteRules 
Opt_RegsGraph 
Opt_RegsIterative 
Opt_PedanticBottoms 
Opt_LlvmTBAA 
Opt_LlvmPassVectorsInRegisters 
Opt_LlvmFillUndefWithGarbage 
Opt_IrrefutableTuples 
Opt_CmmSink 
Opt_CmmElimCommonBlocks 
Opt_AsmShortcutting 
Opt_OmitYields 
Opt_FunToThunk 
Opt_DictsStrict 
Opt_DmdTxDictSel 
Opt_Loopification 
Opt_CprAnal 
Opt_WorkerWrapper 
Opt_SolveConstantDicts 
Opt_AlignmentSanitisation 
Opt_CatchBottoms 
Opt_NumConstantFolding 
Opt_SimplPreInlining 
Opt_IgnoreInterfacePragmas 
Opt_OmitInterfacePragmas 
Opt_ExposeAllUnfoldings 
Opt_WriteInterface 
Opt_AutoSccsOnIndividualCafs 
Opt_ProfCountEntries 
Opt_Pp 
Opt_ForceRecomp 
Opt_IgnoreOptimChanges 
Opt_IgnoreHpcChanges 
Opt_ExcessPrecision 
Opt_EagerBlackHoling 
Opt_NoHsMain 
Opt_SplitObjs 
Opt_SplitSections 
Opt_StgStats 
Opt_HideAllPackages 
Opt_HideAllPluginPackages 
Opt_PrintBindResult 
Opt_Haddock 
Opt_HaddockOptions 
Opt_BreakOnException 
Opt_BreakOnError 
Opt_PrintEvldWithShow 
Opt_PrintBindContents 
Opt_GenManifest 
Opt_EmbedManifest 
Opt_SharedImplib 
Opt_BuildingCabalPackage 
Opt_IgnoreDotGhci 
Opt_GhciSandbox 
Opt_GhciHistory 
Opt_GhciLeakCheck 
Opt_LocalGhciHistory 
Opt_NoIt 
Opt_HelpfulErrors 
Opt_DeferTypeErrors 
Opt_DeferTypedHoles 
Opt_DeferOutOfScopeVariables 
Opt_PIC
-fPIC
Opt_PIE
-fPIE
Opt_PICExecutable
-pie
Opt_ExternalDynamicRefs 
Opt_SccProfilingOn 
Opt_Ticky 
Opt_Ticky_Allocd 
Opt_Ticky_LNE 
Opt_Ticky_Dyn_Thunk 
Opt_RPath 
Opt_RelativeDynlibPaths 
Opt_Hpc 
Opt_FlatCache 
Opt_ExternalInterpreter 
Opt_OptimalApplicativeDo 
Opt_VersionMacros 
Opt_WholeArchiveHsLibs 
Opt_SingleLibFolder 
Opt_ErrorSpans 
Opt_DiagnosticsShowCaret 
Opt_PprCaseAsLet 
Opt_PprShowTicks 
Opt_ShowHoleConstraints 
Opt_ShowValidHoleFits 
Opt_SortValidHoleFits 
Opt_SortBySizeHoleFits 
Opt_SortBySubsumHoleFits 
Opt_AbstractRefHoleFits 
Opt_UnclutterValidHoleFits 
Opt_ShowTypeAppOfHoleFits 
Opt_ShowTypeAppVarsOfHoleFits 
Opt_ShowTypeOfHoleFits 
Opt_ShowProvOfHoleFits 
Opt_ShowMatchesOfHoleFits 
Opt_ShowLoadedModules 
Opt_HexWordLiterals 
Opt_SuppressCoercions 
Opt_SuppressVarKinds 
Opt_SuppressModulePrefixes 
Opt_SuppressTypeApplications 
Opt_SuppressIdInfo 
Opt_SuppressUnfoldings 
Opt_SuppressTypeSignatures 
Opt_SuppressUniques 
Opt_SuppressStgFreeVars 
Opt_SuppressTicks 
Opt_SuppressTimestamps

Suppress timestamps in dumps

Opt_AutoLinkPackages 
Opt_ImplicitImportQualified 
Opt_KeepHiDiffs 
Opt_KeepHcFiles 
Opt_KeepSFiles 
Opt_KeepTmpFiles 
Opt_KeepRawTokenStream 
Opt_KeepLlvmFiles 
Opt_KeepHiFiles 
Opt_KeepOFiles 
Opt_BuildDynamicToo 
Opt_DistrustAllPackages 
Opt_PackageTrust 
Opt_G_NoStateHack 
Opt_G_NoOptCoercion 

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 

data Name #

A unique, unambiguous name for something, containing information about where that thing originated.

Instances
Eq Name

The same comments as for Name's Ord instance apply.

Instance details

Defined in Name

Methods

(==) :: Name -> Name -> Bool #

(/=) :: Name -> Name -> Bool #

Data Name 
Instance details

Defined in Name

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Name -> c Name #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Name #

toConstr :: Name -> Constr #

dataTypeOf :: Name -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Name) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name) #

gmapT :: (forall b. Data b => b -> b) -> Name -> Name #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r #

gmapQ :: (forall d. Data d => d -> u) -> Name -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Name -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Name -> m Name #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name #

Ord Name

Caution: This instance is implemented via nonDetCmpUnique, which means that the ordering is not stable across deserialization or rebuilds.

See nonDetCmpUnique for further information, and trac #15240 for a bug caused by improper use of this instance.

Instance details

Defined in Name

Methods

compare :: Name -> Name -> Ordering #

(<) :: Name -> Name -> Bool #

(<=) :: Name -> Name -> Bool #

(>) :: Name -> Name -> Bool #

(>=) :: Name -> Name -> Bool #

max :: Name -> Name -> Name #

min :: Name -> Name -> Name #

NFData Name 
Instance details

Defined in Name

Methods

rnf :: Name -> () #

NamedThing Name 
Instance details

Defined in Name

HasOccName Name 
Instance details

Defined in Name

Methods

occName :: Name -> OccName #

Binary Name

Assumes that the Name is a non-binding one. See putIfaceTopBndr and getIfaceTopBndr for serializing binding Names. See UserData for the rationale for this distinction.

Instance details

Defined in Name

Methods

put_ :: BinHandle -> Name -> IO () #

put :: BinHandle -> Name -> IO (Bin Name) #

get :: BinHandle -> IO Name #

Uniquable Name 
Instance details

Defined in Name

Methods

getUnique :: Name -> Unique #

Outputable Name 
Instance details

Defined in Name

Methods

ppr :: Name -> SDoc #

pprPrec :: Rational -> Name -> SDoc #

OutputableBndr Name 
Instance details

Defined in Name

HasSrcSpan Name Source # 
Instance details

Defined in Development.IDE.GHC.Compat

Methods

getLoc :: Name -> SrcSpan Source #

gcatch :: (ExceptionMonad m, Exception e) => m a -> (e -> m a) -> m a #

Generalised version of catch, allowing an arbitrary exception handling monad instead of just IO.

gbracket :: ExceptionMonad m => m a -> (a -> m b) -> (a -> m c) -> m c #

Generalised version of bracket, allowing an arbitrary exception handling monad instead of just IO.

gfinally :: ExceptionMonad m => m a -> m b -> m a #

Generalised version of finally, allowing an arbitrary exception handling monad instead of just IO.

data HValue #

Instances
Show HValue 
Instance details

Defined in GHCi.RemoteTypes

coreModule :: DesugaredMod m => m -> ModGuts #

hieVersion :: Integer Source #

Current version of .hie files

data HieFile Source #

GHC builds up a wealth of information about Haskell source as it compiles it. .hie files are a way of persisting some of this information to disk so that external tools that need to work with haskell source don't need to parse, typecheck, and rename all over again. These files contain:

  • a simplified AST

    • nodes are annotated with source positions and types
    • identifiers are annotated with scope information
  • the raw bytes of the initial Haskell source

Besides saving compilation cycles, .hie files also offer a more stable interface than the GHC API.

Constructors

HieFile 

Fields

Instances
Show HieFile Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

NFData HieFile Source # 
Instance details

Defined in Development.IDE.GHC.Orphans

Methods

rnf :: HieFile -> () #

Binary HieFile Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

data HieType a Source #

A flattened version of Type.

See Note [Efficient serialization of redundant type info]

Constructors

HTyVarTy Name 
HAppTy a a 
HTyConApp IfaceTyCon (HieArgs a) 
HForAllTy ((Name, a), ArgFlag) a 
HFunTy a a 
HQualTy a a

type with constraint: t1 => t2 (see IfaceDFunTy)

HLitTy IfaceTyLit 
HCastTy a 
HCoercionTy 
Instances
Functor HieType Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Methods

fmap :: (a -> b) -> HieType a -> HieType b #

(<$) :: a -> HieType b -> HieType a #

Foldable HieType Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Methods

fold :: Monoid m => HieType m -> m #

foldMap :: Monoid m => (a -> m) -> HieType a -> m #

foldr :: (a -> b -> b) -> b -> HieType a -> b #

foldr' :: (a -> b -> b) -> b -> HieType a -> b #

foldl :: (b -> a -> b) -> b -> HieType a -> b #

foldl' :: (b -> a -> b) -> b -> HieType a -> b #

foldr1 :: (a -> a -> a) -> HieType a -> a #

foldl1 :: (a -> a -> a) -> HieType a -> a #

toList :: HieType a -> [a] #

null :: HieType a -> Bool #

length :: HieType a -> Int #

elem :: Eq a => a -> HieType a -> Bool #

maximum :: Ord a => HieType a -> a #

minimum :: Ord a => HieType a -> a #

sum :: Num a => HieType a -> a #

product :: Num a => HieType a -> a #

Traversable HieType Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Methods

traverse :: Applicative f => (a -> f b) -> HieType a -> f (HieType b) #

sequenceA :: Applicative f => HieType (f a) -> f (HieType a) #

mapM :: Monad m => (a -> m b) -> HieType a -> m (HieType b) #

sequence :: Monad m => HieType (m a) -> m (HieType a) #

Eq a => Eq (HieType a) Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Methods

(==) :: HieType a -> HieType a -> Bool #

(/=) :: HieType a -> HieType a -> Bool #

Binary (HieType TypeIndex) Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

newtype HieTypeFix Source #

Roughly isomorphic to the original core Type.

Constructors

Roll (HieType HieTypeFix) 

newtype HieArgs a Source #

A list of type arguments along with their respective visibilities (ie. is this an argument that would return True for isVisibleArgFlag?).

Constructors

HieArgs [(Bool, a)] 
Instances
Functor HieArgs Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Methods

fmap :: (a -> b) -> HieArgs a -> HieArgs b #

(<$) :: a -> HieArgs b -> HieArgs a #

Foldable HieArgs Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Methods

fold :: Monoid m => HieArgs m -> m #

foldMap :: Monoid m => (a -> m) -> HieArgs a -> m #

foldr :: (a -> b -> b) -> b -> HieArgs a -> b #

foldr' :: (a -> b -> b) -> b -> HieArgs a -> b #

foldl :: (b -> a -> b) -> b -> HieArgs a -> b #

foldl' :: (b -> a -> b) -> b -> HieArgs a -> b #

foldr1 :: (a -> a -> a) -> HieArgs a -> a #

foldl1 :: (a -> a -> a) -> HieArgs a -> a #

toList :: HieArgs a -> [a] #

null :: HieArgs a -> Bool #

length :: HieArgs a -> Int #

elem :: Eq a => a -> HieArgs a -> Bool #

maximum :: Ord a => HieArgs a -> a #

minimum :: Ord a => HieArgs a -> a #

sum :: Num a => HieArgs a -> a #

product :: Num a => HieArgs a -> a #

Traversable HieArgs Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Methods

traverse :: Applicative f => (a -> f b) -> HieArgs a -> f (HieArgs b) #

sequenceA :: Applicative f => HieArgs (f a) -> f (HieArgs a) #

mapM :: Monad m => (a -> m b) -> HieArgs a -> m (HieArgs b) #

sequence :: Monad m => HieArgs (m a) -> m (HieArgs a) #

Eq a => Eq (HieArgs a) Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Methods

(==) :: HieArgs a -> HieArgs a -> Bool #

(/=) :: HieArgs a -> HieArgs a -> Bool #

Binary (HieArgs TypeIndex) Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

newtype HieASTs a Source #

Mapping from filepaths (represented using FastString) to the corresponding AST

Constructors

HieASTs 

Fields

Instances
Functor HieASTs Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Methods

fmap :: (a -> b) -> HieASTs a -> HieASTs b #

(<$) :: a -> HieASTs b -> HieASTs a #

Foldable HieASTs Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Methods

fold :: Monoid m => HieASTs m -> m #

foldMap :: Monoid m => (a -> m) -> HieASTs a -> m #

foldr :: (a -> b -> b) -> b -> HieASTs a -> b #

foldr' :: (a -> b -> b) -> b -> HieASTs a -> b #

foldl :: (b -> a -> b) -> b -> HieASTs a -> b #

foldl' :: (b -> a -> b) -> b -> HieASTs a -> b #

foldr1 :: (a -> a -> a) -> HieASTs a -> a #

foldl1 :: (a -> a -> a) -> HieASTs a -> a #

toList :: HieASTs a -> [a] #

null :: HieASTs a -> Bool #

length :: HieASTs a -> Int #

elem :: Eq a => a -> HieASTs a -> Bool #

maximum :: Ord a => HieASTs a -> a #

minimum :: Ord a => HieASTs a -> a #

sum :: Num a => HieASTs a -> a #

product :: Num a => HieASTs a -> a #

Traversable HieASTs Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Methods

traverse :: Applicative f => (a -> f b) -> HieASTs a -> f (HieASTs b) #

sequenceA :: Applicative f => HieASTs (f a) -> f (HieASTs a) #

mapM :: Monad m => (a -> m b) -> HieASTs a -> m (HieASTs b) #

sequence :: Monad m => HieASTs (m a) -> m (HieASTs a) #

Binary (HieASTs TypeIndex) Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

data HieAST a Source #

Constructors

Node 
Instances
Functor HieAST Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Methods

fmap :: (a -> b) -> HieAST a -> HieAST b #

(<$) :: a -> HieAST b -> HieAST a #

Foldable HieAST Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Methods

fold :: Monoid m => HieAST m -> m #

foldMap :: Monoid m => (a -> m) -> HieAST a -> m #

foldr :: (a -> b -> b) -> b -> HieAST a -> b #

foldr' :: (a -> b -> b) -> b -> HieAST a -> b #

foldl :: (b -> a -> b) -> b -> HieAST a -> b #

foldl' :: (b -> a -> b) -> b -> HieAST a -> b #

foldr1 :: (a -> a -> a) -> HieAST a -> a #

foldl1 :: (a -> a -> a) -> HieAST a -> a #

toList :: HieAST a -> [a] #

null :: HieAST a -> Bool #

length :: HieAST a -> Int #

elem :: Eq a => a -> HieAST a -> Bool #

maximum :: Ord a => HieAST a -> a #

minimum :: Ord a => HieAST a -> a #

sum :: Num a => HieAST a -> a #

product :: Num a => HieAST a -> a #

Traversable HieAST Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Methods

traverse :: Applicative f => (a -> f b) -> HieAST a -> f (HieAST b) #

sequenceA :: Applicative f => HieAST (f a) -> f (HieAST a) #

mapM :: Monad m => (a -> m b) -> HieAST a -> m (HieAST b) #

sequence :: Monad m => HieAST (m a) -> m (HieAST a) #

Binary (HieAST TypeIndex) Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

data NodeInfo a Source #

The information stored in one AST node.

The type parameter exists to provide flexibility in representation of types (see Note [Efficient serialization of redundant type info]).

Constructors

NodeInfo 

Fields

Instances
Functor NodeInfo Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Methods

fmap :: (a -> b) -> NodeInfo a -> NodeInfo b #

(<$) :: a -> NodeInfo b -> NodeInfo a #

Foldable NodeInfo Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Methods

fold :: Monoid m => NodeInfo m -> m #

foldMap :: Monoid m => (a -> m) -> NodeInfo a -> m #

foldr :: (a -> b -> b) -> b -> NodeInfo a -> b #

foldr' :: (a -> b -> b) -> b -> NodeInfo a -> b #

foldl :: (b -> a -> b) -> b -> NodeInfo a -> b #

foldl' :: (b -> a -> b) -> b -> NodeInfo a -> b #

foldr1 :: (a -> a -> a) -> NodeInfo a -> a #

foldl1 :: (a -> a -> a) -> NodeInfo a -> a #

toList :: NodeInfo a -> [a] #

null :: NodeInfo a -> Bool #

length :: NodeInfo a -> Int #

elem :: Eq a => a -> NodeInfo a -> Bool #

maximum :: Ord a => NodeInfo a -> a #

minimum :: Ord a => NodeInfo a -> a #

sum :: Num a => NodeInfo a -> a #

product :: Num a => NodeInfo a -> a #

Traversable NodeInfo Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Methods

traverse :: Applicative f => (a -> f b) -> NodeInfo a -> f (NodeInfo b) #

sequenceA :: Applicative f => NodeInfo (f a) -> f (NodeInfo a) #

mapM :: Monad m => (a -> m b) -> NodeInfo a -> m (NodeInfo b) #

sequence :: Monad m => NodeInfo (m a) -> m (NodeInfo a) #

Binary (NodeInfo TypeIndex) Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

data IdentifierDetails a Source #

Information associated with every identifier

We need to include types with identifiers because sometimes multiple identifiers occur in the same span(Overloaded Record Fields and so on)

Instances
Functor IdentifierDetails Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Foldable IdentifierDetails Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Methods

fold :: Monoid m => IdentifierDetails m -> m #

foldMap :: Monoid m => (a -> m) -> IdentifierDetails a -> m #

foldr :: (a -> b -> b) -> b -> IdentifierDetails a -> b #

foldr' :: (a -> b -> b) -> b -> IdentifierDetails a -> b #

foldl :: (b -> a -> b) -> b -> IdentifierDetails a -> b #

foldl' :: (b -> a -> b) -> b -> IdentifierDetails a -> b #

foldr1 :: (a -> a -> a) -> IdentifierDetails a -> a #

foldl1 :: (a -> a -> a) -> IdentifierDetails a -> a #

toList :: IdentifierDetails a -> [a] #

null :: IdentifierDetails a -> Bool #

length :: IdentifierDetails a -> Int #

elem :: Eq a => a -> IdentifierDetails a -> Bool #

maximum :: Ord a => IdentifierDetails a -> a #

minimum :: Ord a => IdentifierDetails a -> a #

sum :: Num a => IdentifierDetails a -> a #

product :: Num a => IdentifierDetails a -> a #

Traversable IdentifierDetails Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Methods

traverse :: Applicative f => (a -> f b) -> IdentifierDetails a -> f (IdentifierDetails b) #

sequenceA :: Applicative f => IdentifierDetails (f a) -> f (IdentifierDetails a) #

mapM :: Monad m => (a -> m b) -> IdentifierDetails a -> m (IdentifierDetails b) #

sequence :: Monad m => IdentifierDetails (m a) -> m (IdentifierDetails a) #

Eq a => Eq (IdentifierDetails a) Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Semigroup (IdentifierDetails a) Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Monoid (IdentifierDetails a) Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Binary (IdentifierDetails TypeIndex) Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Outputable a => Outputable (IdentifierDetails a) Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

data ContextInfo Source #

Different contexts under which identifiers exist

Constructors

Use

regular variable

MatchBind 
IEThing IEType

import/export

TyDecl 
ValBind

Value binding

Fields

  • BindType

    whether or not the binding is in an instance

  • Scope

    scope over which the value is bound

  • (Maybe Span)

    span of entire binding

PatternBind

Pattern binding

This case is tricky because the bound identifier can be used in two distinct scopes. Consider the following example (with -XViewPatterns)

do (b, a, (a -> True)) <- bar
   foo a

The identifier a has two scopes: in the view pattern (a -> True) and in the rest of the do-block in foo a.

Fields

  • Scope

    scope in the pattern (the variable bound can be used further in the pattern)

  • Scope

    rest of the scope outside the pattern

  • (Maybe Span)

    span of entire binding

ClassTyDecl (Maybe Span) 
Decl

Declaration

Fields

TyVarBind Scope TyVarScope

Type variable

RecField RecFieldContext (Maybe Span)

Record field

data IEType Source #

Types of imports and exports

Instances
Enum IEType Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Eq IEType Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Methods

(==) :: IEType -> IEType -> Bool #

(/=) :: IEType -> IEType -> Bool #

Ord IEType Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Show IEType Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Binary IEType Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Methods

put_ :: BinHandle -> IEType -> IO () #

put :: BinHandle -> IEType -> IO (Bin IEType) #

get :: BinHandle -> IO IEType #

data RecFieldContext Source #

Instances
Enum RecFieldContext Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Eq RecFieldContext Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Ord RecFieldContext Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Show RecFieldContext Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Binary RecFieldContext Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

data DeclType Source #

Constructors

FamDec

type or data family

SynDec

type synonym

DataDec

data declaration

ConDec

constructor declaration

PatSynDec

pattern synonym

ClassDec

class declaration

InstDec

instance declaration

data Scope Source #

Instances
Eq Scope Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Methods

(==) :: Scope -> Scope -> Bool #

(/=) :: Scope -> Scope -> Bool #

Data Scope Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Scope -> c Scope #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Scope #

toConstr :: Scope -> Constr #

dataTypeOf :: Scope -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Scope) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Scope) #

gmapT :: (forall b. Data b => b -> b) -> Scope -> Scope #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Scope -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Scope -> r #

gmapQ :: (forall d. Data d => d -> u) -> Scope -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Scope -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Scope -> m Scope #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Scope -> m Scope #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Scope -> m Scope #

Ord Scope Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Methods

compare :: Scope -> Scope -> Ordering #

(<) :: Scope -> Scope -> Bool #

(<=) :: Scope -> Scope -> Bool #

(>) :: Scope -> Scope -> Bool #

(>=) :: Scope -> Scope -> Bool #

max :: Scope -> Scope -> Scope #

min :: Scope -> Scope -> Scope #

Show Scope Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Methods

showsPrec :: Int -> Scope -> ShowS #

show :: Scope -> String #

showList :: [Scope] -> ShowS #

Binary Scope Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Methods

put_ :: BinHandle -> Scope -> IO () #

put :: BinHandle -> Scope -> IO (Bin Scope) #

get :: BinHandle -> IO Scope #

Outputable Scope Source # 
Instance details

Defined in Development.IDE.GHC.HieTypes

Methods

ppr :: Scope -> SDoc #

pprPrec :: Rational -> Scope -> SDoc #

data TyVarScope Source #

Scope of a type variable.

This warrants a data type apart from Scope because of complexities introduced by features like -XScopedTypeVariables and -XInstanceSigs. For example, consider:

foo, bar, baz :: forall a. a -> a

Here a is in scope in all the definitions of foo, bar, and baz, so we need a list of scopes to keep track of this. Furthermore, this list cannot be computed until we resolve the binding sites of foo, bar, and baz.

Consequently, a starts with an UnresolvedScope [foo, bar, baz] Nothing which later gets resolved into a ResolvedScopes.

Constructors

ResolvedScopes [Scope] 
UnresolvedScope

Unresolved scopes should never show up in the final .hie file

Fields

  • [Name]

    names of the definitions over which the scope spans

  • (Maybe Span)

    the location of the instance/class declaration for the case where the type variable is declared in a method type signature

foldType :: (HieType a -> a) -> HieTypeFix -> a Source #

combineAst :: HieAST Type -> HieAST Type -> HieAST Type Source #

One must contain the other. Leaf nodes cannot contain anything

insertAst :: HieAST Type -> [HieAST Type] -> [HieAST Type] Source #

Insert an AST in a sorted list of disjoint Asts

combineNodeInfo :: NodeInfo Type -> NodeInfo Type -> NodeInfo Type Source #

Merge two nodes together.

Precondition and postcondition: elements in nodeType are ordered.

mergeAsts :: [HieAST Type] -> [HieAST Type] -> [HieAST Type] Source #

Merge two sorted, disjoint lists of ASTs, combining when necessary.

In the absence of position-altering pragmas (ex: # line "file.hs" 3), different nodes in an AST tree should either have disjoint spans (in which case you can say for sure which one comes first) or one span should be completely contained in the other (in which case the contained span corresponds to some child node).

However, since Haskell does have position-altering pragmas it is possible for spans to be overlapping. Here is an example of a source file in which foozball and quuuuuux have overlapping spans:

module Baz where

# line 3 "Baz.hs"
foozball :: Int
foozball = 0

# line 3 "Baz.hs"
bar, quuuuuux :: Int
bar = 1
quuuuuux = 2

In these cases, we just do our best to produce sensible HieAST's. The blame should be laid at the feet of whoever wrote the line pragmas in the first place (usually the C preprocessor...).

mergeSortAsts :: [HieAST Type] -> [HieAST Type] Source #

combines and sorts ASTs using a merge sort

makeNode Source #

Arguments

:: (Applicative m, Data a) 
=> a

helps fill in nodeAnnotations (with Data)

-> SrcSpan

return an empty list if this is unhelpful

-> m [HieAST b] 

makeTypeNode Source #

Arguments

:: (Applicative m, Data a) 
=> a

helps fill in nodeAnnotations (with Data)

-> SrcSpan

return an empty list if this is unhelpful

-> Type

type to associate with the node

-> m [HieAST Type]