GHC.TypeLits.Presburger.Compat

Documentation

data TyCon

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

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

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

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

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

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

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

Instances

Data TyCon

Defined in GHC.Core.TyCon

Methods

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

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

toConstr :: TyCon -> Constr

dataTypeOf :: TyCon -> DataType

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

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

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

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

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

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

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

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

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

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

NamedThing TyCon

Defined in GHC.Core.TyCon

Methods

getOccName :: TyCon -> OccName

getName :: TyCon -> Name

Uniquable TyCon

Defined in GHC.Core.TyCon

Methods

getUnique :: TyCon -> Unique

Outputable TyCon

Defined in GHC.Core.TyCon

Methods

ppr :: TyCon -> SDoc

Eq TyCon

Defined in GHC.Core.TyCon

Methods

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

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

data Type

Constructors

TyVarTy Var

Vanilla type or kind variable (*never* a coercion variable)

AppTy Type Type

Type application to something other than a TyCon. Parameters:

1) Function: must not be a TyConApp or CastTy, must be another AppTy, or TyVarTy See Note [Respecting definitional equality] (EQ1) about the no CastTy requirement

2) Argument type

TyConApp TyCon [KindOrType]

Application of a TyCon, including newtypes and synonyms. Invariant: saturated applications of FunTyCon must use FunTy and saturated synonyms must use their own constructors. However, unsaturated FunTyCons do appear as TyConApps. Parameters:

1) Type constructor being applied to.

2) Type arguments. Might not have enough type arguments here to saturate the constructor. Even type synonyms are not necessarily saturated; for example unsaturated type synonyms can appear as the right hand side of a type synonym.

ForAllTy !ForAllTyBinder Type

A Π type. Note [When we quantify over a coercion variable] INVARIANT: If the binder is a coercion variable, it must be mentioned in the Type. See Note [Unused coercion variable in ForAllTy]

FunTy

FUN m t1 t2 Very common, so an important special case See Note [Function types]

Fields

• ft_af :: FunTyFlag
• ft_mult :: Mult
• ft_arg :: Type
• ft_res :: Type

LitTy TyLit

Type literals are similar to type constructors.

CastTy Type KindCoercion

A kind cast. The coercion is always nominal. INVARIANT: The cast is never reflexive (EQ2) INVARIANT: The Type is not a CastTy (use TransCo instead) (EQ3) INVARIANT: The Type is not a ForAllTy over a tyvar (EQ4) See Note [Respecting definitional equality]

CoercionTy Coercion

Injection of a Coercion into a type This should only ever be used in the RHS of an AppTy, in the list of a TyConApp, when applying a promoted GADT data constructor

Instances

Data Type

Defined in GHC.Core.TyCo.Rep

Methods

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

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

toConstr :: Type -> Constr

dataTypeOf :: Type -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable Type

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: Type -> SDoc

Eq (DeBruijn Type)

Defined in GHC.Core.Map.Type

Methods

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

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

data Unique

Unique identifier.

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

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

Instances

Show Unique

Defined in GHC.Types.Unique

Methods

showsPrec :: Int -> Unique -> ShowS

show :: Unique -> String

showList :: [Unique] -> ShowS

Uniquable Unique

Defined in GHC.Types.Unique

Methods

getUnique :: Unique -> Unique

Outputable Unique

Defined in GHC.Types.Unique

Methods

ppr :: Unique -> SDoc

Eq Unique

Defined in GHC.Types.Unique

Methods

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

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

data Subst

Type & coercion & id substitution

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

Constructors

Subst InScopeSet IdSubstEnv TvSubstEnv CvSubstEnv

Instances

Outputable Subst

Defined in GHC.Core.TyCo.Subst

Methods

ppr :: Subst -> SDoc

data NoExtField

A placeholder type for TTG extension points that are not currently unused to represent any particular value.

This should not be confused with DataConCantHappen, which are found in unused extension constructors and therefore should never be inhabited. In contrast, NoExtField is used in extension points (e.g., as the field of some constructor), so it must have an inhabitant to construct AST passes that manipulate fields with that extension point as their type.

Constructors

NoExtField

Instances

Data NoExtField

Defined in Language.Haskell.Syntax.Extension

Methods

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

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

toConstr :: NoExtField -> Constr

dataTypeOf :: NoExtField -> DataType

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

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

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

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

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

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

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

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

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

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

Eq NoExtField

Defined in Language.Haskell.Syntax.Extension

Methods

(==) :: NoExtField -> NoExtField -> Bool

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

Ord NoExtField

Defined in Language.Haskell.Syntax.Extension

Methods

compare :: NoExtField -> NoExtField -> Ordering

(<) :: NoExtField -> NoExtField -> Bool

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

(>) :: NoExtField -> NoExtField -> Bool

(>=) :: NoExtField -> NoExtField -> Bool

max :: NoExtField -> NoExtField -> NoExtField

min :: NoExtField -> NoExtField -> NoExtField

data Plugin

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

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

Constructors

Plugin

Fields

• installCoreToDos :: CorePlugin

  Modify the Core pipeline that will be used for compilation. This is called as the Core pipeline is built for every module being compiled, and plugins get the opportunity to modify the pipeline in a nondeterministic order.

• tcPlugin :: TcPlugin

  An optional typechecker plugin, which may modify the behaviour of the constraint solver.

• defaultingPlugin :: DefaultingPlugin

  An optional defaulting plugin, which may specify the additional type-defaulting rules.

• holeFitPlugin :: HoleFitPlugin

  An optional plugin to handle hole fits, which may re-order or change the list of valid hole fits and refinement hole fits.

• driverPlugin :: [CommandLineOption] -> HscEnv -> IO HscEnv

  An optional plugin to update HscEnv, right after plugin loading. This can be used to register hooks or tweak any field of DynFlags before doing actual work on a module.

  Since: ghc-8.10.1

• pluginRecompile :: [CommandLineOption] -> IO PluginRecompile

  Specify how the plugin should affect recompilation.

• parsedResultAction :: [CommandLineOption] -> ModSummary -> ParsedResult -> Hsc ParsedResult

  Modify the module when it is parsed. This is called by GHC.Driver.Main when the parser has produced no or only non-fatal errors. Compilation will fail if the messages produced by this function contain any errors.

• renamedResultAction :: [CommandLineOption] -> TcGblEnv -> HsGroup GhcRn -> TcM (TcGblEnv, HsGroup GhcRn)

  Modify each group after it is renamed. This is called after each HsGroup has been renamed.

• typeCheckResultAction :: [CommandLineOption] -> ModSummary -> TcGblEnv -> TcM TcGblEnv

  Modify the module when it is type checked. This is called at the very end of typechecking.

• spliceRunAction :: [CommandLineOption] -> LHsExpr GhcTc -> TcM (LHsExpr GhcTc)

  Modify the TH splice or quasiqoute before it is run.

• interfaceLoadAction :: forall lcl. [CommandLineOption] -> ModIface -> IfM lcl ModIface

  Modify an interface that have been loaded. This is called by GHC.Iface.Load when an interface is successfully loaded. Not applied to the loading of the plugin interface. Tools that rely on information from modules other than the currently compiled one should implement this function.

data GenericUnitInfo srcpkgid srcpkgname uid modulename mod

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

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

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

Constructors

GenericUnitInfo

Fields

• unitId :: uid

  Unique unit identifier that is used during compilation (e.g. to generate symbols).

• unitInstanceOf :: uid

  Identifier of an indefinite unit (i.e. with module holes) that this unit is an instance of.

  For non instantiated units, unitInstanceOf=unitId

• unitInstantiations :: [(modulename, mod)]

  How this unit instantiates some of its module holes. Map hole module names to actual module

• unitPackageId :: srcpkgid

  Source package identifier.

  Cabal instantiates this with Distribution.Types.PackageId.PackageId type which only contains the source package name and version. Notice that it doesn't contain the Hackage revision, nor any kind of hash.

• unitPackageName :: srcpkgname

  Source package name

• unitPackageVersion :: Version

  Source package version

• unitComponentName :: Maybe srcpkgname

  Name of the component.

  Cabal supports more than one components (libraries, executables, testsuites) in the same package. Each component has a name except the default one (that can only be a library component) for which we use Nothing.

  GHC only deals with "library" components as they are the only kind of components that can be registered in a database and used by other modules.

• unitAbiHash :: ShortText

  ABI hash used to avoid mixing up units compiled with different dependencies, compiler, options, etc.

• unitDepends :: [uid]

  Identifiers of the units this one depends on

• unitAbiDepends :: [(uid, ShortText)]

  Like unitDepends, but each dependency is annotated with the ABI hash we expect the dependency to respect.

• unitImportDirs :: [FilePathST]

  Directories containing module interfaces

• unitLibraries :: [ShortText]

  Names of the Haskell libraries provided by this unit

• unitExtDepLibsSys :: [ShortText]

  Names of the external system libraries that this unit depends on. See also unitExtDepLibsGhc field.

• unitExtDepLibsGhc :: [ShortText]

  Because of slight differences between the GHC dynamic linker (in GHC.Runtime.Linker) and the native system linker, some packages have to link with a different list of libraries when using GHC's. Examples include: libs that are actually gnu ld scripts, and the possibility that the .a libs do not exactly match the .so/.dll equivalents.

  If this field is set, then we use that instead of the unitExtDepLibsSys field.

• unitLibraryDirs :: [FilePathST]

  Directories containing libraries provided by this unit. See also unitLibraryDynDirs.

  It seems to be used to store paths to external library dependencies too.

• unitLibraryDynDirs :: [FilePathST]

  Directories containing the dynamic libraries provided by this unit. See also unitLibraryDirs.

  It seems to be used to store paths to external dynamic library dependencies too.

• unitExtDepFrameworks :: [ShortText]

  Names of the external MacOS frameworks that this unit depends on.

• unitExtDepFrameworkDirs :: [FilePathST]

  Directories containing MacOS frameworks that this unit depends on.

• unitLinkerOptions :: [ShortText]

  Linker (e.g. ld) command line options

• unitCcOptions :: [ShortText]

  C compiler options that needs to be passed to the C compiler when we compile some C code against this unit.

