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 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 :: Type -> Type)

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 '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 '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 '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 :: TcPluginStage) :: Type -> Type

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

Instances

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 '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 '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 '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

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 '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 '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 'Stop)

Defined in GHC.TcPlugin.API.Internal

Methods

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

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

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 '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 '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 '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

(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 'Solve)

Defined in GHC.TcPlugin.API.Internal

Methods

askBuiltins :: TcPluginM 'Solve BuiltinDefs

MonadTcPluginWork (TcPluginM 'Rewrite)

Defined in GHC.TcPlugin.API.Internal

Methods

askBuiltins :: TcPluginM 'Rewrite BuiltinDefs

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

Defined in GHC.TcPlugin.API.Internal

Methods

askBuiltins :: TcPluginM 'Stop BuiltinDefs

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 '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 '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 '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

newtype TcPluginM 'Init a

Defined in GHC.TcPlugin.API.Internal

newtype TcPluginM 'Init a = TcPluginInitM {

• tcPluginInitM :: 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 'Rewrite a

Defined in GHC.TcPlugin.API.Internal

newtype TcPluginM 'Rewrite a = TcPluginRewriteM {

• tcPluginRewriteM :: BuiltinDefs -> RewriteEnv -> 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 'Solve)

Defined in GHC.TcPlugin.API.Internal

Methods

askBuiltins :: TcPluginM 'Solve BuiltinDefs

MonadTcPluginWork (TcPluginM 'Rewrite)

Defined in GHC.TcPlugin.API.Internal

Methods

askBuiltins :: TcPluginM 'Rewrite 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

data Module

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

Module variables (i.e. H) which can be instantiated to a specific module at some later point in time are represented with moduleUnitId set to holeUnitId (this allows us to avoid having to make moduleUnitId a partial operation.)

Instances

Eq Module

Defined in Module

Methods

(==) :: Module -> Module -> Bool

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

Data Module

Defined in Module

Methods

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

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

toConstr :: Module -> Constr

dataTypeOf :: Module -> DataType

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

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

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

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

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

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

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

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

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

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

Ord Module

Defined in Module

Methods

compare :: Module -> Module -> Ordering

(<) :: Module -> Module -> Bool

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

(>) :: Module -> Module -> Bool

(>=) :: Module -> Module -> Bool

max :: Module -> Module -> Module

min :: Module -> Module -> Module

NFData Module

Defined in Module

Methods

rnf :: Module -> ()

Binary Module

Defined in Module

Methods

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

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

get :: BinHandle -> IO Module

Uniquable Module

Defined in Module

Methods

getUnique :: Module -> Unique

Outputable Module

Defined in Module

Methods

ppr :: Module -> SDoc

pprPrec :: Rational -> Module -> SDoc

DbUnitIdModuleRep InstalledUnitId ComponentId UnitId ModuleName Module

Defined in Module

Methods

fromDbModule :: DbModule InstalledUnitId ComponentId UnitId ModuleName Module -> Module

toDbModule :: Module -> DbModule InstalledUnitId ComponentId UnitId ModuleName Module

fromDbUnitId :: DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module -> UnitId

toDbUnitId :: UnitId -> DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module

data ModuleName

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

Instances

Eq ModuleName

Defined in Module

Methods

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

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

Data ModuleName

Defined in Module

Methods

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

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

toConstr :: ModuleName -> Constr

dataTypeOf :: ModuleName -> DataType

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

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

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

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

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

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

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

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

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

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

Ord ModuleName

Defined in Module

Methods

compare :: ModuleName -> ModuleName -> Ordering

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

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

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

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

max :: ModuleName -> ModuleName -> ModuleName

min :: ModuleName -> ModuleName -> ModuleName

NFData ModuleName

Defined in Module

Methods

rnf :: ModuleName -> ()

Binary ModuleName

Defined in Module

Methods

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

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

get :: BinHandle -> IO ModuleName

Uniquable ModuleName

Defined in Module

Methods

getUnique :: ModuleName -> Unique

Outputable ModuleName

Defined in Module

Methods

ppr :: ModuleName -> SDoc

pprPrec :: Rational -> ModuleName -> SDoc

BinaryStringRep ModuleName

Defined in Module

Methods

fromStringRep :: ByteString -> ModuleName

toStringRep :: ModuleName -> ByteString

DbUnitIdModuleRep InstalledUnitId ComponentId UnitId ModuleName Module

Defined in Module

Methods

fromDbModule :: DbModule InstalledUnitId ComponentId UnitId ModuleName Module -> Module

toDbModule :: Module -> DbModule InstalledUnitId ComponentId UnitId ModuleName Module

fromDbUnitId :: DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module -> UnitId

toDbUnitId :: UnitId -> DbUnitId InstalledUnitId ComponentId UnitId ModuleName Module

data FindResult

The result of searching for an imported module.

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

Constructors

Found ModLocation Module

The module was found

NoPackage UnitId

The requested package was not found

FoundMultiple [(Module, ModuleOrigin)]

_Error_: both in multiple packages

NotFound

Not found

Fields

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

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.

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?

data Pred

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

pattern ClassPred :: Class -> [Type] -> Pred

pattern EqPred :: EqRel -> Type -> Type -> Pred

pattern IrredPred :: PredType -> Pred

pattern ForAllPred :: [TyCoVarBinder] -> [PredType] -> PredType -> Pred

classifyPredType :: PredType -> Pred

ctPred :: Ct -> PredType

Handling type variables

type TyVar = Var

Type or kind Variable

type CoVar = Id

Coercion Variable

data MetaDetails

Instances

Outputable MetaDetails

Defined in TcType

Methods

ppr :: MetaDetails -> SDoc

pprPrec :: Rational -> MetaDetails -> SDoc

data MetaInfo

Instances

Outputable MetaInfo

Defined in TcType

Methods

ppr :: MetaInfo -> SDoc

pprPrec :: Rational -> MetaInfo -> SDoc

isSkolemTyVar :: TcTyVar -> Bool

isMetaTyVar :: TcTyVar -> Bool

isFilledMetaTyVar_maybe :: TcTyVar -> TcM (Maybe Type)

writeMetaTyVar :: TcTyVar -> TcType -> TcM ()

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

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

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.

evDataConApp :: DataCon -> [Type] -> [EvExpr] -> EvTerm

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

askEvBinds :: TcPluginM Solve EvBindsVar

Ask for the evidence currently gathered by the type-checker.

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

lookupEvBind :: EvBindMap -> EvVar -> Maybe EvBind

eb_lhs :: EvBind -> EvVar

eb_rhs :: EvBind -> EvTerm

newName :: OccName -> TcM Name

mkLocalId :: Name -> Type -> Id

For an explanation of global vs. local Ids, see Var

mkTyVar :: Name -> Kind -> TyVar

ctev_pred :: CtEvidence -> TcPredType

ctev_evar :: CtEvidence -> EvVar

ctev_loc :: CtEvidence -> CtLoc

ctev_dest :: CtEvidence -> TcEvDest

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.

For instance, we can apply the class data constructor using mkCoreConApps. Remember that the type-level arguments (the typeclass variables) come first, before the actual evidence term (the class dictionary expression).

classDataCon :: Class -> DataCon

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.

The plugin can also emit additional wanted constraints.

Fields

• tcPluginReduction :: !Reduction
• tcRewriterWanteds :: [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 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

The type-family rewriting environment.

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.

Constructors

Reduction

Fields

• reductionCoercion :: Coercion
• reductionReducedType :: !Type

Instances

Outputable Reduction

Defined in GHC.TcPlugin.API.Internal.Shim.Reduction

Methods

ppr :: Reduction -> SDoc

pprPrec :: Rational -> 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

Eq Unique

Defined in Unique

Methods

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

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

Show Unique

Defined in Unique

Methods

showsPrec :: Int -> Unique -> ShowS

show :: Unique -> String

showList :: [Unique] -> ShowS

Uniquable Unique

Defined in Unique

Methods

getUnique :: Unique -> Unique

Outputable Unique

Defined in Unique

Methods

ppr :: Unique -> SDoc

pprPrec :: Rational -> Unique -> SDoc

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

mkInvisFunTyMany :: Type -> Type -> Type

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

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

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.

Panicking

It is often better for type-checking plugins to panic when encountering a problem, as opposed to silently doing something wrong. Use pprPanic to throw an informative error message, so that users of your plugin can report an issue if a problem occurs.

panic :: String -> a

Panics and asserts.

pprPanic :: HasCallStack => String -> SDoc -> a

Throw an exception saying "bug in GHC"

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 ele

Type of unique deterministic finite maps

Instances

Functor UniqDFM

Defined in UniqDFM

Methods

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

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

Foldable UniqDFM

Deterministic, in O(n log n).

Defined in UniqDFM

Methods

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

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

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

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

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

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

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

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

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

toList :: UniqDFM a -> [a]

null :: UniqDFM a -> Bool

length :: UniqDFM a -> Int

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

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

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

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

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

Traversable UniqDFM

Deterministic, in O(n log n).

Defined in UniqDFM

Methods

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

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

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

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

TrieMap UniqDFM

Defined in TrieMap

Associated Types

type Key UniqDFM

Methods

emptyTM :: UniqDFM a

lookupTM :: Key UniqDFM -> UniqDFM b -> Maybe b

alterTM :: Key UniqDFM -> XT b -> UniqDFM b -> UniqDFM b

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

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

Data ele => Data (UniqDFM ele)

Defined in UniqDFM

Methods

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

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

toConstr :: UniqDFM ele -> Constr

dataTypeOf :: UniqDFM ele -> DataType

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

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

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

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

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

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

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

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

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

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

Semigroup (UniqDFM a)

Defined in UniqDFM

Methods

(<>) :: UniqDFM a -> UniqDFM a -> UniqDFM a

sconcat :: NonEmpty (UniqDFM a) -> UniqDFM a

stimes :: Integral b => b -> UniqDFM a -> UniqDFM a

Monoid (UniqDFM a)

Defined in UniqDFM

Methods

mempty :: UniqDFM a

mappend :: UniqDFM a -> UniqDFM a -> UniqDFM a

mconcat :: [UniqDFM a] -> UniqDFM a

Outputable a => Outputable (UniqDFM a)

Defined in UniqDFM

Methods

ppr :: UniqDFM a -> SDoc

pprPrec :: Rational -> UniqDFM a -> SDoc

type Key UniqDFM

Defined in TrieMap

type Key UniqDFM = Unique

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

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

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

type UniqFM ty a = UniqFM a

emptyUFM :: UniqFM elt

listToUFM :: Uniquable key => [(key, elt)] -> UniqFM 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.

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

Eq Name

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

Defined in Name

Methods

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

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

Data Name

Defined in Name

Methods

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

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

toConstr :: Name -> Constr

dataTypeOf :: Name -> DataType

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

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

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

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

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

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

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

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

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

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

Ord Name

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

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

Defined in Name

Methods

compare :: Name -> Name -> Ordering

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

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

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

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

max :: Name -> Name -> Name

min :: Name -> Name -> Name

NFData Name

Defined in Name

Methods

rnf :: Name -> ()

NamedThing Name

Defined in Name

Methods

getOccName :: Name -> OccName

getName :: Name -> Name

HasOccName Name

Defined in Name

Methods

occName :: Name -> OccName

Binary Name

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

Defined in Name

Methods

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

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

get :: BinHandle -> IO Name

Uniquable Name

Defined in Name

Methods

getUnique :: Name -> Unique

HasSrcSpan Name

Defined in Name

Methods

composeSrcSpan :: Located (SrcSpanLess Name) -> Name

decomposeSrcSpan :: Name -> Located (SrcSpanLess Name)

Outputable Name

Defined in Name

Methods

ppr :: Name -> SDoc

pprPrec :: Rational -> Name -> SDoc

OutputableBndr Name

Defined in Name

Methods

pprBndr :: BindingSite -> Name -> SDoc

pprPrefixOcc :: Name -> SDoc

pprInfixOcc :: Name -> SDoc

bndrIsJoin_maybe :: Name -> Maybe Int

type SrcSpanLess Name

Defined in Name

type SrcSpanLess Name = Name

data OccName

Occurrence Name

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

Instances

Eq OccName

Defined in OccName

Methods

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

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

Data OccName

Defined in OccName

Methods

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

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

toConstr :: OccName -> Constr

dataTypeOf :: OccName -> DataType

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

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

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

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

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

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

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

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

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

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

Ord OccName

Defined in OccName

Methods

compare :: OccName -> OccName -> Ordering

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

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

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

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

max :: OccName -> OccName -> OccName

min :: OccName -> OccName -> OccName

NFData OccName

Defined in OccName

Methods

rnf :: OccName -> ()

HasOccName OccName

Defined in OccName

Methods

occName :: OccName -> OccName

Binary OccName

Defined in OccName

Methods

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

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

get :: BinHandle -> IO OccName

Uniquable OccName

Defined in OccName

Methods

getUnique :: OccName -> Unique

Outputable OccName

Defined in OccName

Methods

ppr :: OccName -> SDoc

pprPrec :: Rational -> OccName -> SDoc

OutputableBndr OccName

Defined in OccName

Methods

pprBndr :: BindingSite -> OccName -> SDoc

pprPrefixOcc :: OccName -> SDoc

pprInfixOcc :: OccName -> SDoc

bndrIsJoin_maybe :: OccName -> Maybe Int

data TyThing

A global typecheckable-thing, essentially anything that has a name. Not to be confused with a TcTyThing, which is also a typecheckable thing but in the *local* context. See TcEnv for how to retrieve a TyThing given a Name.

Instances

NamedThing TyThing

Defined in TyCoRep

Methods

getOccName :: TyThing -> OccName

getName :: TyThing -> Name

Outputable TyThing

Defined in TyCoRep

Methods

ppr :: TyThing -> SDoc

pprPrec :: Rational -> TyThing -> SDoc

data TcTyThing

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

Instances

Outputable TcTyThing

Defined in TcRnTypes

Methods

ppr :: TcTyThing -> SDoc

pprPrec :: Rational -> TcTyThing -> SDoc

data Class

Instances

Eq Class

Defined in Class

Methods

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

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

Data Class

Defined in Class

Methods

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

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

toConstr :: Class -> Constr

dataTypeOf :: Class -> DataType

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

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

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

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

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

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

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

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

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

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

NamedThing Class

Defined in Class

Methods

getOccName :: Class -> OccName

getName :: Class -> Name

Uniquable Class

Defined in Class

Methods

getUnique :: Class -> Unique

Outputable Class

Defined in Class

Methods

ppr :: Class -> SDoc

pprPrec :: Rational -> Class -> SDoc

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

Eq DataCon

Defined in DataCon

Methods

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

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

Data DataCon

Defined in DataCon

Methods

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

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

toConstr :: DataCon -> Constr

dataTypeOf :: DataCon -> DataType

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

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

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

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

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

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

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

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

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

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

NamedThing DataCon

Defined in DataCon

Methods

getOccName :: DataCon -> OccName

getName :: DataCon -> Name

Uniquable DataCon

Defined in DataCon

Methods

getUnique :: DataCon -> Unique

Outputable DataCon

Defined in DataCon

Methods

ppr :: DataCon -> SDoc

pprPrec :: Rational -> DataCon -> SDoc

OutputableBndr DataCon

Defined in DataCon

Methods

pprBndr :: BindingSite -> DataCon -> SDoc

pprPrefixOcc :: DataCon -> SDoc

pprInfixOcc :: DataCon -> SDoc

bndrIsJoin_maybe :: DataCon -> Maybe Int

Lookupable (Promoted DataCon)

Defined in GHC.TcPlugin.API.Names

Methods

mkOccName :: String -> OccName

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

Lookupable DataCon

Defined in GHC.TcPlugin.API.Names

Methods

mkOccName :: String -> OccName

lookup :: MonadTcPlugin m => Name -> m (Wear 'Resolved 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

Eq TyCon

Defined in TyCon

Methods

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

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

Data TyCon

Defined in TyCon

Methods

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

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

toConstr :: TyCon -> Constr

dataTypeOf :: TyCon -> DataType

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

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

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

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

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

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

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

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

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

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

NamedThing TyCon

Defined in TyCon

Methods

getOccName :: TyCon -> OccName

getName :: TyCon -> Name

Uniquable TyCon

Defined in TyCon

Methods

getUnique :: TyCon -> Unique

Outputable TyCon

Defined in TyCon

Methods

ppr :: TyCon -> SDoc

pprPrec :: Rational -> TyCon -> SDoc

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

Eq FastString

Defined in FastString

Methods

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

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

Data FastString

Defined in FastString

Methods

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

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

toConstr :: FastString -> Constr

dataTypeOf :: FastString -> DataType

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

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

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

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

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

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

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

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

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

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

Ord FastString

Defined in FastString

Methods

compare :: FastString -> FastString -> Ordering

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

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

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

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

max :: FastString -> FastString -> FastString

min :: FastString -> FastString -> FastString

Show FastString

Defined in FastString

Methods

showsPrec :: Int -> FastString -> ShowS

show :: FastString -> String

showList :: [FastString] -> ShowS

IsString FastString

Defined in FastString

Methods

fromString :: String -> FastString

Semigroup FastString

Defined in FastString

Methods

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

sconcat :: NonEmpty FastString -> FastString

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

Monoid FastString

Defined in FastString

Methods

mempty :: FastString

mappend :: FastString -> FastString -> FastString

mconcat :: [FastString] -> FastString

NFData FastString

Defined in FastString

Methods

rnf :: FastString -> ()

Uniquable FastString

Defined in Unique

Methods

getUnique :: FastString -> Unique

Outputable FastString

Defined in Outputable

Methods

ppr :: FastString -> SDoc

pprPrec :: Rational -> FastString -> SDoc

Constraints

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

Eq EqRel

Defined in Predicate

Methods

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

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

Ord EqRel

Defined in 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

Outputable EqRel

Defined in Predicate

Methods

ppr :: EqRel -> SDoc

pprPrec :: Rational -> EqRel -> SDoc

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

data CtFlavour

Instances

Eq CtFlavour

Defined in Constraint

Methods

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

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

Outputable CtFlavour

Defined in Constraint

Methods

ppr :: CtFlavour -> SDoc

pprPrec :: Rational -> CtFlavour -> SDoc

data Ct

Instances

Outputable Ct

Defined in Constraint

Methods

ppr :: Ct -> SDoc

pprPrec :: Rational -> Ct -> SDoc

data CtLoc

data CtEvidence

Instances

Outputable CtEvidence

Defined in Constraint

Methods

ppr :: CtEvidence -> SDoc

pprPrec :: Rational -> CtEvidence -> SDoc

data CtOrigin

Instances

Outputable CtOrigin

Defined in TcOrigin

Methods

ppr :: CtOrigin -> SDoc

pprPrec :: Rational -> CtOrigin -> SDoc

data QCInst

Instances

Outputable QCInst

Defined in Constraint

Methods

ppr :: QCInst -> SDoc

pprPrec :: Rational -> QCInst -> SDoc

data Type

Instances

Data Type

Defined in TyCoRep

Methods

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

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

toConstr :: Type -> Constr

dataTypeOf :: Type -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable Type

Defined in TyCoRep

Methods

ppr :: Type -> SDoc

pprPrec :: Rational -> Type -> SDoc

Eq (DeBruijn Type)

Defined in CoreMap

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

Eq TcLevel

Defined in TcType

Methods

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

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

Ord TcLevel

Defined in 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

Outputable TcLevel

Defined in TcType

Methods

ppr :: TcLevel -> SDoc

pprPrec :: Rational -> TcLevel -> SDoc

Coercions and evidence

data Coercion

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

Instances

Data Coercion

Defined in TyCoRep

Methods

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

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

toConstr :: Coercion -> Constr

dataTypeOf :: Coercion -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable Coercion

Defined in TyCoRep

Methods

ppr :: Coercion -> SDoc

pprPrec :: Rational -> Coercion -> SDoc

Eq (DeBruijn Coercion)

Defined in CoreMap

Methods

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

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

data Role

Constructors

Nominal

Representational

Phantom

Instances

Eq Role

Defined in CoAxiom

Methods

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

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

Data Role

Defined in CoAxiom

Methods

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

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

toConstr :: Role -> Constr

dataTypeOf :: Role -> DataType

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

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

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

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

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

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

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

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

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

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

Ord Role

Defined in CoAxiom

Methods

compare :: Role -> Role -> Ordering

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

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

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

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

max :: Role -> Role -> Role

min :: Role -> Role -> Role

Binary Role

Defined in CoAxiom

Methods

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

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

get :: BinHandle -> IO Role

Outputable Role

Defined in CoAxiom

Methods

ppr :: Role -> SDoc

pprPrec :: Rational -> Role -> SDoc

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 TyCoRep

Methods

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

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

toConstr :: UnivCoProvenance -> Constr

dataTypeOf :: UnivCoProvenance -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable UnivCoProvenance

Defined in TyCoRep

Methods

ppr :: UnivCoProvenance -> SDoc

pprPrec :: Rational -> UnivCoProvenance -> SDoc

data CoercionHole

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

Constructors

CoercionHole

Fields

• ch_co_var :: CoVar
• ch_ref :: IORef (Maybe Coercion)

Instances

Data CoercionHole

Defined in TyCoRep

Methods

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

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

toConstr :: CoercionHole -> Constr

dataTypeOf :: CoercionHole -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable CoercionHole

Defined in TyCoRep

Methods

ppr :: CoercionHole -> SDoc

pprPrec :: Rational -> CoercionHole -> SDoc

data EvBind

Instances

Outputable EvBind

Defined in TcEvidence

Methods

ppr :: EvBind -> SDoc

pprPrec :: Rational -> EvBind -> SDoc

data EvTerm

Constructors

EvExpr EvExpr

Instances

Data EvTerm

Defined in TcEvidence

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 TcEvidence

Methods

ppr :: EvTerm -> SDoc

pprPrec :: Rational -> EvTerm -> SDoc

type EvVar = EvId

Evidence Variable

type EvExpr = CoreExpr

data EvBindsVar

Instances

Uniquable EvBindsVar

Defined in TcEvidence

Methods

getUnique :: EvBindsVar -> Unique

Outputable EvBindsVar

Defined in TcEvidence

Methods

ppr :: EvBindsVar -> SDoc

pprPrec :: Rational -> EvBindsVar -> SDoc

data Expr b

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

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

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

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

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

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

But see Note [Shadowing] below.

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

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

The language consists of the following elements:

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

See Note [CoreSyn letrec invariant] See Note [CoreSyn let/app invariant] See Note [Levity polymorphism invariants] See Note [CoreSyn type and coercion invariant]

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

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

IMPORTANT: see Note [Case expression invariants]

• Cast an expression to a particular type. This is used to implement newtypes (a newtype constructor or destructor just becomes a Cast in Core) and GADTs.
• Notes. These allow general information to be added to expressions in the syntax tree
• A type: this should only show up at the top level of an Arg
• A coercion

Constructors

Var Id

Type Type

Coercion Coercion

Instances

Eq (DeBruijn CoreExpr)

Defined in CoreMap

Methods

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

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

Eq (DeBruijn CoreAlt)

Defined in CoreMap

Methods

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

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

Data b => Data (Expr b)

Defined in CoreSyn

Methods

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

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

toConstr :: Expr b -> Constr

dataTypeOf :: Expr b -> DataType

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

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

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

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

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

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

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

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

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

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

type CoreBndr = Var

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

data TcEvDest

A place for type-checking evidence to go after it is generated. Wanted equalities are always HoleDest; other wanteds are always EvVarDest.

Constructors

EvVarDest EvVar

bind this var to the evidence EvVarDest is always used for non-type-equalities e.g. class constraints

HoleDest CoercionHole

fill in this hole with the evidence HoleDest is always used for type-equalities See Note [Coercion holes] in TyCoRep

Instances

Outputable TcEvDest

Defined in Constraint

Methods

ppr :: TcEvDest -> SDoc

pprPrec :: Rational -> TcEvDest -> 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

ContainsCostCentreState TcGblEnv

Defined in TcRnMonad

Methods

extractCostCentreState :: TcGblEnv -> TcRef CostCentreState

ContainsModule TcGblEnv

Defined in TcRnTypes

Methods

extractModule :: TcGblEnv -> Module

data TcLclEnv

Source locations

data GenLocated l e

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

Constructors

L l e

Instances

Functor (GenLocated l)

Defined in SrcLoc

Methods

fmap :: (a -> b) -> GenLocated l a -> GenLocated l b

(<$) :: a -> GenLocated l b -> GenLocated l a

Foldable (GenLocated l)

Defined in SrcLoc

Methods

fold :: Monoid m => GenLocated l m -> m

foldMap :: Monoid m => (a -> m) -> GenLocated l a -> m

foldMap' :: Monoid m => (a -> m) -> GenLocated l a -> m

foldr :: (a -> b -> b) -> b -> GenLocated l a -> b

foldr' :: (a -> b -> b) -> b -> GenLocated l a -> b

foldl :: (b -> a -> b) -> b -> GenLocated l a -> b

foldl' :: (b -> a -> b) -> b -> GenLocated l a -> b

foldr1 :: (a -> a -> a) -> GenLocated l a -> a

foldl1 :: (a -> a -> a) -> GenLocated l a -> a

toList :: GenLocated l a -> [a]

null :: GenLocated l a -> Bool

length :: GenLocated l a -> Int

elem :: Eq a => a -> GenLocated l a -> Bool

maximum :: Ord a => GenLocated l a -> a

minimum :: Ord a => GenLocated l a -> a

sum :: Num a => GenLocated l a -> a

product :: Num a => GenLocated l a -> a

Traversable (GenLocated l)

Defined in SrcLoc

Methods

traverse :: Applicative f => (a -> f b) -> GenLocated l a -> f (GenLocated l b)

sequenceA :: Applicative f => GenLocated l (f a) -> f (GenLocated l a)

mapM :: Monad m => (a -> m b) -> GenLocated l a -> m (GenLocated l b)

sequence :: Monad m => GenLocated l (m a) -> m (GenLocated l a)

NamedThing e => NamedThing (Located e)

Defined in Name

Methods

getOccName :: Located e -> OccName

getName :: Located e -> Name

HasSrcSpan (Located a)

Defined in SrcLoc

Methods

composeSrcSpan :: Located (SrcSpanLess (Located a)) -> Located a

decomposeSrcSpan :: Located a -> Located (SrcSpanLess (Located a))

(Eq l, Eq e) => Eq (GenLocated l e)

Defined in SrcLoc

Methods

(==) :: GenLocated l e -> GenLocated l e -> Bool

(/=) :: GenLocated l e -> GenLocated l e -> Bool

(Data l, Data e) => Data (GenLocated l e)

Defined in SrcLoc

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GenLocated l e -> c (GenLocated l e)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GenLocated l e)

toConstr :: GenLocated l e -> Constr

dataTypeOf :: GenLocated l e -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GenLocated l e))

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

gmapT :: (forall b. Data b => b -> b) -> GenLocated l e -> GenLocated l e

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GenLocated l e -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GenLocated l e -> r

gmapQ :: (forall d. Data d => d -> u) -> GenLocated l e -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> GenLocated l e -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GenLocated l e -> m (GenLocated l e)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GenLocated l e -> m (GenLocated l e)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GenLocated l e -> m (GenLocated l e)

(Ord l, Ord e) => Ord (GenLocated l e)

Defined in SrcLoc

Methods

compare :: GenLocated l e -> GenLocated l e -> Ordering

(<) :: GenLocated l e -> GenLocated l e -> Bool

(<=) :: GenLocated l e -> GenLocated l e -> Bool

(>) :: GenLocated l e -> GenLocated l e -> Bool

(>=) :: GenLocated l e -> GenLocated l e -> Bool

max :: GenLocated l e -> GenLocated l e -> GenLocated l e

min :: GenLocated l e -> GenLocated l e -> GenLocated l e

(Outputable l, Outputable e) => Outputable (GenLocated l e)

Defined in SrcLoc

Methods

ppr :: GenLocated l e -> SDoc

pprPrec :: Rational -> GenLocated l e -> SDoc

type SrcSpanLess (GenLocated l e)

Defined in SrcLoc

type SrcSpanLess (GenLocated l e) = e

type Located = GenLocated SrcSpan

type RealLocated = GenLocated RealSrcSpan

unLoc :: HasSrcSpan a => a -> SrcSpanLess a

getLoc :: HasSrcSpan a => a -> SrcSpan

Pretty-printing

data SDoc

Represents a pretty-printable document.

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

Instances

IsString SDoc

Defined in Outputable

Methods

fromString :: String -> SDoc

Outputable SDoc

Defined in Outputable

Methods

ppr :: SDoc -> SDoc

pprPrec :: Rational -> SDoc -> SDoc

class Outputable a where

Class designating that some type has an SDoc representation

Minimal complete definition

Nothing

Methods

ppr :: a -> SDoc

pprPrec :: Rational -> a -> SDoc

Instances

Outputable Bool

Defined in Outputable

Methods

ppr :: Bool -> SDoc

pprPrec :: Rational -> Bool -> SDoc

Outputable Char

Defined in Outputable

Methods

ppr :: Char -> SDoc

pprPrec :: Rational -> Char -> SDoc

Outputable Double

Defined in Outputable

Methods

ppr :: Double -> SDoc

pprPrec :: Rational -> Double -> SDoc

Outputable Float

Defined in Outputable

Methods

ppr :: Float -> SDoc

pprPrec :: Rational -> Float -> SDoc

Outputable Int

Defined in Outputable

Methods

ppr :: Int -> SDoc

pprPrec :: Rational -> Int -> SDoc

Outputable Int32

Defined in Outputable

Methods

ppr :: Int32 -> SDoc

pprPrec :: Rational -> Int32 -> SDoc

Outputable Int64

Defined in Outputable

Methods

ppr :: Int64 -> SDoc

pprPrec :: Rational -> Int64 -> SDoc

Outputable Integer

Defined in Outputable

Methods

ppr :: Integer -> SDoc

pprPrec :: Rational -> Integer -> SDoc

Outputable Ordering

Defined in Outputable

Methods

ppr :: Ordering -> SDoc

pprPrec :: Rational -> Ordering -> SDoc

Outputable Word

Defined in Outputable

Methods

ppr :: Word -> SDoc

pprPrec :: Rational -> Word -> SDoc

Outputable Word16

Defined in Outputable

Methods

ppr :: Word16 -> SDoc

pprPrec :: Rational -> Word16 -> SDoc

Outputable Word32

Defined in Outputable

Methods

ppr :: Word32 -> SDoc

pprPrec :: Rational -> Word32 -> SDoc

Outputable ()

Defined in Outputable

Methods

ppr :: () -> SDoc

pprPrec :: Rational -> () -> SDoc

Outputable Fingerprint

Defined in Outputable

Methods

ppr :: Fingerprint -> SDoc

pprPrec :: Rational -> Fingerprint -> SDoc

Outputable Serialized

Defined in Outputable

Methods

ppr :: Serialized -> SDoc

pprPrec :: Rational -> Serialized -> SDoc

Outputable Extension

Defined in Outputable

Methods

ppr :: Extension -> SDoc

pprPrec :: Rational -> Extension -> SDoc

Outputable CoreModule

Defined in GHC

Methods

ppr :: CoreModule -> SDoc

pprPrec :: Rational -> CoreModule -> SDoc

Outputable WorkList

Defined in TcSMonad

Methods

ppr :: WorkList -> SDoc

pprPrec :: Rational -> WorkList -> SDoc

Outputable InertSet

Defined in TcSMonad

Methods

ppr :: InertSet -> SDoc

pprPrec :: Rational -> InertSet -> SDoc

Outputable InertCans

Defined in TcSMonad

Methods

ppr :: InertCans -> SDoc

pprPrec :: Rational -> InertCans -> SDoc

Outputable DsMatchContext

Defined in DsMonad

Methods

ppr :: DsMatchContext -> SDoc

pprPrec :: Rational -> DsMatchContext -> SDoc

Outputable EquationInfo

Defined in DsMonad

Methods

ppr :: EquationInfo -> SDoc

pprPrec :: Rational -> EquationInfo -> SDoc

Outputable TypedHole

Defined in TcHoleFitTypes

Methods

ppr :: TypedHole -> SDoc

pprPrec :: Rational -> TypedHole -> SDoc

Outputable HoleFitCandidate

Defined in TcHoleFitTypes

Methods

ppr :: HoleFitCandidate -> SDoc

pprPrec :: Rational -> HoleFitCandidate -> SDoc

Outputable HoleFit

Defined in TcHoleFitTypes

Methods

ppr :: HoleFit -> SDoc

pprPrec :: Rational -> HoleFit -> SDoc

Outputable CandidatesQTvs

Defined in TcMType

Methods

ppr :: CandidatesQTvs -> SDoc

pprPrec :: Rational -> CandidatesQTvs -> SDoc

Outputable TcBinder

Defined in TcRnTypes

Methods

ppr :: TcBinder -> SDoc

pprPrec :: Rational -> TcBinder -> SDoc

Outputable ThStage

Defined in TcRnTypes

Methods

ppr :: ThStage -> SDoc

pprPrec :: Rational -> ThStage -> SDoc

Outputable TcTyThing

Defined in TcRnTypes

Methods

ppr :: TcTyThing -> SDoc

pprPrec :: Rational -> TcTyThing -> SDoc

Outputable PromotionErr

Defined in TcRnTypes

Methods

ppr :: PromotionErr -> SDoc

pprPrec :: Rational -> PromotionErr -> SDoc

Outputable IdBindingInfo

Defined in TcRnTypes

Methods

ppr :: IdBindingInfo -> SDoc

pprPrec :: Rational -> IdBindingInfo -> SDoc

Outputable WhereFrom

Defined in TcRnTypes

Methods

ppr :: WhereFrom -> SDoc

pprPrec :: Rational -> WhereFrom -> SDoc

Outputable TcSigInfo

Defined in TcRnTypes

Methods

ppr :: TcSigInfo -> SDoc

pprPrec :: Rational -> TcSigInfo -> SDoc

Outputable TcIdSigInfo

Defined in TcRnTypes

Methods

ppr :: TcIdSigInfo -> SDoc

pprPrec :: Rational -> TcIdSigInfo -> SDoc

Outputable TcIdSigInst

Defined in TcRnTypes

Methods

ppr :: TcIdSigInst -> SDoc

pprPrec :: Rational -> TcIdSigInst -> SDoc

Outputable TcPatSynInfo

Defined in TcRnTypes

Methods

ppr :: TcPatSynInfo -> SDoc

pprPrec :: Rational -> TcPatSynInfo -> SDoc

Outputable Ct

Defined in Constraint

Methods

ppr :: Ct -> SDoc

pprPrec :: Rational -> Ct -> SDoc

Outputable QCInst

Defined in Constraint

Methods

ppr :: QCInst -> SDoc

pprPrec :: Rational -> QCInst -> SDoc

Outputable Hole

Defined in Constraint

Methods

ppr :: Hole -> SDoc

pprPrec :: Rational -> Hole -> SDoc

Outputable WantedConstraints

Defined in Constraint

Methods

ppr :: WantedConstraints -> SDoc

pprPrec :: Rational -> WantedConstraints -> SDoc

Outputable Implication

Defined in Constraint

Methods

ppr :: Implication -> SDoc

pprPrec :: Rational -> Implication -> SDoc

Outputable ImplicStatus

Defined in Constraint

Methods

ppr :: ImplicStatus -> SDoc

pprPrec :: Rational -> ImplicStatus -> SDoc

Outputable TcEvDest

Defined in Constraint

Methods

ppr :: TcEvDest -> SDoc

pprPrec :: Rational -> TcEvDest -> SDoc

Outputable CtEvidence

Defined in Constraint

Methods

ppr :: CtEvidence -> SDoc

pprPrec :: Rational -> CtEvidence -> SDoc

Outputable CtFlavour

Defined in Constraint

Methods

ppr :: CtFlavour -> SDoc

pprPrec :: Rational -> CtFlavour -> SDoc

Outputable SubGoalDepth

Defined in Constraint

Methods

ppr :: SubGoalDepth -> SDoc

pprPrec :: Rational -> SubGoalDepth -> SDoc

Outputable FloatBind

Defined in MkCore

Methods

ppr :: FloatBind -> SDoc

pprPrec :: Rational -> FloatBind -> SDoc

Outputable Target

Defined in HscTypes

Methods

ppr :: Target -> SDoc

pprPrec :: Rational -> Target -> SDoc

Outputable TargetId

Defined in HscTypes

Methods

ppr :: TargetId -> SDoc

pprPrec :: Rational -> TargetId -> SDoc

Outputable InteractiveImport

Defined in HscTypes

Methods

ppr :: InteractiveImport -> SDoc

pprPrec :: Rational -> InteractiveImport -> SDoc

Outputable FixItem

Defined in HscTypes

Methods

ppr :: FixItem -> SDoc

pprPrec :: Rational -> FixItem -> SDoc

Outputable ModSummary

Defined in HscTypes

Methods

ppr :: ModSummary -> SDoc

pprPrec :: Rational -> ModSummary -> SDoc

Outputable IfaceTrustInfo

Defined in HscTypes

Methods

ppr :: IfaceTrustInfo -> SDoc

pprPrec :: Rational -> IfaceTrustInfo -> SDoc

Outputable CompleteMatch

Defined in HscTypes

Methods

ppr :: CompleteMatch -> SDoc

pprPrec :: Rational -> CompleteMatch -> SDoc

Outputable TyEl

Defined in RdrHsSyn

Methods

ppr :: TyEl -> SDoc

pprPrec :: Rational -> TyEl -> SDoc

Outputable SkolemInfo

Defined in TcOrigin

Methods

ppr :: SkolemInfo -> SDoc

pprPrec :: Rational -> SkolemInfo -> SDoc

Outputable CtOrigin

Defined in TcOrigin

Methods

ppr :: CtOrigin -> SDoc

pprPrec :: Rational -> CtOrigin -> SDoc

Outputable UnboundVar

Defined in GHC.Hs.Expr

Methods

ppr :: UnboundVar -> SDoc

pprPrec :: Rational -> UnboundVar -> SDoc

Outputable SpliceDecoration

Defined in GHC.Hs.Expr

Methods

ppr :: SpliceDecoration -> SDoc

pprPrec :: Rational -> SpliceDecoration -> SDoc

Outputable PendingRnSplice

Defined in GHC.Hs.Expr

Methods

ppr :: PendingRnSplice -> SDoc

pprPrec :: Rational -> PendingRnSplice -> SDoc

Outputable PendingTcSplice

Defined in GHC.Hs.Expr

Methods

ppr :: PendingTcSplice -> SDoc

pprPrec :: Rational -> PendingTcSplice -> SDoc

Outputable NewOrData

Defined in GHC.Hs.Decls

Methods

ppr :: NewOrData -> SDoc

pprPrec :: Rational -> NewOrData -> SDoc

Outputable ForeignImport

Defined in GHC.Hs.Decls

Methods

ppr :: ForeignImport -> SDoc

pprPrec :: Rational -> ForeignImport -> SDoc

Outputable ForeignExport

Defined in GHC.Hs.Decls

Methods

ppr :: ForeignExport -> SDoc

pprPrec :: Rational -> ForeignExport -> SDoc

Outputable DocDecl

Defined in GHC.Hs.Decls

Methods

ppr :: DocDecl -> SDoc

pprPrec :: Rational -> DocDecl -> SDoc

Outputable TcSpecPrag

Defined in GHC.Hs.Binds

Methods

ppr :: TcSpecPrag -> SDoc

pprPrec :: Rational -> TcSpecPrag -> SDoc

Outputable HsWrapper

Defined in TcEvidence

Methods

ppr :: HsWrapper -> SDoc

pprPrec :: Rational -> HsWrapper -> SDoc

Outputable TcEvBinds

Defined in TcEvidence

Methods

ppr :: TcEvBinds -> SDoc

pprPrec :: Rational -> TcEvBinds -> SDoc

Outputable EvBindsVar

Defined in TcEvidence

Methods

ppr :: EvBindsVar -> SDoc

pprPrec :: Rational -> EvBindsVar -> SDoc

Outputable EvBindMap

Defined in TcEvidence

Methods

ppr :: EvBindMap -> SDoc

pprPrec :: Rational -> EvBindMap -> SDoc

Outputable EvBind

Defined in TcEvidence

Methods

ppr :: EvBind -> SDoc

pprPrec :: Rational -> EvBind -> SDoc

Outputable EvTerm

Defined in TcEvidence

Methods

ppr :: EvTerm -> SDoc

pprPrec :: Rational -> EvTerm -> SDoc

Outputable EvTypeable

Defined in TcEvidence

Methods

ppr :: EvTypeable -> SDoc

pprPrec :: Rational -> EvTypeable -> SDoc

Outputable EvCallStack

Defined in TcEvidence

Methods

ppr :: EvCallStack -> SDoc

pprPrec :: Rational -> EvCallStack -> SDoc

Outputable Skeleton

Defined in StgLiftLams.Analysis

Methods

ppr :: Skeleton -> SDoc

pprPrec :: Rational -> Skeleton -> SDoc

Outputable BinderInfo

Defined in StgLiftLams.Analysis

Methods

ppr :: BinderInfo -> SDoc

pprPrec :: Rational -> BinderInfo -> SDoc

Outputable ClsInst

Defined in InstEnv

Methods

ppr :: ClsInst -> SDoc

pprPrec :: Rational -> ClsInst -> SDoc

Outputable ExpType

Defined in TcType

Methods

ppr :: ExpType -> SDoc

pprPrec :: Rational -> ExpType -> SDoc

Outputable InferResult

Defined in TcType

Methods

ppr :: InferResult -> SDoc

pprPrec :: Rational -> InferResult -> SDoc

Outputable MetaInfo

Defined in TcType

Methods

ppr :: MetaInfo -> SDoc

pprPrec :: Rational -> MetaInfo -> SDoc

Outputable TcLevel

Defined in TcType

Methods

ppr :: TcLevel -> SDoc

pprPrec :: Rational -> TcLevel -> SDoc

Outputable FamInst

Defined in FamInstEnv

Methods

ppr :: FamInst -> SDoc

pprPrec :: Rational -> FamInst -> SDoc

Outputable FamInstMatch

Defined in FamInstEnv

Methods

ppr :: FamInstMatch -> SDoc

pprPrec :: Rational -> FamInstMatch -> SDoc

Outputable StgArg

Defined in StgSyn

Methods

ppr :: StgArg -> SDoc

pprPrec :: Rational -> StgArg -> SDoc

Outputable NoExtFieldSilent

Defined in StgSyn

Methods

ppr :: NoExtFieldSilent -> SDoc

pprPrec :: Rational -> NoExtFieldSilent -> SDoc

Outputable AltType

Defined in StgSyn

Methods

ppr :: AltType -> SDoc

pprPrec :: Rational -> AltType -> SDoc

Outputable UpdateFlag

Defined in StgSyn

Methods

ppr :: UpdateFlag -> SDoc

pprPrec :: Rational -> UpdateFlag -> SDoc

Outputable HsIPName

Defined in GHC.Hs.Types

Methods

ppr :: HsIPName -> SDoc

pprPrec :: Rational -> HsIPName -> SDoc

Outputable NewHsTypeX

Defined in GHC.Hs.Types

Methods

ppr :: NewHsTypeX -> SDoc

pprPrec :: Rational -> NewHsTypeX -> SDoc

Outputable HsTyLit

Defined in GHC.Hs.Types

Methods

ppr :: HsTyLit -> SDoc

pprPrec :: Rational -> HsTyLit -> SDoc

Outputable AltCon

Defined in CoreSyn

Methods

ppr :: AltCon -> SDoc

pprPrec :: Rational -> AltCon -> SDoc

Outputable HsSrcBang

Defined in DataCon

Methods

ppr :: HsSrcBang -> SDoc

pprPrec :: Rational -> HsSrcBang -> SDoc

Outputable HsImplBang

Defined in DataCon

Methods

ppr :: HsImplBang -> SDoc

pprPrec :: Rational -> HsImplBang -> SDoc

Outputable SrcStrictness

Defined in DataCon

Methods

ppr :: SrcStrictness -> SDoc

pprPrec :: Rational -> SrcStrictness -> SDoc

Outputable SrcUnpackedness

Defined in DataCon

Methods

ppr :: SrcUnpackedness -> SDoc

pprPrec :: Rational -> SrcUnpackedness -> SDoc

Outputable StrictnessMark

Defined in DataCon

Methods

ppr :: StrictnessMark -> SDoc

pprPrec :: Rational -> StrictnessMark -> SDoc

Outputable EqRel

Defined in Predicate

Methods

ppr :: EqRel -> SDoc

pprPrec :: Rational -> EqRel -> SDoc

Outputable OverLitVal

Defined in GHC.Hs.Lit

Methods

ppr :: OverLitVal -> SDoc

pprPrec :: Rational -> OverLitVal -> SDoc

Outputable Label

Defined in Hoopl.Label

Methods

ppr :: Label -> SDoc

pprPrec :: Rational -> Label -> SDoc

Outputable LabelSet

Defined in Hoopl.Label

Methods

ppr :: LabelSet -> SDoc

pprPrec :: Rational -> LabelSet -> SDoc

Outputable CoercionHole

Defined in TyCoRep

Methods

ppr :: CoercionHole -> SDoc

pprPrec :: Rational -> CoercionHole -> SDoc

Outputable TyConBndrVis

Defined in TyCon

Methods

ppr :: TyConBndrVis -> SDoc

pprPrec :: Rational -> TyConBndrVis -> SDoc

Outputable AlgTyConFlav

Defined in TyCon

Methods

ppr :: AlgTyConFlav -> SDoc

pprPrec :: Rational -> AlgTyConFlav -> SDoc

Outputable FamTyConFlav

Defined in TyCon

Methods

ppr :: FamTyConFlav -> SDoc

pprPrec :: Rational -> FamTyConFlav -> SDoc

Outputable PrimRep

Defined in TyCon

Methods

ppr :: PrimRep -> SDoc

pprPrec :: Rational -> PrimRep -> SDoc

Outputable PrimElemRep

Defined in TyCon

Methods

ppr :: PrimElemRep -> SDoc

pprPrec :: Rational -> PrimElemRep -> SDoc

Outputable TyConFlavour

Defined in TyCon

Methods

ppr :: TyConFlavour -> SDoc

pprPrec :: Rational -> TyConFlavour -> SDoc

Outputable InScopeSet

Defined in VarEnv

Methods

ppr :: InScopeSet -> SDoc

pprPrec :: Rational -> InScopeSet -> SDoc

Outputable Class

Defined in Class

Methods

ppr :: Class -> SDoc

pprPrec :: Rational -> Class -> SDoc

Outputable LiftingContext

Defined in Coercion

Methods

ppr :: LiftingContext -> SDoc

pprPrec :: Rational -> LiftingContext -> SDoc

Outputable CoAxBranch

Defined in CoAxiom

Methods

ppr :: CoAxBranch -> SDoc

pprPrec :: Rational -> CoAxBranch -> SDoc

Outputable Role

Defined in CoAxiom

Methods

ppr :: Role -> SDoc

pprPrec :: Rational -> Role -> SDoc

Outputable CoAxiomRule

Defined in CoAxiom

Methods

ppr :: CoAxiomRule -> SDoc

pprPrec :: Rational -> CoAxiomRule -> SDoc

Outputable DataCon

Defined in DataCon

Methods

ppr :: DataCon -> SDoc

pprPrec :: Rational -> DataCon -> SDoc

Outputable EqSpec

Defined in DataCon

Methods

ppr :: EqSpec -> SDoc

pprPrec :: Rational -> EqSpec -> SDoc

Outputable NoExtField

Defined in GHC.Hs.Extension

Methods

ppr :: NoExtField -> SDoc

pprPrec :: Rational -> NoExtField -> SDoc

Outputable NoExtCon

Defined in GHC.Hs.Extension

Methods

ppr :: NoExtCon -> SDoc

pprPrec :: Rational -> NoExtCon -> SDoc

Outputable PatSyn

Defined in PatSyn

Methods

ppr :: PatSyn -> SDoc

pprPrec :: Rational -> PatSyn -> SDoc

Outputable ForallVisFlag

Defined in Var

Methods

ppr :: ForallVisFlag -> SDoc

pprPrec :: Rational -> ForallVisFlag -> SDoc

Outputable Annotation

Defined in Annotations

Methods

ppr :: Annotation -> SDoc

pprPrec :: Rational -> Annotation -> SDoc

Outputable RdrName

Defined in RdrName

Methods

ppr :: RdrName -> SDoc

pprPrec :: Rational -> RdrName -> SDoc

Outputable LocalRdrEnv

Defined in RdrName

Methods

ppr :: LocalRdrEnv -> SDoc

pprPrec :: Rational -> LocalRdrEnv -> SDoc

Outputable GlobalRdrElt

Defined in RdrName

Methods

ppr :: GlobalRdrElt -> SDoc

pprPrec :: Rational -> GlobalRdrElt -> SDoc

Outputable Parent

Defined in RdrName

Methods

ppr :: Parent -> SDoc

pprPrec :: Rational -> Parent -> SDoc

Outputable ImportSpec

Defined in RdrName

Methods

ppr :: ImportSpec -> SDoc

pprPrec :: Rational -> ImportSpec -> SDoc

Outputable AvailInfo

Defined in Avail

Methods

ppr :: AvailInfo -> SDoc

pprPrec :: Rational -> AvailInfo -> SDoc

Outputable HsDocString

Defined in GHC.Hs.Doc

Methods

ppr :: HsDocString -> SDoc

pprPrec :: Rational -> HsDocString -> SDoc

Outputable DeclDocMap

Defined in GHC.Hs.Doc

Methods

ppr :: DeclDocMap -> SDoc

pprPrec :: Rational -> DeclDocMap -> SDoc

Outputable ArgDocMap

Defined in GHC.Hs.Doc

Methods

ppr :: ArgDocMap -> SDoc

pprPrec :: Rational -> ArgDocMap -> SDoc

Outputable ModuleOrigin

Defined in Packages

Methods

ppr :: ModuleOrigin -> SDoc

pprPrec :: Rational -> ModuleOrigin -> SDoc

Outputable UnusablePackageReason

Defined in Packages

Methods

ppr :: UnusablePackageReason -> SDoc

pprPrec :: Rational -> UnusablePackageReason -> SDoc

Outputable Type

Defined in TyCoRep

Methods

ppr :: Type -> SDoc

pprPrec :: Rational -> Type -> SDoc

Outputable TyThing

Defined in TyCoRep

Methods

ppr :: TyThing -> SDoc

pprPrec :: Rational -> TyThing -> SDoc

Outputable Coercion

Defined in TyCoRep

Methods

ppr :: Coercion -> SDoc

pprPrec :: Rational -> Coercion -> SDoc

Outputable UnivCoProvenance

Defined in TyCoRep

Methods

ppr :: UnivCoProvenance -> SDoc

pprPrec :: Rational -> UnivCoProvenance -> SDoc

Outputable TyLit

Defined in TyCoRep

Methods

ppr :: TyLit -> SDoc

pprPrec :: Rational -> TyLit -> SDoc

Outputable TyCoBinder

Defined in TyCoRep

Methods

ppr :: TyCoBinder -> SDoc

pprPrec :: Rational -> TyCoBinder -> SDoc

Outputable MCoercion

Defined in TyCoRep

Methods

ppr :: MCoercion -> SDoc

pprPrec :: Rational -> MCoercion -> SDoc

Outputable ArgFlag

Defined in Var

Methods

ppr :: ArgFlag -> SDoc

pprPrec :: Rational -> ArgFlag -> SDoc

Outputable AnonArgFlag

Defined in Var

Methods

ppr :: AnonArgFlag -> SDoc

pprPrec :: Rational -> AnonArgFlag -> SDoc

Outputable Var

Defined in Var

Methods

ppr :: Var -> SDoc

pprPrec :: Rational -> Var -> SDoc

Outputable WarnReason

Defined in DynFlags

Methods

ppr :: WarnReason -> SDoc

pprPrec :: Rational -> WarnReason -> SDoc

Outputable Language

Defined in DynFlags

Methods

ppr :: Language -> SDoc

pprPrec :: Rational -> Language -> SDoc

Outputable SafeHaskellMode

Defined in DynFlags

Methods

ppr :: SafeHaskellMode -> SDoc

pprPrec :: Rational -> SafeHaskellMode -> SDoc

Outputable GhcMode

Defined in DynFlags

Methods

ppr :: GhcMode -> SDoc

pprPrec :: Rational -> GhcMode -> SDoc

Outputable PackageArg

Defined in DynFlags

Methods

ppr :: PackageArg -> SDoc

pprPrec :: Rational -> PackageArg -> SDoc

Outputable ModRenaming

Defined in DynFlags

Methods

ppr :: ModRenaming -> SDoc

pprPrec :: Rational -> ModRenaming -> SDoc

Outputable PackageFlag

Defined in DynFlags

Methods

ppr :: PackageFlag -> SDoc

pprPrec :: Rational -> PackageFlag -> SDoc

Outputable Phase

Defined in DriverPhases

Methods

ppr :: Phase -> SDoc

pprPrec :: Rational -> Phase -> SDoc

Outputable ForeignCall

Defined in ForeignCall

Methods

ppr :: ForeignCall -> SDoc

pprPrec :: Rational -> ForeignCall -> SDoc

Outputable Safety

Defined in ForeignCall

Methods

ppr :: Safety -> SDoc

pprPrec :: Rational -> Safety -> SDoc

Outputable CExportSpec

Defined in ForeignCall

Methods

ppr :: CExportSpec -> SDoc

pprPrec :: Rational -> CExportSpec -> SDoc

Outputable CCallSpec

Defined in ForeignCall

Methods

ppr :: CCallSpec -> SDoc

pprPrec :: Rational -> CCallSpec -> SDoc

Outputable CCallConv

Defined in ForeignCall

Methods

ppr :: CCallConv -> SDoc

pprPrec :: Rational -> CCallConv -> SDoc

Outputable Header

Defined in ForeignCall

Methods

ppr :: Header -> SDoc

pprPrec :: Rational -> Header -> SDoc

Outputable CType

Defined in ForeignCall

Methods

ppr :: CType -> SDoc

pprPrec :: Rational -> CType -> SDoc

Outputable ModLocation

Defined in Module

Methods

ppr :: ModLocation -> SDoc

pprPrec :: Rational -> ModLocation -> SDoc

Outputable IndefUnitId

Defined in Module

Methods

ppr :: IndefUnitId -> SDoc

pprPrec :: Rational -> IndefUnitId -> SDoc

Outputable IndefModule

Defined in Module

Methods

ppr :: IndefModule -> SDoc

pprPrec :: Rational -> IndefModule -> SDoc

Outputable InstalledModule

Defined in Module

Methods

ppr :: InstalledModule -> SDoc

pprPrec :: Rational -> InstalledModule -> SDoc

Outputable DefUnitId

Defined in Module

Methods

ppr :: DefUnitId -> SDoc

pprPrec :: Rational -> DefUnitId -> SDoc

Outputable Unique

Defined in Unique

Methods

ppr :: Unique -> SDoc

pprPrec :: Rational -> Unique -> SDoc

Outputable LeftOrRight

Defined in BasicTypes

Methods

ppr :: LeftOrRight -> SDoc

pprPrec :: Rational -> LeftOrRight -> SDoc

Outputable Alignment

Defined in BasicTypes

Methods

ppr :: Alignment -> SDoc

pprPrec :: Rational -> Alignment -> SDoc

Outputable OneShotInfo

Defined in BasicTypes

Methods

ppr :: OneShotInfo -> SDoc

pprPrec :: Rational -> OneShotInfo -> SDoc

Outputable SwapFlag

Defined in BasicTypes

Methods

ppr :: SwapFlag -> SDoc

pprPrec :: Rational -> SwapFlag -> SDoc

Outputable FunctionOrData

Defined in BasicTypes

Methods

ppr :: FunctionOrData -> SDoc

pprPrec :: Rational -> FunctionOrData -> SDoc

Outputable StringLiteral

Defined in BasicTypes

Methods

ppr :: StringLiteral -> SDoc

pprPrec :: Rational -> StringLiteral -> SDoc

Outputable WarningTxt

Defined in BasicTypes

Methods

ppr :: WarningTxt -> SDoc

pprPrec :: Rational -> WarningTxt -> SDoc

Outputable Fixity

Defined in BasicTypes

Methods

ppr :: Fixity -> SDoc

pprPrec :: Rational -> Fixity -> SDoc

Outputable FixityDirection

Defined in BasicTypes

Methods

ppr :: FixityDirection -> SDoc

pprPrec :: Rational -> FixityDirection -> SDoc

Outputable LexicalFixity

Defined in BasicTypes

Methods

ppr :: LexicalFixity -> SDoc

pprPrec :: Rational -> LexicalFixity -> SDoc

Outputable TopLevelFlag

Defined in BasicTypes

Methods

ppr :: TopLevelFlag -> SDoc

pprPrec :: Rational -> TopLevelFlag -> SDoc

Outputable Boxity

Defined in BasicTypes

Methods

ppr :: Boxity -> SDoc

pprPrec :: Rational -> Boxity -> SDoc

Outputable RecFlag

Defined in BasicTypes

Methods

ppr :: RecFlag -> SDoc

pprPrec :: Rational -> RecFlag -> SDoc

Outputable Origin

Defined in BasicTypes

Methods

ppr :: Origin -> SDoc

pprPrec :: Rational -> Origin -> SDoc

Outputable OverlapFlag

Defined in BasicTypes

Methods

ppr :: OverlapFlag -> SDoc

pprPrec :: Rational -> OverlapFlag -> SDoc

Outputable OverlapMode

Defined in BasicTypes

Methods

ppr :: OverlapMode -> SDoc

pprPrec :: Rational -> OverlapMode -> SDoc

Outputable TupleSort

Defined in BasicTypes

Methods

ppr :: TupleSort -> SDoc

pprPrec :: Rational -> TupleSort -> SDoc

Outputable OccInfo

Defined in BasicTypes

Methods

ppr :: OccInfo -> SDoc

pprPrec :: Rational -> OccInfo -> SDoc

Outputable TailCallInfo

Defined in BasicTypes

Methods

ppr :: TailCallInfo -> SDoc

pprPrec :: Rational -> TailCallInfo -> SDoc

Outputable SuccessFlag

Defined in BasicTypes

Methods

ppr :: SuccessFlag -> SDoc

pprPrec :: Rational -> SuccessFlag -> SDoc

Outputable SourceText

Defined in BasicTypes

Methods

ppr :: SourceText -> SDoc

pprPrec :: Rational -> SourceText -> SDoc

Outputable CompilerPhase

Defined in BasicTypes

Methods

ppr :: CompilerPhase -> SDoc

pprPrec :: Rational -> CompilerPhase -> SDoc

Outputable Activation

Defined in BasicTypes

Methods

ppr :: Activation -> SDoc

pprPrec :: Rational -> Activation -> SDoc

Outputable RuleMatchInfo

Defined in BasicTypes

Methods

ppr :: RuleMatchInfo -> SDoc

pprPrec :: Rational -> RuleMatchInfo -> SDoc

Outputable InlinePragma

Defined in BasicTypes

Methods

ppr :: InlinePragma -> SDoc

pprPrec :: Rational -> InlinePragma -> SDoc

Outputable InlineSpec

Defined in BasicTypes

Methods

ppr :: InlineSpec -> SDoc

pprPrec :: Rational -> InlineSpec -> SDoc

Outputable IntegralLit

Defined in BasicTypes

Methods

ppr :: IntegralLit -> SDoc

pprPrec :: Rational -> IntegralLit -> SDoc

Outputable FractionalLit

Defined in BasicTypes

Methods

ppr :: FractionalLit -> SDoc

pprPrec :: Rational -> FractionalLit -> SDoc

Outputable IntWithInf

Defined in BasicTypes

Methods

ppr :: IntWithInf -> SDoc

pprPrec :: Rational -> IntWithInf -> SDoc

Outputable TypeOrKind

Defined in BasicTypes

Methods

ppr :: TypeOrKind -> SDoc

pprPrec :: Rational -> TypeOrKind -> SDoc

Outputable RealSrcLoc

Defined in SrcLoc

Methods

ppr :: RealSrcLoc -> SDoc

pprPrec :: Rational -> RealSrcLoc -> SDoc

Outputable SrcLoc

Defined in SrcLoc

Methods

ppr :: SrcLoc -> SDoc

pprPrec :: Rational -> SrcLoc -> SDoc

Outputable RealSrcSpan

Defined in SrcLoc

Methods

ppr :: RealSrcSpan -> SDoc

pprPrec :: Rational -> RealSrcSpan -> SDoc

Outputable SrcSpan

Defined in SrcLoc

Methods

ppr :: SrcSpan -> SDoc

pprPrec :: Rational -> SrcSpan -> SDoc

Outputable MetaDetails

Defined in TcType

Methods

ppr :: MetaDetails -> SDoc

pprPrec :: Rational -> MetaDetails -> SDoc

Outputable TcTyVarDetails

Defined in TcType

Methods

ppr :: TcTyVarDetails -> SDoc

pprPrec :: Rational -> TcTyVarDetails -> SDoc

Outputable PprStyle

Defined in Outputable

Methods

ppr :: PprStyle -> SDoc

pprPrec :: Rational -> PprStyle -> SDoc

Outputable QualifyName

Defined in Outputable

Methods

ppr :: QualifyName -> SDoc

pprPrec :: Rational -> QualifyName -> SDoc

Outputable Module

Defined in Module

Methods

ppr :: Module -> SDoc

pprPrec :: Rational -> Module -> SDoc

Outputable ModuleName

Defined in Module

Methods

ppr :: ModuleName -> SDoc

pprPrec :: Rational -> ModuleName -> SDoc

Outputable UnitId

Defined in Module

Methods

ppr :: UnitId -> SDoc

pprPrec :: Rational -> UnitId -> SDoc

Outputable InstalledUnitId

Defined in Module

Methods

ppr :: InstalledUnitId -> SDoc

pprPrec :: Rational -> InstalledUnitId -> SDoc

Outputable ComponentId

Defined in Module

Methods

ppr :: ComponentId -> SDoc

pprPrec :: Rational -> ComponentId -> SDoc

Outputable FastString

Defined in Outputable

Methods

ppr :: FastString -> SDoc

pprPrec :: Rational -> FastString -> SDoc

Outputable TyCon

Defined in TyCon

Methods

ppr :: TyCon -> SDoc

pprPrec :: Rational -> TyCon -> SDoc

Outputable SDoc

Defined in Outputable

Methods

ppr :: SDoc -> SDoc

pprPrec :: Rational -> SDoc -> SDoc

Outputable OccName

Defined in OccName

Methods

ppr :: OccName -> SDoc

pprPrec :: Rational -> OccName -> SDoc

Outputable Name

Defined in Name

Methods

ppr :: Name -> SDoc

pprPrec :: Rational -> Name -> SDoc

Outputable Reduction

Defined in GHC.TcPlugin.API.Internal.Shim.Reduction

Methods

ppr :: Reduction -> SDoc

pprPrec :: Rational -> Reduction -> SDoc

Outputable NameSort

Defined in Name

Methods

ppr :: NameSort -> SDoc

pprPrec :: Rational -> NameSort -> SDoc

Outputable FamilyInstEnv

Defined in FamInstEnv

Methods

ppr :: FamilyInstEnv -> SDoc

pprPrec :: Rational -> FamilyInstEnv -> SDoc

Outputable ClsInstEnv

Defined in InstEnv

Methods

ppr :: ClsInstEnv -> SDoc

pprPrec :: Rational -> ClsInstEnv -> SDoc

Outputable UnitVisibility

Defined in Packages

Methods

ppr :: UnitVisibility -> SDoc

pprPrec :: Rational -> UnitVisibility -> SDoc

Outputable a => Outputable [a]

Defined in Outputable

Methods

ppr :: [a] -> SDoc

pprPrec :: Rational -> [a] -> SDoc

Outputable a => Outputable (Maybe a)

Defined in Outputable

Methods

ppr :: Maybe a -> SDoc

pprPrec :: Rational -> Maybe a -> SDoc

Outputable elt => Outputable (IntMap elt)

Defined in Outputable

Methods

ppr :: IntMap elt -> SDoc

pprPrec :: Rational -> IntMap elt -> SDoc

Outputable a => Outputable (SCC a)

Defined in Outputable

Methods

ppr :: SCC a -> SDoc

pprPrec :: Rational -> SCC a -> SDoc

Outputable a => Outputable (Set a)

Defined in Outputable

Methods

ppr :: Set a -> SDoc

pprPrec :: Rational -> Set a -> SDoc

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

Defined in TcEnv

Methods

ppr :: InstInfo (GhcPass a) -> SDoc

pprPrec :: Rational -> InstInfo (GhcPass a) -> SDoc

Outputable (PatBuilder GhcPs)

Defined in RdrHsSyn

Methods

ppr :: PatBuilder GhcPs -> SDoc

pprPrec :: Rational -> PatBuilder GhcPs -> SDoc

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

Defined in GHC.Hs.Expr

Methods

ppr :: HsCmdTop (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Expr

Methods

ppr :: ApplicativeArg (GhcPass idL) -> SDoc

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

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

Defined in GHC.Hs.Expr

Methods

ppr :: HsSplicedThing (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Expr

Methods

ppr :: HsBracket (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Expr

Methods

ppr :: ArithSeqInfo (GhcPass p) -> SDoc

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

OutputableBndr id => Outputable (HsMatchContext id)

Defined in GHC.Hs.Expr

Methods

ppr :: HsMatchContext id -> SDoc

pprPrec :: Rational -> HsMatchContext id -> SDoc

(Outputable (GhcPass p), Outputable (NameOrRdrName (GhcPass p))) => Outputable (HsStmtContext (GhcPass p))

Defined in GHC.Hs.Expr

Methods

ppr :: HsStmtContext (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Decls

Methods

ppr :: HsDecl (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Decls

Methods

ppr :: HsGroup (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Decls

Methods

ppr :: SpliceDecl (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Decls

Methods

ppr :: TyClDecl (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Decls

Methods

ppr :: TyClGroup (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Decls

Methods

ppr :: FamilyDecl (GhcPass p) -> SDoc

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

Outputable (FamilyInfo pass)

Defined in GHC.Hs.Decls

Methods

ppr :: FamilyInfo pass -> SDoc

pprPrec :: Rational -> FamilyInfo pass -> SDoc

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

Defined in GHC.Hs.Decls

Methods

ppr :: HsDataDefn (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Decls

Methods

ppr :: HsDerivingClause (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Decls

Methods

ppr :: StandaloneKindSig (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Decls

Methods

ppr :: ConDecl (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Decls

Methods

ppr :: TyFamInstDecl (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Decls

Methods

ppr :: DataFamInstDecl (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Decls

Methods

ppr :: ClsInstDecl (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Decls

Methods

ppr :: InstDecl (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Decls

Methods

ppr :: DerivDecl (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Decls

Methods

ppr :: DerivStrategy (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Decls

Methods

ppr :: DefaultDecl (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Decls

Methods

ppr :: ForeignDecl (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Decls

Methods

ppr :: RuleDecls (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Decls

Methods

ppr :: RuleDecl (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Decls

Methods

ppr :: RuleBndr (GhcPass p) -> SDoc

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

OutputableBndr (IdP (GhcPass p)) => Outputable (WarnDecls (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: WarnDecls (GhcPass p) -> SDoc

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

OutputableBndr (IdP (GhcPass p)) => Outputable (WarnDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: WarnDecl (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Decls

Methods

ppr :: AnnDecl (GhcPass p) -> SDoc

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

OutputableBndr (IdP (GhcPass p)) => Outputable (RoleAnnotDecl (GhcPass p))

Defined in GHC.Hs.Decls

Methods

ppr :: RoleAnnotDecl (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Binds

Methods

ppr :: ABExport (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Binds

Methods

ppr :: HsIPBinds (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Binds

Methods

ppr :: IPBind (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Binds

Methods

ppr :: Sig (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Binds

Methods

ppr :: FixitySig (GhcPass p) -> SDoc

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

Outputable a => Outputable (RecordPatSynField a)

Defined in GHC.Hs.Binds

Methods

ppr :: RecordPatSynField a -> SDoc

pprPrec :: Rational -> RecordPatSynField a -> SDoc

Outputable a => Outputable (CoreMap a)

Defined in CoreMap

Methods

ppr :: CoreMap a -> SDoc

pprPrec :: Rational -> CoreMap a -> SDoc

OutputablePass pass => Outputable (GenStgTopBinding pass)

Defined in StgSyn

Methods

ppr :: GenStgTopBinding pass -> SDoc

pprPrec :: Rational -> GenStgTopBinding pass -> SDoc

OutputablePass pass => Outputable (GenStgBinding pass)

Defined in StgSyn

Methods

ppr :: GenStgBinding pass -> SDoc

pprPrec :: Rational -> GenStgBinding pass -> SDoc

OutputablePass pass => Outputable (GenStgExpr pass)

Defined in StgSyn

Methods

ppr :: GenStgExpr pass -> SDoc

pprPrec :: Rational -> GenStgExpr pass -> SDoc

OutputablePass pass => Outputable (GenStgRhs pass)

Defined in StgSyn

Methods

ppr :: GenStgRhs pass -> SDoc

pprPrec :: Rational -> GenStgRhs pass -> SDoc

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

Defined in GHC.Hs.Types

Methods

ppr :: LHsQTyVars (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Types

Methods

ppr :: HsTyVarBndr (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Types

Methods

ppr :: HsType (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Types

Methods

ppr :: ConDeclField (GhcPass p) -> SDoc

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

Outputable (FieldOcc pass)

Defined in GHC.Hs.Types

Methods

ppr :: FieldOcc pass -> SDoc

pprPrec :: Rational -> FieldOcc pass -> SDoc

Outputable (AmbiguousFieldOcc (GhcPass p))

Defined in GHC.Hs.Types

Methods

ppr :: AmbiguousFieldOcc (GhcPass p) -> SDoc

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

Outputable b => Outputable (TaggedBndr b)

Defined in CoreSyn

Methods

ppr :: TaggedBndr b -> SDoc

pprPrec :: Rational -> TaggedBndr b -> SDoc

Outputable (HsLit (GhcPass p))

Defined in GHC.Hs.Lit

Methods

ppr :: HsLit (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Lit

Methods

ppr :: HsOverLit (GhcPass p) -> SDoc

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

Outputable a => Outputable (LabelMap a)

Defined in Hoopl.Label

Methods

ppr :: LabelMap a -> SDoc

pprPrec :: Rational -> LabelMap a -> SDoc

Outputable (CoAxiom br)

Defined in CoAxiom

Methods

ppr :: CoAxiom br -> SDoc

pprPrec :: Rational -> CoAxiom br -> SDoc

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

Defined in GHC.Hs.Expr

Methods

ppr :: HsExpr (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Expr

Methods

ppr :: HsCmd (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Expr

Methods

ppr :: HsSplice (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Expr

Methods

ppr :: SyntaxExpr (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.ImpExp

Methods

ppr :: ImportDecl (GhcPass p) -> SDoc

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

OutputableBndr name => Outputable (IEWrappedName name)

Defined in GHC.Hs.ImpExp

Methods

ppr :: IEWrappedName name -> SDoc

pprPrec :: Rational -> IEWrappedName name -> SDoc

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

Defined in GHC.Hs.ImpExp

Methods

ppr :: IE (GhcPass p) -> SDoc

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

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

Defined in GHC.Hs.Pat

Methods

ppr :: Pat (GhcPass p) -> SDoc

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

Outputable name => Outputable (AnnTarget name)

Defined in Annotations

Methods

ppr :: AnnTarget name -> SDoc

pprPrec :: Rational -> AnnTarget name -> SDoc

Outputable a => Outputable (FieldLbl a)

Defined in FieldLabel

Methods

ppr :: FieldLbl a -> SDoc

pprPrec :: Rational -> FieldLbl a -> SDoc

Outputable a => Outputable (OccEnv a)

Defined in OccName

Methods

ppr :: OccEnv a -> SDoc

pprPrec :: Rational -> OccEnv a -> SDoc

Outputable a => Outputable (Bag a)

Defined in Bag

Methods

ppr :: Bag a -> SDoc

pprPrec :: Rational -> Bag a -> SDoc

Outputable a => Outputable (UniqDFM a)

Defined in UniqDFM

Methods

ppr :: UniqDFM a -> SDoc

pprPrec :: Rational -> UniqDFM a -> SDoc

Outputable a => Outputable (UniqSet a)

Defined in UniqSet

Methods

ppr :: UniqSet a -> SDoc

pprPrec :: Rational -> UniqSet a -> SDoc

Outputable a => Outputable (UniqFM a)

Defined in UniqFM

Methods

ppr :: UniqFM a -> SDoc

pprPrec :: Rational -> UniqFM a -> SDoc

Outputable (DefMethSpec ty)

Defined in BasicTypes

Methods

ppr :: DefMethSpec ty -> SDoc

pprPrec :: Rational -> DefMethSpec ty -> SDoc

Outputable a => Outputable (Pair a)

Defined in Pair

Methods

ppr :: Pair a -> SDoc

pprPrec :: Rational -> Pair a -> SDoc

Outputable a => Outputable (TypeMapG a)

Defined in CoreMap

Methods

ppr :: TypeMapG a -> SDoc

pprPrec :: Rational -> TypeMapG a -> SDoc

Outputable a => Outputable (OnOff a)

Defined in DynFlags

Methods

ppr :: OnOff a -> SDoc

pprPrec :: Rational -> OnOff a -> SDoc

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

Defined in Outputable

Methods

ppr :: Either a b -> SDoc

pprPrec :: Rational -> Either a b -> SDoc

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

Defined in Outputable

Methods

ppr :: (a, b) -> SDoc

pprPrec :: Rational -> (a, b) -> SDoc

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

Defined in Outputable

Methods

ppr :: Map key elt -> SDoc

pprPrec :: Rational -> Map key elt -> SDoc

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

Defined in GHC.Hs.Expr

Methods

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

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

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

Defined in GHC.Hs.Expr

Methods

ppr :: ParStmtBlock idL idR -> SDoc

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

Outputable arg => Outputable (HsRecFields p arg)

Defined in GHC.Hs.Pat

Methods

ppr :: HsRecFields p arg -> SDoc

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

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

Defined in GHC.Hs.Pat

Methods

ppr :: HsRecField' p arg -> SDoc

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

(OutputableBndrId pl, OutputableBndrId pr) => Outputable (HsLocalBindsLR (GhcPass pl) (GhcPass pr))

Defined in GHC.Hs.Binds

Methods

ppr :: HsLocalBindsLR (GhcPass pl) (GhcPass pr) -> SDoc

pprPrec :: Rational -> HsLocalBindsLR (GhcPass pl) (GhcPass pr) -> SDoc

(OutputableBndrId pl, OutputableBndrId pr) => Outputable (HsValBindsLR (GhcPass pl) (GhcPass pr))

Defined in GHC.Hs.Binds

Methods

ppr :: HsValBindsLR (GhcPass pl) (GhcPass pr) -> SDoc

pprPrec :: Rational -> HsValBindsLR (GhcPass pl) (GhcPass pr) -> SDoc

(OutputableBndrId pl, OutputableBndrId pr) => Outputable (HsBindLR (GhcPass pl) (GhcPass pr))

Defined in GHC.Hs.Binds

Methods

ppr :: HsBindLR (GhcPass pl) (GhcPass pr) -> SDoc

pprPrec :: Rational -> HsBindLR (GhcPass pl) (GhcPass pr) -> SDoc

(OutputableBndrId l, OutputableBndrId r, Outputable (XXPatSynBind (GhcPass l) (GhcPass r))) => Outputable (PatSynBind (GhcPass l) (GhcPass r))

Defined in GHC.Hs.Binds

Methods

ppr :: PatSynBind (GhcPass l) (GhcPass r) -> SDoc

pprPrec :: Rational -> PatSynBind (GhcPass l) (GhcPass r) -> SDoc

Outputable thing => Outputable (HsImplicitBndrs (GhcPass p) thing)

Defined in GHC.Hs.Types

Methods

ppr :: HsImplicitBndrs (GhcPass p) thing -> SDoc

pprPrec :: Rational -> HsImplicitBndrs (GhcPass p) thing -> SDoc

Outputable thing => Outputable (HsWildCardBndrs (GhcPass p) thing)

Defined in GHC.Hs.Types

Methods

ppr :: HsWildCardBndrs (GhcPass p) thing -> SDoc

pprPrec :: Rational -> HsWildCardBndrs (GhcPass p) thing -> SDoc

(Outputable arg, Outputable rec) => Outputable (HsConDetails arg rec)

Defined in GHC.Hs.Types

Methods

ppr :: HsConDetails arg rec -> SDoc

pprPrec :: Rational -> HsConDetails arg rec -> SDoc

(Outputable tm, Outputable ty) => Outputable (HsArg tm ty)

Defined in GHC.Hs.Types

Methods

ppr :: HsArg tm ty -> SDoc

pprPrec :: Rational -> HsArg tm ty -> SDoc

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

Defined in TrieMap

Methods

ppr :: ListMap m a -> SDoc

pprPrec :: Rational -> ListMap m a -> SDoc

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

Defined in TrieMap

Methods

ppr :: GenMap m a -> SDoc

pprPrec :: Rational -> GenMap m a -> SDoc

Outputable tv => Outputable (VarBndr tv ArgFlag)

Defined in Var

Methods

ppr :: VarBndr tv ArgFlag -> SDoc

pprPrec :: Rational -> VarBndr tv ArgFlag -> SDoc

OutputableBndr tv => Outputable (VarBndr tv TyConBndrVis)

Defined in TyCon

Methods

ppr :: VarBndr tv TyConBndrVis -> SDoc

pprPrec :: Rational -> VarBndr tv TyConBndrVis -> SDoc

(Outputable l, Outputable e) => Outputable (GenLocated l e)

Defined in SrcLoc

Methods

ppr :: GenLocated l e -> SDoc

pprPrec :: Rational -> GenLocated l e -> SDoc

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

Defined in Outputable

Methods

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

pprPrec :: Rational -> (a, b, c) -> SDoc

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

Defined in GHC.Hs.Expr

Methods

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

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

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

Defined in Outputable

Methods

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

pprPrec :: Rational -> (a, b, c, d) -> SDoc

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

Defined in Outputable

Methods

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

pprPrec :: Rational -> (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 Outputable

Methods

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

pprPrec :: Rational -> (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 Outputable

Methods

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

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