GHC.TcPlugin.API

This module provides a unified interface for writing type-checking plugins for GHC.

It attempts to re-export all the functionality from GHC that is relevant to plugin authors, as well as providing utility functions to streamline certain common operations such as creating evidence (to solve constraints), rewriting type family applications, throwing custom type errors.

Consider making use of the table of contents to help navigate this documentation; don't hesitate to jump between sections to get an overview of the relevant aspects.

For an illustration of the functionality, check the examples in the associated GitHub repository.

The internal module GHC.TcPlugin.API.Internal can be used to directly lift and unlift computations in GHC's TcM monad, but it is hoped that the interface provided in this module is sufficient.

Basic TcPlugin functionality

The TcPlugin type

data TcPlugin

A record containing all the stages necessary for the operation of a type-checking plugin, as defined in this API.

Note: this is not the same record as GHC's built-in TcPlugin record. Use mkTcPlugin for the conversion.

To create a type-checking plugin, define something of this type and then call mkTcPlugin on the result. This will return something that can be passed to Plugin:

plugin :: GHC.Plugins.Plugin
plugin =
  GHC.Plugins.defaultPlugin
    { GHC.Plugins.tcPlugin =
        \ args -> Just $
           GHC.TcPlugin.API.mkTcPlugin ( myTcPlugin args )
    }

myTcPlugin :: [String] -> GHC.TcPlugin.API.TcPlugin
myTcPlugin args = ...

Constructors

forall s. TcPlugin

Fields

• tcPluginInit :: TcPluginM Init s

  Initialise plugin, when entering type-checker.

• tcPluginSolve :: s -> TcPluginSolver

  Solve some constraints.

  This function will be invoked at two points in the constraint solving process: once to manipulate given constraints, and once to solve wanted constraints. In the first case (and only in the first case), no wanted constraints will be passed to the plugin.

  The plugin can either return a contradiction, or specify that it has solved some constraints (with evidence), and possibly emit additional wanted constraints.

  Use \ _ _ _ -> pure $ TcPluginOK [] [] if your plugin does not provide this functionality.

• tcPluginRewrite :: s -> UniqFM TyCon TcPluginRewriter

  Rewrite saturated type family applications.

  The plugin is expected to supply a mapping from type family names to rewriting functions. For each type family TyCon, the plugin should provide a function which takes in the given constraints and arguments of a saturated type family application, and return a possible rewriting. See TcPluginRewriter for the expected shape of such a function.

  Use const emptyUFM if your plugin does not provide this functionality.

• tcPluginStop :: s -> TcPluginM Stop ()

  Clean up after the plugin, when exiting the type-checker.

mkTcPlugin

Arguments

:: TcPlugin

type-checking plugin written with this library

-> TcPlugin

type-checking plugin for GHC

Use this function to create a type-checker plugin to pass to GHC.

Plugin state

A type-checker plugin can define its own state, corresponding to the existential parameter s in the definition of TcPlugin. This allows a plugin to look up information a single time on initialisation, and pass it on for access in all further invocations of the plugin.

For example:

data MyDefinitions { myTyFam :: !TyCon, myClass :: !Class }

Usually, the tcPluginInit part of the plugin looks up all this information and returns it:

myTcPluginInit :: TcPluginM Init MyDefinitions

This step should also be used to initialise any external tools, such as an external SMT solver.

This information will then be passed to other stages of the plugin:

myTcPluginSolve :: MyDefinitions -> TcPluginSolver

The type-checking plugin monads

Different stages of type-checking plugins have access to different information. For a unified interface, an MTL-style approach is used, with the MonadTcPlugin typeclass providing overloading (for operations that work in all stages).

data TcPluginStage

Stage of a type-checking plugin, used as a data kind.

Constructors

Init

Solve

Rewrite

Stop

class (Monad m, forall x y. Coercible x y => Coercible (m x) (m y)) => MonadTcPlugin m

A MonadTcPlugin is essentially a reader monad over GHC's TcM monad.

This means we have both a lift and an unlift operation, similar to MonadUnliftIO or MonadBaseControl.

See for instance unsafeLiftThroughTcM, which is an example of function that one would not be able to write using only a lift operation.

Note that you must import the internal module in order to access the methods. Please report a bug if you find yourself needing this functionality.

Minimal complete definition

liftTcPluginM, unsafeWithRunInTcM

Instances