• unitIncludes :: [ShortText]

  C header files that are required by this unit (provided by this unit or external)

• unitIncludeDirs :: [FilePathST]

  Directories containing C header files that this unit depends on.

• unitHaddockInterfaces :: [FilePathST]

  Paths to Haddock interface files for this unit

• unitHaddockHTMLs :: [FilePathST]

  Paths to Haddock directories containing HTML files

• unitExposedModules :: [(modulename, Maybe mod)]

  Modules exposed by the unit.

  A module can be re-exported from another package. In this case, we indicate the module origin in the second parameter.

• unitHiddenModules :: [modulename]

  Hidden modules.

  These are useful for error reporting (e.g. if a hidden module is imported)

• unitIsIndefinite :: Bool

  True if this unit has some module holes that need to be instantiated with real modules to make the unit usable (a.k.a. Backpack).

• unitIsExposed :: Bool

  True if the unit is exposed. A unit could be installed in a database by "disabled" by not being exposed.

• unitIsTrusted :: Bool

  True if the unit is trusted (cf Safe Haskell)

Instances

Binary DbUnitInfo

Defined in GHC.Unit.Database

Methods

put :: DbUnitInfo -> Put

get :: Get DbUnitInfo

putList :: [DbUnitInfo] -> Put

(Show uid, Show modulename, Show mod, Show srcpkgid, Show srcpkgname) => Show (GenericUnitInfo srcpkgid srcpkgname uid modulename mod)

Defined in GHC.Unit.Database

Methods

showsPrec :: Int -> GenericUnitInfo srcpkgid srcpkgname uid modulename mod -> ShowS

show :: GenericUnitInfo srcpkgid srcpkgname uid modulename mod -> String

showList :: [GenericUnitInfo srcpkgid srcpkgname uid modulename mod] -> ShowS

(Eq uid, Eq modulename, Eq mod, Eq srcpkgid, Eq srcpkgname) => Eq (GenericUnitInfo srcpkgid srcpkgname uid modulename mod)

Defined in GHC.Unit.Database

Methods

(==) :: GenericUnitInfo srcpkgid srcpkgname uid modulename mod -> GenericUnitInfo srcpkgid srcpkgname uid modulename mod -> Bool

(/=) :: GenericUnitInfo srcpkgid srcpkgname uid modulename mod -> GenericUnitInfo srcpkgid srcpkgname uid modulename mod -> Bool

data FastString

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

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

Instances

Data FastString

Defined in GHC.Data.FastString

Methods

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

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

toConstr :: FastString -> Constr

dataTypeOf :: FastString -> DataType

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

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

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

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

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

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

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

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

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

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

IsString FastString

Defined in GHC.Data.FastString

Methods

fromString :: String -> FastString

Monoid FastString

Defined in GHC.Data.FastString

Methods

mempty :: FastString

mappend :: FastString -> FastString -> FastString

mconcat :: [FastString] -> FastString

Semigroup FastString

Defined in GHC.Data.FastString

Methods

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

sconcat :: NonEmpty FastString -> FastString

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

Show FastString

Defined in GHC.Data.FastString

Methods

showsPrec :: Int -> FastString -> ShowS

show :: FastString -> String

showList :: [FastString] -> ShowS

NFData FastString

Defined in GHC.Data.FastString

Methods

rnf :: FastString -> ()

Uniquable FastString

Defined in GHC.Types.Unique

Methods

getUnique :: FastString -> Unique

Outputable FastString

Defined in GHC.Utils.Outputable

Methods

ppr :: FastString -> SDoc

Eq FastString

Defined in GHC.Data.FastString

Methods

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

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

type Anno FastString

Defined in GHC.Hs.Expr

type Anno FastString = SrcAnn NoEpAnns

type Anno (SourceText, RuleName)

Defined in GHC.Hs.Decls

type Anno (SourceText, RuleName) = SrcAnn NoEpAnns

data Role

See Note [Roles] in GHC.Core.Coercion

Order of constructors matters: the Ord instance coincides with the *super*typing relation on roles.

Constructors

Nominal

Representational

Phantom

Instances

Data Role

Defined in Language.Haskell.Syntax.Basic

Methods

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

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

toConstr :: Role -> Constr

dataTypeOf :: Role -> DataType

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

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

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

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

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

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

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

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

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

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

Eq Role

Defined in Language.Haskell.Syntax.Basic

Methods

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

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

Ord Role

Defined in Language.Haskell.Syntax.Basic

Methods

compare :: Role -> Role -> Ordering

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

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

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

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

max :: Role -> Role -> Role

min :: Role -> Role -> Role

type Anno (Maybe Role)

Defined in GHC.Hs.Decls

type Anno (Maybe Role) = SrcAnn NoEpAnns

type Anno (Maybe Role)

Defined in GHC.Hs.Decls

type Anno (Maybe Role) = SrcAnn NoEpAnns

data ModuleName

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

Instances

Data ModuleName

Defined in Language.Haskell.Syntax.Module.Name

Methods

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

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

toConstr :: ModuleName -> Constr

dataTypeOf :: ModuleName -> DataType

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

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

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

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

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

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

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

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

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

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

Show ModuleName

Defined in Language.Haskell.Syntax.Module.Name

Methods

showsPrec :: Int -> ModuleName -> ShowS

show :: ModuleName -> String

showList :: [ModuleName] -> ShowS

NFData ModuleName

Defined in Language.Haskell.Syntax.Module.Name

Methods

rnf :: ModuleName -> ()

Uniquable ModuleName

Defined in GHC.Types.Unique

Methods

getUnique :: ModuleName -> Unique

Outputable ModuleName

Defined in GHC.Utils.Outputable

Methods

ppr :: ModuleName -> SDoc

Eq ModuleName

Defined in Language.Haskell.Syntax.Module.Name

Methods

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

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

Ord ModuleName

Defined in Language.Haskell.Syntax.Module.Name

Methods

compare :: ModuleName -> ModuleName -> Ordering

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

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

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

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

max :: ModuleName -> ModuleName -> ModuleName

min :: ModuleName -> ModuleName -> ModuleName

type Anno ModuleName

Defined in GHC.Hs

type Anno ModuleName = SrcSpanAnnA

type Anno ModuleName

Defined in GHC.Hs.ImpExp

type Anno ModuleName = SrcSpanAnnA

data CtOrigin

Constructors

GivenOrigin SkolemInfoAnon

A given constraint from a user-written type signature. The SkolemInfo inside gives more information.

GivenSCOrigin

GivenSCOrigin is used for a Given constraint obtained by superclass selection from the context of an instance declaration. E.g. instance (Foo a, Bar a) => C [a] where ... When typechecking the instance decl itself, including producing evidence for the superclasses of C, the superclasses of (Foo a) and (Bar a) will have GivenSCOrigin origin.

Fields

• SkolemInfoAnon

  Just like GivenOrigin

• ScDepth

  The number of superclass selections necessary to get this constraint; see Note [Replacement vs keeping] in GHC.Tc.Solver.Interact

• Bool

  True => "blocked": cannot use this to solve naked superclass Wanteds i.e. ones with (ScOrigin _ NakedSc) False => can use this to solve all Wanted constraints See Note [Solving superclass constraints] in GHC.Tc.TyCl.Instance

OccurrenceOf Name

OccurrenceOfRecSel RdrName

AppOrigin

SpecPragOrigin UserTypeCtxt

TypeEqOrigin

Fields

• uo_actual :: TcType
• uo_expected :: TcType
• uo_thing :: Maybe TypedThing

  The thing that has type "actual"

• uo_visible :: Bool

  Is at least one of the three elements above visible? (Errors from the polymorphic subsumption check are considered visible.) Only used for prioritizing error messages.

KindEqOrigin TcType TcType CtOrigin (Maybe TypeOrKind)

IPOccOrigin HsIPName

OverLabelOrigin FastString

LiteralOrigin (HsOverLit GhcRn)

NegateOrigin

ArithSeqOrigin (ArithSeqInfo GhcRn)

AssocFamPatOrigin

SectionOrigin

HasFieldOrigin FastString

TupleOrigin

ExprSigOrigin

PatSigOrigin

PatOrigin

ProvCtxtOrigin (PatSynBind GhcRn GhcRn)

RecordUpdOrigin

ViewPatOrigin

ScOrigin ClsInstOrQC NakedScFlag

ScOrigin is used only for the Wanted constraints for the superclasses of an instance declaration.

DerivClauseOrigin

DerivOriginDC DataCon Int Bool

DerivOriginCoerce Id Type Type Bool

StandAloneDerivOrigin

DefaultOrigin

DoOrigin

DoPatOrigin (LPat GhcRn)

MCompOrigin

MCompPatOrigin (LPat GhcRn)

ProcOrigin

ArrowCmdOrigin

AnnOrigin

FunDepOrigin1 PredType CtOrigin RealSrcSpan PredType CtOrigin RealSrcSpan

FunDepOrigin2 PredType CtOrigin PredType SrcSpan

InjTFOrigin1 PredType CtOrigin RealSrcSpan PredType CtOrigin RealSrcSpan

ExprHoleOrigin (Maybe RdrName)

TypeHoleOrigin OccName

PatCheckOrigin

ListOrigin

IfThenElseOrigin

BracketOrigin

StaticOrigin

Shouldn'tHappenOrigin String

GhcBug20076

InstProvidedOrigin

Testing whether the constraint associated with an instance declaration in a signature file is satisfied upon instantiation.

Test cases: backpackshould_failbkpfail{11,43}.bkp

Fields

• Module

  Module in which the instance was declared

• ClsInst

  The declared typeclass instance

NonLinearPatternOrigin

UsageEnvironmentOf Name

CycleBreakerOrigin CtOrigin

FRROrigin FixedRuntimeRepOrigin

WantedSuperclassOrigin PredType CtOrigin

InstanceSigOrigin Name Type Type

AmbiguityCheckOrigin UserTypeCtxt

Instances

Outputable CtOrigin

Defined in GHC.Tc.Types.Origin

Methods

ppr :: CtOrigin -> SDoc

data IsBootInterface

Indicates whether a module name is referring to a boot interface (hs-boot file) or regular module (hs file). We need to treat boot modules specially when building compilation graphs, since they break cycles. Regular source files and signature files are treated equivalently.

Constructors

NotBoot

IsBoot

Instances

Data IsBootInterface

Defined in Language.Haskell.Syntax.ImpExp

Methods

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

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

toConstr :: IsBootInterface -> Constr

dataTypeOf :: IsBootInterface -> DataType

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

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

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

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

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

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

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

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

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

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

Show IsBootInterface

Defined in Language.Haskell.Syntax.ImpExp

Methods

showsPrec :: Int -> IsBootInterface -> ShowS

show :: IsBootInterface -> String

showList :: [IsBootInterface] -> ShowS

Eq IsBootInterface

Defined in Language.Haskell.Syntax.ImpExp

Methods

(==) :: IsBootInterface -> IsBootInterface -> Bool

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

Ord IsBootInterface

Defined in Language.Haskell.Syntax.ImpExp

Methods

compare :: IsBootInterface -> IsBootInterface -> Ordering

(<) :: IsBootInterface -> IsBootInterface -> Bool

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

(>) :: IsBootInterface -> IsBootInterface -> Bool

(>=) :: IsBootInterface -> IsBootInterface -> Bool

max :: IsBootInterface -> IsBootInterface -> IsBootInterface

min :: IsBootInterface -> IsBootInterface -> IsBootInterface

type TyVar = Var

Type or kind Variable

type TyConRepName = Name

data TyLit

Constructors

NumTyLit Integer

Instances

Data TyLit

Defined in GHC.Core.TyCo.Rep

Methods

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

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

toConstr :: TyLit -> Constr

dataTypeOf :: TyLit -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable TyLit

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: TyLit -> SDoc

Eq TyLit

Defined in GHC.Core.TyCo.Rep

Methods

(==) :: TyLit -> TyLit -> Bool

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

data UnivCoProvenance

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

Constructors

PhantomProv KindCoercion

See Note [Phantom coercions]. Only in Phantom roled coercions

ProofIrrelProv KindCoercion

From the fact that any two coercions are considered equivalent. See Note [ProofIrrelProv]. Can be used in Nominal or Representational coercions

PluginProv String

From a plugin, which asserts that this coercion is sound. The string is for the use of the plugin.

CorePrepProv Bool

Instances

Data UnivCoProvenance

Defined in GHC.Core.TyCo.Rep

Methods

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

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

toConstr :: UnivCoProvenance -> Constr

dataTypeOf :: UnivCoProvenance -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable UnivCoProvenance

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: UnivCoProvenance -> SDoc

type GhcPs = GhcPass 'Parsed

data ImportDecl pass

Import Declaration

A single Haskell import declaration.

Constructors

ImportDecl

Fields

• ideclExt :: XCImportDecl pass
• ideclName :: XRec pass ModuleName

  Module name.

• ideclPkgQual :: ImportDeclPkgQual pass

  Package qualifier.

• ideclSource :: IsBootInterface

  IsBoot = {-# SOURCE #-} import

• ideclSafe :: Bool

  True => safe import

• ideclQualified :: ImportDeclQualifiedStyle

  If/how the import is qualified.

• ideclAs :: Maybe (XRec pass ModuleName)

  as Module

• ideclImportList :: Maybe (ImportListInterpretation, XRec pass [LIE pass])

  Explicit import list (EverythingBut => hiding, names)

XImportDecl !(XXImportDecl pass)

AnnKeywordIds

• AnnImport
• AnnOpen, AnnClose for ideclSource
• AnnSafe,AnnQualified, AnnPackageName,AnnAs, AnnVal
• AnnHiding,AnnOpen, AnnClose attached to location in ideclImportList

Instances

type Anno (ImportDecl (GhcPass p))

Defined in GHC.Hs.ImpExp

type Anno (ImportDecl (GhcPass p)) = SrcSpanAnnA

data ImportDeclQualifiedStyle

If/how an import is qualified.

Constructors

QualifiedPre

qualified appears in prepositive position.

QualifiedPost

qualified appears in postpositive position.

NotQualified

Not qualified.

Instances

Data ImportDeclQualifiedStyle

Defined in Language.Haskell.Syntax.ImpExp

Methods

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

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

toConstr :: ImportDeclQualifiedStyle -> Constr

dataTypeOf :: ImportDeclQualifiedStyle -> DataType

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

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

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

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

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

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

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

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

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

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

Eq ImportDeclQualifiedStyle

Defined in Language.Haskell.Syntax.ImpExp

Methods

(==) :: ImportDeclQualifiedStyle -> ImportDeclQualifiedStyle -> Bool

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

newtype PackageName

Constructors

PackageName

Fields

• unPackageName :: FastString

Instances

Uniquable PackageName

Defined in GHC.Unit.Info

Methods

getUnique :: PackageName -> Unique

Outputable PackageName

Defined in GHC.Unit.Info

Methods

ppr :: PackageName -> SDoc

Eq PackageName

Defined in GHC.Unit.Info

Methods

(==) :: PackageName -> PackageName -> Bool

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

data Hsc a

The Hsc monad: Passing an environment and diagnostic state

Instances

MonadIO Hsc

Defined in GHC.Driver.Env.Types

Methods

liftIO :: IO a -> Hsc a

Applicative Hsc

Defined in GHC.Driver.Env.Types

Methods

pure :: a -> Hsc a

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

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

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

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

Functor Hsc

Defined in GHC.Driver.Env.Types

Methods

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

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

Monad Hsc

Defined in GHC.Driver.Env.Types

Methods

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

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

return :: a -> Hsc a

HasDynFlags Hsc

Defined in GHC.Driver.Env.Types

Methods

getDynFlags :: Hsc DynFlags

HasLogger Hsc

Defined in GHC.Driver.Env.Types

Methods

getLogger :: Hsc Logger

data BuiltInSynFamily

Constructors

BuiltInSynFamily

Fields

• sfMatchFam :: [Type] -> Maybe (CoAxiomRule, [Type], Type)
• sfInteractTop :: [Type] -> Type -> [TypeEqn]
• sfInteractInert :: [Type] -> Type -> [Type] -> Type -> [TypeEqn]

data TyConFlavour

Paints a picture of what a TyCon represents, in broad strokes. This is used towards more informative error messages.

Constructors

ClassFlavour

TupleFlavour Boxity

SumFlavour

DataTypeFlavour

NewtypeFlavour

AbstractTypeFlavour

DataFamilyFlavour (Maybe TyCon)

OpenTypeFamilyFlavour (Maybe TyCon)

ClosedTypeFamilyFlavour

TypeSynonymFlavour

BuiltInTypeFlavour

e.g., the (->) TyCon.

PromotedDataConFlavour

Instances

Outputable TyConFlavour

Defined in GHC.Core.TyCon

Methods

ppr :: TyConFlavour -> SDoc

Eq TyConFlavour

Defined in GHC.Core.TyCon

Methods

(==) :: TyConFlavour -> TyConFlavour -> Bool

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

data ExpandSynResult tyco

Constructors

NoExpansion

ExpandsSyn [(TyVar, tyco)] Type [tyco]

data PrimElemRep

Constructors

Int8ElemRep

Int16ElemRep

Int32ElemRep

Int64ElemRep

Word8ElemRep

Word16ElemRep

Word32ElemRep

Word64ElemRep

FloatElemRep

DoubleElemRep

Instances

Data PrimElemRep

Defined in GHC.Core.TyCon

Methods

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

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

toConstr :: PrimElemRep -> Constr

dataTypeOf :: PrimElemRep -> DataType

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

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

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

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

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

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

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

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

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

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

Enum PrimElemRep

Defined in GHC.Core.TyCon

Methods

succ :: PrimElemRep -> PrimElemRep

pred :: PrimElemRep -> PrimElemRep

toEnum :: Int -> PrimElemRep

fromEnum :: PrimElemRep -> Int

enumFrom :: PrimElemRep -> [PrimElemRep]

enumFromThen :: PrimElemRep -> PrimElemRep -> [PrimElemRep]

enumFromTo :: PrimElemRep -> PrimElemRep -> [PrimElemRep]

enumFromThenTo :: PrimElemRep -> PrimElemRep -> PrimElemRep -> [PrimElemRep]

Show PrimElemRep

Defined in GHC.Core.TyCon

Methods

showsPrec :: Int -> PrimElemRep -> ShowS

show :: PrimElemRep -> String

showList :: [PrimElemRep] -> ShowS

Binary PrimElemRep

Defined in GHC.Core.TyCon

Methods

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

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

get :: BinHandle -> IO PrimElemRep

Outputable PrimElemRep

Defined in GHC.Core.TyCon

Methods

ppr :: PrimElemRep -> SDoc

Eq PrimElemRep

Defined in GHC.Core.TyCon

Methods

(==) :: PrimElemRep -> PrimElemRep -> Bool

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

Ord PrimElemRep

Defined in GHC.Core.TyCon

Methods

compare :: PrimElemRep -> PrimElemRep -> Ordering

(<) :: PrimElemRep -> PrimElemRep -> Bool

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

(>) :: PrimElemRep -> PrimElemRep -> Bool

(>=) :: PrimElemRep -> PrimElemRep -> Bool

max :: PrimElemRep -> PrimElemRep -> PrimElemRep

min :: PrimElemRep -> PrimElemRep -> PrimElemRep

data PrimRep

A PrimRep is an abstraction of a type. It contains information that the code generator needs in order to pass arguments, return results, and store values of this type. See also Note [RuntimeRep and PrimRep] in GHC.Types.RepType and Note [VoidRep] in GHC.Types.RepType.

Constructors

VoidRep

LiftedRep

UnliftedRep

Unlifted pointer

Int8Rep

Signed, 8-bit value

Int16Rep

Signed, 16-bit value

Int32Rep

Signed, 32-bit value

Int64Rep

Signed, 64 bit value

IntRep

Signed, word-sized value

Word8Rep

Unsigned, 8 bit value

Word16Rep

Unsigned, 16 bit value

Word32Rep

Unsigned, 32 bit value

Word64Rep

Unsigned, 64 bit value

WordRep

Unsigned, word-sized value

AddrRep

A pointer, but not to a Haskell value (use '(Un)liftedRep')

FloatRep

DoubleRep

VecRep Int PrimElemRep

A vector

Instances

Data PrimRep

Defined in GHC.Core.TyCon

Methods

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

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

toConstr :: PrimRep -> Constr

dataTypeOf :: PrimRep -> DataType

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

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

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

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

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

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

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

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

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

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

Show PrimRep

Defined in GHC.Core.TyCon

Methods

showsPrec :: Int -> PrimRep -> ShowS

show :: PrimRep -> String

showList :: [PrimRep] -> ShowS

Binary PrimRep

Defined in GHC.Core.TyCon

Methods

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

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

get :: BinHandle -> IO PrimRep

Outputable PrimRep

Defined in GHC.Core.TyCon

Methods

ppr :: PrimRep -> SDoc

Eq PrimRep

Defined in GHC.Core.TyCon

Methods

(==) :: PrimRep -> PrimRep -> Bool

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

Ord PrimRep

Defined in GHC.Core.TyCon

Methods

compare :: PrimRep -> PrimRep -> Ordering

(<) :: PrimRep -> PrimRep -> Bool

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

(>) :: PrimRep -> PrimRep -> Bool

(>=) :: PrimRep -> PrimRep -> Bool

max :: PrimRep -> PrimRep -> PrimRep

min :: PrimRep -> PrimRep -> PrimRep

data FamTyConFlav

Information pertaining to the expansion of a type synonym (type)

Constructors

DataFamilyTyCon TyConRepName

Represents an open type family without a fixed right hand side. Additional instances can appear at any time.

These are introduced by either a top level declaration:

data family T a :: *

Or an associated data type declaration, within a class declaration:

class C a b where
  data T b :: *

OpenSynFamilyTyCon

An open type synonym family e.g. type family F x y :: * -> *

ClosedSynFamilyTyCon (Maybe (CoAxiom Branched))

A closed type synonym family e.g. type family F x where { F Int = Bool }

AbstractClosedSynFamilyTyCon

A closed type synonym family declared in an hs-boot file with type family F a where ..

BuiltInSynFamTyCon BuiltInSynFamily

Built-in type family used by the TypeNats solver

Instances

Outputable FamTyConFlav

Defined in GHC.Core.TyCon

Methods

ppr :: FamTyConFlav -> SDoc

data Injectivity

Constructors

NotInjective

Injective [Bool]

Instances

Binary Injectivity

Defined in GHC.Core.TyCon

Methods

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

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

get :: BinHandle -> IO Injectivity

Eq Injectivity

Defined in GHC.Core.TyCon

Methods

(==) :: Injectivity -> Injectivity -> Bool

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

data AlgTyConFlav

Describes the flavour of an algebraic type constructor. For classes and data families, this flavour includes a reference to the parent TyCon.

Constructors

VanillaAlgTyCon TyConRepName

An ordinary algebraic type constructor. This includes unlifted and representation-polymorphic datatypes and newtypes and unboxed tuples, but NOT unboxed sums; see UnboxedSumTyCon.

UnboxedSumTyCon

An unboxed sum type constructor. This is distinct from VanillaAlgTyCon because we currently don't allow unboxed sums to be Typeable since there are too many of them. See #13276.

ClassTyCon Class TyConRepName

Type constructors representing a class dictionary. See Note [ATyCon for classes] in GHC.Core.TyCo.Rep

DataFamInstTyCon (CoAxiom Unbranched) TyCon [Type]

Type constructors representing an *instance* of a *data* family. Parameters:

1) The type family in question