MonadTcPlugin (TcPluginM 'Init)

Defined in GHC.TcPlugin.API.Internal

Methods

liftTcPluginM :: TcPluginM0 a -> TcPluginM 'Init a

unsafeLiftTcM :: TcM a -> TcPluginM 'Init a

unsafeWithRunInTcM :: ((forall a. TcPluginM 'Init a -> TcM a) -> TcM b) -> TcPluginM 'Init b

MonadTcPlugin (TcPluginM 'Rewrite)

Defined in GHC.TcPlugin.API.Internal

Methods

liftTcPluginM :: TcPluginM0 a -> TcPluginM 'Rewrite a

unsafeLiftTcM :: TcM a -> TcPluginM 'Rewrite a

unsafeWithRunInTcM :: ((forall a. TcPluginM 'Rewrite a -> TcM a) -> TcM b) -> TcPluginM 'Rewrite b

MonadTcPlugin (TcPluginM 'Solve)

Defined in GHC.TcPlugin.API.Internal

Methods

liftTcPluginM :: TcPluginM0 a -> TcPluginM 'Solve a

unsafeLiftTcM :: TcM a -> TcPluginM 'Solve a

unsafeWithRunInTcM :: ((forall a. TcPluginM 'Solve a -> TcM a) -> TcM b) -> TcPluginM 'Solve b

MonadTcPlugin (TcPluginM 'Stop)

Defined in GHC.TcPlugin.API.Internal

Methods

liftTcPluginM :: TcPluginM0 a -> TcPluginM 'Stop a

unsafeLiftTcM :: TcM a -> TcPluginM 'Stop a

unsafeWithRunInTcM :: ((forall a. TcPluginM 'Stop a -> TcM a) -> TcM b) -> TcPluginM 'Stop b

data family TcPluginM s

The monad used for a type-checker plugin, parametrised by the TcPluginStage of the plugin.

Instances

Applicative (TcPluginM 'Init)

Defined in GHC.TcPlugin.API.Internal

Methods

pure :: a -> TcPluginM 'Init a

(<*>) :: TcPluginM 'Init (a -> b) -> TcPluginM 'Init a -> TcPluginM 'Init b

liftA2 :: (a -> b -> c) -> TcPluginM 'Init a -> TcPluginM 'Init b -> TcPluginM 'Init c

(*>) :: TcPluginM 'Init a -> TcPluginM 'Init b -> TcPluginM 'Init b

(<*) :: TcPluginM 'Init a -> TcPluginM 'Init b -> TcPluginM 'Init a

Applicative (TcPluginM 'Rewrite)

Defined in GHC.TcPlugin.API.Internal

Methods

pure :: a -> TcPluginM 'Rewrite a

(<*>) :: TcPluginM 'Rewrite (a -> b) -> TcPluginM 'Rewrite a -> TcPluginM 'Rewrite b

liftA2 :: (a -> b -> c) -> TcPluginM 'Rewrite a -> TcPluginM 'Rewrite b -> TcPluginM 'Rewrite c

(*>) :: TcPluginM 'Rewrite a -> TcPluginM 'Rewrite b -> TcPluginM 'Rewrite b

(<*) :: TcPluginM 'Rewrite a -> TcPluginM 'Rewrite b -> TcPluginM 'Rewrite a

Applicative (TcPluginM 'Solve)

Defined in GHC.TcPlugin.API.Internal

Methods

pure :: a -> TcPluginM 'Solve a

(<*>) :: TcPluginM 'Solve (a -> b) -> TcPluginM 'Solve a -> TcPluginM 'Solve b

liftA2 :: (a -> b -> c) -> TcPluginM 'Solve a -> TcPluginM 'Solve b -> TcPluginM 'Solve c

(*>) :: TcPluginM 'Solve a -> TcPluginM 'Solve b -> TcPluginM 'Solve b

(<*) :: TcPluginM 'Solve a -> TcPluginM 'Solve b -> TcPluginM 'Solve a

Applicative (TcPluginM 'Stop)

Defined in GHC.TcPlugin.API.Internal

Methods

pure :: a -> TcPluginM 'Stop a

(<*>) :: TcPluginM 'Stop (a -> b) -> TcPluginM 'Stop a -> TcPluginM 'Stop b

liftA2 :: (a -> b -> c) -> TcPluginM 'Stop a -> TcPluginM 'Stop b -> TcPluginM 'Stop c

(*>) :: TcPluginM 'Stop a -> TcPluginM 'Stop b -> TcPluginM 'Stop b

(<*) :: TcPluginM 'Stop a -> TcPluginM 'Stop b -> TcPluginM 'Stop a

Functor (TcPluginM 'Init)

Defined in GHC.TcPlugin.API.Internal

Methods

fmap :: (a -> b) -> TcPluginM 'Init a -> TcPluginM 'Init b

(<$) :: a -> TcPluginM 'Init b -> TcPluginM 'Init a

Functor (TcPluginM 'Rewrite)

Defined in GHC.TcPlugin.API.Internal

Methods

fmap :: (a -> b) -> TcPluginM 'Rewrite a -> TcPluginM 'Rewrite b

(<$) :: a -> TcPluginM 'Rewrite b -> TcPluginM 'Rewrite a

Functor (TcPluginM 'Solve)

Defined in GHC.TcPlugin.API.Internal

Methods

fmap :: (a -> b) -> TcPluginM 'Solve a -> TcPluginM 'Solve b

(<$) :: a -> TcPluginM 'Solve b -> TcPluginM 'Solve a

Functor (TcPluginM 'Stop)

Defined in GHC.TcPlugin.API.Internal

Methods

fmap :: (a -> b) -> TcPluginM 'Stop a -> TcPluginM 'Stop b

(<$) :: a -> TcPluginM 'Stop b -> TcPluginM 'Stop a

Monad (TcPluginM 'Init)

Defined in GHC.TcPlugin.API.Internal

Methods

(>>=) :: TcPluginM 'Init a -> (a -> TcPluginM 'Init b) -> TcPluginM 'Init b

(>>) :: TcPluginM 'Init a -> TcPluginM 'Init b -> TcPluginM 'Init b

return :: a -> TcPluginM 'Init a

Monad (TcPluginM 'Rewrite)

Defined in GHC.TcPlugin.API.Internal

Methods

(>>=) :: TcPluginM 'Rewrite a -> (a -> TcPluginM 'Rewrite b) -> TcPluginM 'Rewrite b

(>>) :: TcPluginM 'Rewrite a -> TcPluginM 'Rewrite b -> TcPluginM 'Rewrite b

return :: a -> TcPluginM 'Rewrite a

Monad (TcPluginM 'Solve)

Defined in GHC.TcPlugin.API.Internal

Methods

(>>=) :: TcPluginM 'Solve a -> (a -> TcPluginM 'Solve b) -> TcPluginM 'Solve b

(>>) :: TcPluginM 'Solve a -> TcPluginM 'Solve b -> TcPluginM 'Solve b

return :: a -> TcPluginM 'Solve a

Monad (TcPluginM 'Stop)

Defined in GHC.TcPlugin.API.Internal

Methods

(>>=) :: TcPluginM 'Stop a -> (a -> TcPluginM 'Stop b) -> TcPluginM 'Stop b

(>>) :: TcPluginM 'Stop a -> TcPluginM 'Stop b -> TcPluginM 'Stop b

return :: a -> TcPluginM 'Stop a

MonadTcPlugin (TcPluginM 'Init)

Defined in GHC.TcPlugin.API.Internal

Methods

liftTcPluginM :: TcPluginM0 a -> TcPluginM 'Init a

unsafeLiftTcM :: TcM a -> TcPluginM 'Init a

unsafeWithRunInTcM :: ((forall a. TcPluginM 'Init a -> TcM a) -> TcM b) -> TcPluginM 'Init b

MonadTcPlugin (TcPluginM 'Rewrite)

Defined in GHC.TcPlugin.API.Internal

Methods

liftTcPluginM :: TcPluginM0 a -> TcPluginM 'Rewrite a

unsafeLiftTcM :: TcM a -> TcPluginM 'Rewrite a

unsafeWithRunInTcM :: ((forall a. TcPluginM 'Rewrite a -> TcM a) -> TcM b) -> TcPluginM 'Rewrite b

MonadTcPlugin (TcPluginM 'Solve)

Defined in GHC.TcPlugin.API.Internal

Methods

liftTcPluginM :: TcPluginM0 a -> TcPluginM 'Solve a

unsafeLiftTcM :: TcM a -> TcPluginM 'Solve a

unsafeWithRunInTcM :: ((forall a. TcPluginM 'Solve a -> TcM a) -> TcM b) -> TcPluginM 'Solve b

MonadTcPlugin (TcPluginM 'Stop)

Defined in GHC.TcPlugin.API.Internal

Methods

liftTcPluginM :: TcPluginM0 a -> TcPluginM 'Stop a

unsafeLiftTcM :: TcM a -> TcPluginM 'Stop a

unsafeWithRunInTcM :: ((forall a. TcPluginM 'Stop a -> TcM a) -> TcM b) -> TcPluginM 'Stop b

(TypeError ('Text "Cannot emit new work in 'tcPluginInit'.") :: Constraint) => MonadTcPluginWork (TcPluginM 'Init)

Defined in GHC.TcPlugin.API.Internal

Methods

askBuiltins :: TcPluginM 'Init BuiltinDefs

MonadTcPluginWork (TcPluginM 'Rewrite)

Defined in GHC.TcPlugin.API.Internal

Methods

askBuiltins :: TcPluginM 'Rewrite BuiltinDefs

MonadTcPluginWork (TcPluginM 'Solve)

Defined in GHC.TcPlugin.API.Internal

Methods

askBuiltins :: TcPluginM 'Solve BuiltinDefs

(TypeError ('Text "Cannot emit new work in 'tcPluginStop'.") :: Constraint) => MonadTcPluginWork (TcPluginM 'Stop)

Defined in GHC.TcPlugin.API.Internal

Methods

askBuiltins :: TcPluginM 'Stop BuiltinDefs

newtype TcPluginM 'Init a

Defined in GHC.TcPlugin.API.Internal

newtype TcPluginM 'Init a = TcPluginInitM {

• tcPluginInitM :: TcPluginM a

}

newtype TcPluginM 'Rewrite a

Defined in GHC.TcPlugin.API.Internal

newtype TcPluginM 'Rewrite a = TcPluginRewriteM {

• tcPluginRewriteM :: BuiltinDefs -> RewriteEnv -> TcPluginM a

}

newtype TcPluginM 'Solve a

Defined in GHC.TcPlugin.API.Internal

newtype TcPluginM 'Solve a = TcPluginSolveM {

• tcPluginSolveM :: BuiltinDefs -> EvBindsVar -> [Ct] -> TcPluginM a

}

newtype TcPluginM 'Stop a

Defined in GHC.TcPlugin.API.Internal

newtype TcPluginM 'Stop a = TcPluginStopM {

• tcPluginStopM :: TcPluginM a

}

tcPluginIO :: MonadTcPlugin m => IO a -> m a

Run an IO computation within the plugin.

Emitting new work, and throwing type-errors

Some operations only make sense in the two main phases, solving and rewriting. This is captured by the MonadTcPluginWork typeclass, which allows emitting new work, including throwing type errors.

class MonadTcPlugin m => MonadTcPluginWork m

Monads for type-checking plugins which are able to emit new constraints and throw errors.

These operations are supported by the monads that tcPluginSolve and tcPluginRewrite use; it is not possible to emit work or throw type errors in tcPluginInit or tcPluginStop.

See mkTcPluginErrorTy and emitWork for functions which require this typeclass.

Instances

(TypeError ('Text "Cannot emit new work in 'tcPluginInit'.") :: Constraint) => MonadTcPluginWork (TcPluginM 'Init)

Defined in GHC.TcPlugin.API.Internal

Methods

askBuiltins :: TcPluginM 'Init BuiltinDefs

MonadTcPluginWork (TcPluginM 'Rewrite)

Defined in GHC.TcPlugin.API.Internal

Methods

askBuiltins :: TcPluginM 'Rewrite BuiltinDefs

MonadTcPluginWork (TcPluginM 'Solve)

Defined in GHC.TcPlugin.API.Internal

Methods

askBuiltins :: TcPluginM 'Solve BuiltinDefs

(TypeError ('Text "Cannot emit new work in 'tcPluginStop'.") :: Constraint) => MonadTcPluginWork (TcPluginM 'Stop)

Defined in GHC.TcPlugin.API.Internal

Methods

askBuiltins :: TcPluginM 'Stop BuiltinDefs

data TcPluginErrorMessage

Use this type like ErrorMessage to write an error message. This error message can then be thrown at the type-level by the plugin, by emitting a wanted constraint whose predicate is obtained from mkTcPluginErrorTy.

A CtLoc will still need to be provided in order to inform GHC of the origin of the error (e.g.: which part of the source code should be highlighted?). See setCtLocM.

Constructors

Txt !String

Show the text as is.

PrintType !Type

Pretty print the given type.

(:|:) !TcPluginErrorMessage !TcPluginErrorMessage infixl 5

Put two messages side by side.

(:-:) !TcPluginErrorMessage !TcPluginErrorMessage infixl 6

Stack two messages vertically.

mkTcPluginErrorTy :: MonadTcPluginWork m => TcPluginErrorMessage -> m PredType

Create an error type with the desired error message.

The result can be paired with a CtLoc in order to throw a type error, for instance by using newWanted.

Name resolution

Name resolution is usually the first step in writing a type-checking plugin: plugins need to look up the names of the objects they want to manipulate.

For instance, to lookup the type family MyFam in module MyModule in package my-pkg:

lookupMyModule :: MonadTcPlugin m => m Module
lookupMyModule = do
   findResult <- findImportedModule ( mkModuleName "MyModule" ) ( Just $ fsLit "my-pkg" )
   case findResult of
     Found _ myModule -> pure myModule
     _ -> error "MyPlugin couldn't find MyModule in my-pkg"

lookupMyFam :: MonadTcPlugin m => Module -> m TyCon
lookupMyFam myModule = tcLookupTyCon =<< lookupOrig myModule ( mkTcOcc "MyFam" )

Most of these operations should be performed in tcPluginInit, and passed on to the other stages: the plugin initialisation is called only once in each module that the plugin is used, whereas the solver and rewriter are usually called repeatedly.

Packages and modules

Use these functions to lookup a module, from the current package or imported packages.

findImportedModule

Arguments

:: MonadTcPlugin m

=> ModuleName

Module name, e.g. Data.List.

-> Maybe FastString

Package name, e.g. Just "base". Use Nothing for the current home package

-> m FindResult

Lookup a Haskell module from the given package.

fsLit :: String -> FastString

mkModuleName :: String -> ModuleName

type Module = GenModule Unit

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

data ModuleName

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

Instances

Data ModuleName

Defined in GHC.Unit.Module.Name

Methods

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

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

toConstr :: ModuleName -> Constr

dataTypeOf :: ModuleName -> DataType

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

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

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

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

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

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

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

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

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

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

Show ModuleName

Defined in GHC.Unit.Module.Name

Methods

showsPrec :: Int -> ModuleName -> ShowS

show :: ModuleName -> String

showList :: [ModuleName] -> ShowS

NFData ModuleName

Defined in GHC.Unit.Module.Name

Methods

rnf :: ModuleName -> ()

Uniquable ModuleName

Defined in GHC.Unit.Module.Name

Methods

getUnique :: ModuleName -> Unique

Binary ModuleName

Defined in GHC.Unit.Module.Name

Methods

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

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

get :: BinHandle -> IO ModuleName

Outputable ModuleName

Defined in GHC.Unit.Module.Name

Methods

ppr :: ModuleName -> SDoc

Eq ModuleName

Defined in GHC.Unit.Module.Name

Methods

(==) :: ModuleName -> ModuleName -> Bool

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

Ord ModuleName

Defined in GHC.Unit.Module.Name

Methods

compare :: ModuleName -> ModuleName -> Ordering

(<) :: ModuleName -> ModuleName -> Bool

(<=) :: ModuleName -> ModuleName -> Bool

(>) :: ModuleName -> ModuleName -> Bool

(>=) :: ModuleName -> ModuleName -> Bool

max :: ModuleName -> ModuleName -> ModuleName

min :: ModuleName -> ModuleName -> ModuleName

type Anno ModuleName

Defined in GHC.Hs.ImpExp

type Anno ModuleName = SrcSpan

data FindResult

The result of searching for an imported module.

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

Constructors

Found ModLocation Module

The module was found

NoPackage Unit

The requested unit was not found

FoundMultiple [(Module, ModuleOrigin)]

_Error_: both in multiple packages

NotFound

Not found

Fields

• fr_paths :: [FilePath]

  Places where I looked

• fr_pkg :: Maybe Unit

  Just p => module is in this unit's manifest, but couldn't find the .hi file

• fr_mods_hidden :: [Unit]

  Module is in these units, but the *module* is hidden

• fr_pkgs_hidden :: [Unit]

  Module is in these units, but the *unit* is hidden

• fr_unusables :: [(Unit, UnusableUnitReason)]

  Module is in these units, but it is unusable

• fr_suggestions :: [ModuleSuggestion]

  Possible mis-spelled modules

Names

Occurence names

The most basic type of name is the OccName, which is a simple textual name within a namespace (e.g. the class namespace), without any disambiguation (no module qualifier, etc).

mkVarOcc :: String -> OccName

mkDataOcc :: String -> OccName

mkTyVarOcc :: String -> OccName

mkTcOcc :: String -> OccName

mkClsOcc :: String -> OccName

Names

After having looked up the Module, we can obtain the full Name referred to by an OccName. This is fully unambiguous, as it contains a Unique identifier for the name.

lookupOrig :: MonadTcPlugin m => Module -> OccName -> m Name

Obtain the full internal Name (with its unique identifier, etc) from its OccName.

Example usage:

lookupOrig preludeModule ( mkTcOcc "Bool" )

This will obtain the Name associated with the type Bool.

You can then call tcLookupTyCon to obtain the associated TyCon.

TyCon, Class, DataCon, etc

Finally, we can obtain the actual objects we're interested in handling, such as classes, type families, data constructors... by looking them up using their Name.

tcLookupTyCon :: MonadTcPlugin m => Name -> m TyCon

Lookup a type constructor from its name (datatype, type synonym or type family).

tcLookupDataCon :: MonadTcPlugin m => Name -> m DataCon

Lookup a data constructor (such as True, Just, ...) from its name.

tcLookupClass :: MonadTcPlugin m => Name -> m Class

Lookup a typeclass from its name.

tcLookupGlobal :: MonadTcPlugin m => Name -> m TyThing

Lookup a global typecheckable-thing from its name.

tcLookup :: MonadTcPlugin m => Name -> m TcTyThing

Lookup a typecheckable-thing available in a local context, such as a local type variable.

tcLookupId :: MonadTcPlugin m => Name -> m Id

Lookup an identifier, such as a type variable.

promoteDataCon :: DataCon -> TyCon

Constraint solving

Type-checking plugins will often want to manipulate constraints, e.g. solve constraints that GHC can't solve on its own, or emit their own constraints.

There are two different constraint flavours:

• Given constraints, which are already known and have evidence associated to them,
• Wanted constraints, for which evidence has not yet been found.

When GHC can't solve a Wanted constraint, it will get reported to the user as a type error.

type TcPluginSolver

Arguments

 = [Ct]

Givens

-> [Ct]

Wanteds

-> TcPluginM Solve TcPluginSolveResult

The solve function of a type-checking plugin takes in Given and Wanted constraints, and should return a TcPluginSolveResult indicating which Wanted constraints it could solve, or whether any are insoluble.

data TcPluginSolveResult

Result of running a solver plugin.

Constructors

TcPluginSolveResult

Fields

• tcPluginInsolubleCts :: [Ct]

  Insoluble constraints found by the plugin.

  These constraints will be added to the inert set, and reported as insoluble to the user.

• tcPluginSolvedCts :: [(EvTerm, Ct)]

  Solved constraints, together with their evidence.

  These are removed from the inert set, and the evidence for them is recorded.

• tcPluginNewCts :: [Ct]

  New constraints that the plugin wishes to emit.

  These will be added to the work list.

Bundled Patterns

pattern TcPluginContradiction :: [Ct] -> TcPluginSolveResult

The plugin found a contradiction. The returned constraints are removed from the inert set, and recorded as insoluble.

The returned list of constraints should never be empty.

pattern TcPluginOk :: [(EvTerm, Ct)] -> [Ct] -> TcPluginSolveResult

The plugin has not found any contradictions,

The first field is for constraints that were solved. The second field contains new work, that should be processed by the constraint solver.

The tcPluginSolve method of a typechecker plugin will be invoked in two different ways:

1. to simplify Given constraints. In this case, the tcPluginSolve function will not be passed any Wanted constraints, and
2. to solve Wanted constraints.

The plugin can then respond in one of two ways:

• with TcPluginOk solved new, where solved is a list of solved constraints and new is a list of new constraints for GHC to process;
• with TcPluginContradiction contras, where contras is a list of impossible constraints, so that they can be turned into errors.

In both cases, the plugin must respond with constraints of the same flavour, i.e. in (1) it should return only Givens, and for (2) it should return only Wanteds; all other constraints will be ignored.

Getting started with constraint solving

To get started, it can be helpful to immediately print out all the constraints that the plugin is given, using tcPluginTrace:

solver _ givens wanteds = do
  tcPluginTrace "---Plugin start---" (ppr givens $$ ppr wanteds)
  pure $ TcPluginOk [] []

This creates a plugin that prints outs the constraints it is passed, without doing anything with them.

To see this output, you will need to pass the flags -ddump-tc-trace and -ddump-to-file to GHC. This will output the trace as a log file, and you can search for "---Plugin start---" to find the plugin inputs.

Note that pretty-printing in GHC is done using the Outputable type class. We use its ppr method to turn things into pretty-printable documents, and ($$) to combine documents vertically. If you need more capabilities for pretty-printing documents, import GHC's GHC.Utils.Outputable module.

tcPluginTrace

Arguments

:: MonadTcPlugin m

=> String

Text at the top of the debug message.

-> SDoc

Formatted document to print (use the ppr pretty-printing function to obtain an SDoc from any Outputable)

-> m ()

Output some debugging information within the plugin.

Inspecting constraints & predicates

Canonical and non-canonical constraints

A constraint in GHC starts out as "non-canonical", which means that GHC doesn't know what type of constraint it is. GHC will inspect the constraint to turn it into a canonical form (class constraint, equality constraint, etc.) which satisfies certain invariants used during constraint solving.

Thus, whenever emitting new constraints, it is usually best to emit a non-canonical constraint, letting GHC canonicalise it.

mkNonCanonical :: CtEvidence -> Ct

Predicates

A type-checking plugin will usually need to inspect constraints, so that it can pick out the constraints it is going to interact with.

In general, type-checking plugins can encounter all sorts of constraints, whether in canonical form or not. In order to handle these constraints in a uniform manner, it is usually preferable to inspect each constraint's predicate, which can be obtained by using classifyPredType and ctPred.

This allows the plugin to determine what kind of constraints it is dealing with:

• an equality constraint? at Nominal or Representational role?
• a type-class constraint? for which class?
• an irreducible constraint, e.g. something of the form c a?
• a quantified constraint?

classifyPredType :: PredType -> Pred

ctPred :: Ct -> PredType

Some further functions for inspecting constraints

eqType :: Type -> Type -> Bool

Type equality on source types. Does not look through newtypes or PredTypes, but it does look through type synonyms. This first checks that the kinds of the types are equal and then checks whether the types are equal, ignoring casts and coercions. (The kind check is a recursive call, but since all kinds have type Type, there is no need to check the types of kinds.) See also Note [Non-trivial definitional equality] in GHC.Core.TyCo.Rep.

ctLoc :: Ct -> CtLoc

ctEvidence :: Ct -> CtEvidence

ctFlavour :: Ct -> CtFlavour

Get the flavour of the given Ct

ctEqRel :: Ct -> EqRel

Get the equality relation for the given Ct

ctOrigin :: Ct -> CtOrigin

Constraint evidence

Coercions

Coercions are the evidence for type equalities. As such, when proving an equality, a type-checker plugin needs to construct the associated coercions.

mkPluginUnivCo

Arguments

:: String

Name of equality (for the plugin's internal use, or for debugging)

-> Role

-> TcType

LHS

-> TcType

RHS

-> Coercion

Conjure up a coercion witnessing an equality between two types at the given Role (Nominal or Representational).

This amounts to telling GHC "believe me, these things are equal".

The plugin is responsible for not emitting any unsound coercions, such as a coercion between Int and Float.

newCoercionHole :: PredType -> TcPluginM Solve CoercionHole

Create a fresh coercion hole.

mkReflCo :: Role -> Type -> Coercion

Make a reflexive coercion

mkSymCo :: Coercion -> Coercion

Create a symmetric version of the given Coercion that asserts equality between the same types but in the other "direction", so a kind of t1 ~ t2 becomes the kind t2 ~ t1.

mkTransCo :: Coercion -> Coercion -> Coercion

Create a new Coercion by composing the two given Coercions transitively. (co1 ; co2)

mkUnivCo

Arguments

:: UnivCoProvenance

-> Role

role of the built coercion, "r"

-> Type

t1 :: k1

-> Type

t2 :: k2

-> Coercion

:: t1 ~r t2

Make a universal coercion between two arbitrary types.

mkCoercionTy :: Coercion -> Type

isCoercionTy :: Type -> Bool

isCoercionTy_maybe :: Type -> Maybe Coercion

pattern Coercion :: Coercion -> Expr b

Evidence terms

Typeclass constraints have a different notion of evidence: evidence terms.

A plugin that wants to solve a class constraint will need to provide an evidence term. Such evidence can be created from scratch, or it can be obtained by combining evidence that is already available.

mkPluginUnivEvTerm

Arguments

:: String

Name of equality (for the plugin's internal use, or for debugging)

-> Role

-> TcType

LHS

-> TcType

RHS

-> EvTerm

Conjure up an evidence term for an equality between two types at the given Role (Nominal or Representational).

This can be used to supply a proof of a wanted equality in TcPluginOk.

The plugin is responsible for not emitting any unsound equalities, such as an equality between Int and Float.

newEvVar :: PredType -> TcPluginM Solve EvVar

Create a fresh evidence variable.

setEvBind :: EvBind -> TcPluginM Solve ()

Bind an evidence variable.

evCoercion :: TcCoercion -> EvTerm

evCast :: EvExpr -> TcCoercion -> EvTerm

d |> co

ctEvExpr :: CtEvidence -> EvExpr

pattern Type :: Type -> Expr b

Class dictionaries

To create evidence terms for class constraints, type-checking plugins need to be able to construct the appropriate dictionaries containing the values for the class methods.

The class dictionary constructor can be obtained using classDataCon. Functions from GHC.Core.Make, re-exported here, will be useful for constructing the necessary terms, e.g. mkCoreApp for an application.

classDataCon :: Class -> DataCon

module GHC.Core.Make

Class instances

In some cases, a type-checking plugin might need to access the class instances that are currently in scope, e.g. to obtain certain evidence terms.

getInstEnvs :: MonadTcPlugin m => m InstEnvs

Obtain all currently-reachable typeclass instances.

Emitting new constraints

newWanted :: MonadTcPluginWork m => CtLoc -> PredType -> m CtEvidence

Create a new derived constraint.

Requires a location (so that error messages can say where the constraint came from, what things were in scope at that point, etc), as well as the actual constraint (encoded as a type).

newGiven :: CtLoc -> PredType -> EvExpr -> TcPluginM Solve CtEvidence

Create a new given constraint.

Unlike newWanted and newDerived, we need to supply evidence for this constraint.

Use setCtLocM to pass along the location information, as only the CtOrigin gets taken into account here.

The following functions allow plugins to create constraints for typeclasses and type equalities.

mkClassPred :: Class -> [Type] -> PredType

mkPrimEqPredRole :: Role -> Type -> Type -> PredType

Makes a lifted equality predicate at the given role

Deriveds

Derived constraints are like Wanted constraints, except that they don't require evidence in order to be solved, and won't be seen in error messages if they go unsolved.

Solver plugins usually ignore this type of constraint entirely. They occur mostly when dealing with functional dependencies and type-family injectivity annotations.

GHC 9.4 removes this flavour of constraints entirely, subsuming their uses into Wanted constraints.

askDeriveds :: TcPluginM Solve [Ct]

Ask for the Derived constraints that the solver was provided with.

Always returns the empty list on GHC 9.4 or above.

newDerived :: MonadTcPluginWork m => CtLoc -> PredType -> m CtEvidence

Create a new derived constraint. See also newWanted.

Location information and CtLocs

When creating new constraints, one still needs a mechanism allowing GHC to report a certain source location associated to them when throwing an error, as well as other information the type-checker was aware of at that point (e.g. available instances, given constraints, etc).

This is the purpose of CtLoc.

setCtLocM :: MonadTcPluginWork m => CtLoc -> m a -> m a

Set the location information for a computation, so that the constraint solver reports an error at the given location.

setCtLocRewriteM :: TcPluginM Rewrite a -> TcPluginM Rewrite a

Use the RewriteEnv to set the CtLoc for a computation.

bumpCtLocDepth adds one to the "depth" of the constraint. Can help avoid loops, by triggering a "maximum depth exceeded" error.

bumpCtLocDepth :: CtLoc -> CtLoc

Rewriting type-family applications

type TcPluginRewriter

Arguments

 = [Ct]

Givens

-> [Type]

Type family arguments (saturated)

-> TcPluginM Rewrite TcPluginRewriteResult

For rewriting type family applications, a type-checking plugin provides a function of this type for each type family TyCon.

The function is provided with the current set of Given constraints, together with the arguments to the type family. The type family application will always be fully saturated.

data TcPluginRewriteResult

Constructors

TcPluginNoRewrite

The plugin does not rewrite the type family application.

TcPluginRewriteTo

The plugin rewrites the type family application providing a rewriting together with evidence: a Reduction, which contains the rewritten type together with a Coercion whose right-hand-side type is the rewritten type.

The plugin can also emit additional Wanted constraints.

Fields

• tcPluginReduction :: !Reduction
• tcRewriterNewWanteds :: [Ct]

Querying for type family reductions

matchFam :: MonadTcPlugin m => TyCon -> [TcType] -> m (Maybe Reduction)

Ask GHC what a type family application reduces to.

Warning: can cause a loop when used within tcPluginRewrite.

getFamInstEnvs :: MonadTcPlugin m => m (FamInstEnv, FamInstEnv)

Obtain all currently-reachable data/type family instances.

First result: external instances. Second result: instances in the current home package.

type FamInstEnv = UniqDFM TyCon FamilyInstEnv

Specifying type family reductions

A plugin that wants to rewrite a type family application must provide two pieces of information:

• the type that the type family application reduces to,
• evidence for this reduction, i.e. a Coercion proving the equality.

In the rewriting stage, type-checking plugins have access to the rewriter environment RewriteEnv, which has information about the location of the type family application, the local type-checking environment, among other things.

Note that a plugin should provide a UniqFM from TyCon to rewriting functions, which specifies a rewriting function for each type family. Use emptyUFM or listToUFM to construct this map, or import the GHC module GHC.Types.Unique.FM for a more complete API.

askRewriteEnv :: TcPluginM Rewrite RewriteEnv

Ask for the current rewriting environment.

Only available in the rewriter part of the type-checking plugin.

rewriteEnvCtLoc :: RewriteEnv -> CtLoc

Obtain the CtLoc from a RewriteEnv.

This can be useful to obtain the location of the constraint currently being rewritten, so that newly emitted constraints can be given the same location information.

data RewriteEnv

A RewriteEnv carries the necessary context for performing rewrites (i.e. type family reductions and following filled-in metavariables) in the solver.

mkTyFamAppReduction

Arguments

:: String

Name of reduction (for debugging)

-> Role

Role of reduction (Nominal or Representational)

-> TyCon

Type family TyCon

-> [TcType]

Type family arguments

-> TcType

The type that the type family application reduces to

-> Reduction

Provide a rewriting of a saturated type family application at the given Role (Nominal or Representational).

The result can be passed to TcPluginRewriteTo to specify the outcome of rewriting a type family application.

data Reduction

A Reduction is the result of an operation that rewrites a type ty_in. The Reduction includes the rewritten type ty_out and a Coercion co such that co :: ty_in ~ ty_out, where the role of the coercion is determined by the context. That is, the LHS type of the coercion is the original type ty_in, while its RHS type is the rewritten type ty_out.

A Reduction is always homogeneous, unless it is wrapped inside a HetReduction, which separately stores the kind coercion.

See Note [The Reduction type].

Constructors

Reduction

Fields

• reductionCoercion :: Coercion
• reductionReducedType :: !Type

Instances

Outputable Reduction

Defined in GHC.Core.Reduction

Methods

ppr :: Reduction -> SDoc

Handling Haskell types

Type variables

newUnique :: MonadTcPlugin m => m Unique

Create a new unique. Useful for generating new variables in the plugin.

newFlexiTyVar :: MonadTcPlugin m => Kind -> m TcTyVar

Create a new meta-variable (unification variable) of the given kind.

isTouchableTcPluginM :: MonadTcPlugin m => TcTyVar -> m Bool

Query whether a type variable is touchable: - is it a unification variable (and not a skolem variable)? - is it actually unifiable given the current TcLevel?

mkTyVarTy :: TyVar -> Type

mkTyVarTys :: [TyVar] -> [Type]

isTyVarTy :: Type -> Bool

getTyVar_maybe :: Type -> Maybe TyVar

Attempts to obtain the type variable underlying a Type

type TcType = Type

type TcTyVar = Var

Type variable that might be a metavariable

data Unique

Unique identifier.

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

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

Instances

Show Unique

Defined in GHC.Types.Unique

Methods

showsPrec :: Int -> Unique -> ShowS

show :: Unique -> String

showList :: [Unique] -> ShowS

Uniquable Unique

Defined in GHC.Types.Unique

Methods

getUnique :: Unique -> Unique

Outputable Unique

Defined in GHC.Types.Unique

Methods

ppr :: Unique -> SDoc

Eq Unique

Defined in GHC.Types.Unique

Methods

(==) :: Unique -> Unique -> Bool

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

type Kind = Type

The key type representing kinds in the compiler.

Creating and decomposing applications

mkTyConTy :: TyCon -> Type

Create the plain type constructor type which has been applied to no type arguments at all.

mkTyConApp :: TyCon -> [Type] -> Type

A key function: builds a TyConApp or FunTy as appropriate to its arguments. Applies its arguments to the constructor from left to right.

splitTyConApp_maybe :: HasDebugCallStack => Type -> Maybe (TyCon, [Type])

Attempts to tease a type apart into a type constructor and the application of a number of arguments to that constructor

mkAppTy :: Type -> Type -> Type

Applies a type to another, as in e.g. k a

mkAppTys :: Type -> [Type] -> Type

Function types

data AnonArgFlag

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

Constructors

VisArg

Used for (->): an ordinary non-dependent arrow. The argument is visible in source code.

InvisArg

Used for (=>): a non-dependent predicate arrow. The argument is invisible in source code.

Instances

Data AnonArgFlag

Defined in GHC.Types.Var

Methods

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

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

toConstr :: AnonArgFlag -> Constr

dataTypeOf :: AnonArgFlag -> DataType

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

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

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

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

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

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

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

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

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

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

Binary AnonArgFlag

Defined in GHC.Types.Var

Methods

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

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

get :: BinHandle -> IO AnonArgFlag

Outputable AnonArgFlag

Defined in GHC.Types.Var

Methods

ppr :: AnonArgFlag -> SDoc

Eq AnonArgFlag

Defined in GHC.Types.Var

Methods

(==) :: AnonArgFlag -> AnonArgFlag -> Bool

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

Ord AnonArgFlag

Defined in GHC.Types.Var

Methods

compare :: AnonArgFlag -> AnonArgFlag -> Ordering

(<) :: AnonArgFlag -> AnonArgFlag -> Bool

(<=) :: AnonArgFlag -> AnonArgFlag -> Bool

(>) :: AnonArgFlag -> AnonArgFlag -> Bool

(>=) :: AnonArgFlag -> AnonArgFlag -> Bool

max :: AnonArgFlag -> AnonArgFlag -> AnonArgFlag

min :: AnonArgFlag -> AnonArgFlag -> AnonArgFlag

mkFunTy :: AnonArgFlag -> Mult -> Type -> Type -> Type infixr 3

mkVisFunTy :: Mult -> Type -> Type -> Type infixr 3

mkInvisFunTy :: Mult -> Type -> Type -> Type infixr 3

mkVisFunTys :: [Scaled Type] -> Type -> Type

Make nested arrow types

mkForAllTy :: TyCoVar -> ArgFlag -> Type -> Type

Like mkTyCoForAllTy, but does not check the occurrence of the binder See Note [Unused coercion variable in ForAllTy]

mkForAllTys :: [TyCoVarBinder] -> Type -> Type

Wraps foralls over the type using the provided TyCoVars from left to right

mkPiTy :: TyCoBinder -> Type -> Type

mkPiTys :: [TyCoBinder] -> Type -> Type

type Mult = Type

Mult is a type alias for Type.

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

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

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

mkFunTyMany :: AnonArgFlag -> Type -> Type -> Type

mkScaledFunTy :: AnonArgFlag -> Scaled Type -> Type -> Type

mkVisFunTyMany :: Type -> Type -> Type infixr 3

Special, common, case: Arrow type with mult Many

mkVisFunTysMany :: [Type] -> Type -> Type

mkInvisFunTyMany :: Type -> Type -> Type infixr 3

mkInvisFunTysMany :: [Type] -> Type -> Type

Zonking

Zonking is the operation in which GHC actually switches out mutable unification variables for their actual filled in type.

See the Note [What is zonking?] in GHC's source code for more information.

zonkTcType :: MonadTcPluginWork m => TcType -> m TcType

Zonk the given type, which takes the metavariables in the type and substitutes their actual value.

zonkCt :: MonadTcPluginWork m => Ct -> m Ct

Zonk a given constraint.

Map-like data structures based on Uniques

Import GHC.Types.Unique.FM or GHC.Types.Unique.DFM for a more complete interface to maps whose keys are Uniques.

data UniqDFM key ele

Type of unique deterministic finite maps

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

Instances

Foldable (UniqDFM key)

Deterministic, in O(n log n).

Defined in GHC.Types.Unique.DFM

Methods

fold :: Monoid m => UniqDFM key m -> m

foldMap :: Monoid m => (a -> m) -> UniqDFM key a -> m

foldMap' :: Monoid m => (a -> m) -> UniqDFM key a -> m

foldr :: (a -> b -> b) -> b -> UniqDFM key a -> b

foldr' :: (a -> b -> b) -> b -> UniqDFM key a -> b

foldl :: (b -> a -> b) -> b -> UniqDFM key a -> b

foldl' :: (b -> a -> b) -> b -> UniqDFM key a -> b

foldr1 :: (a -> a -> a) -> UniqDFM key a -> a

foldl1 :: (a -> a -> a) -> UniqDFM key a -> a

toList :: UniqDFM key a -> [a]

null :: UniqDFM key a -> Bool

length :: UniqDFM key a -> Int

elem :: Eq a => a -> UniqDFM key a -> Bool

maximum :: Ord a => UniqDFM key a -> a

minimum :: Ord a => UniqDFM key a -> a

sum :: Num a => UniqDFM key a -> a

product :: Num a => UniqDFM key a -> a

Traversable (UniqDFM key)

Deterministic, in O(n log n).

Defined in GHC.Types.Unique.DFM

Methods

traverse :: Applicative f => (a -> f b) -> UniqDFM key a -> f (UniqDFM key b)

sequenceA :: Applicative f => UniqDFM key (f a) -> f (UniqDFM key a)

mapM :: Monad m => (a -> m b) -> UniqDFM key a -> m (UniqDFM key b)

sequence :: Monad m => UniqDFM key (m a) -> m (UniqDFM key a)

Functor (UniqDFM key)

Defined in GHC.Types.Unique.DFM

Methods

fmap :: (a -> b) -> UniqDFM key a -> UniqDFM key b

(<$) :: a -> UniqDFM key b -> UniqDFM key a

Uniquable key => TrieMap (UniqDFM key)

Defined in GHC.Data.TrieMap

Associated Types

type Key (UniqDFM key)

Methods

emptyTM :: UniqDFM key a

lookupTM :: Key (UniqDFM key) -> UniqDFM key b -> Maybe b

alterTM :: Key (UniqDFM key) -> XT b -> UniqDFM key b -> UniqDFM key b

mapTM :: (a -> b) -> UniqDFM key a -> UniqDFM key b

filterTM :: (a -> Bool) -> UniqDFM key a -> UniqDFM key a

foldTM :: (a -> b -> b) -> UniqDFM key a -> b -> b

(Data key, Data ele) => Data (UniqDFM key ele)

Defined in GHC.Types.Unique.DFM

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UniqDFM key ele -> c (UniqDFM key ele)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UniqDFM key ele)

toConstr :: UniqDFM key ele -> Constr

dataTypeOf :: UniqDFM key ele -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UniqDFM key ele))

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

gmapT :: (forall b. Data b => b -> b) -> UniqDFM key ele -> UniqDFM key ele

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UniqDFM key ele -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UniqDFM key ele -> r

gmapQ :: (forall d. Data d => d -> u) -> UniqDFM key ele -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> UniqDFM key ele -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UniqDFM key ele -> m (UniqDFM key ele)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UniqDFM key ele -> m (UniqDFM key ele)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UniqDFM key ele -> m (UniqDFM key ele)

Outputable a => Outputable (UniqDFM key a)

Defined in GHC.Types.Unique.DFM

Methods

ppr :: UniqDFM key a -> SDoc

type Key (UniqDFM key)

Defined in GHC.Data.TrieMap

type Key (UniqDFM key) = key

lookupUDFM :: Uniquable key => UniqDFM key elt -> key -> Maybe elt

lookupUDFM_Directly :: UniqDFM key elt -> Unique -> Maybe elt

elemUDFM :: Uniquable key => key -> UniqDFM key elt -> Bool

data UniqFM key ele

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

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

Instances

Functor (UniqFM key)

Defined in GHC.Types.Unique.FM

Methods

fmap :: (a -> b) -> UniqFM key a -> UniqFM key b

(<$) :: a -> UniqFM key b -> UniqFM key a

(Data key, Data ele) => Data (UniqFM key ele)

Defined in GHC.Types.Unique.FM

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UniqFM key ele -> c (UniqFM key ele)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (UniqFM key ele)

toConstr :: UniqFM key ele -> Constr

dataTypeOf :: UniqFM key ele -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (UniqFM key ele))

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

gmapT :: (forall b. Data b => b -> b) -> UniqFM key ele -> UniqFM key ele

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UniqFM key ele -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UniqFM key ele -> r

gmapQ :: (forall d. Data d => d -> u) -> UniqFM key ele -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> UniqFM key ele -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UniqFM key ele -> m (UniqFM key ele)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UniqFM key ele -> m (UniqFM key ele)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UniqFM key ele -> m (UniqFM key ele)

Monoid (UniqFM key a)

Defined in GHC.Types.Unique.FM

Methods

mempty :: UniqFM key a

mappend :: UniqFM key a -> UniqFM key a -> UniqFM key a

mconcat :: [UniqFM key a] -> UniqFM key a

Semigroup (UniqFM key a)

Defined in GHC.Types.Unique.FM

Methods

(<>) :: UniqFM key a -> UniqFM key a -> UniqFM key a

sconcat :: NonEmpty (UniqFM key a) -> UniqFM key a

stimes :: Integral b => b -> UniqFM key a -> UniqFM key a

Outputable a => Outputable (UniqFM key a)

Defined in GHC.Types.Unique.FM

Methods

ppr :: UniqFM key a -> SDoc

Eq ele => Eq (UniqFM key ele)

Defined in GHC.Types.Unique.FM

Methods

(==) :: UniqFM key ele -> UniqFM key ele -> Bool

(/=) :: UniqFM key ele -> UniqFM key ele -> Bool

emptyUFM :: UniqFM key elt

listToUFM :: Uniquable key => [(key, elt)] -> UniqFM key elt

The type-checking environment

getEnvs :: MonadTcPlugin m => m (TcGblEnv, TcLclEnv)

Obtain the current global and local type-checking environments.

Built-in types

This module also re-exports the built-in types that GHC already knows about.

This allows plugins to directly refer to e.g. the promoted data constructor True without having to look up its name.

module GHC.Builtin.Types

GHC types

These are the types that the plugin will inspect and manipulate.

END OF API DOCUMENTATION, RE-EXPORTS FOLLOW

Names

data Name

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

Instances

Data Name

Defined in GHC.Types.Name

Methods

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

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

toConstr :: Name -> Constr

dataTypeOf :: Name -> DataType

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

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

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

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

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

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

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

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

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

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

NFData Name

Defined in GHC.Types.Name

Methods

rnf :: Name -> ()

NamedThing Name

Defined in GHC.Types.Name

Methods

getOccName :: Name -> OccName

getName :: Name -> Name

HasOccName Name

Defined in GHC.Types.Name

Methods

occName :: Name -> OccName

Uniquable Name

Defined in GHC.Types.Name

Methods

getUnique :: Name -> Unique

Binary Name

Assumes that the Name is a non-binding one. See putIfaceTopBndr and getIfaceTopBndr for serializing binding Names. See UserData for the rationale for this distinction.

Defined in GHC.Types.Name

Methods

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

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

get :: BinHandle -> IO Name

Outputable Name

Defined in GHC.Types.Name

Methods

ppr :: Name -> SDoc

OutputableBndr Name

Defined in GHC.Types.Name

Methods

pprBndr :: BindingSite -> Name -> SDoc

pprPrefixOcc :: Name -> SDoc

pprInfixOcc :: Name -> SDoc

bndrIsJoin_maybe :: Name -> Maybe Int

Eq Name

The same comments as for Name's Ord instance apply.

Defined in GHC.Types.Name

Methods

(==) :: Name -> Name -> Bool

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

Ord Name

Caution: This instance is implemented via nonDetCmpUnique, which means that the ordering is not stable across deserialization or rebuilds.

See nonDetCmpUnique for further information, and trac #15240 for a bug caused by improper use of this instance.

Defined in GHC.Types.Name

Methods

compare :: Name -> Name -> Ordering

(<) :: Name -> Name -> Bool

(<=) :: Name -> Name -> Bool

(>) :: Name -> Name -> Bool

(>=) :: Name -> Name -> Bool

max :: Name -> Name -> Name

min :: Name -> Name -> Name

type Anno Name

Defined in GHC.Hs.Extension

type Anno Name = SrcSpanAnnN

type Anno (LocatedN Name)

Defined in GHC.Hs.Binds

type Anno (LocatedN Name) = SrcSpan

type Anno [LocatedN Name]

Defined in GHC.Hs.Binds

type Anno [LocatedN Name] = SrcSpan

data OccName

Occurrence Name

In this context that means: "classified (i.e. as a type name, value name, etc) but not qualified and not yet resolved"

Instances

Data OccName

Defined in GHC.Types.Name.Occurrence

Methods

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

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

toConstr :: OccName -> Constr

dataTypeOf :: OccName -> DataType

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

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

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

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

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

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

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

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

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

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

NFData OccName

Defined in GHC.Types.Name.Occurrence

Methods

rnf :: OccName -> ()

HasOccName OccName

Defined in GHC.Types.Name.Occurrence

Methods

occName :: OccName -> OccName

Uniquable OccName

Defined in GHC.Types.Name.Occurrence

Methods

getUnique :: OccName -> Unique

Binary OccName

Defined in GHC.Types.Name.Occurrence

Methods

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

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

get :: BinHandle -> IO OccName

Outputable OccName

Defined in GHC.Types.Name.Occurrence

Methods

ppr :: OccName -> SDoc

OutputableBndr OccName

Defined in GHC.Types.Name.Occurrence

Methods

pprBndr :: BindingSite -> OccName -> SDoc

pprPrefixOcc :: OccName -> SDoc

pprInfixOcc :: OccName -> SDoc

bndrIsJoin_maybe :: OccName -> Maybe Int

Eq OccName

Defined in GHC.Types.Name.Occurrence

Methods

(==) :: OccName -> OccName -> Bool

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

Ord OccName

Defined in GHC.Types.Name.Occurrence

Methods

compare :: OccName -> OccName -> Ordering

(<) :: OccName -> OccName -> Bool

(<=) :: OccName -> OccName -> Bool

(>) :: OccName -> OccName -> Bool

(>=) :: OccName -> OccName -> Bool

max :: OccName -> OccName -> OccName

min :: OccName -> OccName -> OccName

data 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 GHC.Tc.Utils.Env for how to retrieve a TyThing given a Name.

Instances

NamedThing TyThing

Defined in GHC.Types.TyThing

Methods

getOccName :: TyThing -> OccName

getName :: TyThing -> Name

Outputable TyThing

Defined in GHC.Types.TyThing

Methods

ppr :: TyThing -> SDoc

data TcTyThing

A typecheckable thing available in a local context. Could be AGlobal TyThing, but also lexically scoped variables, etc. See GHC.Tc.Utils.Env for how to retrieve a TyThing given a Name.

Instances

Outputable TcTyThing

Defined in GHC.Tc.Types

Methods

ppr :: TcTyThing -> SDoc

data Class

Instances

Data Class

Defined in GHC.Core.Class

Methods

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

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

toConstr :: Class -> Constr

dataTypeOf :: Class -> DataType

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

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

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

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

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

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

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

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

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

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

NamedThing Class

Defined in GHC.Core.Class

Methods

getOccName :: Class -> OccName

getName :: Class -> Name

Uniquable Class

Defined in GHC.Core.Class

Methods

getUnique :: Class -> Unique

Outputable Class

Defined in GHC.Core.Class

Methods

ppr :: Class -> SDoc

Eq Class

Defined in GHC.Core.Class

Methods

(==) :: Class -> Class -> Bool

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

Lookupable Class

Defined in GHC.TcPlugin.API.Names

Methods

mkOccName :: String -> OccName

lookup :: MonadTcPlugin m => Name -> m (Wear 'Resolved Class)

data DataCon

A data constructor

• AnnKeywordId : AnnOpen, AnnClose,AnnComma

Instances

Data DataCon

Defined in GHC.Core.DataCon

Methods

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

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

toConstr :: DataCon -> Constr

dataTypeOf :: DataCon -> DataType

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

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

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

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

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

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

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

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

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

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

NamedThing DataCon

Defined in GHC.Core.DataCon

Methods

getOccName :: DataCon -> OccName

getName :: DataCon -> Name

Uniquable DataCon

Defined in GHC.Core.DataCon

Methods

getUnique :: DataCon -> Unique

Outputable DataCon

Defined in GHC.Core.DataCon

Methods

ppr :: DataCon -> SDoc

OutputableBndr DataCon

Defined in GHC.Core.DataCon

Methods

pprBndr :: BindingSite -> DataCon -> SDoc

pprPrefixOcc :: DataCon -> SDoc

pprInfixOcc :: DataCon -> SDoc

bndrIsJoin_maybe :: DataCon -> Maybe Int

Eq DataCon

Defined in GHC.Core.DataCon

Methods

(==) :: DataCon -> DataCon -> Bool

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

Lookupable DataCon

Defined in GHC.TcPlugin.API.Names

Methods

mkOccName :: String -> OccName

lookup :: MonadTcPlugin m => Name -> m (Wear 'Resolved DataCon)

Lookupable (Promoted DataCon)

Defined in GHC.TcPlugin.API.Names

Methods

mkOccName :: String -> OccName

lookup :: MonadTcPlugin m => Name -> m (Wear 'Resolved (Promoted DataCon))

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

Data TyCon

Defined in GHC.Core.TyCon

Methods

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

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

toConstr :: TyCon -> Constr

dataTypeOf :: TyCon -> DataType

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

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

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

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

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

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

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

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

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

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

NamedThing TyCon

Defined in GHC.Core.TyCon

Methods

getOccName :: TyCon -> OccName

getName :: TyCon -> Name

Uniquable TyCon

Defined in GHC.Core.TyCon

Methods

getUnique :: TyCon -> Unique

Outputable TyCon

Defined in GHC.Core.TyCon

Methods

ppr :: TyCon -> SDoc

Eq TyCon

Defined in GHC.Core.TyCon

Methods

(==) :: TyCon -> TyCon -> Bool

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

Lookupable TyCon

Defined in GHC.TcPlugin.API.Names

Methods

mkOccName :: String -> OccName

lookup :: MonadTcPlugin m => Name -> m (Wear 'Resolved TyCon)

type Id = Var

Identifier

data FastString

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

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

Instances

Data FastString

Defined in GHC.Data.FastString

Methods

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

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

toConstr :: FastString -> Constr

dataTypeOf :: FastString -> DataType

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

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

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

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

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

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

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

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

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

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

IsString FastString

Defined in GHC.Data.FastString

Methods

fromString :: String -> FastString

Monoid FastString

Defined in GHC.Data.FastString

Methods

mempty :: FastString

mappend :: FastString -> FastString -> FastString

mconcat :: [FastString] -> FastString

Semigroup FastString

Defined in GHC.Data.FastString

Methods

(<>) :: FastString -> FastString -> FastString

sconcat :: NonEmpty FastString -> FastString

stimes :: Integral b => b -> FastString -> FastString

Show FastString

Defined in GHC.Data.FastString

Methods

showsPrec :: Int -> FastString -> ShowS

show :: FastString -> String

showList :: [FastString] -> ShowS

NFData FastString

Defined in GHC.Data.FastString

Methods

rnf :: FastString -> ()

Uniquable FastString

Defined in GHC.Types.Unique

Methods

getUnique :: FastString -> Unique

Outputable FastString

Defined in GHC.Utils.Outputable

Methods

ppr :: FastString -> SDoc

Eq FastString

Defined in GHC.Data.FastString

Methods

(==) :: FastString -> FastString -> Bool

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

type Anno FieldLabelString

Defined in GHC.Hs.Expr

type Anno FieldLabelString = SrcSpan

type Anno (SourceText, RuleName)

Defined in GHC.Hs.Decls

type Anno (SourceText, RuleName) = SrcSpan

type Anno (SourceText, RuleName)

Defined in GHC.Hs.Decls

type Anno (SourceText, RuleName) = SrcSpan

Constraints

data Pred

A predicate in the solver. The solver tries to prove Wanted predicates from Given ones.

Constructors

ClassPred Class [Type]

EqPred EqRel Type Type

IrredPred PredType

ForAllPred [TyVar] [PredType] PredType

data EqRel

A choice of equality relation. This is separate from the type Role because Phantom does not define a (non-trivial) equality relation.

Constructors

NomEq

ReprEq

Instances

Outputable EqRel

Defined in GHC.Core.Predicate

Methods

ppr :: EqRel -> SDoc

Eq EqRel

Defined in GHC.Core.Predicate

Methods

(==) :: EqRel -> EqRel -> Bool

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

Ord EqRel

Defined in GHC.Core.Predicate

Methods

compare :: EqRel -> EqRel -> Ordering

(<) :: EqRel -> EqRel -> Bool

(<=) :: EqRel -> EqRel -> Bool

(>) :: EqRel -> EqRel -> Bool

(>=) :: EqRel -> EqRel -> Bool

max :: EqRel -> EqRel -> EqRel

min :: EqRel -> EqRel -> EqRel

type FunDep a = ([a], [a])

data CtFlavour

Instances

Outputable CtFlavour

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: CtFlavour -> SDoc

Eq CtFlavour

Defined in GHC.Tc.Types.Constraint

Methods

(==) :: CtFlavour -> CtFlavour -> Bool

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

data Ct

Instances

Outputable Ct

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: Ct -> SDoc

data CtLoc

data CtEvidence

Instances

Outputable CtEvidence

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: CtEvidence -> SDoc

data CtOrigin

Instances

Outputable CtOrigin

Defined in GHC.Tc.Types.Origin

Methods

ppr :: CtOrigin -> SDoc

data QCInst

Instances

Outputable QCInst

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: QCInst -> SDoc

data Type

Instances

Data Type

Defined in GHC.Core.TyCo.Rep

Methods

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

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

toConstr :: Type -> Constr

dataTypeOf :: Type -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable Type

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: Type -> SDoc

Eq (DeBruijn Type)

Defined in GHC.Core.Map.Type

Methods

(==) :: DeBruijn Type -> DeBruijn Type -> Bool

(/=) :: DeBruijn Type -> DeBruijn Type -> Bool

type PredType = Type

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

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

It can be expanded into its representation, but:

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

Consider these examples:

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

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

data InstEnvs

InstEnvs represents the combination of the global type class instance environment, the local type class instance environment, and the set of transitively reachable orphan modules (according to what modules have been directly imported) used to test orphan instance visibility.

data TcLevel

Instances

Outputable TcLevel

Defined in GHC.Tc.Utils.TcType

Methods

ppr :: TcLevel -> SDoc

Eq TcLevel

Defined in GHC.Tc.Utils.TcType

Methods

(==) :: TcLevel -> TcLevel -> Bool

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

Ord TcLevel

Defined in GHC.Tc.Utils.TcType

Methods

compare :: TcLevel -> TcLevel -> Ordering

(<) :: TcLevel -> TcLevel -> Bool

(<=) :: TcLevel -> TcLevel -> Bool

(>) :: TcLevel -> TcLevel -> Bool

(>=) :: TcLevel -> TcLevel -> Bool

max :: TcLevel -> TcLevel -> TcLevel

min :: TcLevel -> TcLevel -> TcLevel

Coercions and evidence

data Coercion

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

Instances

Data Coercion

Defined in GHC.Core.TyCo.Rep

Methods

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

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

toConstr :: Coercion -> Constr

dataTypeOf :: Coercion -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable Coercion

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: Coercion -> SDoc

Eq (DeBruijn Coercion)

Defined in GHC.Core.Map.Type

Methods

(==) :: DeBruijn Coercion -> DeBruijn Coercion -> Bool

(/=) :: DeBruijn Coercion -> DeBruijn Coercion -> Bool

data Role

Constructors

Nominal

Representational

Phantom

Instances

Data Role

Defined in GHC.Core.Coercion.Axiom

Methods

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

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

toConstr :: Role -> Constr

dataTypeOf :: Role -> DataType

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

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

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

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

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

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

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

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

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

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

Binary Role

Defined in GHC.Core.Coercion.Axiom

Methods

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

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

get :: BinHandle -> IO Role

Outputable Role

Defined in GHC.Core.Coercion.Axiom

Methods

ppr :: Role -> SDoc

Eq Role

Defined in GHC.Core.Coercion.Axiom

Methods

(==) :: Role -> Role -> Bool

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

Ord Role

Defined in GHC.Core.Coercion.Axiom

Methods

compare :: Role -> Role -> Ordering

(<) :: Role -> Role -> Bool

(<=) :: Role -> Role -> Bool

(>) :: Role -> Role -> Bool

(>=) :: Role -> Role -> Bool

max :: Role -> Role -> Role

min :: Role -> Role -> Role

type Anno (Maybe Role)

Defined in GHC.Hs.Decls

type Anno (Maybe Role) = SrcSpan

type Anno (Maybe Role)

Defined in GHC.Hs.Decls

type Anno (Maybe Role) = SrcSpan

data UnivCoProvenance

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

Instances

Data UnivCoProvenance

Defined in GHC.Core.TyCo.Rep

Methods

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

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

toConstr :: UnivCoProvenance -> Constr

dataTypeOf :: UnivCoProvenance -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable UnivCoProvenance

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: UnivCoProvenance -> SDoc

data CoercionHole

A coercion to be filled in by the type-checker. See Note [Coercion holes]

Instances

Data CoercionHole

Defined in GHC.Core.TyCo.Rep

Methods

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

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

toConstr :: CoercionHole -> Constr

dataTypeOf :: CoercionHole -> DataType

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

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

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

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

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

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

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

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

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

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

Uniquable CoercionHole

Defined in GHC.Core.TyCo.Rep

Methods

getUnique :: CoercionHole -> Unique

Outputable CoercionHole

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: CoercionHole -> SDoc

data EvBind

Instances

Outputable EvBind

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: EvBind -> SDoc

data EvTerm

Instances

Data EvTerm

Defined in GHC.Tc.Types.Evidence

Methods

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

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

toConstr :: EvTerm -> Constr

dataTypeOf :: EvTerm -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable EvTerm

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: EvTerm -> SDoc

type EvVar = EvId

Evidence Variable

type EvExpr = CoreExpr

data EvBindsVar

Instances

Uniquable EvBindsVar

Defined in GHC.Tc.Types.Evidence

Methods

getUnique :: EvBindsVar -> Unique

Outputable EvBindsVar

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: EvBindsVar -> SDoc

The type-checking environment

data TcGblEnv

TcGblEnv describes the top-level of the module at the point at which the typechecker is finished work. It is this structure that is handed on to the desugarer For state that needs to be updated during the typechecking phase and returned at end, use a TcRef (= IORef).

Instances

ContainsModule TcGblEnv

Defined in GHC.Tc.Types

Methods

extractModule :: TcGblEnv -> Module

data TcLclEnv

Pretty-printing

data SDoc

Represents a pretty-printable document.

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

Instances

IsString SDoc

Defined in GHC.Utils.Outputable

Methods

fromString :: String -> SDoc

Outputable SDoc

Defined in GHC.Utils.Outputable

Methods

ppr :: SDoc -> SDoc

OutputableP env SDoc

Defined in GHC.Utils.Outputable

Methods

pdoc :: env -> SDoc -> SDoc

class Outputable a where

Class designating that some type has an SDoc representation

Methods

ppr :: a -> SDoc

Instances

Outputable Fingerprint

Defined in GHC.Utils.Outputable

Methods

ppr :: Fingerprint -> SDoc

Outputable Int32

Defined in GHC.Utils.Outputable

Methods

ppr :: Int32 -> SDoc

Outputable Int64

Defined in GHC.Utils.Outputable

Methods

ppr :: Int64 -> SDoc

Outputable Word16

Defined in GHC.Utils.Outputable

Methods

ppr :: Word16 -> SDoc

Outputable Word32

Defined in GHC.Utils.Outputable

Methods

ppr :: Word32 -> SDoc

Outputable Word64

Defined in GHC.Utils.Outputable

Methods

ppr :: Word64 -> SDoc

Outputable IntSet

Defined in GHC.Utils.Outputable

Methods

ppr :: IntSet -> SDoc

Outputable CoreModule

Defined in GHC

Methods

ppr :: CoreModule -> SDoc

Outputable Label

Defined in GHC.Cmm.Dataflow.Label

Methods

ppr :: Label -> SDoc

Outputable LabelSet

Defined in GHC.Cmm.Dataflow.Label

Methods

ppr :: LabelSet -> SDoc

Outputable AltCon

Defined in GHC.Core

Methods

ppr :: AltCon -> SDoc

Outputable Class

Defined in GHC.Core.Class

Methods

ppr :: Class -> SDoc

Outputable LiftingContext

Defined in GHC.Core.Coercion

Methods

ppr :: LiftingContext -> SDoc

Outputable CoAxBranch

Defined in GHC.Core.Coercion.Axiom

Methods

ppr :: CoAxBranch -> SDoc

Outputable CoAxiomRule

Defined in GHC.Core.Coercion.Axiom

Methods

ppr :: CoAxiomRule -> SDoc

Outputable Role

Defined in GHC.Core.Coercion.Axiom

Methods

ppr :: Role -> SDoc

Outputable DataCon

Defined in GHC.Core.DataCon

Methods

ppr :: DataCon -> SDoc

Outputable EqSpec

Defined in GHC.Core.DataCon

Methods

ppr :: EqSpec -> SDoc

Outputable HsImplBang

Defined in GHC.Core.DataCon

Methods

ppr :: HsImplBang -> SDoc

Outputable HsSrcBang

Defined in GHC.Core.DataCon

Methods

ppr :: HsSrcBang -> SDoc

Outputable SrcStrictness

Defined in GHC.Core.DataCon

Methods

ppr :: SrcStrictness -> SDoc

Outputable SrcUnpackedness

Defined in GHC.Core.DataCon

Methods

ppr :: SrcUnpackedness -> SDoc

Outputable StrictnessMark

Defined in GHC.Core.DataCon

Methods

ppr :: StrictnessMark -> SDoc

Outputable FamInst

Defined in GHC.Core.FamInstEnv

Methods

ppr :: FamInst -> SDoc

Outputable FamInstMatch

Defined in GHC.Core.FamInstEnv

Methods

ppr :: FamInstMatch -> SDoc

Outputable FamilyInstEnv

Defined in GHC.Core.FamInstEnv

Methods

ppr :: FamilyInstEnv -> SDoc

Outputable ClsInst

Defined in GHC.Core.InstEnv

Methods

ppr :: ClsInst -> SDoc

Outputable ClsInstEnv

Defined in GHC.Core.InstEnv

Methods

ppr :: ClsInstEnv -> SDoc

Outputable FloatBind

Defined in GHC.Core.Make

Methods

ppr :: FloatBind -> SDoc

Outputable PatSyn

Defined in GHC.Core.PatSyn

Methods

ppr :: PatSyn -> SDoc

Outputable EqRel

Defined in GHC.Core.Predicate

Methods

ppr :: EqRel -> SDoc

Outputable Reduction

Defined in GHC.Core.Reduction

Methods

ppr :: Reduction -> SDoc

Outputable Coercion

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: Coercion -> SDoc

Outputable CoercionHole

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: CoercionHole -> SDoc

Outputable MCoercion

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: MCoercion -> SDoc

Outputable TyCoBinder

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: TyCoBinder -> SDoc

Outputable TyLit

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: TyLit -> SDoc

Outputable Type

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: Type -> SDoc

Outputable UnivCoProvenance

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: UnivCoProvenance -> SDoc

Outputable AlgTyConFlav

Defined in GHC.Core.TyCon

Methods

ppr :: AlgTyConFlav -> SDoc

Outputable FamTyConFlav

Defined in GHC.Core.TyCon

Methods

ppr :: FamTyConFlav -> SDoc

Outputable PrimElemRep

Defined in GHC.Core.TyCon

Methods

ppr :: PrimElemRep -> SDoc

Outputable PrimRep

Defined in GHC.Core.TyCon

Methods

ppr :: PrimRep -> SDoc

Outputable TyCon

Defined in GHC.Core.TyCon

Methods

ppr :: TyCon -> SDoc

Outputable TyConBndrVis

Defined in GHC.Core.TyCon

Methods

ppr :: TyConBndrVis -> SDoc

Outputable TyConFlavour

Defined in GHC.Core.TyCon

Methods

ppr :: TyConFlavour -> SDoc

Outputable Usage

Defined in GHC.Core.UsageEnv

Methods

ppr :: Usage -> SDoc

Outputable UsageEnv

Defined in GHC.Core.UsageEnv

Methods

ppr :: UsageEnv -> SDoc

Outputable FastString

Defined in GHC.Utils.Outputable

Methods

ppr :: FastString -> SDoc

Outputable LexicalFastString

Defined in GHC.Utils.Outputable

Methods

ppr :: LexicalFastString -> SDoc

Outputable NonDetFastString

Defined in GHC.Utils.Outputable

Methods

ppr :: NonDetFastString -> SDoc

Outputable XViaStrategyPs

Defined in GHC.Hs.Decls

Methods

ppr :: XViaStrategyPs -> SDoc

Outputable ArgDocMap

Defined in GHC.Hs.Doc

Methods

ppr :: ArgDocMap -> SDoc

Outputable DeclDocMap

Defined in GHC.Hs.Doc

Methods

ppr :: DeclDocMap -> SDoc

Outputable HsDocString

Defined in GHC.Hs.Doc

Methods

ppr :: HsDocString -> SDoc

Outputable GrhsAnn

Defined in GHC.Hs.Expr

Methods

ppr :: GrhsAnn -> SDoc

Outputable PendingRnSplice

Defined in GHC.Hs.Expr

Methods

ppr :: PendingRnSplice -> SDoc

Outputable PendingTcSplice

Defined in GHC.Hs.Expr

Methods

ppr :: PendingTcSplice -> SDoc

Outputable SyntaxExprRn

Defined in GHC.Hs.Expr

Methods

ppr :: SyntaxExprRn -> SDoc

Outputable SyntaxExprTc

Defined in GHC.Hs.Expr

Methods

ppr :: SyntaxExprTc -> SDoc

Outputable XXExprGhcTc

Defined in GHC.Hs.Expr

Methods

ppr :: XXExprGhcTc -> SDoc

Outputable DsMatchContext

Defined in GHC.HsToCore.Monad

Methods

ppr :: DsMatchContext -> SDoc

Outputable EquationInfo

Defined in GHC.HsToCore.Monad

Methods

ppr :: EquationInfo -> SDoc

Outputable DataConBuilder

Defined in GHC.Parser.Types

Methods

ppr :: DataConBuilder -> SDoc

Outputable BinderInfo

Defined in GHC.Stg.Lift.Analysis

Methods

ppr :: BinderInfo -> SDoc

Outputable Skeleton

Defined in GHC.Stg.Lift.Analysis

Methods

ppr :: Skeleton -> SDoc

Outputable AltType

Defined in GHC.Stg.Syntax

Methods

ppr :: AltType -> SDoc

Outputable ConstructorNumber

Defined in GHC.Stg.Syntax

Methods

ppr :: ConstructorNumber -> SDoc

Outputable NoExtFieldSilent

Defined in GHC.Stg.Syntax

Methods

ppr :: NoExtFieldSilent -> SDoc

Outputable StgArg

Defined in GHC.Stg.Syntax

Methods

ppr :: StgArg -> SDoc

Outputable UpdateFlag

Defined in GHC.Stg.Syntax

Methods

ppr :: UpdateFlag -> SDoc

Outputable HoleFit

Defined in GHC.Tc.Errors.Hole.FitTypes

Methods

ppr :: HoleFit -> SDoc

Outputable HoleFitCandidate

Defined in GHC.Tc.Errors.Hole.FitTypes

Methods

ppr :: HoleFitCandidate -> SDoc

Outputable TypedHole

Defined in GHC.Tc.Errors.Hole.FitTypes

Methods

ppr :: TypedHole -> SDoc

Outputable IdBindingInfo

Defined in GHC.Tc.Types

Methods

ppr :: IdBindingInfo -> SDoc

Outputable PromotionErr

Defined in GHC.Tc.Types

Methods

ppr :: PromotionErr -> SDoc

Outputable TcBinder

Defined in GHC.Tc.Types

Methods

ppr :: TcBinder -> SDoc

Outputable TcIdSigInfo

Defined in GHC.Tc.Types

Methods

ppr :: TcIdSigInfo -> SDoc

Outputable TcIdSigInst

Defined in GHC.Tc.Types

Methods

ppr :: TcIdSigInst -> SDoc

Outputable TcPatSynInfo

Defined in GHC.Tc.Types

Methods

ppr :: TcPatSynInfo -> SDoc

Outputable TcSigInfo

Defined in GHC.Tc.Types

Methods

ppr :: TcSigInfo -> SDoc

Outputable TcTyThing

Defined in GHC.Tc.Types

Methods

ppr :: TcTyThing -> SDoc

Outputable ThStage

Defined in GHC.Tc.Types

Methods

ppr :: ThStage -> SDoc

Outputable WhereFrom

Defined in GHC.Tc.Types

Methods

ppr :: WhereFrom -> SDoc

Outputable CanEqLHS

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: CanEqLHS -> SDoc

Outputable CheckTyEqResult

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: CheckTyEqResult -> SDoc

Outputable Ct

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: Ct -> SDoc

Outputable CtEvidence

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: CtEvidence -> SDoc

Outputable CtFlavour

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: CtFlavour -> SDoc

Outputable CtIrredReason

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: CtIrredReason -> SDoc

Outputable HasGivenEqs

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: HasGivenEqs -> SDoc

Outputable Hole

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: Hole -> SDoc

Outputable HoleSort

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: HoleSort -> SDoc

Outputable ImplicStatus

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: ImplicStatus -> SDoc

Outputable Implication

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: Implication -> SDoc

Outputable QCInst

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: QCInst -> SDoc

Outputable SubGoalDepth

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: SubGoalDepth -> SDoc

Outputable TcEvDest

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: TcEvDest -> SDoc

Outputable WantedConstraints

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: WantedConstraints -> SDoc

Outputable EvBind

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: EvBind -> SDoc

Outputable EvBindMap

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: EvBindMap -> SDoc

Outputable EvBindsVar

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: EvBindsVar -> SDoc

Outputable EvCallStack

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: EvCallStack -> SDoc

Outputable EvTerm

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: EvTerm -> SDoc

Outputable EvTypeable

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: EvTypeable -> SDoc

Outputable HoleExprRef

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: HoleExprRef -> SDoc

Outputable HsWrapper

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: HsWrapper -> SDoc

Outputable TcEvBinds

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: TcEvBinds -> SDoc

Outputable CtOrigin

Defined in GHC.Tc.Types.Origin

Methods

ppr :: CtOrigin -> SDoc

Outputable SkolemInfo

Defined in GHC.Tc.Types.Origin

Methods

ppr :: SkolemInfo -> SDoc

Outputable IsExtraConstraint

Defined in GHC.Tc.Utils.Monad

Methods

ppr :: IsExtraConstraint -> SDoc

Outputable ExpType

Defined in GHC.Tc.Utils.TcType

Methods

ppr :: ExpType -> SDoc

Outputable InferResult

Defined in GHC.Tc.Utils.TcType

Methods

ppr :: InferResult -> SDoc

Outputable MetaDetails

Defined in GHC.Tc.Utils.TcType

Methods

ppr :: MetaDetails -> SDoc

Outputable MetaInfo

Defined in GHC.Tc.Utils.TcType

Methods

ppr :: MetaInfo -> SDoc

Outputable TcLevel

Defined in GHC.Tc.Utils.TcType

Methods

ppr :: TcLevel -> SDoc

Outputable TcTyVarDetails

Defined in GHC.Tc.Utils.TcType

Methods

ppr :: TcTyVarDetails -> SDoc

Outputable Annotation

Defined in GHC.Types.Annotations

Methods

ppr :: Annotation -> SDoc

Outputable AvailInfo

Defined in GHC.Types.Avail

Methods

ppr :: AvailInfo -> SDoc

Outputable GreName

Defined in GHC.Types.Avail

Methods

ppr :: GreName -> SDoc

Outputable Activation

Defined in GHC.Types.Basic

Methods

ppr :: Activation -> SDoc

Outputable Alignment

Defined in GHC.Types.Basic

Methods

ppr :: Alignment -> SDoc

Outputable Boxity

Defined in GHC.Types.Basic

Methods

ppr :: Boxity -> SDoc

Outputable CompilerPhase

Defined in GHC.Types.Basic

Methods

ppr :: CompilerPhase -> SDoc

Outputable FunctionOrData

Defined in GHC.Types.Basic

Methods

ppr :: FunctionOrData -> SDoc

Outputable InlinePragma

Defined in GHC.Types.Basic

Methods

ppr :: InlinePragma -> SDoc

Outputable InlineSpec

Defined in GHC.Types.Basic

Methods

ppr :: InlineSpec -> SDoc

Outputable IntWithInf

Defined in GHC.Types.Basic

Methods

ppr :: IntWithInf -> SDoc

Outputable LeftOrRight

Defined in GHC.Types.Basic

Methods

ppr :: LeftOrRight -> SDoc

Outputable OccInfo

Defined in GHC.Types.Basic

Methods

ppr :: OccInfo -> SDoc

Outputable OneShotInfo

Defined in GHC.Types.Basic

Methods

ppr :: OneShotInfo -> SDoc

Outputable Origin

Defined in GHC.Types.Basic

Methods

ppr :: Origin -> SDoc

Outputable OverlapFlag

Defined in GHC.Types.Basic

Methods

ppr :: OverlapFlag -> SDoc

Outputable OverlapMode

Defined in GHC.Types.Basic

Methods

ppr :: OverlapMode -> SDoc

Outputable PromotionFlag

Defined in GHC.Types.Basic

Methods

ppr :: PromotionFlag -> SDoc

Outputable RecFlag

Defined in GHC.Types.Basic

Methods

ppr :: RecFlag -> SDoc

Outputable RuleMatchInfo

Defined in GHC.Types.Basic

Methods

ppr :: RuleMatchInfo -> SDoc

Outputable SuccessFlag

Defined in GHC.Types.Basic

Methods

ppr :: SuccessFlag -> SDoc

Outputable SwapFlag

Defined in GHC.Types.Basic

Methods

ppr :: SwapFlag -> SDoc

Outputable TailCallInfo

Defined in GHC.Types.Basic

Methods

ppr :: TailCallInfo -> SDoc

Outputable TopLevelFlag

Defined in GHC.Types.Basic

Methods

ppr :: TopLevelFlag -> SDoc

Outputable TupleSort

Defined in GHC.Types.Basic

Methods

ppr :: TupleSort -> SDoc

Outputable TypeOrKind

Defined in GHC.Types.Basic

Methods

ppr :: TypeOrKind -> SDoc

Outputable CompleteMatch

Defined in GHC.Types.CompleteMatch

Methods

ppr :: CompleteMatch -> SDoc

Outputable DiagnosticHint

Defined in GHC.Types.Error

Methods

ppr :: DiagnosticHint -> SDoc

Outputable DiagnosticReason

Defined in GHC.Types.Error

Methods

ppr :: DiagnosticReason -> SDoc

Outputable Severity

Defined in GHC.Types.Error

Methods

ppr :: Severity -> SDoc

Outputable DuplicateRecordFields

Defined in GHC.Types.FieldLabel

Methods

ppr :: DuplicateRecordFields -> SDoc

Outputable FieldLabel

Defined in GHC.Types.FieldLabel

Methods

ppr :: FieldLabel -> SDoc

Outputable FieldSelectors

Defined in GHC.Types.FieldLabel

Methods

ppr :: FieldSelectors -> SDoc

Outputable FixItem

Defined in GHC.Types.Fixity.Env

Methods

ppr :: FixItem -> SDoc

Outputable CCallConv

Defined in GHC.Types.ForeignCall

Methods

ppr :: CCallConv -> SDoc

Outputable CCallSpec

Defined in GHC.Types.ForeignCall

Methods

ppr :: CCallSpec -> SDoc

Outputable CExportSpec

Defined in GHC.Types.ForeignCall

Methods

ppr :: CExportSpec -> SDoc

Outputable CType

Defined in GHC.Types.ForeignCall

Methods

ppr :: CType -> SDoc

Outputable ForeignCall

Defined in GHC.Types.ForeignCall

Methods

ppr :: ForeignCall -> SDoc

Outputable Header

Defined in GHC.Types.ForeignCall

Methods

ppr :: Header -> SDoc

Outputable Safety

Defined in GHC.Types.ForeignCall

Methods

ppr :: Safety -> SDoc

Outputable Name

Defined in GHC.Types.Name

Methods

ppr :: Name -> SDoc

Outputable NameSort

Defined in GHC.Types.Name

Methods

ppr :: NameSort -> SDoc

Outputable OccName

Defined in GHC.Types.Name.Occurrence

Methods

ppr :: OccName -> SDoc

Outputable GlobalRdrElt

Defined in GHC.Types.Name.Reader

Methods

ppr :: GlobalRdrElt -> SDoc

Outputable ImportSpec

Defined in GHC.Types.Name.Reader

Methods

ppr :: ImportSpec -> SDoc

Outputable LocalRdrEnv

Defined in GHC.Types.Name.Reader

Methods

ppr :: LocalRdrEnv -> SDoc

Outputable Parent

Defined in GHC.Types.Name.Reader

Methods

ppr :: Parent -> SDoc

Outputable RdrName

Defined in GHC.Types.Name.Reader

Methods

ppr :: RdrName -> SDoc

Outputable RealSrcLoc

Defined in GHC.Types.SrcLoc

Methods

ppr :: RealSrcLoc -> SDoc

Outputable RealSrcSpan

Defined in GHC.Types.SrcLoc

Methods

ppr :: RealSrcSpan -> SDoc

Outputable SrcLoc

Defined in GHC.Types.SrcLoc

Methods

ppr :: SrcLoc -> SDoc

Outputable SrcSpan

Defined in GHC.Types.SrcLoc

Methods

ppr :: SrcSpan -> SDoc

Outputable UnhelpfulSpanReason

Defined in GHC.Types.SrcLoc

Methods

ppr :: UnhelpfulSpanReason -> SDoc

Outputable TyThing

Defined in GHC.Types.TyThing

Methods

ppr :: TyThing -> SDoc

Outputable Unique

Defined in GHC.Types.Unique

Methods

ppr :: Unique -> SDoc

Outputable AnonArgFlag

Defined in GHC.Types.Var

Methods

ppr :: AnonArgFlag -> SDoc

Outputable ArgFlag

Defined in GHC.Types.Var

Methods

ppr :: ArgFlag -> SDoc

Outputable Var

Defined in GHC.Types.Var

Methods

ppr :: Var -> SDoc

Outputable ModLocation

Defined in GHC.Unit.Module.Location

Methods

ppr :: ModLocation -> SDoc

Outputable ModuleName

Defined in GHC.Unit.Module.Name

Methods

ppr :: ModuleName -> SDoc

Outputable WarningTxt

Defined in GHC.Unit.Module.Warnings

Methods

ppr :: WarningTxt -> SDoc

Outputable ModuleOrigin

Defined in GHC.Unit.State

Methods

ppr :: ModuleOrigin -> SDoc

Outputable UnitErr

Defined in GHC.Unit.State

Methods

ppr :: UnitErr -> SDoc

Outputable UnitVisibility

Defined in GHC.Unit.State

Methods

ppr :: UnitVisibility -> SDoc

Outputable UnusableUnitReason

Defined in GHC.Unit.State

Methods

ppr :: UnusableUnitReason -> SDoc

Outputable InstalledModule

Defined in GHC.Unit.Types

Methods

ppr :: InstalledModule -> SDoc

Outputable InstantiatedModule

Defined in GHC.Unit.Types

Methods

ppr :: InstantiatedModule -> SDoc

Outputable InstantiatedUnit

Defined in GHC.Unit.Types

Methods

ppr :: InstantiatedUnit -> SDoc

Outputable Module

Defined in GHC.Unit.Types

Methods

ppr :: Module -> SDoc

Outputable Unit

Defined in GHC.Unit.Types

Methods

ppr :: Unit -> SDoc

Outputable UnitId

Defined in GHC.Unit.Types

Methods

ppr :: UnitId -> SDoc

Outputable PprStyle

Defined in GHC.Utils.Outputable

Methods

ppr :: PprStyle -> SDoc

Outputable QualifyName

Defined in GHC.Utils.Outputable

Methods

ppr :: QualifyName -> SDoc

Outputable SDoc

Defined in GHC.Utils.Outputable

Methods

ppr :: SDoc -> SDoc

Outputable DocDecl

Defined in Language.Haskell.Syntax.Decls

Methods

ppr :: DocDecl -> SDoc

Outputable ForeignExport

Defined in Language.Haskell.Syntax.Decls

Methods

ppr :: ForeignExport -> SDoc

Outputable ForeignImport

Defined in Language.Haskell.Syntax.Decls

Methods

ppr :: ForeignImport -> SDoc

Outputable NewOrData

Defined in Language.Haskell.Syntax.Decls

Methods

ppr :: NewOrData -> SDoc

Outputable SpliceDecoration

Defined in Language.Haskell.Syntax.Expr

Methods

ppr :: SpliceDecoration -> SDoc

Outputable Serialized

Defined in GHC.Utils.Outputable

Methods

ppr :: Serialized -> SDoc

Outputable Extension

Defined in GHC.Utils.Outputable

Methods

ppr :: Extension -> SDoc

Outputable Ordering

Defined in GHC.Utils.Outputable

Methods

ppr :: Ordering -> SDoc

Outputable UTCTime

Defined in GHC.Utils.Outputable

Methods

ppr :: UTCTime -> SDoc

Outputable Integer

Defined in GHC.Utils.Outputable

Methods

ppr :: Integer -> SDoc

Outputable ()

Defined in GHC.Utils.Outputable

Methods

ppr :: () -> SDoc

Outputable Bool

Defined in GHC.Utils.Outputable

Methods

ppr :: Bool -> SDoc

Outputable Char

Defined in GHC.Utils.Outputable

Methods

ppr :: Char -> SDoc

Outputable Double

Defined in GHC.Utils.Outputable

Methods

ppr :: Double -> SDoc

Outputable Float

Defined in GHC.Utils.Outputable

Methods

ppr :: Float -> SDoc

Outputable Int

Defined in GHC.Utils.Outputable

Methods

ppr :: Int -> SDoc

Outputable Word

Defined in GHC.Utils.Outputable

Methods

ppr :: Word -> SDoc

Outputable a => Outputable (NonEmpty a)

Defined in GHC.Utils.Outputable

Methods

ppr :: NonEmpty a -> SDoc

Outputable a => Outputable (SCC a)

Defined in GHC.Utils.Outputable

Methods

ppr :: SCC a -> SDoc

Outputable elt => Outputable (IntMap elt)

Defined in GHC.Utils.Outputable

Methods

ppr :: IntMap elt -> SDoc

Outputable a => Outputable (Set a)

Defined in GHC.Utils.Outputable

Methods

ppr :: Set a -> SDoc

Outputable a => Outputable (LabelMap a)

Defined in GHC.Cmm.Dataflow.Label

Methods

ppr :: LabelMap a -> SDoc

Outputable b => Outputable (TaggedBndr b)

Defined in GHC.Core

Methods

ppr :: TaggedBndr b -> SDoc

Outputable ev => Outputable (NormaliseStepResult ev)

Defined in GHC.Core.Coercion

Methods

ppr :: NormaliseStepResult ev -> SDoc

Outputable (CoAxiom br)

Defined in GHC.Core.Coercion.Axiom

Methods

ppr :: CoAxiom br -> SDoc

Outputable a => Outputable (CoreMap a)

Defined in GHC.Core.Map.Expr

Methods

ppr :: CoreMap a -> SDoc

Outputable a => Outputable (TypeMapG a)

Defined in GHC.Core.Map.Type

Methods

ppr :: TypeMapG a -> SDoc

Outputable a => Outputable (Scaled a)

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: Scaled a -> SDoc

Outputable a => Outputable (Bag a)

Defined in GHC.Data.Bag

Methods

ppr :: Bag a -> SDoc

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

Defined in GHC.Hs.ImpExp

Methods

ppr :: IE (GhcPass p) -> SDoc

OutputableBndr name => Outputable (IEWrappedName name)

Defined in GHC.Hs.ImpExp

Methods

ppr :: IEWrappedName name -> SDoc

(OutputableBndrId p, Outputable (Anno (IE (GhcPass p)))) => Outputable (ImportDecl (GhcPass p))

Defined in GHC.Hs.ImpExp

Methods

ppr :: ImportDecl (GhcPass p) -> SDoc

Outputable (PatBuilder GhcPs)

Defined in GHC.Parser.Types

Methods

ppr :: PatBuilder GhcPs -> SDoc

OutputableBndrId a => Outputable (InstInfo (GhcPass a))

Defined in GHC.Tc.Utils.Env

Methods

ppr :: InstInfo (GhcPass a) -> SDoc

Outputable name => Outputable (AnnTarget name)

Defined in GHC.Types.Annotations

Methods

ppr :: AnnTarget name -> SDoc

Outputable (DefMethSpec ty)

Defined in GHC.Types.Basic

Methods

ppr :: DefMethSpec ty -> SDoc

Outputable a => Outputable (OccEnv a)

Defined in GHC.Types.Name.Occurrence

Methods

ppr :: OccEnv a -> SDoc

Outputable e => Outputable (Located e)

Defined in GHC.Types.SrcLoc

Methods

ppr :: Located e -> SDoc

Outputable unit => Outputable (Definite unit)

Defined in GHC.Unit.Types

Methods

ppr :: Definite unit -> SDoc

Outputable a => Outputable (GenWithIsBoot a)

Defined in GHC.Unit.Types

Methods

ppr :: GenWithIsBoot a -> SDoc

Outputable unit => Outputable (Indefinite unit)

Defined in GHC.Unit.Types

Methods

ppr :: Indefinite unit -> SDoc

Outputable (XRec a RdrName) => Outputable (RecordPatSynField a)

Defined in Language.Haskell.Syntax.Binds

Methods

ppr :: RecordPatSynField a -> SDoc

Outputable (FamilyInfo pass)

Defined in Language.Haskell.Syntax.Decls

Methods

ppr :: FamilyInfo pass -> SDoc

Outputable (XRec p FieldLabelString) => Outputable (DotFieldOcc p)

Defined in Language.Haskell.Syntax.Expr

Methods

ppr :: DotFieldOcc p -> SDoc

(UnXRec p, Outputable (XRec p FieldLabelString)) => Outputable (FieldLabelStrings p)

Defined in Language.Haskell.Syntax.Expr

Methods

ppr :: FieldLabelStrings p -> SDoc

Outputable a => Outputable (Maybe a)

Defined in GHC.Utils.Outputable

Methods

ppr :: Maybe a -> SDoc

Outputable a => Outputable [a]

Defined in GHC.Utils.Outputable

Methods

ppr :: [a] -> SDoc

(Outputable a, Outputable b) => Outputable (Either a b)

Defined in GHC.Utils.Outputable

Methods

ppr :: Either a b -> SDoc

(Outputable key, Outputable elt) => Outputable (Map key elt)

Defined in GHC.Utils.Outputable

Methods

ppr :: Map key elt -> SDoc

(Outputable a, Outputable (m a)) => Outputable (GenMap m a)

Defined in GHC.Data.TrieMap

Methods

ppr :: GenMap m a -> SDoc

(TrieMap m, Outputable a) => Outputable (ListMap m a)

Defined in GHC.Data.TrieMap

Methods

ppr :: ListMap m a -> SDoc

(Outputable a, Outputable b) => Outputable (HsExpansion a b)

Just print the original expression (the a).

Defined in GHC.Hs.Expr

Methods

ppr :: HsExpansion a b -> SDoc

(Outputable a, Outputable b) => Outputable (HsPatExpansion a b)

Defined in GHC.Hs.Pat

Methods

ppr :: HsPatExpansion a b -> SDoc

Outputable e => Outputable (GenLocated RealSrcSpan e)

Defined in GHC.Types.SrcLoc

Methods

ppr :: GenLocated RealSrcSpan e -> SDoc

Outputable a => Outputable (UniqDFM key a)

Defined in GHC.Types.Unique.DFM

Methods

ppr :: UniqDFM key a -> SDoc

Outputable a => Outputable (UniqFM key a)

Defined in GHC.Types.Unique.FM

Methods

ppr :: UniqFM key a -> SDoc

OutputableBndr tv => Outputable (VarBndr tv TyConBndrVis)

Defined in GHC.Core.TyCon

Methods

ppr :: VarBndr tv TyConBndrVis -> SDoc

Outputable tv => Outputable (VarBndr tv ArgFlag)

Defined in GHC.Types.Var

Methods

ppr :: VarBndr tv ArgFlag -> SDoc

Outputable tv => Outputable (VarBndr tv Specificity)

Defined in GHC.Types.Var

Methods

ppr :: VarBndr tv Specificity -> SDoc

(Outputable a, Outputable b) => Outputable (a, b)

Defined in GHC.Utils.Outputable

Methods

ppr :: (a, b) -> SDoc

(Outputable a, Outputable b, Outputable c) => Outputable (a, b, c)

Defined in GHC.Utils.Outputable

Methods

ppr :: (a, b, c) -> SDoc

(Outputable a, Outputable b, Outputable c, Outputable d) => Outputable (a, b, c, d)

Defined in GHC.Utils.Outputable

Methods

ppr :: (a, b, c, d) -> SDoc

(Outputable a, Outputable b, Outputable c, Outputable d, Outputable e) => Outputable (a, b, c, d, e)

Defined in GHC.Utils.Outputable

Methods

ppr :: (a, b, c, d, e) -> SDoc

(Outputable a, Outputable b, Outputable c, Outputable d, Outputable e, Outputable f) => Outputable (a, b, c, d, e, f)

Defined in GHC.Utils.Outputable

Methods

ppr :: (a, b, c, d, e, f) -> SDoc

(Outputable a, Outputable b, Outputable c, Outputable d, Outputable e, Outputable f, Outputable g) => Outputable (a, b, c, d, e, f, g)

Defined in GHC.Utils.Outputable

Methods

ppr :: (a, b, c, d, e, f, g) -> SDoc