2) Instance types; free variables are the tyConTyVars of the current TyCon (not the family one). INVARIANT: the number of types matches the arity of the family TyCon

3) A CoTyCon identifying the representation type with the type instance family

Instances

Outputable AlgTyConFlav

Defined in GHC.Core.TyCon

Methods

ppr :: AlgTyConFlav -> SDoc

data PromDataConInfo

Some promoted datacons signify extra info relevant to GHC. For example, the IntRep constructor of RuntimeRep corresponds to the IntRep constructor of PrimRep. This data structure allows us to store this information right in the TyCon. The other approach would be to look up things like RuntimeRep's PrimRep by known-key every time. See also Note [Getting from RuntimeRep to PrimRep] in GHC.Types.RepType

Constructors

NoPromInfo

an ordinary promoted data con

RuntimeRep ([Type] -> [PrimRep])

A constructor of RuntimeRep. The argument to the function should be the list of arguments to the promoted datacon.

VecCount Int

A constructor of VecCount

VecElem PrimElemRep

A constructor of VecElem

Levity Levity

A constructor of PromDataConInfo

data AlgTyConRhs

Represents right-hand-sides of TyCons for algebraic types

Constructors

AbstractTyCon

Says that we know nothing about this data type, except that it's represented by a pointer. Used when we export a data type abstractly into an .hi file.

DataTyCon

Information about those TyCons derived from a data declaration. This includes data types with no constructors at all.

Fields

• data_cons :: [DataCon]

  The data type constructors; can be empty if the user declares the type to have no constructors

  INVARIANT: Kept in order of increasing DataCon tag (see the tag assignment in mkTyConTagMap)

• data_cons_size :: Int

  Cached value: length data_cons

• is_enum :: Bool

  Cached value: is this an enumeration type? See Note [Enumeration types]

• is_type_data :: Bool
• data_fixed_lev :: Bool

  True if the data type constructor has a known, fixed levity when fully applied to its arguments, False otherwise.

  This can only be False with UnliftedDatatypes, e.g.

  data A :: TYPE (BoxedRep l) where { MkA :: Int -> A }

  This boolean is cached to make it cheaper to check for levity and representation-polymorphism in tcHasFixedRuntimeRep.

TupleTyCon

Fields

• data_con :: DataCon

  The unique constructor for the newtype. It has no existentials

• tup_sort :: TupleSort

  Is this a boxed, unboxed or constraint tuple?

SumTyCon

An unboxed sum type.

Fields

• data_cons :: [DataCon]

  The data type constructors; can be empty if the user declares the type to have no constructors

  INVARIANT: Kept in order of increasing DataCon tag (see the tag assignment in mkTyConTagMap)

• data_cons_size :: Int

  Cached value: length data_cons

NewTyCon

Information about those TyCons derived from a newtype declaration

Fields

• data_con :: DataCon

  The unique constructor for the newtype. It has no existentials

• nt_rhs :: Type

  Cached value: the argument type of the constructor, which is just the representation type of the TyCon (remember that newtypes do not exist at runtime so need a different representation type).

  The free TyVars of this type are the tyConTyVars from the corresponding TyCon

• nt_etad_rhs :: ([TyVar], Type)

  Same as the nt_rhs, but this time eta-reduced. Hence the list of TyVars in this field may be shorter than the declared arity of the TyCon.

• nt_co :: CoAxiom Unbranched
• nt_fixed_rep :: Bool

  True if the newtype has a known, fixed representation when fully applied to its arguments, False otherwise. This can only ever be False with UnliftedNewtypes.

  Example:

  newtype N (a :: TYPE r) = MkN a

  Invariant: nt_fixed_rep nt = tcHasFixedRuntimeRep (nt_rhs nt)

  This boolean is cached to make it cheaper to check if a variable binding is representation-polymorphic in tcHasFixedRuntimeRep.

data TyConBndrVis

Constructors

NamedTCB ForAllTyFlag

AnonTCB FunTyFlag

Instances

Binary TyConBndrVis

Defined in GHC.Core.TyCon

Methods

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

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

get :: BinHandle -> IO TyConBndrVis

Outputable TyConBndrVis

Defined in GHC.Core.TyCon

Methods

ppr :: TyConBndrVis -> SDoc

OutputableBndr tv => Outputable (VarBndr tv TyConBndrVis)

Defined in GHC.Core.TyCon

Methods

ppr :: VarBndr tv TyConBndrVis -> SDoc

type TyConPiTyBinder = VarBndr TyCoVar TyConBndrVis

type TyConBinder = VarBndr TyVar TyConBndrVis

type TvSubstEnv = TyVarEnv Type

A substitution of Types for TyVars and Kinds for KindVars

data EqRel

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

Constructors

NomEq

ReprEq

Instances

Outputable EqRel

Defined in GHC.Core.Predicate

Methods

ppr :: EqRel -> SDoc

Eq EqRel

Defined in GHC.Core.Predicate

Methods

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

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

Ord EqRel

Defined in GHC.Core.Predicate

Methods

compare :: EqRel -> EqRel -> Ordering

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

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

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

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

max :: EqRel -> EqRel -> EqRel

min :: EqRel -> EqRel -> EqRel

data Pred

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

Constructors

ClassPred Class [Type]

A typeclass predicate.

EqPred EqRel Type Type

A type equality predicate.

IrredPred PredType

An irreducible predicate.

ForAllPred [TyVar] [PredType] PredType

A quantified predicate.

See Note [Quantified constraints] in GHC.Tc.Solver.Canonical

data HsModule p

Haskell Module

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

Constructors

HsModule

AnnKeywordIds

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

Fields

• hsmodExt :: XCModule p

  HsModule extension point

• hsmodName :: Maybe (XRec p ModuleName)

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

• hsmodExports :: Maybe (XRec p [LIE p])

  Export list

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

  Type, class, value, and interface signature decls

XModule !(XXModule p)

data FamInstMatch

Constructors

FamInstMatch

Fields

• fim_instance :: FamInst
• fim_tys :: [Type]
• fim_cos :: [Coercion]

Instances

Outputable FamInstMatch

Defined in GHC.Core.FamInstEnv

Methods

ppr :: FamInstMatch -> SDoc

data InjectivityCheckResult

Result of testing two type family equations for injectiviy.

Constructors

InjectivityAccepted

Either RHSs are distinct or unification of RHSs leads to unification of LHSs

InjectivityUnified CoAxBranch CoAxBranch

RHSs unify but LHSs don't unify under that substitution. Relevant for closed type families where equation after unification might be overlapped (in which case it is OK if they don't unify). Constructor stores axioms after unification.

data FamInstEnv

Instances

Outputable FamInstEnv

Defined in GHC.Core.FamInstEnv

Methods

ppr :: FamInstEnv -> SDoc

type FamInstEnvs = (FamInstEnv, FamInstEnv)

data FamFlavor

Constructors

SynFamilyInst

DataFamilyInst TyCon

data FamInst

Constructors

FamInst

Fields

• fi_axiom :: CoAxiom Unbranched
• fi_flavor :: FamFlavor
• fi_fam :: Name
• fi_tcs :: [RoughMatchTc]
• fi_tvs :: [TyVar]
• fi_cvs :: [CoVar]
• fi_tys :: [Type]
• fi_rhs :: Type

Instances

NamedThing FamInst

Defined in GHC.Core.FamInstEnv

Methods

getOccName :: FamInst -> OccName

getName :: FamInst -> Name

Outputable FamInst

Defined in GHC.Core.FamInstEnv

Methods

ppr :: FamInst -> SDoc

data EvTerm

Instances

Data EvTerm

Defined in GHC.Tc.Types.Evidence

Methods

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

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

toConstr :: EvTerm -> Constr

dataTypeOf :: EvTerm -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable EvTerm

Defined in GHC.Tc.Types.Evidence

Methods

ppr :: EvTerm -> SDoc

data UnitDatabase unit

Unit database

Constructors

UnitDatabase

Fields

• unitDatabasePath :: FilePath
• unitDatabaseUnits :: [GenUnitInfo unit]

Instances

Outputable u => Outputable (UnitDatabase u)

Defined in GHC.Unit.State

Methods

ppr :: UnitDatabase u -> SDoc

data HsParsedModule

Constructors

HsParsedModule

Fields

• hpm_module :: Located (HsModule GhcPs)
• hpm_src_files :: [FilePath]

  extra source files (e.g. from #includes). The lexer collects these from '# file line' pragmas, which the C preprocessor leaves behind. These files and their timestamps are stored in the .hi file, so that we can force recompilation if any of them change (#3589)

data CtLoc

Constructors

CtLoc

Fields

• ctl_origin :: CtOrigin
• ctl_env :: TcLclEnv
• ctl_t_or_k :: Maybe TypeOrKind
• ctl_depth :: !SubGoalDepth

data CtEvidence

Instances

Outputable CtEvidence

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: CtEvidence -> SDoc

data Ct

Instances

Outputable Ct

Defined in GHC.Tc.Types.Constraint

Methods

ppr :: Ct -> SDoc

data HscEnv

HscEnv is like Session, except that some of the fields are immutable. An HscEnv is used to compile a single module from plain Haskell source code (after preprocessing) to either C, assembly or C--. It's also used to store the dynamic linker state to allow for multiple linkers in the same address space. Things like the module graph don't change during a single compilation.

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

Instances

ContainsDynFlags HscEnv

Defined in GHC.Driver.Env.Types

Methods

extractDynFlags :: HscEnv -> DynFlags

data TcPluginSolveResult

Result of running a solver plugin.

Constructors

TcPluginSolveResult

Fields

• tcPluginInsolubleCts :: [Ct]

  Insoluble constraints found by the plugin.

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

• tcPluginSolvedCts :: [(EvTerm, Ct)]

  Solved constraints, together with their evidence.

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

• tcPluginNewCts :: [Ct]

  New constraints that the plugin wishes to emit.

  These will be added to the work list.

Bundled Patterns

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

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.

data TcPlugin

Constructors

TcPlugin

Fields

• tcPluginInit :: TcPluginM s

  Initialize 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 simplify 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 constraints. These returned constraints must be Givens in the first case, and Wanteds in the second.

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

• tcPluginRewrite :: s -> UniqFM TyCon TcPluginRewriter

  Rewrite saturated type family applications.

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

  Use \ _ -> emptyUFM if your plugin does not provide this functionality.

• tcPluginStop :: s -> TcPluginM ()

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

data TcPluginM a

TcPluginM is the monad in which type-checking plugins operate.

Instances

MonadFail TcPluginM

Defined in GHC.Tc.Types

Methods

fail :: String -> TcPluginM a

Applicative TcPluginM

Defined in GHC.Tc.Types

Methods

pure :: a -> TcPluginM a

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

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

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

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

Functor TcPluginM

Defined in GHC.Tc.Types

Methods

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

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

Monad TcPluginM

Defined in GHC.Tc.Types

Methods

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

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

return :: a -> TcPluginM a

type PredTree = Pred

data TvSubst

Constructors

TvSubst InScopeSet TvSubstEnv

Instances

Outputable TvSubst

Defined in GHC.TypeLits.Presburger.Compat

Methods

ppr :: TvSubst -> SDoc

type TCvSubst = Subst

newtype TypeEq

Constructors

TypeEq

Fields

• runTypeEq :: Type

Instances

Eq TypeEq

Defined in GHC.TypeLits.Presburger.Compat

Methods

(==) :: TypeEq -> TypeEq -> Bool

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

Ord TypeEq

Defined in GHC.TypeLits.Presburger.Compat

Methods

compare :: TypeEq -> TypeEq -> Ordering

(<) :: TypeEq -> TypeEq -> Bool

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

(>) :: TypeEq -> TypeEq -> Bool

(>=) :: TypeEq -> TypeEq -> Bool

max :: TypeEq -> TypeEq -> TypeEq

min :: TypeEq -> TypeEq -> TypeEq

type Substitution = [(TcTyVar, TcType)]

type RawPackageName = FastString

type ModuleUnit = Unit

type HsModule' = HsModule

text :: IsLine doc => String -> doc

splitTyConApp :: Type -> (TyCon, [Type])

Attempts to tease a type apart into a type constructor and the application of a number of arguments to that constructor. Panics if that is not possible. See also splitTyConApp_maybe

mkTyConTy :: TyCon -> Type

(mkTyConTy tc) returns (TyConApp tc []) but arranges to share that TyConApp among all calls See Note [Sharing nullary TyConApps] So it's just an alias for tyConNullaryTy!

unpackFS :: FastString -> String

Lazily unpacks and decodes the FastString

fsLit :: String -> FastString

noExtField :: NoExtField

mkModuleName :: String -> ModuleName

ppr :: Outputable a => a -> SDoc

showSDocUnsafe :: SDoc -> String

getUnique :: Uniquable a => a -> Unique

getKey :: Unique -> Int

mkPrelTyConRepName :: Name -> TyConRepName

Make a Name for the Typeable representation of the given wired-in type

tyConRepName_maybe :: TyCon -> Maybe TyConRepName

isUnboxedTupleTyCon :: TyCon -> Bool

Is this the TyCon for an unboxed tuple?

isTupleTyCon :: TyCon -> Bool

Does this TyCon represent a tuple?

NB: when compiling Data.Tuple, the tycons won't reply True to isTupleTyCon, because they are built as AlgTyCons. However they get spat into the interface file as tuple tycons, so I don't think it matters.

mkUniqSet :: Uniquable a => [a] -> UniqSet a

elementOfUniqSet :: Uniquable a => a -> UniqSet a -> Bool

mkModule :: u -> ModuleName -> GenModule u

dataConWrapId :: DataCon -> Id

Returns an Id which looks like the Haskell-source constructor by using the wrapper if it exists (see dataConWrapId_maybe) and failing over to the worker (see dataConWorkId)

cTupleDataCon :: Arity -> DataCon

mkTcOcc :: String -> OccName

emptyOccSet :: OccSet

mkInstTyTcOcc

Arguments

:: String

Family name, e.g. Map

-> OccSet

avoid these Occs

-> OccName

R:Map

Derive a name for the representation type constructor of a data/newtype instance.

tyConAppTyCon_maybe :: Type -> Maybe TyCon

The same as fst . splitTyConApp We can short-cut the FunTy case

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

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

typeKind :: HasDebugCallStack => Type -> Kind

mkBaseModule :: FastString -> Module

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.

classTyCon :: Class -> TyCon

className :: Class -> Name

algTcFields :: TyConDetails -> FieldLabelEnv

Maps a label to information about the field

mkAnonTyConBinder :: TyVar -> TyConBinder

mkAnonTyConBinders :: [TyVar] -> [TyConBinder]

mkInvisAnonTyConBinder :: TyVar -> TyConBinder

mkNamedTyConBinder :: ForAllTyFlag -> TyVar -> TyConBinder

mkNamedTyConBinders :: ForAllTyFlag -> [TyVar] -> [TyConBinder]

mkRequiredTyConBinder :: TyCoVarSet -> TyVar -> TyConBinder

Make a Required TyConBinder. It chooses between NamedTCB and AnonTCB based on whether the tv is mentioned in the dependent set

tyConBinderForAllTyFlag :: TyConBinder -> ForAllTyFlag

tyConBndrVisForAllTyFlag :: TyConBndrVis -> ForAllTyFlag

isNamedTyConBinder :: TyConBinder -> Bool

isVisibleTyConBinder :: VarBndr tv TyConBndrVis -> Bool

isVisibleTcbVis :: TyConBndrVis -> Bool

isInvisibleTyConBinder :: VarBndr tv TyConBndrVis -> Bool

mkTyConKind :: [TyConBinder] -> Kind -> Kind

tyConInvisTVBinders :: [TyConBinder] -> [InvisTVBinder]

tyConVisibleTyVars :: TyCon -> [TyVar]

mkLevPolyDataTyConRhs

Arguments

:: Bool

whether the DataCon has a fixed levity

-> Bool

True if this is a "type data" declaration See Note [Type data declarations] in GHC.Rename.Module

-> [DataCon]

-> AlgTyConRhs

Create an AlgTyConRhs from the data constructors, for a potentially levity-polymorphic datatype (with UnliftedDatatypes).

mkDataTyConRhs :: [DataCon] -> AlgTyConRhs

Create an AlgTyConRhs from the data constructors.

Use mkLevPolyDataConRhs if the datatype can be levity-polymorphic or if it comes from a "data type" declaration

visibleDataCons :: AlgTyConRhs -> [DataCon]

Extract those DataCons that we are able to learn about. Note that visibility in this sense does not correspond to visibility in the context of any particular user program!

isNoParent :: AlgTyConFlav -> Bool

tyConRepModOcc :: Module -> OccName -> (Module, OccName)

The name (and defining module) for the Typeable representation (TyCon) of a type constructor.

See Note [Grand plan for Typeable] in GHC.Tc.Instance.Typeable.

isVoidRep :: PrimRep -> Bool

isGcPtrRep :: PrimRep -> Bool

primRepCompatible :: Platform -> PrimRep -> PrimRep -> Bool

primRepsCompatible :: Platform -> [PrimRep] -> [PrimRep] -> Bool

primRepSizeB :: Platform -> PrimRep -> Int

The size of a PrimRep in bytes.

This applies also when used in a constructor, where we allow packing the fields. For instance, in data Foo = Foo Float# Float# the two fields will take only 8 bytes, which for 64-bit arch will be equal to 1 word. See also mkVirtHeapOffsetsWithPadding for details of how data fields are laid out.

primElemRepSizeB :: Platform -> PrimElemRep -> Int

primElemRepToPrimRep :: PrimElemRep -> PrimRep

primRepIsFloat :: PrimRep -> Maybe Bool

Return if Rep stands for floating type, returns Nothing for vector types.

primRepIsWord :: PrimRep -> Bool

primRepIsInt :: PrimRep -> Bool

tyConFieldLabels :: TyCon -> [FieldLabel]

The labels for the fields of this particular TyCon

lookupTyConFieldLabel :: FieldLabelString -> TyCon -> Maybe FieldLabel

Look up a field label belonging to this TyCon

mkAlgTyCon

Arguments

:: Name

-> [TyConBinder]

Binders of the TyCon

-> Kind

Result kind

-> [Role]

The roles for each TyVar

-> Maybe CType

The C type this type corresponds to when using the CAPI FFI

-> [PredType]

Stupid theta: see algTcStupidTheta

-> AlgTyConRhs

Information about data constructors

-> AlgTyConFlav

What flavour is it? (e.g. vanilla, type family)

-> Bool

Was the TyCon declared with GADT syntax?

-> TyCon

This is the making of an algebraic TyCon.

mkClassTyCon :: Name -> [TyConBinder] -> [Role] -> AlgTyConRhs -> Class -> Name -> TyCon

Simpler specialization of mkAlgTyCon for classes

mkTupleTyCon

Arguments

:: Name

-> [TyConBinder]

-> Kind

Result kind of the TyCon

-> DataCon

-> TupleSort

Whether the tuple is boxed or unboxed

-> AlgTyConFlav

-> TyCon

mkSumTyCon

Arguments

:: Name

-> [TyConBinder]

-> Kind

Kind of the resulting TyCon

-> [DataCon]

-> AlgTyConFlav

-> TyCon

mkTcTyCon

Arguments

:: Name

-> [TyConBinder]

-> Kind

result kind only

-> [(Name, TcTyVar)]

Scoped type variables; see Note [How TcTyCons work] in GHC.Tc.TyCl

-> Bool

Is this TcTyCon generalised already?

-> TyConFlavour

What sort of TyCon this represents

-> TyCon

Makes a tycon suitable for use during type-checking. It stores a variety of details about the definition of the TyCon, but no right-hand side. It lives only during the type-checking of a mutually-recursive group of tycons; it is then zonked to a proper TyCon in zonkTcTyCon. See also Note [Kind checking recursive type and class declarations] in GHC.Tc.TyCl.

noTcTyConScopedTyVars :: [(Name, TcTyVar)]

No scoped type variables (to be used with mkTcTyCon).

mkPrimTyCon

Arguments

:: Name

-> [TyConBinder]

-> Kind

result kind Must answer True to isFixedRuntimeRepKind (i.e., no representation polymorphism). (If you need a representation-polymorphic PrimTyCon, change tcHasFixedRuntimeRep, marshalablePrimTyCon, reifyTyCon for PrimTyCons.)

-> [Role]

-> TyCon

Create an primitive TyCon, such as Int#, Type or RealWorld# Primitive TyCons are marshalable iff not lifted. If you'd like to change this, modify marshalablePrimTyCon.

mkSynonymTyCon

Arguments

:: Name

-> [TyConBinder]

-> Kind

result kind

-> [Role]

-> Type

-> Bool

-> Bool

-> Bool

-> TyCon

Create a type synonym TyCon

mkFamilyTyCon

Arguments

:: Name

-> [TyConBinder]

-> Kind

result kind

-> Maybe Name

-> FamTyConFlav

-> Maybe Class

-> Injectivity

-> TyCon

Create a type family TyCon

mkPromotedDataCon :: DataCon -> Name -> TyConRepName -> [TyConPiTyBinder] -> Kind -> [Role] -> PromDataConInfo -> TyCon

Create a promoted data constructor TyCon Somewhat dodgily, we give it the same Name as the data constructor itself; when we pretty-print the TyCon we add a quote; see the Outputable TyCon instance

isAbstractTyCon :: TyCon -> Bool

Test if the TyCon is algebraic but abstract (invisible data constructors)

isPrimTyCon :: TyCon -> Bool

Does this TyCon represent something that cannot be defined in Haskell?

isAlgTyCon :: TyCon -> Bool

Returns True if the supplied TyCon resulted from either a data or newtype declaration

isVanillaAlgTyCon :: TyCon -> Bool

Returns True for vanilla AlgTyCons -- that is, those created with a data or newtype declaration.

isDataTyCon :: TyCon -> Bool

Returns True for data types that are definitely represented by heap-allocated constructors. These are scrutinised by Core-level case expressions, and they get info tables allocated for them.

Generally, the function will be true for all data types and false for newtypes, unboxed tuples, unboxed sums and type family TyCons. But it is not guaranteed to return True in all cases that it could.

NB: for a data type family, only the instance TyCons get an info table. The family declaration TyCon does not

isTypeDataTyCon :: TyCon -> Bool

Was this TyCon declared as "type data"? See Note [Type data declarations] in GHC.Rename.Module.

isInjectiveTyCon :: TyCon -> Role -> Bool

isInjectiveTyCon is true of TyCons for which this property holds (where r is the role passed in): If (T a1 b1 c1) ~r (T a2 b2 c2), then (a1 ~r1 a2), (b1 ~r2 b2), and (c1 ~r3 c2) (where r1, r2, and r3, are the roles given by tyConRolesX tc r) See also Note [Decomposing TyConApp equalities] in GHC.Tc.Solver.Canonical

isGenerativeTyCon :: TyCon -> Role -> Bool

isGenerativeTyCon is true of TyCons for which this property holds (where r is the role passed in): If (T tys ~r t), then (t's head ~r T). See also Note [Decomposing TyConApp equalities] in GHC.Tc.Solver.Canonical

isGenInjAlgRhs :: AlgTyConRhs -> Bool

Is this an AlgTyConRhs of a TyCon that is generative and injective with respect to representational equality?

isNewTyCon :: TyCon -> Bool

Is this TyCon that for a newtype

unwrapNewTyCon_maybe :: TyCon -> Maybe ([TyVar], Type, CoAxiom Unbranched)

Take a TyCon apart into the TyVars it scopes over, the Type it expands into, and (possibly) a coercion from the representation type to the newtype. Returns Nothing if this is not possible.

unwrapNewTyConEtad_maybe :: TyCon -> Maybe ([TyVar], Type, CoAxiom Unbranched)

isTypeSynonymTyCon :: TyCon -> Bool

Is this a TyCon representing a regular H98 type synonym (type)?

isTauTyCon :: TyCon -> Bool

isFamFreeTyCon :: TyCon -> Bool

Is this tycon neither a type family nor a synonym that expands to a type family?

isForgetfulSynTyCon :: TyCon -> Bool

Is this a forgetful type synonym? If this is a type synonym whose RHS does not mention one (or more) of its bound variables, returns True. Thus, False means that all bound variables appear on the RHS; True may not mean anything, as the test to set this flag is conservative.

tyConMustBeSaturated :: TyCon -> Bool

True iff we can decompose (T a b c) into ((T a b) c) I.e. is it injective and generative w.r.t nominal equality? That is, if (T a b) ~N d e f, is it always the case that (T ~N d), (a ~N e) and (b ~N f)? Specifically NOT true of synonyms (open and otherwise)

It'd be unusual to call tyConMustBeSaturated on a regular H98 type synonym, because you should probably have expanded it first But regardless, it's not decomposable

isGadtSyntaxTyCon :: TyCon -> Bool

Is this an algebraic TyCon declared with the GADT syntax?

isEnumerationTyCon :: TyCon -> Bool

Is this an algebraic TyCon which is just an enumeration of values?

isFamilyTyCon :: TyCon -> Bool

Is this a TyCon, synonym or otherwise, that defines a family?

isOpenFamilyTyCon :: TyCon -> Bool

Is this a TyCon, synonym or otherwise, that defines a family with instances?

isTypeFamilyTyCon :: TyCon -> Bool

Is this a synonym TyCon that can have may have further instances appear?

isDataFamilyTyCon :: TyCon -> Bool

Is this a synonym TyCon that can have may have further instances appear?

isOpenTypeFamilyTyCon :: TyCon -> Bool

Is this an open type family TyCon?

isClosedSynFamilyTyConWithAxiom_maybe :: TyCon -> Maybe (CoAxiom Branched)

Is this a non-empty closed type family? Returns Nothing for abstract or empty closed families.

isBuiltInSynFamTyCon_maybe :: TyCon -> Maybe BuiltInSynFamily

tyConFamilyResVar_maybe :: TyCon -> Maybe Name

Extract type variable naming the result of injective type family

tyConInjectivityInfo :: TyCon -> Injectivity

tyConInjectivityInfo tc returns Injective is if tc is an injective tycon (where is states for which tyConBinders tc is injective), or NotInjective otherwise.

isTyConAssoc :: TyCon -> Bool

Is this TyCon for an associated type?

tyConAssoc_maybe :: TyCon -> Maybe TyCon

Get the enclosing class TyCon (if there is one) for the given TyCon.

tyConFlavourAssoc_maybe :: TyConFlavour -> Maybe TyCon

Get the enclosing class TyCon (if there is one) for the given TyConFlavour

tyConTuple_maybe :: TyCon -> Maybe TupleSort

isBoxedTupleTyCon :: TyCon -> Bool

Is this the TyCon for a boxed tuple?

isUnboxedSumTyCon :: TyCon -> Bool

Is this the TyCon for an unboxed sum?

isLiftedAlgTyCon :: TyCon -> Bool

isPromotedDataCon_maybe :: TyCon -> Maybe DataCon

Retrieves the promoted DataCon if this is a PromotedDataCon;

isPromotedTupleTyCon :: TyCon -> Bool

Is this the TyCon for a promoted tuple?

isPromotedDataCon :: TyCon -> Bool

Is this a PromotedDataCon?

isDataKindsPromotedDataCon :: TyCon -> Bool

This function identifies PromotedDataCon's from data constructors in `data T = K1 | K2`, promoted by -XDataKinds. These type constructors are printed with a tick mark 'K1 and 'K2, and similarly have a tick mark added to their OccName's.

In contrast, constructors in `type data T = K1 | K2` are printed and represented with their original undecorated names. See Note [Type data declarations] in GHC.Rename.Module

isKindTyCon :: TyCon -> Bool

Is this tycon really meant for use at the kind level? That is, should it be permitted without -XDataKinds?

isLiftedTypeKindTyConName :: Name -> Bool

isImplicitTyCon :: TyCon -> Bool

Identifies implicit tycons that, in particular, do not go into interface files (because they are implicitly reconstructed when the interface is read).

Note that:

• Associated families are implicit, as they are re-constructed from the class declaration in which they reside, and
• Family instances are not implicit as they represent the instance body (similar to a dfun does that for a class instance).
• Tuples are implicit iff they have a wired-in name (namely: boxed and unboxed tuples are wired-in and implicit, but constraint tuples are not)

tyConCType_maybe :: TyCon -> Maybe CType

tcHasFixedRuntimeRep :: TyCon -> Bool

Does this TyCon have a syntactically fixed RuntimeRep when fully applied, as per Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete?

False is safe. True means we're sure. Does only a quick check, based on the TyCon's category.

See Note [Representation-polymorphic TyCons]

isConcreteTyCon :: TyCon -> Bool

Is this TyCon concrete (i.e. not a synonym/type family)?

Used for representation polymorphism checks.

isTcTyCon :: TyCon -> Bool

Is this a TcTyCon? (That is, one only used during type-checking?)

setTcTyConKind :: TyCon -> Kind -> TyCon

isMonoTcTyCon :: TyCon -> Bool

tcTyConScopedTyVars :: TyCon -> [(Name, TcTyVar)]

expandSynTyCon_maybe

Arguments

:: TyCon

-> [tyco]

Arguments to TyCon

-> ExpandSynResult tyco

Returns a TyVar substitution, the body type of the synonym (not yet substituted) and any arguments remaining from the application ^ Expand a type synonym application Return Nothing if the TyCon is not a synonym, or if not enough arguments are supplied

isTyConWithSrcDataCons :: TyCon -> Bool

Check if the tycon actually refers to a proper `data` or `newtype` with user defined constructors rather than one from a class or other construction.

tyConDataCons :: TyCon -> [DataCon]

As tyConDataCons_maybe, but returns the empty list of constructors if no constructors could be found

tyConDataCons_maybe :: TyCon -> Maybe [DataCon]

Determine the DataCons originating from the given TyCon, if the TyCon is the sort that can have any constructors (note: this does not include abstract algebraic types)

tyConSingleDataCon_maybe :: TyCon -> Maybe DataCon

If the given TyCon has a single data constructor, i.e. it is a data type with one alternative, a tuple type or a newtype then that constructor is returned. If the TyCon has more than one constructor, or represents a primitive or function type constructor then Nothing is returned.

tyConSingleDataCon :: TyCon -> DataCon

Like tyConSingleDataCon_maybe, but panics if Nothing.

tyConSingleAlgDataCon_maybe :: TyCon -> Maybe DataCon

Like tyConSingleDataCon_maybe, but returns Nothing for newtypes.

tyConAlgDataCons_maybe :: TyCon -> Maybe [DataCon]

Returns Just dcs if the given TyCon is a data type, a tuple type or a sum type with data constructors dcs. If the TyCon has more than one constructor, or represents a primitive or function type constructor then Nothing is returned.

Like tyConDataCons_maybe, but returns Nothing for newtypes.

tyConFamilySize :: TyCon -> Int

Determine the number of value constructors a TyCon has. Panics if the TyCon is not algebraic or a tuple

algTyConRhs :: TyCon -> AlgTyConRhs

Extract an AlgTyConRhs with information about data constructors from an algebraic or tuple TyCon. Panics for any other sort of TyCon

newTyConRhs :: TyCon -> ([TyVar], Type)

Extract the bound type variables and type expansion of a type synonym TyCon. Panics if the TyCon is not a synonym

newTyConEtadArity :: TyCon -> Int

The number of type parameters that need to be passed to a newtype to resolve it. May be less than in the definition if it can be eta-contracted.

newTyConEtadRhs :: TyCon -> ([TyVar], Type)

Extract the bound type variables and type expansion of an eta-contracted type synonym TyCon. Panics if the TyCon is not a synonym

newTyConCo_maybe :: TyCon -> Maybe (CoAxiom Unbranched)

Extracts the newtype coercion from such a TyCon, which can be used to construct something with the newtypes type from its representation type (right hand side). If the supplied TyCon is not a newtype, returns Nothing

newTyConCo :: TyCon -> CoAxiom Unbranched

newTyConDataCon_maybe :: TyCon -> Maybe DataCon

tyConStupidTheta :: TyCon -> [PredType]

Find the "stupid theta" of the TyCon. A "stupid theta" is the context to the left of an algebraic type declaration, e.g. Eq a in the declaration data Eq a => T a .... See Note [The stupid context] in GHC.Core.DataCon.

synTyConDefn_maybe :: TyCon -> Maybe ([TyVar], Type)

Extract the TyVars bound by a vanilla type synonym and the corresponding (unsubstituted) right hand side.

synTyConRhs_maybe :: TyCon -> Maybe Type

Extract the information pertaining to the right hand side of a type synonym (type) declaration.

famTyConFlav_maybe :: TyCon -> Maybe FamTyConFlav

Extract the flavour of a type family (with all the extra information that it carries)

isClassTyCon :: TyCon -> Bool

Is this TyCon that for a class instance?

tyConClass_maybe :: TyCon -> Maybe Class

If this TyCon is that for a class instance, return the class it is for. Otherwise returns Nothing

tyConATs :: TyCon -> [TyCon]

Return the associated types of the TyCon, if any

isFamInstTyCon :: TyCon -> Bool

Is this TyCon that for a data family instance?

tyConFamInstSig_maybe :: TyCon -> Maybe (TyCon, [Type], CoAxiom Unbranched)

tyConFamInst_maybe :: TyCon -> Maybe (TyCon, [Type])

If this TyCon is that of a data family instance, return the family in question and the instance types. Otherwise, return Nothing

tyConFamilyCoercion_maybe :: TyCon -> Maybe (CoAxiom Unbranched)

If this TyCon is that of a data family instance, return a TyCon which represents a coercion identifying the representation type with the type instance family. Otherwise, return Nothing

tyConPromDataConInfo :: TyCon -> PromDataConInfo

Extract any RuntimeRepInfo from this TyCon

mkTyConTagMap :: TyCon -> NameEnv ConTag

tyConFlavour :: TyCon -> TyConFlavour

tcFlavourIsOpen :: TyConFlavour -> Bool

Is this flavour of TyCon an open type family or a data family?

pprPromotionQuote :: TyCon -> SDoc

tyConSkolem :: TyCon -> Bool

Returns whether or not this TyCon is definite, or a hole that may be filled in at some later point. See Note [Skolem abstract data]

mkTyVarTy :: TyVar -> Type

emptySubst :: Subst

unionSubst :: Subst -> Subst -> Subst

substTy :: TvSubst -> Type -> Type

isNumLitTy :: Type -> Maybe Integer

Is this a numeric literal. We also look through type synonyms.

isStrLitTy :: Type -> Maybe FastString

Is this a symbol literal. We also look through type synonyms.

eqType :: Type -> Type -> Bool

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

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

Makes a lifted equality predicate at the given role

tcUnifyTy :: Type -> Type -> Maybe TvSubst

classifyPredType :: Type -> PredTree

isEqPred :: PredType -> Bool

lookupTyCon :: MonadThings m => Name -> m TyCon

eqTyConName :: Name

cTupleTyCon :: Arity -> TyCon

boolTyCon :: TyCon

nilDataCon :: DataCon

consDataCon :: DataCon

promotedTrueDataCon :: TyCon

promotedFalseDataCon :: TyCon

promotedLTDataCon :: TyCon

promotedEQDataCon :: TyCon

promotedGTDataCon :: TyCon

famInstAxiom :: FamInst -> CoAxiom Unbranched

famInstRHS :: FamInst -> Type

famInstTyCon :: FamInst -> TyCon

famInstsRepTyCons :: [FamInst] -> [TyCon]

famInstRepTyCon_maybe :: FamInst -> Maybe TyCon

dataFamInstRepTyCon :: FamInst -> TyCon

orphNamesOfFamInst :: FamInst -> NameSet

pprFamInst :: FamInst -> SDoc

pprFamInsts :: [FamInst] -> SDoc

mkImportedFamInst :: Name -> [RoughMatchTc] -> CoAxiom Unbranched -> FamInst

famInstEnvSize :: FamInstEnv -> Int

emptyFamInstEnvs :: (FamInstEnv, FamInstEnv)

Create a FamInstEnv from Name indices. INVARIANTS: * The fs_tvs are distinct in each FamInst of a range value of the map (so we can safely unify them)

emptyFamInstEnv :: FamInstEnv

famInstEnvElts :: FamInstEnv -> [FamInst]

familyInstances :: (FamInstEnv, FamInstEnv) -> TyCon -> [FamInst]

familyNameInstances :: (FamInstEnv, FamInstEnv) -> Name -> [FamInst]

unionFamInstEnv :: FamInstEnv -> FamInstEnv -> FamInstEnv

Makes no particular effort to detect conflicts.

extendFamInstEnvList :: FamInstEnv -> [FamInst] -> FamInstEnv

extendFamInstEnv :: FamInstEnv -> FamInst -> FamInstEnv

compatibleBranches :: CoAxBranch -> CoAxBranch -> Bool

injectiveBranches :: [Bool] -> CoAxBranch -> CoAxBranch -> InjectivityCheckResult

Check whether two type family axioms don't violate injectivity annotation.

mkCoAxBranch :: [TyVar] -> [TyVar] -> [CoVar] -> [Type] -> Type -> [Role] -> SrcSpan -> CoAxBranch

mkBranchedCoAxiom :: Name -> TyCon -> [CoAxBranch] -> CoAxiom Branched

mkUnbranchedCoAxiom :: Name -> TyCon -> CoAxBranch -> CoAxiom Unbranched

mkSingleCoAxiom :: Role -> Name -> [TyVar] -> [TyVar] -> [CoVar] -> TyCon -> [Type] -> Type -> CoAxiom Unbranched

mkNewTypeCoAxiom :: Name -> TyCon -> [TyVar] -> [Role] -> Type -> CoAxiom Unbranched

Create a coercion constructor (axiom) suitable for the given newtype TyCon. The Name should be that of a new coercion CoAxiom, the TyVars the arguments expected by the newtype and the type the appropriate right hand side of the newtype, with the free variables a subset of those TyVars.

lookupFamInstEnvByTyCon :: FamInstEnvs -> TyCon -> [FamInst]

lookupFamInstEnv :: FamInstEnvs -> TyCon -> [Type] -> [FamInstMatch]

lookupFamInstEnvConflicts :: FamInstEnvs -> FamInst -> [FamInst]

lookupFamInstEnvInjectivityConflicts :: [Bool] -> FamInstEnvs -> FamInst -> [CoAxBranch]

Check whether an open type family equation can be added to already existing instance environment without causing conflicts with supplied injectivity annotations. Returns list of conflicting axioms (type instance declarations).

isDominatedBy :: CoAxBranch -> [CoAxBranch] -> Bool

reduceTyFamApp_maybe :: FamInstEnvs -> Role -> TyCon -> [Type] -> Maybe Reduction

apartnessCheck

Arguments

:: [Type]

flattened target arguments. Make sure they're flattened! See Note [Flattening type-family applications when matching instances] in GHC.Core.Unify.

-> CoAxBranch

the candidate equation we wish to use Precondition: this matches the target

-> Bool

True = equation can fire

Do an apartness check, as described in the "Closed Type Families" paper (POPL '14). This should be used when determining if an equation (CoAxBranch) of a closed type family can be used to reduce a certain target type family application.

topNormaliseType :: FamInstEnvs -> Type -> Type

topNormaliseType_maybe :: FamInstEnvs -> Type -> Maybe Reduction

Get rid of *outermost* (or toplevel) * type function redex * data family redex * newtypes returning an appropriate Representational coercion. Specifically, if topNormaliseType_maybe env ty = Just (co, ty') then (a) co :: ty ~R ty' (b) ty' is not a newtype, and is not a type-family or data-family redex

However, ty' can be something like (Maybe (F ty)), where (F ty) is a redex.

Always operates homogeneously: the returned type has the same kind as the original type, and the returned coercion is always homogeneous.

topReduceTyFamApp_maybe :: FamInstEnvs -> TyCon -> [Type] -> Maybe HetReduction

Try to simplify a type-family application, by *one* step If topReduceTyFamApp_maybe env r F tys = Just (HetReduction (Reduction co rhs) res_co) then co :: F tys ~R# rhs res_co :: typeKind(F tys) ~ typeKind(rhs) Type families and data families; always Representational role

normaliseType :: FamInstEnvs -> Role -> Type -> Reduction

normaliseTcApp :: FamInstEnvs -> Role -> TyCon -> [Type] -> Reduction

tcTyFamInsts :: Type -> [(TyCon, [Type])]

Finds outermost type-family applications occurring in a type, after expanding synonyms. In the list (F, tys) that is returned we guarantee that tys matches F's arity. For example, given type family F a :: * -> * (arity 1) calling tcTyFamInsts on (Maybe (F Int Bool) will return (F, [Int]), not (F, [Int,Bool])

This is important for its use in deciding termination of type instances (see #11581). E.g. type instance G [Int] = ...(F Int <big type>)... we don't need to take <big type> into account when asking if the calls on the RHS are smaller than the LHS

evCast :: EvExpr -> TcCoercion -> EvTerm

d |> co

classInstances :: InstEnvs -> Class -> [ClsInst]

lookupPackageName :: UnitState -> PackageName -> Maybe UnitId

Find the unit we know about with the given package name (e.g. foo), if any (NB: there might be a locally defined unit name which overrides this) This function is unsafe to use in general because it doesn't respect package visibility.

ctEvidence :: Ct -> CtEvidence

ctEvPred :: CtEvidence -> TcPredType

isWanted :: CtEvidence -> Bool

initialSubGoalDepth :: SubGoalDepth

unsafeTcPluginTcM :: TcM a -> TcPluginM a

This function provides an escape for direct access to the TcM monad. It should not be used lightly, and the provided TcPluginM API should be favoured instead.

purePlugin :: [CommandLineOption] -> IO PluginRecompile

defaultPlugin :: Plugin

Default plugin: does nothing at all, except for marking that safe inference has failed unless -fplugin-trustworthy is passed. For compatibility reason you should base all your plugin definitions on this default value.

lookupName :: Module -> OccName -> TcPluginM Name

Find a Name in a GenModule given an OccName

typeNatTyCons :: [TyCon]

typeNatAddTyCon :: TyCon

typeNatSubTyCon :: TyCon

typeNatMulTyCon :: TyCon

typeNatDivTyCon :: TyCon

typeNatModTyCon :: TyCon

typeNatExpTyCon :: TyCon

typeNatLogTyCon :: TyCon

typeNatCmpTyCon :: TyCon

typeSymbolCmpTyCon :: TyCon

typeSymbolAppendTyCon :: TyCon

typeConsSymbolTyCon :: TyCon

typeUnconsSymbolTyCon :: TyCon

typeCharToNatTyCon :: TyCon

typeNatToCharTyCon :: TyCon

typeNatCoAxiomRules :: UniqFM FastString CoAxiomRule

typeCharCmpTyCon :: TyCon

getTopEnv :: TcPluginM HscEnv

getCtLocM :: CtOrigin -> Maybe TypeOrKind -> TcM CtLoc

newWanted :: CtLoc -> PredType -> TcPluginM CtEvidence

Create a new Wanted constraint with the given CtLoc.

newFlexiTyVar :: Kind -> TcPluginM TcTyVar

lookupOrig :: Module -> OccName -> TcPluginM Name

tcLookupClass :: Name -> TcPluginM Class

tcLookupTyCon :: Name -> TcPluginM TyCon

getInstEnvs :: TcPluginM InstEnvs

matchFam :: TyCon -> [Type] -> TcPluginM (Maybe Reduction)

tcPluginIO :: IO a -> TcPluginM a

Perform some IO, typically to interact with an external tool.

tcPluginTrace :: String -> SDoc -> TcPluginM ()

Output useful for debugging the compiler.

lookupModule

Arguments

:: ModuleName

Name of the module

-> FastString

Name of the package containing the module. NOTE: This value is ignored on ghc>=8.0.

-> TcPluginM Module

Find a module

evByFiat

Arguments

:: String

Name the coercion should have

-> Type

The LHS of the equivalence relation (~)

-> Type

The RHS of the equivalence relation (~)

-> EvTerm

The EvTerm equivalent for unsafeCoerce

tracePlugin :: String -> TcPlugin -> TcPlugin

Print out extra information about the initialisation, stop, and every run of the plugin when -ddump-tc-trace is enabled.

dATA_TYPE_EQUALITY :: Module

unionTCvSubst :: TCvSubst -> TCvSubst -> TCvSubst

emptyTCvSubst :: Subst

toTCv :: TvSubst -> TCvSubst

emptyTvSubst :: TvSubst

unionTvSubst :: TvSubst -> TvSubst -> TvSubst

fromTCv :: TCvSubst -> TvSubst

promotedBoolTyCon :: TyCon

viewFunTy :: Type -> Maybe (Type, Type)

getEqTyCon :: TcPluginM TyCon

getEqWitnessTyCon :: TcPluginM TyCon

getEqBoolTyCon :: TcPluginM TyCon

decompFunTy :: Type -> [Type]

isTrivial :: PredType -> Bool

normaliseGivens :: [Ct] -> TcPluginM [Ct]

subsCt :: Substitution -> Ct -> Ct

subsType :: Substitution -> Type -> Type

mkSubstitution :: [Ct] -> Substitution

fsToUnitId :: FastString -> UnitId

loadedPackageNames :: [UnitDatabase UnitId] -> UnitState -> [RawPackageName]

preloadedUnitsM :: TcPluginM [RawPackageName]

moduleUnit' :: Module -> ModuleUnit

typeNatKind :: TcType

mtypeNatLeqTyCon :: Maybe TyCon

dATA_TYPE_ORD :: Module

lookupTyNatPredLeq :: TcPluginM Name

lookupTyNatBoolLeq :: TcPluginM TyCon

lookupAssertTyCon :: TcPluginM (Maybe TyCon)

lookupTyNatPredLt :: TcPluginM (Maybe TyCon)

lookupTyNatBoolLt :: TcPluginM (Maybe TyCon)

lookupTyNatPredGt :: TcPluginM (Maybe TyCon)

lookupTyNatBoolGt :: TcPluginM (Maybe TyCon)

lookupTyNatPredGeq :: TcPluginM (Maybe TyCon)

lookupTyNatBoolGeq :: TcPluginM (Maybe TyCon)

mOrdCondTyCon :: TcPluginM (Maybe TyCon)

lookupTyGenericCompare :: TcPluginM (Maybe TyCon)

lookupBool47 :: String -> TcPluginM (Maybe TyCon)

lookupTyNot :: TcPluginM (Maybe TyCon)

lookupTyIf :: TcPluginM (Maybe TyCon)

lookupTyAnd :: TcPluginM (Maybe TyCon)

lookupTyOr :: TcPluginM (Maybe TyCon)

matchFam' :: TyCon -> [Type] -> TcPluginM (Maybe Type)

getVoidTyCon :: TcPluginM TyCon