GHC.Plugins

This module is not used by GHC itself. Rather, it exports all of the functions and types you are likely to need when writing a plugin for GHC. So authors of plugins can probably get away simply with saying "import GHC.Plugins".

Particularly interesting modules for plugin writers include GHC.Core and GHC.Core.Opt.Monad.

Documentation

module GHC.Driver.Plugins

module GHC.Types.Name.Reader

data NameSpace

Instances

Binary NameSpace

Defined in GHC.Types.Name.Occurrence

Methods

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

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

get :: BinHandle -> IO NameSpace

Eq NameSpace

Defined in GHC.Types.Name.Occurrence

Methods

(==) :: NameSpace -> NameSpace -> Bool

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

Ord NameSpace

Defined in GHC.Types.Name.Occurrence

Methods

compare :: NameSpace -> NameSpace -> Ordering

(<) :: NameSpace -> NameSpace -> Bool

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

(>) :: NameSpace -> NameSpace -> Bool

(>=) :: NameSpace -> NameSpace -> Bool

max :: NameSpace -> NameSpace -> NameSpace

min :: NameSpace -> NameSpace -> NameSpace

data OccName

Occurrence Name

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

Instances

Data OccName

Defined in GHC.Types.Name.Occurrence

Methods

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

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

toConstr :: OccName -> Constr

dataTypeOf :: OccName -> DataType

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

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

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

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

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

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

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

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

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

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

NFData OccName

Defined in GHC.Types.Name.Occurrence

Methods

rnf :: OccName -> ()

HasOccName OccName

Defined in GHC.Types.Name.Occurrence

Methods

occName :: OccName -> OccName

Uniquable OccName

Defined in GHC.Types.Name.Occurrence

Methods

getUnique :: OccName -> Unique

Binary OccName

Defined in GHC.Types.Name.Occurrence

Methods

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

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

get :: BinHandle -> IO OccName

Outputable OccName

Defined in GHC.Types.Name.Occurrence

Methods

ppr :: OccName -> SDoc

OutputableBndr OccName

Defined in GHC.Types.Name.Occurrence

Methods

pprBndr :: BindingSite -> OccName -> SDoc

pprPrefixOcc :: OccName -> SDoc

pprInfixOcc :: OccName -> SDoc

bndrIsJoin_maybe :: OccName -> Maybe Int

Eq OccName

Defined in GHC.Types.Name.Occurrence

Methods

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

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

Ord OccName

Defined in GHC.Types.Name.Occurrence

Methods

compare :: OccName -> OccName -> Ordering

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

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

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

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

max :: OccName -> OccName -> OccName

min :: OccName -> OccName -> OccName

type FastStringEnv a = UniqFM FastString a

A non-deterministic set of FastStrings. See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM for explanation why it's not deterministic and why it matters. Use DFastStringEnv if the set eventually gets converted into a list or folded over in a way where the order changes the generated code.

class HasOccName name where

Other names in the compiler add additional information to an OccName. This class provides a consistent way to access the underlying OccName.

Methods

occName :: name -> OccName

Instances

HasOccName IfaceClassOp

Defined in GHC.Iface.Syntax

Methods

occName :: IfaceClassOp -> OccName

HasOccName IfaceConDecl

Defined in GHC.Iface.Syntax

Methods

occName :: IfaceConDecl -> OccName

HasOccName IfaceDecl

Defined in GHC.Iface.Syntax

Methods

occName :: IfaceDecl -> OccName

HasOccName HoleFitCandidate

Defined in GHC.Tc.Errors.Hole.FitTypes

Methods

occName :: HoleFitCandidate -> OccName

HasOccName TcBinder

Defined in GHC.Tc.Types

Methods

occName :: TcBinder -> OccName

HasOccName GreName

Defined in GHC.Types.Avail

Methods

occName :: GreName -> OccName

HasOccName FieldLabel

Defined in GHC.Types.FieldLabel

Methods

occName :: FieldLabel -> OccName

HasOccName Name

Defined in GHC.Types.Name

Methods

occName :: Name -> OccName

HasOccName OccName

Defined in GHC.Types.Name.Occurrence

Methods

occName :: OccName -> OccName

HasOccName GlobalRdrElt

Defined in GHC.Types.Name.Reader

Methods

occName :: GlobalRdrElt -> OccName

HasOccName RdrName

Defined in GHC.Types.Name.Reader

Methods

occName :: RdrName -> OccName

HasOccName Var

Defined in GHC.Types.Var

Methods

occName :: Var -> OccName

(HasOccName (IdP (GhcPass p)), OutputableBndrId p) => HasOccName (IEWrappedName (GhcPass p))

Defined in GHC.Hs.ImpExp

Methods

occName :: IEWrappedName (GhcPass p) -> OccName

data OccEnv a

Instances

Data a => Data (OccEnv a)

Defined in GHC.Types.Name.Occurrence

Methods

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

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

toConstr :: OccEnv a -> Constr

dataTypeOf :: OccEnv a -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable a => Outputable (OccEnv a)

Defined in GHC.Types.Name.Occurrence

Methods

ppr :: OccEnv a -> SDoc

type OccSet = UniqSet OccName

type TidyOccEnv = UniqFM FastString Int

mkOccName :: NameSpace -> String -> OccName

isSymOcc :: OccName -> Bool

Test if the OccName is that for any operator (whether it is a data constructor or variable or whatever)

tcName :: NameSpace

clsName :: NameSpace

dataName :: NameSpace

mkFsEnv :: [(FastString, a)] -> FastStringEnv a

emptyFsEnv :: FastStringEnv a

extendFsEnv :: FastStringEnv a -> FastString -> a -> FastStringEnv a

lookupFsEnv :: FastStringEnv a -> FastString -> Maybe a

tcClsName :: NameSpace

tvName :: NameSpace

mkVarOccFS :: FastString -> OccName

occNameString :: OccName -> String

pprNameSpace :: NameSpace -> SDoc

isValNameSpace :: NameSpace -> Bool

srcDataName :: NameSpace

pprNonVarNameSpace :: NameSpace -> SDoc

pprNameSpaceBrief :: IsLine doc => NameSpace -> doc

pprOccName :: IsLine doc => OccName -> doc

mkOccNameFS :: NameSpace -> FastString -> OccName

mkVarOcc :: String -> OccName

mkDataOcc :: String -> OccName

mkDataOccFS :: FastString -> OccName

mkTyVarOcc :: String -> OccName

mkTyVarOccFS :: FastString -> OccName

mkTcOcc :: String -> OccName

mkTcOccFS :: FastString -> OccName

mkClsOcc :: String -> OccName

mkClsOccFS :: FastString -> OccName

mkDFunOcc

Arguments

:: String

Typically the class and type glommed together e.g. OrdMaybe. Only used in debug mode, for extra clarity

-> Bool

Is this a hs-boot instance DFun?

-> OccSet

avoid these Occs

-> OccName

E.g. $f3OrdMaybe

setOccNameSpace :: NameSpace -> OccName -> OccName

demoteOccName :: OccName -> Maybe OccName

promoteOccName :: OccName -> Maybe OccName

isDerivedOccName :: OccName -> Bool

Test for definitions internally generated by GHC. This predicate is used to suppress printing of internal definitions in some debug prints

mkDataConWrapperOcc :: OccName -> OccName

mkWorkerOcc :: OccName -> OccName

mkMatcherOcc :: OccName -> OccName

mkBuilderOcc :: OccName -> OccName

mkDefaultMethodOcc :: OccName -> OccName

isDefaultMethodOcc :: OccName -> Bool

isTypeableBindOcc :: OccName -> Bool

Is an OccName one of a Typeable TyCon or Module binding? This is needed as these bindings are renamed differently. See Note [Grand plan for Typeable] in GHC.Tc.Instance.Typeable.

mkNewTyCoOcc :: OccName -> OccName

mkClassOpAuxOcc :: OccName -> OccName

mkCon2TagOcc :: OccName -> OccName

mkTag2ConOcc :: OccName -> OccName

mkMaxTagOcc :: OccName -> OccName

mkClassDataConOcc :: OccName -> OccName

mkDictOcc :: OccName -> OccName

mkIPOcc :: OccName -> OccName

mkSpecOcc :: OccName -> OccName

mkForeignExportOcc :: OccName -> OccName

mkRepEqOcc :: OccName -> OccName

mkGenR :: OccName -> OccName

mkGen1R :: OccName -> OccName

mkDataTOcc :: OccName -> OccName

mkDataCOcc :: OccName -> OccName

mkDataConWorkerOcc :: OccName -> OccName

mkSuperDictSelOcc

Arguments

:: Int

Index of superclass, e.g. 3

-> OccName

Class, e.g. Ord

-> OccName

Derived Occname, e.g. $p3Ord

mkSuperDictAuxOcc :: Int -> OccName -> OccName

mkLocalOcc

Arguments

:: Unique

Unique to combine with the OccName

-> OccName

Local name, e.g. sat

-> OccName

Nice unique version, e.g. $L23sat

mkMethodOcc :: OccName -> OccName

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.

mkInstTyCoOcc :: OccName -> OccName

mkEqPredCoOcc :: OccName -> OccName

mkRecFldSelOcc :: FastString -> OccName

mkTyConRepOcc :: OccName -> OccName

isVarOcc :: OccName -> Bool

isTvOcc :: OccName -> Bool

isTcOcc :: OccName -> Bool

isDataOcc :: OccName -> Bool

isDataSymOcc :: OccName -> Bool

Test if the OccName is a data constructor that starts with a symbol (e.g. :, or [])

isValOcc :: OccName -> Bool

Value OccNamess are those that are either in the variable or data constructor namespaces

parenSymOcc :: OccName -> SDoc -> SDoc

Wrap parens around an operator

startsWithUnderscore :: OccName -> Bool

Haskell 98 encourages compilers to suppress warnings about unused names in a pattern if they start with _: this implements that test

isTcClsNameSpace :: NameSpace -> Bool

isTvNameSpace :: NameSpace -> Bool

isDataConNameSpace :: NameSpace -> Bool

isVarNameSpace :: NameSpace -> Bool

emptyOccEnv :: OccEnv a

unitOccEnv :: OccName -> a -> OccEnv a

extendOccEnv :: OccEnv a -> OccName -> a -> OccEnv a

mapOccEnv :: (a -> b) -> OccEnv a -> OccEnv b

lookupOccEnv :: OccEnv a -> OccName -> Maybe a

mkOccEnv :: [(OccName, a)] -> OccEnv a

mkOccEnv_C :: (a -> a -> a) -> [(OccName, a)] -> OccEnv a

extendOccEnvList :: OccEnv a -> [(OccName, a)] -> OccEnv a

elemOccEnv :: OccName -> OccEnv a -> Bool

nonDetOccEnvElts :: OccEnv a -> [a]

foldOccEnv :: (a -> b -> b) -> b -> OccEnv a -> b

plusOccEnv :: OccEnv a -> OccEnv a -> OccEnv a

plusOccEnv_C :: (a -> a -> a) -> OccEnv a -> OccEnv a -> OccEnv a

extendOccEnv_C :: (a -> a -> a) -> OccEnv a -> OccName -> a -> OccEnv a

extendOccEnv_Acc :: (a -> b -> b) -> (a -> b) -> OccEnv b -> OccName -> a -> OccEnv b

filterOccEnv :: (elt -> Bool) -> OccEnv elt -> OccEnv elt

delListFromOccEnv :: OccEnv a -> [OccName] -> OccEnv a

delFromOccEnv :: OccEnv a -> OccName -> OccEnv a

alterOccEnv :: (Maybe elt -> Maybe elt) -> OccEnv elt -> OccName -> OccEnv elt

minusOccEnv :: OccEnv a -> OccEnv b -> OccEnv a

minusOccEnv_C :: (a -> b -> Maybe a) -> OccEnv a -> OccEnv b -> OccEnv a

Alters (replaces or removes) those elements of the map that are mentioned in the second map

pprOccEnv :: (a -> SDoc) -> OccEnv a -> SDoc

emptyOccSet :: OccSet

unitOccSet :: OccName -> OccSet

mkOccSet :: [OccName] -> OccSet

extendOccSet :: OccSet -> OccName -> OccSet

extendOccSetList :: OccSet -> [OccName] -> OccSet

unionOccSets :: OccSet -> OccSet -> OccSet

unionManyOccSets :: [OccSet] -> OccSet

minusOccSet :: OccSet -> OccSet -> OccSet

elemOccSet :: OccName -> OccSet -> Bool

isEmptyOccSet :: OccSet -> Bool

intersectOccSet :: OccSet -> OccSet -> OccSet

filterOccSet :: (OccName -> Bool) -> OccSet -> OccSet

occSetToEnv :: OccSet -> OccEnv OccName

Converts an OccSet to an OccEnv (operationally the identity)

emptyTidyOccEnv :: TidyOccEnv

initTidyOccEnv :: [OccName] -> TidyOccEnv

tidyOccName :: TidyOccEnv -> OccName -> (TidyOccEnv, OccName)

avoidClashesOccEnv :: TidyOccEnv -> [OccName] -> TidyOccEnv

delTidyOccEnvList :: TidyOccEnv -> [FastString] -> TidyOccEnv

data Name

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

Instances

Data Name

Defined in GHC.Types.Name

Methods

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

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

toConstr :: Name -> Constr

dataTypeOf :: Name -> DataType

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

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

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

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

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

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

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

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

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

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

NFData Name

Defined in GHC.Types.Name

Methods

rnf :: Name -> ()

NamedThing Name

Defined in GHC.Types.Name

Methods

getOccName :: Name -> OccName

getName :: Name -> Name

HasOccName Name

Defined in GHC.Types.Name

Methods

occName :: Name -> OccName

Uniquable Name

Defined in GHC.Types.Name

Methods

getUnique :: Name -> Unique

Binary Name

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

Defined in GHC.Types.Name

Methods

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

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

get :: BinHandle -> IO Name

Outputable Name

Defined in GHC.Types.Name

Methods

ppr :: Name -> SDoc

OutputableBndr Name

Defined in GHC.Types.Name

Methods

pprBndr :: BindingSite -> Name -> SDoc

pprPrefixOcc :: Name -> SDoc

pprInfixOcc :: Name -> SDoc

bndrIsJoin_maybe :: Name -> Maybe Int

Eq Name

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

Defined in GHC.Types.Name

Methods

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

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

Ord Name

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

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

Defined in GHC.Types.Name

Methods

compare :: Name -> Name -> Ordering

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

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

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

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

max :: Name -> Name -> Name

min :: Name -> Name -> Name

type Anno Name

Defined in GHC.Hs.Extension

type Anno Name = SrcSpanAnnN

type Anno (LocatedN Name)

Defined in GHC.Hs.Binds

type Anno (LocatedN Name) = SrcSpan

type Anno [LocatedN Name]

Defined in GHC.Hs.Binds

type Anno [LocatedN Name] = SrcSpan

data NameSpace

Instances

Binary NameSpace

Defined in GHC.Types.Name.Occurrence

Methods

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

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

get :: BinHandle -> IO NameSpace

Eq NameSpace

Defined in GHC.Types.Name.Occurrence

Methods

(==) :: NameSpace -> NameSpace -> Bool

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

Ord NameSpace

Defined in GHC.Types.Name.Occurrence

Methods

compare :: NameSpace -> NameSpace -> Ordering

(<) :: NameSpace -> NameSpace -> Bool

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

(>) :: NameSpace -> NameSpace -> Bool

(>=) :: NameSpace -> NameSpace -> Bool

max :: NameSpace -> NameSpace -> NameSpace

min :: NameSpace -> NameSpace -> NameSpace

data OccName

Occurrence Name

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

Instances

Data OccName

Defined in GHC.Types.Name.Occurrence

Methods

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

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

toConstr :: OccName -> Constr

dataTypeOf :: OccName -> DataType

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

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

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

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

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

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

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

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

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

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

NFData OccName

Defined in GHC.Types.Name.Occurrence

Methods

rnf :: OccName -> ()

HasOccName OccName

Defined in GHC.Types.Name.Occurrence

Methods

occName :: OccName -> OccName

Uniquable OccName

Defined in GHC.Types.Name.Occurrence

Methods

getUnique :: OccName -> Unique

Binary OccName

Defined in GHC.Types.Name.Occurrence

Methods

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

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

get :: BinHandle -> IO OccName

Outputable OccName

Defined in GHC.Types.Name.Occurrence

Methods

ppr :: OccName -> SDoc

OutputableBndr OccName

Defined in GHC.Types.Name.Occurrence

Methods

pprBndr :: BindingSite -> OccName -> SDoc

pprPrefixOcc :: OccName -> SDoc

pprInfixOcc :: OccName -> SDoc

bndrIsJoin_maybe :: OccName -> Maybe Int

Eq OccName

Defined in GHC.Types.Name.Occurrence

Methods

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

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

Ord OccName

Defined in GHC.Types.Name.Occurrence

Methods

compare :: OccName -> OccName -> Ordering

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

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

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

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

max :: OccName -> OccName -> OccName

min :: OccName -> OccName -> OccName

class NamedThing a where

A class allowing convenient access to the Name of various datatypes

Minimal complete definition

getName

Methods

getOccName :: a -> OccName

getName :: a -> Name

Instances

NamedThing Class

Defined in GHC.Core.Class

Methods

getOccName :: Class -> OccName

getName :: Class -> Name

NamedThing ConLike

Defined in GHC.Core.ConLike

Methods

getOccName :: ConLike -> OccName

getName :: ConLike -> Name

NamedThing DataCon

Defined in GHC.Core.DataCon

Methods

getOccName :: DataCon -> OccName

getName :: DataCon -> Name

NamedThing FamInst

Defined in GHC.Core.FamInstEnv

Methods

getOccName :: FamInst -> OccName

getName :: FamInst -> Name

NamedThing ClsInst

Defined in GHC.Core.InstEnv

Methods

getOccName :: ClsInst -> OccName

getName :: ClsInst -> Name

NamedThing PatSyn

Defined in GHC.Core.PatSyn

Methods

getOccName :: PatSyn -> OccName

getName :: PatSyn -> Name

NamedThing TyCon

Defined in GHC.Core.TyCon

Methods

getOccName :: TyCon -> OccName

getName :: TyCon -> Name

NamedThing IfaceClassOp

Defined in GHC.Iface.Syntax

Methods

getOccName :: IfaceClassOp -> OccName

getName :: IfaceClassOp -> Name

NamedThing IfaceConDecl

Defined in GHC.Iface.Syntax

Methods

getOccName :: IfaceConDecl -> OccName

getName :: IfaceConDecl -> Name

NamedThing IfaceDecl

Defined in GHC.Iface.Syntax

Methods

getOccName :: IfaceDecl -> OccName

getName :: IfaceDecl -> Name

NamedThing HoleFitCandidate

Defined in GHC.Tc.Errors.Hole.FitTypes

Methods

getOccName :: HoleFitCandidate -> OccName

getName :: HoleFitCandidate -> Name

NamedThing Name

Defined in GHC.Types.Name

Methods

getOccName :: Name -> OccName

getName :: Name -> Name

NamedThing TyThing

Defined in GHC.Types.TyThing

Methods

getOccName :: TyThing -> OccName

getName :: TyThing -> Name

NamedThing Var

Defined in GHC.Types.Var

Methods

getOccName :: Var -> OccName

getName :: Var -> Name

NamedThing (CoAxiom br)

Defined in GHC.Core.Coercion.Axiom

Methods

getOccName :: CoAxiom br -> OccName

getName :: CoAxiom br -> Name

NamedThing e => NamedThing (Located e)

Defined in GHC.Types.Name

Methods

getOccName :: Located e -> OccName

getName :: Located e -> Name

NamedThing (Located a) => NamedThing (LocatedAn an a)

Defined in GHC.Parser.Annotation

Methods

getOccName :: LocatedAn an a -> OccName

getName :: LocatedAn an a -> Name

NamedThing tv => NamedThing (VarBndr tv flag)

Defined in GHC.Types.Var

Methods

getOccName :: VarBndr tv flag -> OccName

getName :: VarBndr tv flag -> Name

NamedThing (HsTyVarBndr flag GhcRn)

Defined in GHC.Hs.Type

Methods

getOccName :: HsTyVarBndr flag GhcRn -> OccName

getName :: HsTyVarBndr flag GhcRn -> Name

data BuiltInSyntax

BuiltInSyntax is for things like (:), [] and tuples, which have special syntactic forms. They aren't in scope as such.

Constructors

BuiltInSyntax

UserSyntax

type FastStringEnv a = UniqFM FastString a

A non-deterministic set of FastStrings. See Note [Deterministic UniqFM] in GHC.Types.Unique.DFM for explanation why it's not deterministic and why it matters. Use DFastStringEnv if the set eventually gets converted into a list or folded over in a way where the order changes the generated code.

class HasOccName name where

Other names in the compiler add additional information to an OccName. This class provides a consistent way to access the underlying OccName.

Methods

occName :: name -> OccName

Instances

HasOccName IfaceClassOp

Defined in GHC.Iface.Syntax

Methods

occName :: IfaceClassOp -> OccName

HasOccName IfaceConDecl

Defined in GHC.Iface.Syntax

Methods

occName :: IfaceConDecl -> OccName

HasOccName IfaceDecl

Defined in GHC.Iface.Syntax

Methods

occName :: IfaceDecl -> OccName

HasOccName HoleFitCandidate

Defined in GHC.Tc.Errors.Hole.FitTypes

Methods

occName :: HoleFitCandidate -> OccName

HasOccName TcBinder

Defined in GHC.Tc.Types

Methods

occName :: TcBinder -> OccName

HasOccName GreName

Defined in GHC.Types.Avail

Methods

occName :: GreName -> OccName

HasOccName FieldLabel

Defined in GHC.Types.FieldLabel

Methods

occName :: FieldLabel -> OccName

HasOccName Name

Defined in GHC.Types.Name

Methods

occName :: Name -> OccName

HasOccName OccName

Defined in GHC.Types.Name.Occurrence

Methods

occName :: OccName -> OccName

HasOccName GlobalRdrElt

Defined in GHC.Types.Name.Reader

Methods

occName :: GlobalRdrElt -> OccName

HasOccName RdrName

Defined in GHC.Types.Name.Reader

Methods

occName :: RdrName -> OccName

HasOccName Var

Defined in GHC.Types.Var

Methods

occName :: Var -> OccName

(HasOccName (IdP (GhcPass p)), OutputableBndrId p) => HasOccName (IEWrappedName (GhcPass p))

Defined in GHC.Hs.ImpExp

Methods

occName :: IEWrappedName (GhcPass p) -> OccName

data OccEnv a

Instances

Data a => Data (OccEnv a)

Defined in GHC.Types.Name.Occurrence

Methods

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

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

toConstr :: OccEnv a -> Constr

dataTypeOf :: OccEnv a -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable a => Outputable (OccEnv a)

Defined in GHC.Types.Name.Occurrence

Methods

ppr :: OccEnv a -> SDoc

type OccSet = UniqSet OccName

type TidyOccEnv = UniqFM FastString Int

mkOccName :: NameSpace -> String -> OccName

nameModule :: HasDebugCallStack => Name -> Module

pprName :: forall doc. IsLine doc => Name -> doc

isSymOcc :: OccName -> Bool

Test if the OccName is that for any operator (whether it is a data constructor or variable or whatever)

isExternalName :: Name -> Bool

nameSrcSpan :: Name -> SrcSpan

tcName :: NameSpace

clsName :: NameSpace

dataName :: NameSpace

nameOccName :: Name -> OccName

mkSystemVarName :: Unique -> FastString -> Name

getOccFS :: NamedThing a => a -> FastString

pprInfixName :: (Outputable a, NamedThing a) => a -> SDoc

pprPrefixName :: NamedThing a => a -> SDoc

nameIsLocalOrFrom :: Module -> Name -> Bool

Returns True if the name is (a) Internal (b) External but from the specified module (c) External but from the interactive package

The key idea is that False means: the entity is defined in some other module you can find the details (type, fixity, instances) in some interface file those details will be stored in the EPT or HPT

True means: the entity is defined in this module or earlier in the GHCi session you can find details (type, fixity, instances) in the TcGblEnv or TcLclEnv

The isInteractiveModule part is because successive interactions of a GHCi session each give rise to a fresh module (Ghci1, Ghci2, etc), but they all come from the magic interactive package; and all the details are kept in the TcLclEnv, TcGblEnv, NOT in the HPT or EPT. See Note [The interactive package] in GHC.Runtime.Context

tidyNameOcc :: Name -> OccName -> Name

mkSysTvName :: Unique -> FastString -> Name

nameModule_maybe :: Name -> Maybe Module

isInternalName :: Name -> Bool

mkFsEnv :: [(FastString, a)] -> FastStringEnv a

emptyFsEnv :: FastStringEnv a

extendFsEnv :: FastStringEnv a -> FastString -> a -> FastStringEnv a

lookupFsEnv :: FastStringEnv a -> FastString -> Maybe a

nameUnique :: Name -> Unique

tcClsName :: NameSpace

tvName :: NameSpace

mkVarOccFS :: FastString -> OccName

occNameString :: OccName -> String

getSrcLoc :: NamedThing a => a -> SrcLoc

isDynLinkName :: Platform -> Module -> Name -> Bool

Will the Name come from a dynamically linked package?

getSrcSpan :: NamedThing a => a -> SrcSpan

pprDefinedAt :: Name -> SDoc

isSystemName :: Name -> Bool

pprNameSpace :: NameSpace -> SDoc

isValNameSpace :: NameSpace -> Bool

mkSystemName :: Unique -> OccName -> Name

Create a name brought into being by the compiler

mkSystemNameAt :: Unique -> OccName -> SrcSpan -> Name

mkInternalName :: Unique -> OccName -> SrcSpan -> Name

Create a name which is (for now at least) local to the current module and hence does not need a GenModule to disambiguate it from other Names

mkClonedInternalName :: Unique -> Name -> Name

mkDerivedInternalName :: (OccName -> OccName) -> Unique -> Name -> Name

mkFCallName :: Unique -> FastString -> Name

Make a name for a foreign call

mkExternalName :: Unique -> Module -> OccName -> SrcSpan -> Name

Create a name which definitely originates in the given module

mkWiredInName :: Module -> OccName -> Unique -> TyThing -> BuiltInSyntax -> Name

Create a name which is actually defined by the compiler itself

setNameUnique :: Name -> Unique -> Name

nameNameSpace :: Name -> NameSpace

setNameLoc :: Name -> SrcSpan -> Name

localiseName :: Name -> Name

Make the Name into an internal name, regardless of what it was to begin with

namePun_maybe :: Name -> Maybe FastString

nameSrcLoc :: Name -> SrcLoc

pprNameDefnLoc :: Name -> SDoc

pprFullName :: Module -> Name -> SDoc

Print fully qualified name (with unit-id, module and unique)

pprTickyName :: Module -> Name -> SDoc

Print a ticky ticky styled name

Module argument is the module to use for internal and system names. When printing the name in a ticky profile, the module name is included even for local things. However, ticky uses the format "x (M)" rather than "M.x". Hence, this function provides a separation from normal styling.

isTyVarName :: Name -> Bool

isTyConName :: Name -> Bool

isDataConName :: Name -> Bool

isValName :: Name -> Bool

isVarName :: Name -> Bool

isWiredInName :: Name -> Bool

isWiredIn :: NamedThing thing => thing -> Bool

isBuiltInSyntax :: Name -> Bool

isHoleName :: Name -> Bool

wiredInNameTyThing_maybe :: Name -> Maybe TyThing

nameIsExternalOrFrom :: Module -> Name -> Bool

Returns True if the name is external or from the interactive package See documentation of nameIsLocalOrFrom function

nameIsHomePackage :: Module -> Name -> Bool

nameIsHomePackageImport :: Module -> Name -> Bool

nameIsFromExternalPackage :: HomeUnit -> Name -> Bool

Returns True if the Name comes from some other package: neither this package nor the interactive package.

stableNameCmp :: Name -> Name -> Ordering

Compare Names lexicographically This only works for Names that originate in the source code or have been tidied.

getOccString :: NamedThing a => a -> String

pprModulePrefix :: IsLine doc => PprStyle -> Module -> OccName -> doc

pprNameUnqualified :: Name -> SDoc

Print the string of Name unqualifiedly directly.

nameStableString :: Name -> String

Get a string representation of a Name that's unique and stable across recompilations. Used for deterministic generation of binds for derived instances. eg. "$aeson_70dylHtv1FFGeai1IoxcQr$Data.Aeson.Types.Internal$String"

srcDataName :: NameSpace

pprNonVarNameSpace :: NameSpace -> SDoc

pprNameSpaceBrief :: IsLine doc => NameSpace -> doc

pprOccName :: IsLine doc => OccName -> doc

mkOccNameFS :: NameSpace -> FastString -> OccName

mkVarOcc :: String -> OccName

mkDataOcc :: String -> OccName

mkDataOccFS :: FastString -> OccName

mkTyVarOcc :: String -> OccName

mkTyVarOccFS :: FastString -> OccName

mkTcOcc :: String -> OccName

mkTcOccFS :: FastString -> OccName

mkClsOcc :: String -> OccName

mkClsOccFS :: FastString -> OccName

mkDFunOcc

Arguments

:: String

Typically the class and type glommed together e.g. OrdMaybe. Only used in debug mode, for extra clarity

-> Bool

Is this a hs-boot instance DFun?

-> OccSet

avoid these Occs

-> OccName

E.g. $f3OrdMaybe

setOccNameSpace :: NameSpace -> OccName -> OccName

demoteOccName :: OccName -> Maybe OccName

promoteOccName :: OccName -> Maybe OccName

isDerivedOccName :: OccName -> Bool

Test for definitions internally generated by GHC. This predicate is used to suppress printing of internal definitions in some debug prints

mkDataConWrapperOcc :: OccName -> OccName

mkWorkerOcc :: OccName -> OccName

mkMatcherOcc :: OccName -> OccName

mkBuilderOcc :: OccName -> OccName

mkDefaultMethodOcc :: OccName -> OccName

isDefaultMethodOcc :: OccName -> Bool

isTypeableBindOcc :: OccName -> Bool

Is an OccName one of a Typeable TyCon or Module binding? This is needed as these bindings are renamed differently. See Note [Grand plan for Typeable] in GHC.Tc.Instance.Typeable.

mkNewTyCoOcc :: OccName -> OccName

mkClassOpAuxOcc :: OccName -> OccName

mkCon2TagOcc :: OccName -> OccName

mkTag2ConOcc :: OccName -> OccName

mkMaxTagOcc :: OccName -> OccName

mkClassDataConOcc :: OccName -> OccName

mkDictOcc :: OccName -> OccName

mkIPOcc :: OccName -> OccName

mkSpecOcc :: OccName -> OccName

mkForeignExportOcc :: OccName -> OccName

mkRepEqOcc :: OccName -> OccName

mkGenR :: OccName -> OccName

mkGen1R :: OccName -> OccName

mkDataTOcc :: OccName -> OccName

mkDataCOcc :: OccName -> OccName

mkDataConWorkerOcc :: OccName -> OccName

mkSuperDictSelOcc

Arguments

:: Int

Index of superclass, e.g. 3

-> OccName

Class, e.g. Ord

-> OccName

Derived Occname, e.g. $p3Ord

mkSuperDictAuxOcc :: Int -> OccName -> OccName

mkLocalOcc

Arguments

:: Unique

Unique to combine with the OccName

-> OccName

Local name, e.g. sat

-> OccName

Nice unique version, e.g. $L23sat

mkMethodOcc :: OccName -> OccName

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.

mkInstTyCoOcc :: OccName -> OccName

mkEqPredCoOcc :: OccName -> OccName

mkRecFldSelOcc :: FastString -> OccName

mkTyConRepOcc :: OccName -> OccName

isVarOcc :: OccName -> Bool

isTvOcc :: OccName -> Bool

isTcOcc :: OccName -> Bool

isDataOcc :: OccName -> Bool

isDataSymOcc :: OccName -> Bool

Test if the OccName is a data constructor that starts with a symbol (e.g. :, or [])

isValOcc :: OccName -> Bool

Value OccNamess are those that are either in the variable or data constructor namespaces

parenSymOcc :: OccName -> SDoc -> SDoc

Wrap parens around an operator

startsWithUnderscore :: OccName -> Bool

Haskell 98 encourages compilers to suppress warnings about unused names in a pattern if they start with _: this implements that test

isTcClsNameSpace :: NameSpace -> Bool

isTvNameSpace :: NameSpace -> Bool

isDataConNameSpace :: NameSpace -> Bool

isVarNameSpace :: NameSpace -> Bool

emptyOccEnv :: OccEnv a

unitOccEnv :: OccName -> a -> OccEnv a

extendOccEnv :: OccEnv a -> OccName -> a -> OccEnv a

mapOccEnv :: (a -> b) -> OccEnv a -> OccEnv b

lookupOccEnv :: OccEnv a -> OccName -> Maybe a

mkOccEnv :: [(OccName, a)] -> OccEnv a

mkOccEnv_C :: (a -> a -> a) -> [(OccName, a)] -> OccEnv a

extendOccEnvList :: OccEnv a -> [(OccName, a)] -> OccEnv a

elemOccEnv :: OccName -> OccEnv a -> Bool

nonDetOccEnvElts :: OccEnv a -> [a]

foldOccEnv :: (a -> b -> b) -> b -> OccEnv a -> b

plusOccEnv :: OccEnv a -> OccEnv a -> OccEnv a

plusOccEnv_C :: (a -> a -> a) -> OccEnv a -> OccEnv a -> OccEnv a

extendOccEnv_C :: (a -> a -> a) -> OccEnv a -> OccName -> a -> OccEnv a

extendOccEnv_Acc :: (a -> b -> b) -> (a -> b) -> OccEnv b -> OccName -> a -> OccEnv b

filterOccEnv :: (elt -> Bool) -> OccEnv elt -> OccEnv elt

delListFromOccEnv :: OccEnv a -> [OccName] -> OccEnv a

delFromOccEnv :: OccEnv a -> OccName -> OccEnv a

alterOccEnv :: (Maybe elt -> Maybe elt) -> OccEnv elt -> OccName -> OccEnv elt

minusOccEnv :: OccEnv a -> OccEnv b -> OccEnv a

minusOccEnv_C :: (a -> b -> Maybe a) -> OccEnv a -> OccEnv b -> OccEnv a

Alters (replaces or removes) those elements of the map that are mentioned in the second map

pprOccEnv :: (a -> SDoc) -> OccEnv a -> SDoc

emptyOccSet :: OccSet

unitOccSet :: OccName -> OccSet

mkOccSet :: [OccName] -> OccSet

extendOccSet :: OccSet -> OccName -> OccSet

extendOccSetList :: OccSet -> [OccName] -> OccSet

unionOccSets :: OccSet -> OccSet -> OccSet

unionManyOccSets :: [OccSet] -> OccSet

minusOccSet :: OccSet -> OccSet -> OccSet

elemOccSet :: OccName -> OccSet -> Bool

isEmptyOccSet :: OccSet -> Bool

intersectOccSet :: OccSet -> OccSet -> OccSet

filterOccSet :: (OccName -> Bool) -> OccSet -> OccSet

occSetToEnv :: OccSet -> OccEnv OccName

Converts an OccSet to an OccEnv (operationally the identity)

emptyTidyOccEnv :: TidyOccEnv

initTidyOccEnv :: [OccName] -> TidyOccEnv

tidyOccName :: TidyOccEnv -> OccName -> (TidyOccEnv, OccName)

avoidClashesOccEnv :: TidyOccEnv -> [OccName] -> TidyOccEnv

delTidyOccEnvList :: TidyOccEnv -> [FastString] -> TidyOccEnv

module GHC.Types.Var

type Id = Var

Identifier

data Var

Variable

Essentially a typed Name, that may also contain some additional information about the Var and its use sites.

Instances

Data Var

Defined in GHC.Types.Var

Methods

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

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

toConstr :: Var -> Constr

dataTypeOf :: Var -> DataType

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

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

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

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

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

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

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

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

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

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

NamedThing Var

Defined in GHC.Types.Var

Methods

getOccName :: Var -> OccName

getName :: Var -> Name

HasOccName Var

Defined in GHC.Types.Var

Methods

occName :: Var -> OccName

Uniquable Var

Defined in GHC.Types.Var

Methods

getUnique :: Var -> Unique

Outputable Var

Defined in GHC.Types.Var

Methods

ppr :: Var -> SDoc

OutputableBndr Var

Defined in GHC.Core.Ppr

Methods

pprBndr :: BindingSite -> Var -> SDoc

pprPrefixOcc :: Var -> SDoc

pprInfixOcc :: Var -> SDoc

bndrIsJoin_maybe :: Var -> Maybe Int

Eq Var

Defined in GHC.Types.Var

Methods

(==) :: Var -> Var -> Bool

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

Ord Var

Defined in GHC.Types.Var

Methods

compare :: Var -> Var -> Ordering

(<) :: Var -> Var -> Bool

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

(>) :: Var -> Var -> Bool

(>=) :: Var -> Var -> Bool

max :: Var -> Var -> Var

min :: Var -> Var -> Var

Eq (DeBruijn CoreAlt)

Defined in GHC.Core.Map.Expr

Methods

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

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

Eq (DeBruijn CoreExpr)

Defined in GHC.Core.Map.Expr

Methods

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

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

Eq (DeBruijn Var)

Defined in GHC.Core.Map.Type

Methods

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

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

OutputableBndr (Id, TagSig)

Defined in GHC.Stg.InferTags.TagSig

Methods

pprBndr :: BindingSite -> (Id, TagSig) -> SDoc

pprPrefixOcc :: (Id, TagSig) -> SDoc

pprInfixOcc :: (Id, TagSig) -> SDoc

bndrIsJoin_maybe :: (Id, TagSig) -> Maybe Int

type Anno Id

Defined in GHC.Hs.Extension

type Anno Id = SrcSpanAnnN

type Anno (LocatedN Id)

Defined in GHC.Hs.Binds

type Anno (LocatedN Id) = SrcSpan

type Anno [LocatedN Id]

Defined in GHC.Hs.Binds

type Anno [LocatedN Id] = SrcSpan

type InId = Id

type InVar = Var

type OutId = Id

type OutVar = Var

type JoinId = Id

idType :: Id -> Kind

isImplicitId :: Id -> Bool

isImplicitId tells whether an Ids info is implied by other declarations, so we don't need to put its signature in an interface file, even if it's mentioned in some other interface unfolding.

isDeadBinder :: Id -> Bool

isExportedId :: Var -> Bool

isExportedIdVar means "don't throw this away"

isLocalId :: Var -> Bool

isGlobalId :: Var -> Bool

isRecordSelector :: Id -> Bool

isPrimOpId :: Id -> Bool

isFCallId :: Id -> Bool

isClassOpId_maybe :: Id -> Maybe Class

isDataConWorkId :: Id -> Bool

idDataCon :: Id -> DataCon

Get from either the worker or the wrapper Id to the DataCon. Currently used only in the desugarer.

INVARIANT: idDataCon (dataConWrapId d) = d: remember, dataConWrapId can return either the wrapper or the worker

isDeadEndId :: Var -> Bool

Returns true if an application to n args diverges or throws an exception See Note [Dead ends] in GHC.Types.Demand.

recordSelectorTyCon :: Id -> RecSelParent

If the Id is that for a record selector, extract the sel_tycon. Panic otherwise.

isId :: Var -> Bool

Is this a value-level (i.e., computationally relevant) Varentifier? Satisfies isId = not . isTyVar.

idHasRules :: Id -> Bool

zapStableUnfolding :: Id -> Id

idInlineActivation :: Id -> Activation

setInlineActivation :: Id -> Activation -> Id infixl 1

zapIdOccInfo :: Id -> Id

zapIdUsageInfo :: Id -> Id

idInlinePragma :: Id -> InlinePragma

isJoinId :: Var -> Bool

isJoinId_maybe :: Var -> Maybe JoinArity

Doesn't return strictness marks

idUnfolding :: Id -> Unfolding

Returns the Ids unfolding, but does not expose the unfolding of a strong loop breaker. See unfoldingInfo.

If you really want the unfolding of a strong loopbreaker, call realIdUnfolding.

mkSysLocalOrCoVarM :: MonadUnique m => FastString -> Mult -> Type -> m Id

idInfo :: HasDebugCallStack => Id -> IdInfo

isDataConId_maybe :: Id -> Maybe DataCon

mkLocalId :: HasDebugCallStack => Name -> Mult -> Type -> Id

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

idName :: Id -> Name

setInlinePragma :: Id -> InlinePragma -> Id infixl 1

realIdUnfolding :: Id -> Unfolding

Expose the unfolding if there is one, including for loop breakers

mkTemplateLocals :: [Type] -> [Id]

Create a template local for a series of types

idScaledType :: Id -> Scaled Type

mkGlobalId :: IdDetails -> Name -> Type -> IdInfo -> Id

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

mkVanillaGlobal :: Name -> Type -> Id

Make a global Id without any extra information at all

mkVanillaGlobalWithInfo :: Name -> Type -> IdInfo -> Id

Make a global Id with no global information but some generic IdInfo

mkLocalCoVar :: Name -> Type -> CoVar

Make a local CoVar

mkLocalIdOrCoVar :: Name -> Mult -> Type -> Id

Like mkLocalId, but checks the type to see if it should make a covar

mkLocalIdWithInfo :: HasDebugCallStack => Name -> Mult -> Type -> IdInfo -> Id

mkExportedLocalId :: IdDetails -> Name -> Type -> Id

Create a local Id that is marked as exported. This prevents things attached to it from being removed as dead code. See Note [Exported LocalIds]

mkExportedVanillaId :: Name -> Type -> Id

mkSysLocal :: FastString -> Unique -> Mult -> Type -> Id

Create a system local Id. These are local Ids (see Var) that are created by the compiler out of thin air

mkSysLocalM :: MonadUnique m => FastString -> Mult -> Type -> m Id

mkSysLocalOrCoVar :: FastString -> Unique -> Mult -> Type -> Id

Like mkSysLocal, but checks to see if we have a covar type

mkUserLocal :: OccName -> Unique -> Mult -> Type -> SrcSpan -> Id

Create a user local Id. These are local Ids (see GHC.Types.Var) with a name and location that the user might recognize

mkUserLocalOrCoVar :: OccName -> Unique -> Mult -> Type -> SrcSpan -> Id

Like mkUserLocal, but checks if we have a coercion type

mkTemplateLocalsNum :: Int -> [Type] -> [Id]

Create a template local for a series of type, but start from a specified template local

mkTemplateLocal :: Int -> Type -> Id

Create a template local: a family of system local Ids in bijection with Ints, typically used in unfoldings

mkScaledTemplateLocal :: Int -> Scaled Type -> Id

mkWorkerId :: Unique -> Id -> Type -> Id

Workers get local names. CoreTidy will externalise these if necessary

idMult :: Id -> Mult

idUnique :: Id -> Unique

idDetails :: Id -> IdDetails

recordSelectorTyCon_maybe :: Id -> Maybe RecSelParent

setIdName :: Id -> Name -> Id

setIdUnique :: Id -> Unique -> Id

setIdMult :: Id -> Mult -> Id

updateIdTypeButNotMult :: (Type -> Type) -> Id -> Id

updateIdTypeAndMult :: (Type -> Type) -> Id -> Id

updateIdTypeAndMultM :: Monad m => (Type -> m Type) -> Id -> m Id

globaliseId :: Id -> Id

If it's a local, make it global

localiseId :: Id -> Id

setIdInfo :: Id -> IdInfo -> Id

modifyIdInfo :: HasDebugCallStack => (IdInfo -> IdInfo) -> Id -> Id

maybeModifyIdInfo :: Maybe IdInfo -> Id -> Id

zapLamIdInfo :: Id -> Id

zapIdDemandInfo :: Id -> Id

zapIdUsageEnvInfo :: Id -> Id

zapIdUsedOnceInfo :: Id -> Id

zapIdTailCallInfo :: Id -> Id

zapFragileIdInfo :: Id -> Id

zapIdDmdSig :: Id -> Id

transferPolyIdInfo :: Id -> [Var] -> Id -> Id

scaleIdBy :: Mult -> Id -> Id

scaleVarBy :: Mult -> Var -> Var

Like scaleIdBy, but skips non-Ids. Useful for scaling a mixed list of ids and tyvars.

isStrictId :: Id -> Bool

This predicate says whether the Id has a strict demand placed on it or has a type such that it can always be evaluated strictly (i.e an unlifted type, as of GHC 7.6). We need to check separately whether the Id has a so-called "strict type" because if the demand for the given id hasn't been computed yet but id has a strict type, we still want isStrictId id to be True.

isNaughtyRecordSelector :: Id -> Bool

isPatSynRecordSelector :: Id -> Bool

isDataConRecordSelector :: Id -> Bool

isClassOpId :: Id -> Bool

isDFunId :: Id -> Bool

isPrimOpId_maybe :: Id -> Maybe PrimOp

isFCallId_maybe :: Id -> Maybe ForeignCall

isDataConWorkId_maybe :: Id -> Maybe DataCon

isDataConWrapId :: Id -> Bool

isDataConWrapId_maybe :: Id -> Maybe DataCon

isConLikeId :: Id -> Bool

isWorkerLikeId :: Id -> Bool

An Id for which we might require all callers to pass strict arguments properly tagged + evaluated.

See Note [CBV Function Ids]

idIsFrom :: Module -> Id -> Bool

hasNoBinding :: Id -> Bool

Returns True of an Id which may not have a binding, even though it is defined in this module.

idJoinArity :: JoinId -> JoinArity

asJoinId :: Id -> JoinArity -> JoinId infixl 1

asJoinId_maybe :: Id -> Maybe JoinArity -> Id infixl 1

zapJoinId :: Id -> Id

modifyInlinePragma :: Id -> (InlinePragma -> InlinePragma) -> Id

idRuleMatchInfo :: Id -> RuleMatchInfo

setOneShotLambda :: Id -> Id

clearOneShotLambda :: Id -> Id

updOneShotInfo :: Id -> OneShotInfo -> Id

setIdOneShotInfo :: Id -> OneShotInfo -> Id infixl 1

idArity :: Id -> Arity

idCallArity :: Id -> Arity

idFunRepArity :: Id -> RepArity

idSpecialisation :: Id -> RuleInfo

idCoreRules :: Id -> [CoreRule]

idCafInfo :: Id -> CafInfo infixl 1

idLFInfo_maybe :: Id -> Maybe LambdaFormInfo

idOneShotInfo :: Id -> OneShotInfo

idOccInfo :: Id -> OccInfo

setIdUnfolding :: Id -> Unfolding -> Id infixl 1

zapIdUnfolding :: Id -> Id

Similar to trimUnfolding, but also removes evaldness info.

setCaseBndrEvald :: StrictnessMark -> Id -> Id

setIdArity :: Id -> Arity -> Id infixl 1

setIdCallArity :: Id -> Arity -> Id infixl 1

setIdSpecialisation :: Id -> RuleInfo -> Id infixl 1

setIdCafInfo :: Id -> CafInfo -> Id

setIdOccInfo :: Id -> OccInfo -> Id infixl 1

setIdLFInfo :: Id -> LambdaFormInfo -> Id

setIdDemandInfo :: Id -> Demand -> Id infixl 1

setIdDmdSig :: Id -> DmdSig -> Id infixl 1

setIdCprSig :: Id -> CprSig -> Id infixl 1

setIdCbvMarks :: Id -> [CbvMark] -> Id infixl 1

If all marks are NotMarkedStrict we just set nothing.

idCbvMarks_maybe :: Id -> Maybe [CbvMark]

idCbvMarkArity :: Id -> Arity

asWorkerLikeId :: Id -> Id

Turn this id into a WorkerLikeId if possible.

asNonWorkerLikeId :: Id -> Id

Remove any cbv marks on arguments from a given Id.

idDemandInfo :: Id -> Demand

idDmdSig :: Id -> DmdSig

Accesses the Id's dmdSigInfo.

idCprSig :: Id -> CprSig

idTagSig_maybe :: Id -> Maybe TagSig

setIdTagSig :: Id -> TagSig -> Id

setIdType :: Id -> Type -> Id

Not only does this set the Id Type, it also evaluates the type to try and reduce space usage

module GHC.Types.Id.Info

module GHC.Types.PkgQual

module GHC.Core.Opt.Monad

module GHC.Core.Opt.Pipeline.Types

module GHC.Core.Opt.Stats

module GHC.Core

module GHC.Types.Literal

module GHC.Core.DataCon

module GHC.Core.Utils

module GHC.Core.Make

module GHC.Core.FVs

data InScopeSet

A set of variables that are in scope at some point.

Note that this is a superset of the variables that are currently in scope. See Note [The InScopeSet invariant].

"Secrets of the Glasgow Haskell Compiler inliner" Section 3.2 provides the motivation for this abstraction.

Instances

Outputable InScopeSet

Defined in GHC.Types.Var.Env

Methods

ppr :: InScopeSet -> SDoc

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

type TvSubstEnv = TyVarEnv Type

A substitution of Types for TyVars and Kinds for KindVars

type IdSubstEnv = IdEnv CoreExpr

A substitution of Exprs for non-coercion Ids

substCo :: HasDebugCallStack => Subst -> Coercion -> Coercion

Substitute within a Coercion The substitution has to satisfy the invariants described in Note [The substitution invariant].

extendIdSubst :: Subst -> Id -> CoreExpr -> Subst

Add a substitution for an Id to the Subst: you must ensure that the in-scope set is such that TyCoSubst Note [The substitution invariant] holds after extending the substitution like this

extendTvSubst :: Subst -> TyVar -> Type -> Subst

Add a substitution for a TyVar to the Subst The TyVar *must* be a real TyVar, and not a CoVar You must ensure that the in-scope set is such that Note [The substitution invariant] holds after extending the substitution like this.

zapSubst :: Subst -> Subst

Remove all substitutions that might have been built up while preserving the in-scope set originally called zapSubstEnv

extendTvSubstList :: Subst -> [(TyVar, Type)] -> Subst

Adds multiple TyVar substitutions to the Subst: see also extendTvSubst

isInScope :: Var -> Subst -> Bool

deShadowBinds :: CoreProgram -> CoreProgram

De-shadowing the program is sometimes a useful pre-pass. It can be done simply by running over the bindings with an empty substitution, because substitution returns a result that has no-shadowing guaranteed.

(Actually, within a single type there might still be shadowing, because substTy is a no-op for the empty substitution, but that's probably OK.)

Aug 09

This function is not used in GHC at the moment, but seems so short and simple that I'm going to leave it here

substRuleInfo :: Subst -> Id -> RuleInfo -> RuleInfo

Substitutes for the Ids within the RuleInfo given the new function Id

substRulesForImportedIds :: Subst -> [CoreRule] -> [CoreRule]

substTyUnchecked :: Subst -> Type -> Type

Substitute within a Type disabling the sanity checks. The problems that the sanity checks in substTy catch are described in Note [The substitution invariant]. The goal of #11371 is to migrate all the calls of substTyUnchecked to substTy and remove this function. Please don't use in new code.

substExpr :: HasDebugCallStack => Subst -> CoreExpr -> CoreExpr

substExpr applies a substitution to an entire CoreExpr. Remember, you may only apply the substitution once: See Note [Substitutions apply only once] in GHC.Core.TyCo.Subst

Do *not* attempt to short-cut in the case of an empty substitution! See Note [Extending the IdSubstEnv]

substExprSC :: HasDebugCallStack => Subst -> CoreExpr -> CoreExpr

substBind :: HasDebugCallStack => Subst -> CoreBind -> (Subst, CoreBind)

Apply a substitution to an entire CoreBind, additionally returning an updated Subst that should be used by subsequent substitutions.

substBindSC :: HasDebugCallStack => Subst -> CoreBind -> (Subst, CoreBind)

Apply a substitution to an entire CoreBind, additionally returning an updated Subst that should be used by subsequent substitutions.

substUnfolding :: Subst -> Unfolding -> Unfolding

Substitutes for the Ids within an unfolding NB: substUnfolding discards any unfolding without without a Stable source. This is usually what we want, but it may be a bit unexpected

substUnfoldingSC :: Subst -> Unfolding -> Unfolding

Substitutes for the Ids within an unfolding NB: substUnfolding discards any unfolding without without a Stable source. This is usually what we want, but it may be a bit unexpected

lookupIdSubst :: HasDebugCallStack => Subst -> Id -> CoreExpr

Find the substitution for an Id in the Subst The Id should not be a CoVar

lookupIdSubst_maybe :: HasDebugCallStack => Subst -> Id -> Maybe CoreExpr

substIdType :: Subst -> Id -> Id

substIdOcc :: Subst -> Id -> Id

substTickish :: Subst -> CoreTickish -> CoreTickish

substDVarSet :: HasDebugCallStack => Subst -> DVarSet -> DVarSet

substIdInfo :: Subst -> Id -> IdInfo -> Maybe IdInfo

Substitute into some IdInfo with regard to the supplied new Id. Discards unfoldings, unless they are Stable

emptySubst :: Subst

mkEmptySubst :: InScopeSet -> Subst

mkSubst :: InScopeSet -> TvSubstEnv -> CvSubstEnv -> IdSubstEnv -> Subst

mkOpenSubst :: InScopeSet -> [(Var, CoreArg)] -> Subst

Simultaneously substitute for a bunch of variables No left-right shadowing ie the substitution for (x y. e) a1 a2 so neither x nor y scope over a1 a2

isEmptySubst :: Subst -> Bool

extendIdSubstList :: Subst -> [(Id, CoreExpr)] -> Subst

Adds multiple Id substitutions to the Subst: see also extendIdSubst

extendTCvSubst :: Subst -> TyCoVar -> Type -> Subst

extendIdSubstWithClone :: Subst -> Id -> Id -> Subst

extendSubst :: Subst -> Var -> CoreArg -> Subst

Add a substitution appropriate to the thing being substituted (whether an expression, type, or coercion). See also extendIdSubst, extendTvSubst, extendCvSubst

extendSubstList :: Subst -> [(Var, CoreArg)] -> Subst

Add a substitution as appropriate to each of the terms being substituted (whether expressions, types, or coercions). See also extendSubst.

extendSubstWithVar :: Subst -> Var -> Var -> Subst

extendSubstInScope :: Subst -> Var -> Subst

Add the Var to the in-scope set

extendSubstInScopeList :: Subst -> [Var] -> Subst

Add the Vars to the in-scope set: see also extendInScope

setInScope :: Subst -> InScopeSet -> Subst

getSubstInScope :: Subst -> InScopeSet

Find the in-scope set: see Note [The substitution invariant]

delBndr :: Subst -> Var -> Subst

delBndrs :: Subst -> [Var] -> Subst

substBndr :: Subst -> Var -> (Subst, Var)

Substitutes a Expr for another one according to the Subst given, returning the result and an updated Subst that should be used by subsequent substitutions. IdInfo is preserved by this process, although it is substituted into appropriately.

substBndrs :: Traversable f => Subst -> f Var -> (Subst, f Var)

Applies substBndr to a number of Exprs, accumulating a new Subst left-to-right

substRecBndrs :: Traversable f => Subst -> f Id -> (Subst, f Id)

Substitute in a mutually recursive group of Ids

cloneBndr :: Subst -> Unique -> Var -> (Subst, Var)

cloneBndrs :: Subst -> UniqSupply -> [Var] -> (Subst, [Var])

cloneIdBndr :: Subst -> UniqSupply -> Id -> (Subst, Id)

Very similar to substBndr, but it always allocates a new Unique for each variable in its output. It substitutes the IdInfo though. Discards non-Stable unfoldings

cloneIdBndrs :: Subst -> UniqSupply -> [Id] -> (Subst, [Id])

Applies cloneIdBndr to a number of Ids, accumulating a final substitution from left to right Discards non-Stable unfoldings

cloneRecIdBndrs :: Subst -> UniqSupply -> [Id] -> (Subst, [Id])

Clone a mutually recursive group of Ids

module GHC.Core.Rules

module GHC.Types.Annotations

module GHC.Driver.Session

module GHC.Driver.Ppr

module GHC.Unit.State

module GHC.Unit.Module

module GHC.Unit.Home

data Type

Instances

Data Type

Defined in GHC.Core.TyCo.Rep

Methods

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

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

toConstr :: Type -> Constr

dataTypeOf :: Type -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable Type

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: Type -> SDoc

Eq (DeBruijn Type)

Defined in GHC.Core.Map.Type

Methods

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

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

type Kind = Type

The key type representing kinds in the compiler.

data Specificity

Whether an Invisible argument may appear in source Haskell.

Constructors

InferredSpec

the argument may not appear in source Haskell, it is only inferred.

SpecifiedSpec

the argument may appear in source Haskell, but isn't required.

Instances

Data Specificity

Defined in GHC.Types.Var

Methods

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

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

toConstr :: Specificity -> Constr

dataTypeOf :: Specificity -> DataType

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

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

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

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

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

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

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

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

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

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

Binary Specificity

Defined in GHC.Types.Var

Methods

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

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

get :: BinHandle -> IO Specificity

Eq Specificity

Defined in GHC.Types.Var

Methods

(==) :: Specificity -> Specificity -> Bool

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

Ord Specificity

Defined in GHC.Types.Var

Methods

compare :: Specificity -> Specificity -> Ordering

(<) :: Specificity -> Specificity -> Bool

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

(>) :: Specificity -> Specificity -> Bool

(>=) :: Specificity -> Specificity -> Bool

max :: Specificity -> Specificity -> Specificity

min :: Specificity -> Specificity -> Specificity

OutputableBndrFlag Specificity p

Defined in GHC.Hs.Type

Methods

pprTyVarBndr :: HsTyVarBndr Specificity (GhcPass p) -> SDoc

Outputable tv => Outputable (VarBndr tv Specificity)

Defined in GHC.Types.Var

Methods

ppr :: VarBndr tv Specificity -> SDoc

type TyVar = Var

Type or kind Variable

type PredType = Type

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

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

It can be expanded into its representation, but:

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

Consider these examples:

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

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

type ThetaType = [PredType]

A collection of PredTypes

data Var

Variable

Essentially a typed Name, that may also contain some additional information about the Var and its use sites.

Instances

Data Var

Defined in GHC.Types.Var

Methods

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

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

toConstr :: Var -> Constr

dataTypeOf :: Var -> DataType

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

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

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

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

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

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

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

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

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

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

NamedThing Var

Defined in GHC.Types.Var

Methods

getOccName :: Var -> OccName

getName :: Var -> Name

HasOccName Var

Defined in GHC.Types.Var

Methods

occName :: Var -> OccName

Uniquable Var

Defined in GHC.Types.Var

Methods

getUnique :: Var -> Unique

Outputable Var

Defined in GHC.Types.Var

Methods

ppr :: Var -> SDoc

OutputableBndr Var

Defined in GHC.Core.Ppr

Methods

pprBndr :: BindingSite -> Var -> SDoc

pprPrefixOcc :: Var -> SDoc

pprInfixOcc :: Var -> SDoc

bndrIsJoin_maybe :: Var -> Maybe Int

Eq Var

Defined in GHC.Types.Var

Methods

(==) :: Var -> Var -> Bool

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

Ord Var

Defined in GHC.Types.Var

Methods

compare :: Var -> Var -> Ordering

(<) :: Var -> Var -> Bool

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

(>) :: Var -> Var -> Bool

(>=) :: Var -> Var -> Bool

max :: Var -> Var -> Var

min :: Var -> Var -> Var

Eq (DeBruijn CoreAlt)

Defined in GHC.Core.Map.Expr

Methods

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

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

Eq (DeBruijn CoreExpr)

Defined in GHC.Core.Map.Expr

Methods

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

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

Eq (DeBruijn Var)

Defined in GHC.Core.Map.Type

Methods

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

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

OutputableBndr (Id, TagSig)

Defined in GHC.Stg.InferTags.TagSig

Methods

pprBndr :: BindingSite -> (Id, TagSig) -> SDoc

pprPrefixOcc :: (Id, TagSig) -> SDoc

pprInfixOcc :: (Id, TagSig) -> SDoc

bndrIsJoin_maybe :: (Id, TagSig) -> Maybe Int

type Anno Id

Defined in GHC.Hs.Extension

type Anno Id = SrcSpanAnnN

type Anno (LocatedN Id)

Defined in GHC.Hs.Binds

type Anno (LocatedN Id) = SrcSpan

type Anno [LocatedN Id]

Defined in GHC.Hs.Binds

type Anno [LocatedN Id] = SrcSpan

type TyVarBinder = VarBndr TyVar ForAllTyFlag

type TyCoVar = Id

Type or Coercion Variable

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

type Mult = Type

Mult is a type alias for Type.

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

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

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

data Scaled a

A shorthand for data with an attached Mult element (the multiplicity).

Instances

Data a => Data (Scaled a)

Defined in GHC.Core.TyCo.Rep

Methods

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

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

toConstr :: Scaled a -> Constr

dataTypeOf :: Scaled a -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable a => Outputable (Scaled a)

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: Scaled a -> SDoc

data PiTyBinder

A PiTyBinder represents an argument to a function. PiTyBinders can be dependent (Named) or nondependent (Anon). They may also be visible or not. See Note [PiTyBinders]

Instances

Data PiTyBinder

Defined in GHC.Types.Var

Methods

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

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

toConstr :: PiTyBinder -> Constr

dataTypeOf :: PiTyBinder -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable PiTyBinder

Defined in GHC.Types.Var

Methods

ppr :: PiTyBinder -> SDoc

type TvSubstEnv = TyVarEnv Type

A substitution of Types for TyVars and Kinds for KindVars

type IdSubstEnv = IdEnv CoreExpr

A substitution of Exprs for non-coercion Ids

type KindOrType = Type

The key representation of types within the compiler

type RuntimeRepType = Type

Type synonym used for types of kind RuntimeRep.

type KnotTied ty = ty

A type labeled KnotTied might have knot-tied tycons in it. See Note [Type checking recursive type and class declarations] in GHC.Tc.TyCl

type FRRType = Type

data ForAllTyFlag

ForAllTyFlag

Is something required to appear in source Haskell (Required), permitted by request (Specified) (visible type application), or prohibited entirely from appearing in source Haskell (Inferred)? See Note [VarBndrs, ForAllTyBinders, TyConBinders, and visibility] in GHC.Core.TyCo.Rep

Constructors

Invisible Specificity

Required

Bundled Patterns

pattern Specified :: ForAllTyFlag

pattern Inferred :: ForAllTyFlag

Instances

Data ForAllTyFlag

Defined in GHC.Types.Var

Methods

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

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

toConstr :: ForAllTyFlag -> Constr

dataTypeOf :: ForAllTyFlag -> DataType

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

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

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

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

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

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

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

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

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

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

Binary ForAllTyFlag

Defined in GHC.Types.Var

Methods

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

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

get :: BinHandle -> IO ForAllTyFlag

Outputable ForAllTyFlag

Defined in GHC.Types.Var

Methods

ppr :: ForAllTyFlag -> SDoc

Eq ForAllTyFlag

Defined in GHC.Types.Var

Methods

(==) :: ForAllTyFlag -> ForAllTyFlag -> Bool

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

Ord ForAllTyFlag

Defined in GHC.Types.Var

Methods

compare :: ForAllTyFlag -> ForAllTyFlag -> Ordering

(<) :: ForAllTyFlag -> ForAllTyFlag -> Bool

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

(>) :: ForAllTyFlag -> ForAllTyFlag -> Bool

(>=) :: ForAllTyFlag -> ForAllTyFlag -> Bool

max :: ForAllTyFlag -> ForAllTyFlag -> ForAllTyFlag

min :: ForAllTyFlag -> ForAllTyFlag -> ForAllTyFlag

Outputable tv => Outputable (VarBndr tv ForAllTyFlag)

Defined in GHC.Types.Var

Methods

ppr :: VarBndr tv ForAllTyFlag -> SDoc

data FunTyFlag

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

Constructors

FTF_T_T

FTF_T_C

FTF_C_T

FTF_C_C

Instances

Data FunTyFlag

Defined in GHC.Types.Var

Methods

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

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

toConstr :: FunTyFlag -> Constr

dataTypeOf :: FunTyFlag -> DataType

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

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

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

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

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

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

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

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

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

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

Binary FunTyFlag

Defined in GHC.Types.Var

Methods

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

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

get :: BinHandle -> IO FunTyFlag

Outputable FunTyFlag

Defined in GHC.Types.Var

Methods

ppr :: FunTyFlag -> SDoc

Eq FunTyFlag

Defined in GHC.Types.Var

Methods

(==) :: FunTyFlag -> FunTyFlag -> Bool

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

Ord FunTyFlag

Defined in GHC.Types.Var

Methods

compare :: FunTyFlag -> FunTyFlag -> Ordering

(<) :: FunTyFlag -> FunTyFlag -> Bool

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

(>) :: FunTyFlag -> FunTyFlag -> Bool

(>=) :: FunTyFlag -> FunTyFlag -> Bool

max :: FunTyFlag -> FunTyFlag -> FunTyFlag

min :: FunTyFlag -> FunTyFlag -> FunTyFlag

data TyCoFolder env a

Constructors

TyCoFolder

Fields

• tcf_view :: Type -> Maybe Type
• tcf_tyvar :: env -> TyVar -> a
• tcf_covar :: env -> CoVar -> a
• tcf_hole :: env -> CoercionHole -> a

  What to do with coercion holes. See Note [Coercion holes] in GHC.Core.TyCo.Rep.

• tcf_tycobinder :: env -> TyCoVar -> ForAllTyFlag -> env

  The returned env is used in the extended scope

type ForAllTyBinder = VarBndr TyCoVar ForAllTyFlag

Variable Binder

A ForAllTyBinder is the binder of a ForAllTy It's convenient to define this synonym here rather its natural home in GHC.Core.TyCo.Rep, because it's used in GHC.Core.DataCon.hs-boot

A TyVarBinder is a binder with only TyVar

data TyCoMapper env m

This describes how a "map" operation over a type/coercion should behave

Constructors

TyCoMapper

Fields

• tcm_tyvar :: env -> TyVar -> m Type
• tcm_covar :: env -> CoVar -> m Coercion
• tcm_hole :: env -> CoercionHole -> m Coercion

  What to do with coercion holes. See Note [Coercion holes] in GHC.Core.TyCo.Rep.

• tcm_tycobinder :: env -> TyCoVar -> ForAllTyFlag -> m (env, TyCoVar)

  The returned env is used in the extended scope

• tcm_tycon :: TyCon -> m TyCon

  This is used only for TcTyCons a) To zonk TcTyCons b) To turn TcTyCons into TyCons. See Note [Type checking recursive type and class declarations] in GHC.Tc.TyCl

pattern OneTy :: Mult

pattern ManyTy :: Mult

funResultTy :: HasDebugCallStack => Type -> Type

Extract the function result type and panic if that is not possible

mkFunTy :: HasDebugCallStack => FunTyFlag -> Mult -> Type -> Type -> Type infixr 3

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

isAlgType :: Type -> Bool

See Type for what an algebraic type is. Should only be applied to types, as opposed to e.g. partially saturated type constructors

typeKind :: HasDebugCallStack => Type -> Kind

splitForAllTyCoVars :: Type -> ([TyCoVar], Type)

Take a ForAllTy apart, returning the list of tycovars and the result type. This always succeeds, even if it returns only an empty list. Note that the result type returned may have free variables that were bound by a forall.

mkForAllTys :: [ForAllTyBinder] -> Type -> Type

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

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

argsHaveFixedRuntimeRep :: Type -> Bool

True if the argument types of this function type all have a fixed-runtime-rep

liftedTypeKind :: Type

unliftedTypeKind :: Type

funTyFlagTyCon :: FunTyFlag -> TyCon

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

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

getLevity :: HasDebugCallStack => Type -> Type

Extract the PromDataConInfo of a type. For example, getLevity Int = Lifted, or getLevity (Array# Int) = Unlifted.

Panics if this is not possible. Does not look through type family applications.

binderVar :: VarBndr tv argf -> tv

binderVars :: [VarBndr tv argf] -> [tv]

mkTyVarBinder :: vis -> TyVar -> VarBndr TyVar vis

Make a named binder var should be a type variable

mkTyVarBinders :: vis -> [TyVar] -> [VarBndr TyVar vis]

Make many named binders Input vars should be type variables

substCo :: HasDebugCallStack => Subst -> Coercion -> Coercion

Substitute within a Coercion The substitution has to satisfy the invariants described in Note [The substitution invariant].

extendTvSubstAndInScope :: Subst -> TyVar -> Type -> Subst

substTyVarBndr :: HasDebugCallStack => Subst -> TyVar -> (Subst, TyVar)

unrestricted :: a -> Scaled a

Scale a payload by Many

linear :: a -> Scaled a

Scale a payload by One

tymult :: a -> Scaled a

Scale a payload by Many; used for type arguments in core

irrelevantMult :: Scaled a -> a

mkScaled :: Mult -> a -> Scaled a

scaledSet :: Scaled a -> b -> Scaled b

tyConAppArgs :: HasCallStack => Type -> [Type]

tyCoVarsOfType :: Type -> TyCoVarSet

mightBeUnliftedType :: Type -> Bool

Returns:

• False if the type is guaranteed lifted or
• True if it is unlifted, OR we aren't sure (e.g. in a representation-polymorphic case)

closeOverKindsDSet :: DTyVarSet -> DTyVarSet

Add the kind variables free in the kinds of the tyvars in the given set. Returns a deterministic set.

typeHasFixedRuntimeRep :: HasDebugCallStack => Type -> Bool

Returns True if a type has a syntactically fixed runtime rep, as per Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete.

This function is equivalent to `isFixedRuntimeRepKind . typeKind` but much faster.

Precondition: The type has kind (TYPE blah)

extendCvSubst :: Subst -> CoVar -> Coercion -> Subst

Add a substitution from a CoVar to a Coercion to the Subst: you must ensure that the in-scope set satisfies Note [The substitution invariant] after extending the substitution like this

substTyVar :: Subst -> TyVar -> Type

zapSubst :: Subst -> Subst

Remove all substitutions that might have been built up while preserving the in-scope set originally called zapSubstEnv

isPredTy :: HasDebugCallStack => Type -> Bool

getTyVar_maybe :: Type -> Maybe TyVar

Attempts to obtain the type variable underlying a Type

tcSplitTyConApp_maybe :: HasCallStack => Type -> Maybe (TyCon, [Type])

tcSplitTyConApp_maybe splits a type constructor application into its type constructor and applied types.

Differs from splitTyConApp_maybe in that it does *not* split types headed with (=>), as that's not a TyCon in the type-checker.

Note that this may fail (in funTyConAppTy_maybe) in the case of a FunTy with an argument of unknown kind FunTy (e.g. `FunTy (a :: k) Int`, since the kind of a isn't of the form `TYPE rep`. This isn't usually a problem but may be temporarily the cas during canonicalization: see Note [Decomposing FunTy] in GHC.Tc.Solver.Canonical and Note [The Purely Kinded Type Invariant (PKTI)] in GHC.Tc.Gen.HsType, Wrinkle around FunTy

Consequently, you may need to zonk your type before using this function.

tyVarKind :: TyVar -> Kind

seqType :: Type -> ()

isTyVar :: Var -> Bool

Is this a type-level (i.e., computationally irrelevant, thus erasable) variable? Satisfies isTyVar = not . isId.

cloneTyVarBndr :: Subst -> TyVar -> Unique -> (Subst, TyVar)

typeSize :: Type -> Int

substTyUnchecked :: Subst -> Type -> Type

Substitute within a Type disabling the sanity checks. The problems that the sanity checks in substTy catch are described in Note [The substitution invariant]. The goal of #11371 is to migrate all the calls of substTyUnchecked to substTy and remove this function. Please don't use in new code.

emptySubst :: Subst

mkEmptySubst :: InScopeSet -> Subst

mkSubst :: InScopeSet -> TvSubstEnv -> CvSubstEnv -> IdSubstEnv -> Subst

isEmptySubst :: Subst -> Bool

extendTCvSubst :: Subst -> TyCoVar -> Type -> Subst

extendSubstInScope :: Subst -> Var -> Subst

Add the Var to the in-scope set

extendSubstInScopeList :: Subst -> [Var] -> Subst

Add the Vars to the in-scope set: see also extendInScope

extendSubstInScopeSet :: Subst -> VarSet -> Subst

Add the Vars to the in-scope set: see also extendInScope

setInScope :: Subst -> InScopeSet -> Subst

getSubstInScope :: Subst -> InScopeSet

Find the in-scope set: see Note [The substitution invariant]

coreView :: Type -> Maybe Type

This function strips off the top layer only of a type synonym application (if any) its underlying representation type. Returns Nothing if there is nothing to look through.

This function does not look through type family applications.

By being non-recursive and inlined, this case analysis gets efficiently joined onto the case analysis that the caller is already doing

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

Just like splitAppTyNoView_maybe, but does not split (c => t) See Note [Decomposing fat arrow c=>t]

splitAppTyNoView_maybe :: HasDebugCallStack => Type -> Maybe (Type, Type)

Does the AppTy split as in splitAppTy_maybe, but assumes that any coreView stuff is already done

tyCoVarsOfTypes :: [Type] -> TyCoVarSet

tyCoVarsOfTypeDSet :: Type -> DTyCoVarSet

tyCoFVsOfType that returns free variables of a type in a deterministic set. For explanation of why using VarSet is not deterministic see Note [Deterministic FV] in GHC.Utils.FV.

tyCoFVsBndr :: ForAllTyBinder -> FV -> FV

tyCoFVsVarBndr :: Var -> FV -> FV

tyCoFVsVarBndrs :: [Var] -> FV -> FV

tyCoFVsOfType :: Type -> FV

The worker for tyCoFVsOfType and tyCoFVsOfTypeList. The previous implementation used unionVarSet which is O(n+m) and can make the function quadratic. It's exported, so that it can be composed with other functions that compute free variables. See Note [FV naming conventions] in GHC.Utils.FV.

Eta-expanded because that makes it run faster (apparently) See Note [FV eta expansion] in GHC.Utils.FV for explanation.

coVarsOfType :: Type -> CoVarSet

coVarsOfTypes :: [Type] -> CoVarSet

anyFreeVarsOfType :: (TyCoVar -> Bool) -> Type -> Bool

anyFreeVarsOfTypes :: (TyCoVar -> Bool) -> [Type] -> Bool

noFreeVarsOfType :: Type -> Bool

tyConsOfType :: Type -> UniqSet TyCon

All type constructors occurring in the type; looking through type synonyms, but not newtypes. When it finds a Class, it returns the class TyCon.

occCheckExpand :: [Var] -> Type -> Maybe Type

scopedSort :: [TyCoVar] -> [TyCoVar]

Do a topological sort on a list of tyvars, so that binders occur before occurrences E.g. given [ a::k, k::*, b::k ] it'll return a well-scoped list [ k::*, a::k, b::k ]

This is a deterministic sorting operation (that is, doesn't depend on Uniques).

It is also meant to be stable: that is, variables should not be reordered unnecessarily. This is specified in Note [ScopedSort] See also Note [Ordering of implicit variables] in GHC.Rename.HsType

tyCoVarsOfTypeWellScoped :: Type -> [TyVar]

Get the free vars of a type in scoped order

tyCoVarsOfTypesWellScoped :: [Type] -> [TyVar]

Get the free vars of types in scoped order

closeOverKindsList :: [TyVar] -> [TyVar]

Add the kind variables free in the kinds of the tyvars in the given set. Returns a deterministically ordered list.

closeOverKinds :: TyCoVarSet -> TyCoVarSet

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

Given a TyCon and a list of argument types, partition the arguments into:

1. Inferred or Specified (i.e., invisible) arguments and
2. Required (i.e., visible) arguments

pickyIsLiftedTypeKind :: Kind -> Bool

splitForAllReqTyBinders :: Type -> ([ReqTyBinder], Type)

Like splitForAllTyCoVars, but only splits ForAllTys with Required type variable binders. Furthermore, each returned tyvar is annotated with ().

splitForAllInvisTyBinders :: Type -> ([InvisTyBinder], Type)

Like splitForAllTyCoVars, but only splits ForAllTys with Invisible type variable binders. Furthermore, each returned tyvar is annotated with its Specificity.

mkTyVarTy :: TyVar -> Type

mkTyVarTys :: [TyVar] -> [Type]

mkVisFunTy :: HasDebugCallStack => Mult -> Type -> Type -> Type

mkScaledFunTys :: HasDebugCallStack => [Scaled Type] -> Type -> Type

mkInvisFunTy :: HasDebugCallStack => Type -> Type -> Type infixr 3

mkInvisFunTys :: HasDebugCallStack => [Type] -> Type -> Type

tcMkVisFunTy :: Mult -> Type -> Type -> Type

tcMkInvisFunTy :: TypeOrConstraint -> Type -> Type -> Type

tcMkScaledFunTys :: [Scaled Type] -> Type -> Type

mkForAllTy :: ForAllTyBinder -> Type -> Type

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

mkInvisForAllTys :: [InvisTVBinder] -> Type -> Type

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

mkPiTy :: PiTyBinder -> Type -> Type

mkPiTys :: [PiTyBinder] -> Type -> Type

mkVisFunTyMany :: HasDebugCallStack => Type -> Type -> Type infixr 3

Make nested arrow types | Special, common, case: Arrow type with mult Many

foldTyCo :: Monoid a => TyCoFolder env a -> env -> (Type -> a, [Type] -> a, Coercion -> a, [Coercion] -> a)

noView :: Type -> Maybe Type

A view function that looks through nothing.

chooseFunTyFlag :: HasDebugCallStack => Type -> Type -> FunTyFlag

See GHC.Types.Var Note [FunTyFlag]

typeTypeOrConstraint :: HasDebugCallStack => Type -> TypeOrConstraint

emptyTvSubstEnv :: TvSubstEnv

composeTCvSubst :: Subst -> Subst -> Subst

Composes two substitutions, applying the second one provided first, like in function composition. This function leaves IdSubstEnv untouched because IdSubstEnv is not used during substitution for types.

isEmptyTCvSubst :: Subst -> Bool

Checks whether the tyvar and covar environments are empty. This function should be used over isEmptySubst when substituting for types, because types currently do not contain expressions; we can safely disregard the expression environment when deciding whether to skip a substitution. Using isEmptyTCvSubst gives us a non-trivial performance boost (up to 70% less allocation for T18223)

getTvSubstEnv :: Subst -> TvSubstEnv

getSubstRangeTyCoFVs :: Subst -> VarSet

Returns the free variables of the types in the range of a substitution as a non-deterministic set.

notElemSubst :: Var -> Subst -> Bool

extendTCvSubstWithClone :: Subst -> TyCoVar -> TyCoVar -> Subst

extendTvSubstBinderAndInScope :: Subst -> PiTyBinder -> Type -> Subst

extendTvSubstWithClone :: Subst -> TyVar -> TyVar -> Subst

extendTCvSubstList :: Subst -> [Var] -> [Type] -> Subst

unionSubst :: Subst -> Subst -> Subst

zipTyEnv :: HasDebugCallStack => [TyVar] -> [Type] -> TvSubstEnv

The InScopeSet is just a thunk so with a bit of luck it'll never be evaluated

zipCoEnv :: HasDebugCallStack => [CoVar] -> [Coercion] -> CvSubstEnv

zipTvSubst :: HasDebugCallStack => [TyVar] -> [Type] -> Subst

Generates the in-scope set for the Subst from the types in the incoming environment. No CoVars or Ids, please!

zipTCvSubst :: HasDebugCallStack => [TyCoVar] -> [Type] -> Subst

mkTvSubstPrs :: [(TyVar, Type)] -> Subst

Generates the in-scope set for the TCvSubst from the types in the incoming environment. No CoVars, please! The InScopeSet is just a thunk so with a bit of luck it'll never be evaluated

substTyWith :: HasDebugCallStack => [TyVar] -> [Type] -> Type -> Type

Type substitution, see zipTvSubst

substTysWith :: [TyVar] -> [Type] -> [Type] -> [Type]

Type substitution, see zipTvSubst

substTyAddInScope :: Subst -> Type -> Type

Substitute within a Type after adding the free variables of the type to the in-scope set. This is useful for the case when the free variables aren't already in the in-scope set or easily available. See also Note [The substitution invariant].

substScaledTy :: HasDebugCallStack => Subst -> Scaled Type -> Scaled Type

substTysUnchecked :: Subst -> [Type] -> [Type]

Substitute within several Types disabling the sanity checks. The problems that the sanity checks in substTys catch are described in Note [The substitution invariant]. The goal of #11371 is to migrate all the calls of substTysUnchecked to substTys and remove this function. Please don't use in new code.

substScaledTysUnchecked :: Subst -> [Scaled Type] -> [Scaled Type]

substThetaUnchecked :: Subst -> ThetaType -> ThetaType

Substitute within a ThetaType disabling the sanity checks. The problems that the sanity checks in substTys catch are described in Note [The substitution invariant]. The goal of #11371 is to migrate all the calls of substThetaUnchecked to substTheta and remove this function. Please don't use in new code.

substTyWithUnchecked :: [TyVar] -> [Type] -> Type -> Type

Type substitution, see zipTvSubst. Disables sanity checks. The problems that the sanity checks in substTy catch are described in Note [The substitution invariant]. The goal of #11371 is to migrate all the calls of substTyUnchecked to substTy and remove this function. Please don't use in new code.

substScaledTyUnchecked :: HasDebugCallStack => Subst -> Scaled Type -> Scaled Type

substCoUnchecked :: Subst -> Coercion -> Coercion

Substitute within a Coercion disabling sanity checks. The problems that the sanity checks in substCo catch are described in Note [The substitution invariant]. The goal of #11371 is to migrate all the calls of substCoUnchecked to substCo and remove this function. Please don't use in new code.

substCoWithUnchecked :: [TyVar] -> [Type] -> Coercion -> Coercion

Coercion substitution, see zipTvSubst. Disables sanity checks. The problems that the sanity checks in substCo catch are described in Note [The substitution invariant]. The goal of #11371 is to migrate all the calls of substCoUnchecked to substCo and remove this function. Please don't use in new code.

substTys :: HasDebugCallStack => Subst -> [Type] -> [Type]

Substitute within several Types The substitution has to satisfy the invariants described in Note [The substitution invariant].

substScaledTys :: HasDebugCallStack => Subst -> [Scaled Type] -> [Scaled Type]

substTheta :: HasDebugCallStack => Subst -> ThetaType -> ThetaType

Substitute within a ThetaType The substitution has to satisfy the invariants described in Note [The substitution invariant].

lookupTyVar :: Subst -> TyVar -> Maybe Type

cloneTyVarBndrs :: Subst -> [TyVar] -> UniqSupply -> (Subst, [TyVar])

substVarBndr :: HasDebugCallStack => Subst -> TyCoVar -> (Subst, TyCoVar)

substVarBndrs :: HasDebugCallStack => Subst -> [TyCoVar] -> (Subst, [TyCoVar])

substTyVarBndrs :: HasDebugCallStack => Subst -> [TyVar] -> (Subst, [TyVar])

substTyVars :: Subst -> [TyVar] -> [Type]

substTyVarToTyVar :: HasDebugCallStack => Subst -> TyVar -> TyVar

substTyCoBndr :: Subst -> PiTyBinder -> (Subst, PiTyBinder)

mkCastTy :: Type -> Coercion -> Type

Make a CastTy. The Coercion must be nominal. Checks the Coercion for reflexivity, dropping it if it's reflexive. See Note [Respecting definitional equality] in GHC.Core.TyCo.Rep

mkAppTy :: Type -> Type -> Type

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

isCoercionTy :: Type -> Bool

tidyType :: TidyEnv -> Type -> Type

Tidy a Type

See Note [Strictness in tidyType and friends]

tidyTypes :: TidyEnv -> [Type] -> [Type]

Tidy a list of Types

See Note [Strictness in tidyType and friends]

tidyOpenType :: TidyEnv -> Type -> (TidyEnv, Type)

tidyOpenTypes :: TidyEnv -> [Type] -> (TidyEnv, [Type])

Grabs the free type variables, tidies them and then uses tidyType to work over the type itself

tidyVarBndr :: TidyEnv -> TyCoVar -> (TidyEnv, TyCoVar)

tidyVarBndrs :: TidyEnv -> [TyCoVar] -> (TidyEnv, [TyCoVar])

This tidies up a type for printing in an error message, or in an interface file.

It doesn't change the uniques at all, just the print names.

tidyFreeTyCoVars :: TidyEnv -> [TyCoVar] -> TidyEnv

Add the free TyVars to the env in tidy form, so that we can tidy the type they are free in

tidyOpenTyCoVar :: TidyEnv -> TyCoVar -> (TidyEnv, TyCoVar)

Treat a new TyCoVar as a binder, and give it a fresh tidy name using the environment if one has not already been allocated. See also tidyVarBndr

tidyOpenTyCoVars :: TidyEnv -> [TyCoVar] -> (TidyEnv, [TyCoVar])

tidyTyCoVarOcc :: TidyEnv -> TyCoVar -> TyCoVar

tidyTopType :: Type -> Type

Calls tidyType on a top-level type (i.e. with an empty tidying environment)

tidyForAllTyBinder :: TidyEnv -> VarBndr TyCoVar vis -> (TidyEnv, VarBndr TyCoVar vis)

tidyForAllTyBinders :: TidyEnv -> [VarBndr TyCoVar vis] -> (TidyEnv, [VarBndr TyCoVar vis])

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!

isLiftedTypeKind :: Kind -> Bool

Returns True if the argument is (lifted) Type or Constraint See Note [TYPE and CONSTRAINT] in GHC.Builtin.Types.Prim

getTyVar :: HasDebugCallStack => Type -> TyVar

Attempts to obtain the type variable underlying a Type, and panics with the given message if this is not a type variable type. See also getTyVar_maybe

repGetTyVar_maybe :: Type -> Maybe TyVar

Attempts to obtain the type variable underlying a Type, without any expansion

getCastedTyVar_maybe :: Type -> Maybe (TyVar, CoercionN)

If the type is a tyvar, possibly under a cast, returns it, along with the coercion. Thus, the co is :: kind tv ~N kind ty

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

splitAppTy :: Type -> (Type, Type)

Attempts to take a type application apart, as in splitAppTy_maybe, and panics if this is not possible

splitAppTys :: Type -> (Type, [Type])

Recursively splits a type as far as is possible, leaving a residual type being applied to and the type arguments applied to it. Never fails, even if that means returning an empty list of type applications.

splitAppTysNoView :: HasDebugCallStack => Type -> (Type, [Type])

Like splitAppTys, but doesn't look through type synonyms

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

Attempt to take a type application apart, whether it is a function, type constructor, or plain type application. Note that type family applications are NEVER unsaturated by this!

splitFunTy :: Type -> (Mult, Type, Type)

Attempts to extract the multiplicity, argument and result types from a type, and panics if that is not possible. See also splitFunTy_maybe

splitFunTy_maybe :: Type -> Maybe (FunTyFlag, Mult, Type, Type)

Attempts to extract the multiplicity, argument and result types from a type

splitFunTys :: Type -> ([Scaled Type], Type)

funArgTy :: Type -> Type

Just like piResultTys but for a single argument Try not to iterate piResultTy, because it's inefficient to substitute one variable at a time; instead use 'piResultTys"

Extract the function argument type and panic if that is not possible

funTyConAppTy_maybe :: FunTyFlag -> Type -> Type -> Type -> Maybe (TyCon, [Type])

Given the components of a FunTy figure out the corresponding TyConApp.

tyConAppFunTy_maybe :: HasDebugCallStack => TyCon -> [Type] -> Maybe Type

Return Just if this TyConApp should be represented as a FunTy

tyConAppFunCo_maybe :: HasDebugCallStack => Role -> TyCon -> [Coercion] -> Maybe Coercion

Return Just if this TyConAppCo should be represented as a FunCo

mkFunctionType :: Mult -> Type -> Type -> Type

This one works out the FunTyFlag from the argument type See GHC.Types.Var Note [FunTyFlag]

mkScaledFunctionTys :: [Scaled Type] -> Type -> Type

Like mkFunctionType, compute the FunTyFlag from the arguments

tyConAppTyCon_maybe :: Type -> Maybe TyCon

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

tyConAppTyConPicky_maybe :: Type -> Maybe TyCon

Retrieve the tycon heading this type, if there is one. Does not look through synonyms.

tyConAppArgs_maybe :: Type -> Maybe [Type]

The same as snd . splitTyConApp

tyConAppTyCon :: HasDebugCallStack => Type -> TyCon

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

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

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

mkTyCoInvForAllTys :: [TyCoVar] -> Type -> Type

Like mkForAllTys, but assumes all variables are dependent and Inferred, a common case

mkSpecForAllTy :: TyVar -> Type -> Type

Like mkForAllTy, but assumes the variable is dependent and Specified, a common case

mkSpecForAllTys :: [TyVar] -> Type -> Type

Like mkForAllTys, but assumes all variables are dependent and Specified, a common case

mkVisForAllTys :: [TyVar] -> Type -> Type

Like mkForAllTys, but assumes all variables are dependent and visible

mkTyCoInvForAllTy :: TyCoVar -> Type -> Type

Make a dependent forall over an Inferred variable

mkInfForAllTy :: TyVar -> Type -> Type

Like mkTyCoInvForAllTy, but tv should be a tyvar

mkInfForAllTys :: [TyVar] -> Type -> Type

Like mkTyCoInvForAllTys, but tvs should be a list of tyvar

splitForAllForAllTyBinders :: Type -> ([ForAllTyBinder], Type)

Take a ForAllTy apart, returning the binders and result type

splitForAllTyCoVar_maybe :: Type -> Maybe (TyCoVar, Type)

Attempts to take a forall type apart, but only if it's a proper forall, with a named binder

splitForAllTyCoVar :: Type -> (TyCoVar, Type)

Take a forall type apart, or panics if that is not possible.

splitForAllTyVar_maybe :: Type -> Maybe (TyVar, Type)

Like splitForAllTyCoVar_maybe, but only returns Just if it is a tyvar binder.

splitForAllCoVar_maybe :: Type -> Maybe (CoVar, Type)

Like splitForAllTyCoVar_maybe, but only returns Just if it is a covar binder.

splitPiTy_maybe :: Type -> Maybe (PiTyBinder, Type)

Attempts to take a forall type apart; works with proper foralls and functions

splitPiTy :: Type -> (PiTyBinder, Type)

Takes a forall type apart, or panics

splitPiTys :: Type -> ([PiTyBinder], Type)

Split off all PiTyBinders to a type, splitting both proper foralls and functions

getRuntimeArgTys :: Type -> [(Scaled Type, FunTyFlag)]

Extracts a list of run-time arguments from a function type, looking through newtypes to the right of arrows.

Examples:

   newtype Identity a = I a

   getRuntimeArgTys (Int -> Bool -> Double) == [(Int, FTF_T_T), (Bool, FTF_T_T)]
   getRuntimeArgTys (Identity Int -> Bool -> Double) == [(Identity Int, FTF_T_T), (Bool, FTF_T_T)]
   getRuntimeArgTys (Int -> Identity (Bool -> Identity Double)) == [(Int, FTF_T_T), (Bool, FTF_T_T)]
   getRuntimeArgTys (forall a. Show a => Identity a -> a -> Int -> Bool)
            == [(Show a, FTF_C_T), (Identity a, FTF_T_T),(a, FTF_T_T),(Int, FTF_T_T)]

Note that, in the last case, the returned types might mention an out-of-scope type variable. This function is used only when we really care about the kinds of the returned types, so this is OK.

• *Warning**: this function can return an infinite list. For example:

  newtype N a = MkN (a -> N a)
  getRuntimeArgTys (N a) == repeat (a, FTF_T_T)

mkTyConBindersPreferAnon

Arguments

:: [TyVar]

binders

-> TyCoVarSet

free variables of result

-> [TyConBinder]

Given a list of type-level vars and the free vars of a result kind, makes PiTyBinders, preferring anonymous binders if the variable is, in fact, not dependent. e.g. mkTyConBindersPreferAnon (k:*),(b:k),(c:k) We want (k:*) Named, (b:k) Anon, (c:k) Anon

All non-coercion binders are visible.

piResultTy :: HasDebugCallStack => Type -> Type -> Type

piResultTys :: HasDebugCallStack => Type -> [Type] -> Type

(piResultTys f_ty [ty1, .., tyn]) gives the type of (f ty1 .. tyn) where f :: f_ty piResultTys is interesting because: 1. f_ty may have more for-alls than there are args 2. Less obviously, it may have fewer for-alls For case 2. think of: piResultTys (forall a.a) [forall b.b, Int] This really can happen, but only (I think) in situations involving undefined. For example: undefined :: forall a. a Term: undefined (forall b. b->b) Int This term should have type (Int -> Int), but notice that there are more type args than foralls in undefineds type.

applyTysX :: [TyVar] -> Type -> [Type] -> Type

dropForAlls :: Type -> Type

Drops all ForAllTys

mkFamilyTyConApp :: TyCon -> [Type] -> Type

Given a family instance TyCon and its arg types, return the corresponding family type. E.g:

data family T a
data instance T (Maybe b) = MkT b

Where the instance tycon is :RTL, so:

mkFamilyTyConApp :RTL Int  =  T (Maybe Int)

buildSynTyCon

Arguments

:: Name

-> [KnotTied TyConBinder]

-> Kind

result kind

-> [Role]

-> KnotTied Type

-> TyCon

mkNumLitTy :: Integer -> Type

isNumLitTy :: Type -> Maybe Integer

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

mkStrLitTy :: FastString -> Type

isStrLitTy :: Type -> Maybe FastString

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

mkCharLitTy :: Char -> Type

isCharLitTy :: Type -> Maybe Char

Is this a char literal? We also look through type synonyms.

isLitTy :: Type -> Maybe TyLit

Is this a type literal (symbol, numeric, or char)?

getRuntimeRep :: HasDebugCallStack => Type -> RuntimeRepType

Extract the RuntimeRep classifier of a type. For instance, getRuntimeRep_maybe Int = LiftedRep. Panics if this is not possible.

splitRuntimeRep_maybe :: RuntimeRepType -> Maybe (TyCon, [Type])

(splitRuntimeRep_maybe rr) takes a Type rr :: RuntimeRep, and returns the (TyCon,[Type]) for the RuntimeRep, if possible, where the TyCon is one of the promoted DataCons of RuntimeRep. Remember: the unique on TyCon that is a a promoted DataCon is the same as the unique on the DataCon See Note [Promoted data constructors] in GHC.Core.TyCon May not be possible if rr is a type variable or type family application

kindRep_maybe :: HasDebugCallStack => Kind -> Maybe RuntimeRepType

Given a kind (TYPE rr) or (CONSTRAINT rr), extract its RuntimeRep classifier rr. For example, kindRep_maybe * = Just LiftedRep Returns Nothing if the kind is not of form (TYPE rr)

kindRep :: HasDebugCallStack => Kind -> RuntimeRepType

Extract the RuntimeRep classifier of a type from its kind. For example, kindRep * = LiftedRep; Panics if this is not possible. Treats * and Constraint as the same

levityType_maybe :: LevityType -> Maybe Levity

levity_maybe takes a Type of kind Levity, and returns its levity May not be possible for a type variable or type family application

mkCoercionTy :: Coercion -> Type

splitCastTy_maybe :: Type -> Maybe (Type, Coercion)

userTypeError_maybe :: Type -> Maybe Type

Is this type a custom user error? If so, give us the kind and the error message.

pprUserTypeErrorTy :: Type -> SDoc

Render a type corresponding to a user type error into a SDoc.

coAxNthLHS :: CoAxiom br -> Int -> Type

Get the type on the LHS of a coercion induced by a type/data family instance.

stripCoercionTy :: Type -> Coercion

splitInvisPiTys :: Type -> ([PiTyBinder], Type)

Like splitPiTys, but returns only *invisible* binders, including constraints. Stops at the first visible binder.

splitInvisPiTysN :: Int -> Type -> ([PiTyBinder], Type)

Same as splitInvisPiTys, but stop when - you have found n PiTyBinders, - or you run out of invisible binders

invisibleTyBndrCount :: Type -> Int

filterOutInvisibleTypes :: TyCon -> [Type] -> [Type]

Given a TyCon and a list of argument types, filter out any invisible (i.e., Inferred or Specified) arguments.

filterOutInferredTypes :: TyCon -> [Type] -> [Type]

Given a TyCon and a list of argument types, filter out any Inferred arguments.

partitionInvisibles :: [(a, ForAllTyFlag)] -> ([a], [a])

Given a list of things paired with their visibilities, partition the things into (invisible things, visible things).

tyConForAllTyFlags :: TyCon -> [Type] -> [ForAllTyFlag]

Given a TyCon and a list of argument types to which the TyCon is applied, determine each argument's visibility (Inferred, Specified, or Required).

Wrinkle: consider the following scenario:

T :: forall k. k -> k
tyConForAllTyFlags T [forall m. m -> m -> m, S, R, Q]

After substituting, we get

T (forall m. m -> m -> m) :: (forall m. m -> m -> m) -> forall n. n -> n -> n

Thus, the first argument is invisible, S is visible, R is invisible again, and Q is visible.

appTyForAllTyFlags :: Type -> [Type] -> [ForAllTyFlag]

Given a Type and a list of argument types to which the Type is applied, determine each argument's visibility (Inferred, Specified, or Required).

Most of the time, the arguments will be Required, but not always. Consider f :: forall a. a -> Type. In f Type Bool, the first argument (Type) is Specified and the second argument (Bool) is Required. It is precisely this sort of higher-rank situation in which appTyForAllTyFlags comes in handy, since f Type Bool would be represented in Core using AppTys. (See also #15792).

mapTyCo :: Monad m => TyCoMapper () m -> (Type -> m Type, [Type] -> m [Type], Coercion -> m Coercion, [Coercion] -> m [Coercion])

mapTyCoX :: Monad m => TyCoMapper env m -> (env -> Type -> m Type, env -> [Type] -> m [Type], env -> Coercion -> m Coercion, env -> [Coercion] -> m [Coercion])

newTyConInstRhs :: TyCon -> [Type] -> Type

Unwrap one layer of newtype on a type constructor and its arguments, using an eta-reduced version of the newtype if possible. This requires tys to have at least newTyConInstArity tycon elements.

mkForAllTyBinder :: vis -> TyCoVar -> VarBndr TyCoVar vis

Make a named binder

mkForAllTyBinders :: vis -> [TyCoVar] -> [VarBndr TyCoVar vis]

Make many named binders

tyVarSpecToBinders :: [VarBndr a Specificity] -> [VarBndr a ForAllTyFlag]

isAnonPiTyBinder :: PiTyBinder -> Bool

Does this binder bind a variable that is not erased? Returns True for anonymous binders.

binderType :: VarBndr TyCoVar argf -> Type

binderFlag :: VarBndr tv argf -> argf

binderFlags :: [VarBndr tv argf] -> [argf]

piTyBinderType :: PiTyBinder -> Type

namedPiTyBinder_maybe :: PiTyBinder -> Maybe TyCoVar

anonPiTyBinderType_maybe :: PiTyBinder -> Maybe Type

Extract a relevant type, if there is one.

isVisibleForAllTyFlag :: ForAllTyFlag -> Bool

Does this ForAllTyFlag classify an argument that is written in Haskell?

isInvisibleForAllTyFlag :: ForAllTyFlag -> Bool

Does this ForAllTyFlag classify an argument that is not written in Haskell?

isVisiblePiTyBinder :: PiTyBinder -> Bool

Does this binder bind a visible argument?

isInvisiblePiTyBinder :: PiTyBinder -> Bool

Does this binder bind an invisible argument?

isNamedPiTyBinder :: PiTyBinder -> Bool

tyConBindersPiTyBinders :: [TyConBinder] -> [PiTyBinder]

isTyVarTy :: Type -> Bool

isFunTy :: Type -> Bool

Is this a function?

isCoercionTy_maybe :: Type -> Maybe Coercion

isForAllTy :: Type -> Bool

Checks whether this is a proper forall (with a named binder)

isForAllTy_ty :: Type -> Bool

Like isForAllTy, but returns True only if it is a tyvar binder

isForAllTy_co :: Type -> Bool

Like isForAllTy, but returns True only if it is a covar binder

isPiTy :: Type -> Bool

Is this a function or forall?

isTauTy :: Type -> Bool

isFamFreeTy :: Type -> Bool

isCoVarType :: Type -> Bool

Does this type classify a core (unlifted) Coercion? At either role nominal or representational (t1 ~# t2) or (t1 ~R# t2) See Note [Types for coercions, predicates, and evidence] in GHC.Core.TyCo.Rep

isAtomicTy :: Type -> Bool

isValidJoinPointType :: JoinArity -> Type -> Bool

Determine whether a type could be the type of a join point of given total arity, according to the polymorphism rule. A join point cannot be polymorphic in its return type, since given join j a b x y z = e1 in e2, the types of e1 and e2 must be the same, and a and b are not in scope for e2. (See Note [The polymorphism rule of join points] in GHC.Core.) Returns False also if the type simply doesn't have enough arguments.

Note that we need to know how many arguments (type *and* value) the putative join point takes; for instance, if j :: forall a. a -> Int then j could be a binary join point returning an Int, but it could *not* be a unary join point returning a -> Int.

TODO: See Note [Excess polymorphism and join points]

tyConAppNeedsKindSig

Arguments

:: Bool

Should specified binders count towards injective positions in the kind of the TyCon? (If you're using visible kind applications, then you want True here.

-> TyCon

-> Int

The number of args the TyCon is applied to.

-> Bool

Does T t_1 ... t_n need a kind signature? (Where n is the number of arguments)

Does a TyCon (that is applied to some number of arguments) need to be ascribed with an explicit kind signature to resolve ambiguity if rendered as a source-syntax type? (See Note [When does a tycon application need an explicit kind signature?] for a full explanation of what this function checks for.)

mkTYPEapp :: RuntimeRepType -> Type

mkTYPEapp_maybe :: RuntimeRepType -> Maybe Type

Given a RuntimeRep, applies TYPE to it. On the fly it rewrites TYPE LiftedRep --> liftedTypeKind (a synonym) TYPE UnliftedRep --> unliftedTypeKind (ditto) TYPE ZeroBitRep --> zeroBitTypeKind (ditto) NB: no need to check for TYPE (BoxedRep Lifted), TYPE (BoxedRep Unlifted) because those inner types should already have been rewritten to LiftedRep and UnliftedRep respectively, by mkTyConApp

see Note [TYPE and CONSTRAINT] in GHC.Builtin.Types.Prim. See Note [Using synonyms to compress types] in GHC.Core.Type

mkCONSTRAINTapp :: RuntimeRepType -> Type

Just like mkTYPEapp

mkCONSTRAINTapp_maybe :: RuntimeRepType -> Maybe Type

Just like mkTYPEapp_maybe

mkBoxedRepApp_maybe :: LevityType -> Maybe Type

Given a PromDataConInfo, apply BoxedRep to it On the fly, rewrite BoxedRep Lifted --> liftedRepTy (a synonym) BoxedRep Unlifted --> unliftedRepTy (ditto) See Note [TYPE and CONSTRAINT] in GHC.Builtin.Types.Prim. See Note [Using synonyms to compress types] in GHC.Core.Type

mkTupleRepApp_maybe :: Type -> Maybe Type

Given a `[RuntimeRep]`, apply TupleRep to it On the fly, rewrite TupleRep [] -> zeroBitRepTy (a synonym) See Note [TYPE and CONSTRAINT] in GHC.Builtin.Types.Prim. See Note [Using synonyms to compress types] in GHC.Core.Type

typeOrConstraintKind :: TypeOrConstraint -> RuntimeRepType -> Kind

sORTKind_maybe :: Kind -> Maybe (TypeOrConstraint, Type)

typeLevity_maybe :: HasDebugCallStack => Type -> Maybe Levity

Tries to compute the PromDataConInfo of the given type. Returns either a definite PromDataConInfo, or Nothing if we aren't sure (e.g. the type is representation-polymorphic).

Panics if the kind does not have the shape TYPE r.

isUnliftedTypeKind :: Kind -> Bool

Returns True if the kind classifies unlifted types (like 'Int#') and False otherwise. Note that this returns False for representation-polymorphic kinds, which may be specialized to a kind that classifies unlifted types.

isLiftedRuntimeRep :: RuntimeRepType -> Bool

Check whether a type of kind RuntimeRep is lifted.

isLiftedRuntimeRep is:

• True of LiftedRep :: RuntimeRep
• False of type variables, type family applications, and of other reps such as IntRep :: RuntimeRep.

isUnliftedRuntimeRep :: RuntimeRepType -> Bool

Check whether a type of kind RuntimeRep is unlifted.

• True of definitely unlifted RuntimeReps such as UnliftedRep, IntRep, FloatRep, ...
• False of LiftedRep,
• False for type variables and type family applications.

runtimeRepLevity_maybe :: RuntimeRepType -> Maybe Levity

Check whether a type of kind RuntimeRep is lifted, unlifted, or unknown.

`isLiftedRuntimeRep rr` returns:

• `Just Lifted` if rr is `LiftedRep :: RuntimeRep`
• `Just Unlifted` if rr is definitely unlifted, e.g. IntRep
• Nothing if not known (e.g. it's a type variable or a type family application).

isBoxedRuntimeRep :: RuntimeRepType -> Bool

See isBoxedRuntimeRep_maybe.

isLiftedLevity :: Type -> Bool

isUnliftedLevity :: Type -> Bool

isUnliftedType :: HasDebugCallStack => Type -> Bool

Is the given type definitely unlifted? See Type for what an unlifted type is.

Panics on representation-polymorphic types; See mightBeUnliftedType for a more approximate predicate that behaves better in the presence of representation polymorphism.

isBoxedType :: Type -> Bool

See Type for what a boxed type is. Panics on representation-polymorphic types; See mightBeUnliftedType for a more approximate predicate that behaves better in the presence of representation polymorphism.

isUnboxedTupleType :: Type -> Bool

isUnboxedSumType :: Type -> Bool

kindBoxedRepLevity_maybe :: Type -> Maybe Levity

Check whether a kind is of the form `TYPE (BoxedRep Lifted)` or `TYPE (BoxedRep Unlifted)`.

Returns:

• `Just Lifted` for `TYPE (BoxedRep Lifted)` and Type,
• `Just Unlifted` for `TYPE (BoxedRep Unlifted)` and UnliftedType,
• Nothing for anything else, e.g. `TYPE IntRep`, `TYPE (BoxedRep l)`, etc.

mightBeLiftedType :: Type -> Bool

Returns:

• False if the type is guaranteed unlifted or
• True if it lifted, OR we aren't sure (e.g. in a representation-polymorphic case)

isDataFamilyAppType :: Type -> Bool

Check whether a type is a data family type

isPrimitiveType :: Type -> Bool

Returns true of types that are opaque to Haskell.

isStrictType :: HasDebugCallStack => Type -> Bool

Computes whether an argument (or let right hand side) should be computed strictly or lazily, based only on its type. Currently, it's just isUnliftedType. Panics on representation-polymorphic types.

isLevityTy :: Type -> Bool

Is this the type PromDataConInfo?

isLevityVar :: TyVar -> Bool

Is a tyvar of type PromDataConInfo?

isRuntimeRepTy :: Type -> Bool

Is this the type RuntimeRep?

isRuntimeRepVar :: TyVar -> Bool

Is a tyvar of type RuntimeRep?

isRuntimeRepKindedTy :: Type -> Bool

Is this a type of kind RuntimeRep? (e.g. LiftedRep)

dropRuntimeRepArgs :: [Type] -> [Type]

Drops prefix of RuntimeRep constructors in TyConApps. Useful for e.g. dropping 'LiftedRep arguments of unboxed tuple TyCon applications:

dropRuntimeRepArgs [ 'LiftedRep, 'IntRep , String, Int# ] == [String, Int#]

isMultiplicityTy :: Type -> Bool

Is this the type Multiplicity?

isMultiplicityVar :: TyVar -> Bool

Is a tyvar of type Multiplicity?

isOneTy :: Mult -> Bool

isManyTy :: Mult -> Bool

isLinearType :: Type -> Bool

isLinear t returns True of a if t is a type of (curried) function where at least one argument is linear (or otherwise non-unrestricted). We use this function to check whether it is safe to eta reduce an Id in CorePrep. It is always safe to return True, because True deactivates the optimisation.

tcIsLiftedTypeKind :: Kind -> Bool

Is this kind equivalent to Type i.e. TYPE LiftedRep?

isConstraintKind :: Kind -> Bool

isConstraintLikeKind :: Kind -> Bool

returnsConstraintKind :: Kind -> Bool

tcIsBoxedTypeKind :: Kind -> Bool

Is this kind equivalent to TYPE (BoxedRep l) for some l :: Levity?

isTypeLikeKind :: Kind -> Bool

Is this kind equivalent to TYPE r (for some unknown r)?

This considers Constraint to be distinct from *.

expandTypeSynonyms :: Type -> Type

Expand out all type synonyms. Actually, it'd suffice to expand out just the ones that discard type variables (e.g. type Funny a = Int) But we don't know which those are currently, so we just expand all.

expandTypeSynonyms only expands out type synonyms mentioned in the type, not in the kinds of any TyCon or TyVar mentioned in the type.

Keep this synchronized with synonymTyConsOfType

seqTypes :: [Type] -> ()

isTYPEorCONSTRAINT :: Kind -> Bool

Does this classify a type allowed to have values? Responds True to things like *, TYPE Lifted, TYPE IntRep, TYPE v, Constraint.

True of a kind `TYPE _` or `CONSTRAINT _`

isConcrete :: Type -> Bool

Tests whether the given type is concrete, i.e. it whether it consists only of concrete type constructors, concrete type variables, and applications.

See Note [Concrete types] in GHC.Tc.Utils.Concrete.

isFixedRuntimeRepKind :: HasDebugCallStack => Kind -> Bool

Checks that a kind of the form Type, Constraint or 'TYPE r is concrete. See isConcrete.

Precondition: The type has kind `TYPE blah` or `CONSTRAINT blah`

module GHC.Core.TyCon

data Coercion

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

Instances

Data Coercion

Defined in GHC.Core.TyCo.Rep

Methods

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

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

toConstr :: Coercion -> Constr

dataTypeOf :: Coercion -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable Coercion

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: Coercion -> SDoc

Eq (DeBruijn Coercion)

Defined in GHC.Core.Map.Type

Methods

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

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

data Role

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

Binary Role

Defined in GHC.Core.Coercion.Axiom

Methods

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

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

get :: BinHandle -> IO Role

Outputable Role

Defined in GHC.Core.Coercion.Axiom

Methods

ppr :: Role -> SDoc

Eq Role

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

Variable

Essentially a typed Name, that may also contain some additional information about the Var and its use sites.

Instances

Data Var

Defined in GHC.Types.Var

Methods

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

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

toConstr :: Var -> Constr

dataTypeOf :: Var -> DataType

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

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

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

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

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

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

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

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

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

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

NamedThing Var

Defined in GHC.Types.Var

Methods

getOccName :: Var -> OccName

getName :: Var -> Name

HasOccName Var

Defined in GHC.Types.Var

Methods

occName :: Var -> OccName

Uniquable Var

Defined in GHC.Types.Var

Methods

getUnique :: Var -> Unique

Outputable Var

Defined in GHC.Types.Var

Methods

ppr :: Var -> SDoc

OutputableBndr Var

Defined in GHC.Core.Ppr

Methods

pprBndr :: BindingSite -> Var -> SDoc

pprPrefixOcc :: Var -> SDoc

pprInfixOcc :: Var -> SDoc

bndrIsJoin_maybe :: Var -> Maybe Int

Eq Var

Defined in GHC.Types.Var

Methods

(==) :: Var -> Var -> Bool

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

Ord Var

Defined in GHC.Types.Var

Methods

compare :: Var -> Var -> Ordering

(<) :: Var -> Var -> Bool

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

(>) :: Var -> Var -> Bool

(>=) :: Var -> Var -> Bool

max :: Var -> Var -> Var

min :: Var -> Var -> Var

Eq (DeBruijn CoreAlt)

Defined in GHC.Core.Map.Expr

Methods

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

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

Eq (DeBruijn CoreExpr)

Defined in GHC.Core.Map.Expr

Methods

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

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

Eq (DeBruijn Var)

Defined in GHC.Core.Map.Type

Methods

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

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

OutputableBndr (Id, TagSig)

Defined in GHC.Stg.InferTags.TagSig

Methods

pprBndr :: BindingSite -> (Id, TagSig) -> SDoc

pprPrefixOcc :: (Id, TagSig) -> SDoc

pprInfixOcc :: (Id, TagSig) -> SDoc

bndrIsJoin_maybe :: (Id, TagSig) -> Maybe Int

type Anno Id

Defined in GHC.Hs.Extension

type Anno Id = SrcSpanAnnN

type Anno (LocatedN Id)

Defined in GHC.Hs.Binds

type Anno (LocatedN Id) = SrcSpan

type Anno [LocatedN Id]

Defined in GHC.Hs.Binds

type Anno [LocatedN Id] = SrcSpan

type CoercionN = Coercion

type CoercionR = Coercion

type CoercionP = Coercion

data MCoercion

A semantically more meaningful type to represent what may or may not be a useful Coercion.

Constructors

MRefl

MCo Coercion

Instances

Data MCoercion

Defined in GHC.Core.TyCo.Rep

Methods

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

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

toConstr :: MCoercion -> Constr

dataTypeOf :: MCoercion -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable MCoercion

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: MCoercion -> SDoc

type MCoercionN = MCoercion

type MCoercionR = MCoercion

data CoSel

Constructors

SelTyCon Int Role

SelFun FunSel

SelForAll

Instances

Data CoSel

Defined in GHC.Core.TyCo.Rep

Methods

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

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

toConstr :: CoSel -> Constr

dataTypeOf :: CoSel -> DataType

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

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

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

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

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

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

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

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

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

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

NFData CoSel

Defined in GHC.Core.TyCo.Rep

Methods

rnf :: CoSel -> ()

Binary CoSel

Defined in GHC.Core.TyCo.Rep

Methods

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

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

get :: BinHandle -> IO CoSel

Outputable CoSel

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: CoSel -> SDoc

Eq CoSel

Defined in GHC.Core.TyCo.Rep

Methods

(==) :: CoSel -> CoSel -> Bool

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

data FunSel

Constructors

SelMult

SelArg

SelRes

Instances

Data FunSel

Defined in GHC.Core.TyCo.Rep

Methods

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

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

toConstr :: FunSel -> Constr

dataTypeOf :: FunSel -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable FunSel

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: FunSel -> SDoc

Eq FunSel

Defined in GHC.Core.TyCo.Rep

Methods

(==) :: FunSel -> FunSel -> Bool

(/=) :: FunSel -> FunSel -> 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.

Instances

Data UnivCoProvenance

Defined in GHC.Core.TyCo.Rep

Methods

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

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

toConstr :: UnivCoProvenance -> Constr

dataTypeOf :: UnivCoProvenance -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable UnivCoProvenance

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: UnivCoProvenance -> SDoc

data CoercionHole

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

Constructors

CoercionHole

Fields

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

Instances

Data CoercionHole

Defined in GHC.Core.TyCo.Rep

Methods

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

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

toConstr :: CoercionHole -> Constr

dataTypeOf :: CoercionHole -> DataType

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

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

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

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

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

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

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

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

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

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

Uniquable CoercionHole

Defined in GHC.Core.TyCo.Rep

Methods

getUnique :: CoercionHole -> Unique

Outputable CoercionHole

Defined in GHC.Core.TyCo.Rep

Methods

ppr :: CoercionHole -> SDoc

data LeftOrRight

Constructors

CLeft

CRight

Instances

Data LeftOrRight

Defined in GHC.Types.Basic

Methods

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

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

toConstr :: LeftOrRight -> Constr

dataTypeOf :: LeftOrRight -> DataType

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

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

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

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

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

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

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

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

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

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

Binary LeftOrRight

Defined in GHC.Types.Basic

Methods

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

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

get :: BinHandle -> IO LeftOrRight

Outputable LeftOrRight

Defined in GHC.Types.Basic

Methods

ppr :: LeftOrRight -> SDoc

Eq LeftOrRight

Defined in GHC.Types.Basic

Methods

(==) :: LeftOrRight -> LeftOrRight -> Bool

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

type CoVar = Id

Coercion Variable

type TyCoVar = Id

Type or Coercion Variable

type NormaliseStepper ev = RecTcChecker -> TyCon -> [Type] -> NormaliseStepResult ev

A function to check if we can reduce a type by one step. Used with topNormaliseTypeX.

data NormaliseStepResult ev

The result of stepping in a normalisation function. See topNormaliseTypeX.

Constructors

NS_Done

Nothing more to do

NS_Abort

Utter failure. The outer function should fail too.

NS_Step RecTcChecker Type ev

We stepped, yielding new bits; ^ ev is evidence; Usually a co :: old type ~ new type

Instances

Functor NormaliseStepResult

Defined in GHC.Core.Coercion

Methods

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

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

Outputable ev => Outputable (NormaliseStepResult ev)

Defined in GHC.Core.Coercion

Methods

ppr :: NormaliseStepResult ev -> SDoc

type CvSubstEnv = CoVarEnv Coercion

A substitution of Coercions for CoVars

type LiftCoEnv = VarEnv Coercion

data LiftingContext

Constructors

LC Subst LiftCoEnv

Instances

Outputable LiftingContext

Defined in GHC.Core.Coercion

Methods

ppr :: LiftingContext -> SDoc

coHoleCoVar :: CoercionHole -> CoVar

setCoHoleCoVar :: CoercionHole -> CoVar -> CoercionHole

ltRole :: Role -> Role -> Bool

coVarRType :: HasDebugCallStack => CoVar -> Type

coVarLType :: HasDebugCallStack => CoVar -> Type

coVarTypes :: HasDebugCallStack => CoVar -> Pair Type

coVarKind :: CoVar -> Type

coVarKindsTypesRole :: HasDebugCallStack => CoVar -> (Kind, Kind, Type, Type, Role)

coVarRole :: CoVar -> Role

coercionType :: Coercion -> Type

mkCoercionType :: Role -> Type -> Type -> Type

Makes a coercion type from two types: the types whose equality is proven by the relevant Coercion

coercionKind :: Coercion -> Pair Type

If it is the case that

c :: (t1 ~ t2)

i.e. the kind of c relates t1 and t2, then coercionKind c = Pair t1 t2.

coercionLKind :: Coercion -> Type

coercionRKind :: Coercion -> Type

coercionKinds :: [Coercion] -> Pair [Type]

Apply coercionKind to multiple Coercions

coercionRole :: Coercion -> Role

Retrieve the role from a coercion.

coercionKindRole :: Coercion -> (Pair Type, Role)

Get a coercion's kind and role.

mkGReflCo :: Role -> Type -> MCoercionN -> Coercion

Make a generalized reflexive coercion

mkReflCo :: Role -> Type -> Coercion

Make a reflexive coercion

mkRepReflCo :: Type -> Coercion

Make a representational reflexive coercion

mkNomReflCo :: Type -> Coercion

Make a nominal reflexive coercion

mkCoVarCo :: CoVar -> Coercion

mkCoVarCos :: [CoVar] -> [Coercion]

mkAxInstCo :: Role -> CoAxiom br -> BranchIndex -> [Type] -> [Coercion] -> Coercion

mkUnbranchedAxInstCo :: Role -> CoAxiom Unbranched -> [Type] -> [Coercion] -> Coercion

mkAxInstRHS :: CoAxiom br -> BranchIndex -> [Type] -> [Coercion] -> Type

mkUnbranchedAxInstRHS :: CoAxiom Unbranched -> [Type] -> [Coercion] -> Type

mkAxInstLHS :: CoAxiom br -> BranchIndex -> [Type] -> [Coercion] -> Type

Return the left-hand type of the axiom, when the axiom is instantiated at the types given.

mkUnbranchedAxInstLHS :: CoAxiom Unbranched -> [Type] -> [Coercion] -> Type

Instantiate the left-hand side of an unbranched axiom

mkPiCo :: Role -> Var -> Coercion -> Coercion

Make a forall Coercion, where both types related by the coercion are quantified over the same variable.

mkPiCos :: Role -> [Var] -> Coercion -> Coercion

mkCoCast :: Coercion -> CoercionR -> Coercion

mkSymCo :: Coercion -> Coercion

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

mkTransCo :: Coercion -> Coercion -> Coercion

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

mkSelCo :: HasDebugCallStack => CoSel -> Coercion -> Coercion

getNthFun

Arguments

:: FunSel

-> a

multiplicity

-> a

argument

-> a

result

-> a

One of the above three

Extract the nth field of a FunCo

getNthFromType :: HasDebugCallStack => CoSel -> Type -> Type

mkLRCo :: LeftOrRight -> Coercion -> Coercion

mkInstCo :: Coercion -> CoercionN -> Coercion

Instantiates a Coercion.

mkAppCo

Arguments

:: Coercion

:: t1 ~r t2

-> Coercion

:: s1 ~N s2, where s1 :: k1, s2 :: k2

-> Coercion

:: t1 s1 ~r t2 s2

Apply a Coercion to another Coercion. The second coercion must be Nominal, unless the first is Phantom. If the first is Phantom, then the second can be either Phantom or Nominal.

mkAppCos :: Coercion -> [Coercion] -> Coercion

Applies multiple Coercions to another Coercion, from left to right. See also mkAppCo.

mkTyConAppCo :: HasDebugCallStack => Role -> TyCon -> [Coercion] -> Coercion

Apply a type constructor to a list of coercions. It is the caller's responsibility to get the roles correct on argument coercions.

mkFunCo1 :: HasDebugCallStack => Role -> FunTyFlag -> CoercionN -> Coercion -> Coercion -> Coercion

Build a function Coercion from two other Coercions. That is, given co1 :: a ~ b and co2 :: x ~ y produce co :: (a -> x) ~ (b -> y) or (a => x) ~ (b => y), depending on the kind of a/b. This (most common) version takes a single FunTyFlag, which is used for both fco_afl and ftf_afr of the FunCo

mkFunCo2 :: HasDebugCallStack => Role -> FunTyFlag -> FunTyFlag -> CoercionN -> Coercion -> Coercion -> Coercion

mkFunCoNoFTF :: HasDebugCallStack => Role -> CoercionN -> Coercion -> Coercion -> Coercion

mkFunResCo :: Role -> Id -> Coercion -> Coercion

mkNakedFunCo1 :: Role -> FunTyFlag -> CoercionN -> Coercion -> Coercion -> Coercion

mkNakedFunCo2 :: Role -> FunTyFlag -> FunTyFlag -> CoercionN -> Coercion -> Coercion -> Coercion

mkForAllCo :: TyCoVar -> CoercionN -> Coercion -> Coercion

Make a Coercion from a tycovar, a kind coercion, and a body coercion. The kind of the tycovar should be the left-hand kind of the kind coercion. See Note [Unused coercion variable in ForAllCo]

mkForAllCos :: [(TyCoVar, CoercionN)] -> Coercion -> Coercion

Make nested ForAllCos

mkHomoForAllCos :: [TyCoVar] -> Coercion -> Coercion

Make a Coercion quantified over a type/coercion variable; the variable has the same type in both sides of the coercion

mkPhantomCo :: Coercion -> Type -> Type -> Coercion

Make a phantom coercion between two types. The coercion passed in must be a nominal coercion between the kinds of the types.

mkHoleCo :: CoercionHole -> Coercion

Make a coercion from a coercion hole

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.

mkSubCo :: HasDebugCallStack => Coercion -> Coercion

mkAxiomInstCo :: CoAxiom Branched -> BranchIndex -> [Coercion] -> Coercion

mkProofIrrelCo

Arguments

:: Role

role of the created coercion, "r"

-> CoercionN

:: phi1 ~N phi2

-> Coercion

g1 :: phi1

-> Coercion

g2 :: phi2

-> Coercion

:: g1 ~r g2

Make a "coercion between coercions".

downgradeRole :: Role -> Role -> Coercion -> Coercion

Like downgradeRole_maybe, but panics if the change isn't a downgrade. See Note [Role twiddling functions]

mkAxiomRuleCo :: CoAxiomRule -> [Coercion] -> Coercion

mkGReflRightCo :: Role -> Type -> CoercionN -> Coercion

Given ty :: k1, co :: k1 ~ k2, produces co' :: ty ~r (ty |> co)

mkGReflLeftCo :: Role -> Type -> CoercionN -> Coercion

Given r, ty :: k1, and co :: k1 ~N k2, produces co' :: (ty |> co) ~r ty

mkCoherenceLeftCo :: Role -> Type -> CoercionN -> Coercion -> Coercion

Given ty :: k1, co :: k1 ~ k2, co2:: ty ~r ty', produces @co' :: (ty |> co) ~r ty' It is not only a utility function, but it saves allocation when co is a GRefl coercion.

mkCoherenceRightCo :: Role -> Type -> CoercionN -> Coercion -> Coercion

Given ty :: k1, co :: k1 ~ k2, co2:: ty' ~r ty, produces @co' :: ty' ~r (ty |> co) It is not only a utility function, but it saves allocation when co is a GRefl coercion.

mkKindCo :: Coercion -> Coercion

Given co :: (a :: k) ~ (b :: k') produce co' :: k ~ k'.

castCoercionKind :: Coercion -> CoercionN -> CoercionN -> Coercion

Creates a new coercion with both of its types casted by different casts castCoercionKind g h1 h2, where g :: t1 ~r t2, has type (t1 |> h1) ~r (t2 |> h2). h1 and h2 must be nominal. It calls coercionKindRole, so it's quite inefficient (which I stands for) Use castCoercionKind2 instead if t1, t2, and r are known beforehand.

castCoercionKind1 :: Coercion -> Role -> Type -> Type -> CoercionN -> Coercion

castCoercionKind1 g r t1 t2 h = coercionKind g r t1 t2 h h That is, it's a specialised form of castCoercionKind, where the two kind coercions are identical castCoercionKind1 g r t1 t2 h, where g :: t1 ~r t2, has type (t1 |> h) ~r (t2 |> h). h must be nominal. See Note [castCoercionKind1]

castCoercionKind2 :: Coercion -> Role -> Type -> Type -> CoercionN -> CoercionN -> Coercion

Creates a new coercion with both of its types casted by different casts castCoercionKind2 g r t1 t2 h1 h2, where g :: t1 ~r t2, has type (t1 |> h1) ~r (t2 |> h2). h1 and h2 must be nominal.

mkPrimEqPred :: Type -> Type -> Type

Creates a primitive type equality predicate. Invariant: the types are not Coercions

mkReprPrimEqPred :: Type -> Type -> Type

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

Makes a lifted equality predicate at the given role

mkHeteroPrimEqPred :: Kind -> Kind -> Type -> Type -> Type

Creates a primitive type equality predicate with explicit kinds

mkHeteroReprPrimEqPred :: Kind -> Kind -> Type -> Type -> Type

Creates a primitive representational type equality predicate with explicit kinds

instNewTyCon_maybe :: TyCon -> [Type] -> Maybe (Type, Coercion)

If `instNewTyCon_maybe T ts = Just (rep_ty, co)` then `co :: T ts ~R# rep_ty`

Checks for a newtype, and for being saturated

composeSteppers :: NormaliseStepper ev -> NormaliseStepper ev -> NormaliseStepper ev

Try one stepper and then try the next, if the first doesn't make progress. So if it returns NS_Done, it means that both steppers are satisfied

unwrapNewTypeStepper :: NormaliseStepper Coercion

A NormaliseStepper that unwraps newtypes, careful not to fall into a loop. If it would fall into a loop, it produces NS_Abort.

topNormaliseNewType_maybe :: Type -> Maybe (Coercion, Type)

Sometimes we want to look through a newtype and get its associated coercion. This function strips off newtype layers enough to reveal something that isn't a newtype. Specifically, here's the invariant:

topNormaliseNewType_maybe rec_nts ty = Just (co, ty')

then (a) co : ty ~ ty'. (b) ty' is not a newtype.

The function returns Nothing for non-newtypes, or unsaturated applications

This function does *not* look through type families, because it has no access to the type family environment. If you do have that at hand, consider to use topNormaliseType_maybe, which should be a drop-in replacement for topNormaliseNewType_maybe If topNormliseNewType_maybe ty = Just (co, ty'), then co : ty ~R ty'

topNormaliseTypeX :: NormaliseStepper ev -> (ev -> ev -> ev) -> Type -> Maybe (ev, Type)

A general function for normalising the top-level of a type. It continues to use the provided NormaliseStepper until that function fails, and then this function returns. The roles of the coercions produced by the NormaliseStepper must all be the same, which is the role returned from the call to topNormaliseTypeX.

Typically ev is Coercion.

If topNormaliseTypeX step plus ty = Just (ev, ty') then ty ~ev1~ t1 ~ev2~ t2 ... ~evn~ ty' and ev = ev1 plus ev2 plus ... plus evn If it returns Nothing then no newtype unwrapping could happen

decomposeCo :: Arity -> Coercion -> Infinite Role -> [Coercion]

This breaks a Coercion with type T A B C ~ T D E F into a list of Coercions of kinds A ~ D, B ~ E and E ~ F. Hence:

decomposeCo 3 c [r1, r2, r3] = [nth r1 0 c, nth r2 1 c, nth r3 2 c]

decomposeFunCo :: HasDebugCallStack => Coercion -> (CoercionN, Coercion, Coercion)

decomposePiCos :: HasDebugCallStack => CoercionN -> Pair Type -> [Type] -> ([CoercionN], CoercionN)

getCoVar_maybe :: Coercion -> Maybe CoVar

Extract a covar, if possible. This check is dirty. Be ashamed of yourself. (It's dirty because it cares about the structure of a coercion, which is morally reprehensible.)

splitAppCo_maybe :: Coercion -> Maybe (Coercion, Coercion)

Attempt to take a coercion application apart.

splitFunCo_maybe :: Coercion -> Maybe (Coercion, Coercion)

splitForAllCo_maybe :: Coercion -> Maybe (TyCoVar, Coercion, Coercion)

splitForAllCo_ty_maybe :: Coercion -> Maybe (TyVar, Coercion, Coercion)

Like splitForAllCo_maybe, but only returns Just for tyvar binder

splitForAllCo_co_maybe :: Coercion -> Maybe (CoVar, Coercion, Coercion)

Like splitForAllCo_maybe, but only returns Just for covar binder

tyConRole :: Role -> TyCon -> Int -> Role

tyConRolesX :: Role -> TyCon -> Infinite Role

tyConRolesRepresentational :: TyCon -> Infinite Role

setNominalRole_maybe :: Role -> Coercion -> Maybe Coercion

Converts a coercion to be nominal, if possible. See Note [Role twiddling functions]

tyConRoleListX :: Role -> TyCon -> [Role]

tyConRoleListRepresentational :: TyCon -> [Role]

funRole :: Role -> FunSel -> Role

pickLR :: LeftOrRight -> (a, a) -> a

isGReflCo :: Coercion -> Bool

Tests if this coercion is obviously a generalized reflexive coercion. Guaranteed to work very quickly.

isReflCo :: Coercion -> Bool

Tests if this coercion is obviously reflexive. Guaranteed to work very quickly. Sometimes a coercion can be reflexive, but not obviously so. c.f. isReflexiveCo

isReflCo_maybe :: Coercion -> Maybe (Type, Role)

Returns the type coerced if this coercion is reflexive. Guaranteed to work very quickly. Sometimes a coercion can be reflexive, but not obviously so. c.f. isReflexiveCo_maybe

isGReflCo_maybe :: Coercion -> Maybe (Type, Role)

Returns the type coerced if this coercion is a generalized reflexive coercion. Guaranteed to work very quickly.

isReflexiveCo :: Coercion -> Bool

Slowly checks if the coercion is reflexive. Don't call this in a loop, as it walks over the entire coercion.

isReflexiveCo_maybe :: Coercion -> Maybe (Type, Role)

Extracts the coerced type from a reflexive coercion. This potentially walks over the entire coercion, so avoid doing this in a loop.

isReflCoVar_maybe :: Var -> Maybe Coercion

isGReflMCo :: MCoercion -> Bool

Tests if this MCoercion is obviously generalized reflexive Guaranteed to work very quickly.

mkGReflLeftMCo :: Role -> Type -> MCoercionN -> Coercion

mkGReflRightMCo :: Role -> Type -> MCoercionN -> Coercion

mkCoherenceRightMCo :: Role -> Type -> MCoercionN -> Coercion -> Coercion

Like mkCoherenceRightCo, but with an MCoercion

coToMCo :: Coercion -> MCoercion

mkTransMCo :: MCoercion -> MCoercion -> MCoercion

Compose two MCoercions via transitivity

mkTransMCoL :: MCoercion -> Coercion -> MCoercion

mkTransMCoR :: Coercion -> MCoercion -> MCoercion

mkCastTyMCo :: Type -> MCoercion -> Type

Cast a type by an MCoercion

mkSymMCo :: MCoercion -> MCoercion

Get the reverse of an MCoercion

mkHomoForAllMCo :: TyCoVar -> MCoercion -> MCoercion

mkFunResMCo :: Id -> MCoercionR -> MCoercionR

mkPiMCos :: [Var] -> MCoercion -> MCoercion

isReflMCo :: MCoercion -> Bool

checkReflexiveMCo :: MCoercion -> MCoercion

mkCoVar :: Name -> Type -> CoVar

isCoVar :: Var -> Bool

Is this a coercion variable? Satisfies isId v ==> isCoVar v == not (isNonCoVarId v).

coVarName :: CoVar -> Name

setCoVarName :: CoVar -> Name -> CoVar

setCoVarUnique :: CoVar -> Unique -> CoVar

tyCoVarsOfCo :: Coercion -> TyCoVarSet

tyCoVarsOfCos :: [Coercion] -> TyCoVarSet

coVarsOfCo :: Coercion -> CoVarSet

tyCoFVsOfCo :: Coercion -> FV

tyCoFVsOfCos :: [Coercion] -> FV

tyCoVarsOfCoDSet :: Coercion -> DTyCoVarSet

Get a deterministic set of the vars free in a coercion

coercionSize :: Coercion -> Int

anyFreeVarsOfCo :: (TyCoVar -> Bool) -> Coercion -> Bool

emptyCvSubstEnv :: CvSubstEnv

lookupCoVar :: Subst -> Var -> Maybe Coercion

substCos :: HasDebugCallStack => Subst -> [Coercion] -> [Coercion]

Substitute within several Coercions The substitution has to satisfy the invariants described in Note [The substitution invariant].

substCoVar :: Subst -> CoVar -> Coercion

substCoVars :: Subst -> [CoVar] -> [Coercion]

substCoWith :: HasDebugCallStack => [TyVar] -> [Type] -> Coercion -> Coercion

Coercion substitution, see zipTvSubst

substCoVarBndr :: HasDebugCallStack => Subst -> CoVar -> (Subst, CoVar)

extendTvSubstAndInScope :: Subst -> TyVar -> Type -> Subst

getCvSubstEnv :: Subst -> CvSubstEnv

liftCoSubst :: HasDebugCallStack => Role -> LiftingContext -> Type -> Coercion

liftCoSubst role lc ty produces a coercion (at role role) that coerces between lc_left(ty) and lc_right(ty), where lc_left is a substitution mapping type variables to the left-hand types of the mapped coercions in lc, and similar for lc_right.

liftCoSubstTyVar :: LiftingContext -> Role -> TyVar -> Maybe Coercion

liftCoSubstWith :: Role -> [TyCoVar] -> [Coercion] -> Type -> Coercion

liftCoSubstWithEx :: Role -> [TyVar] -> [Coercion] -> [TyCoVar] -> [Type] -> (Type -> Coercion, [Type])

emptyLiftingContext :: InScopeSet -> LiftingContext

extendLiftingContext

Arguments

:: LiftingContext

original LC

-> TyCoVar

new variable to map...

-> Coercion

...to this lifted version

-> LiftingContext

Extend a lifting context with a new mapping.

extendLiftingContextAndInScope

Arguments

:: LiftingContext

Original LC

-> TyCoVar

new variable to map...

-> Coercion

to this coercion

-> LiftingContext

Extend a lifting context with a new mapping, and extend the in-scope set

liftCoSubstVarBndrUsing

Arguments

:: (r -> CoercionN)

coercion getter

-> (LiftingContext -> Type -> r)

callback

-> LiftingContext

-> TyCoVar

-> (LiftingContext, TyCoVar, r)

isMappedByLC :: TyCoVar -> LiftingContext -> Bool

Is a var in the domain of a lifting context?

mkSubstLiftingContext :: Subst -> LiftingContext

zapLiftingContext :: LiftingContext -> LiftingContext

Erase the environments in a lifting context

substForAllCoBndrUsingLC :: Bool -> (Coercion -> Coercion) -> LiftingContext -> TyCoVar -> Coercion -> (LiftingContext, TyCoVar, Coercion)

Like substForAllCoBndr, but works on a lifting context

lcSubst :: LiftingContext -> Subst

Extract the underlying substitution from the LiftingContext

lcInScopeSet :: LiftingContext -> InScopeSet

Get the InScopeSet from a LiftingContext

liftEnvSubstLeft :: Subst -> LiftCoEnv -> Subst

liftEnvSubstRight :: Subst -> LiftCoEnv -> Subst

substRightCo :: LiftingContext -> Coercion -> Coercion

substLeftCo :: LiftingContext -> Coercion -> Coercion

swapLiftCoEnv :: LiftCoEnv -> LiftCoEnv

Apply "sym" to all coercions in a LiftCoEnv

lcSubstLeft :: LiftingContext -> Subst

lcSubstRight :: LiftingContext -> Subst

eqCoercion :: Coercion -> Coercion -> Bool

Syntactic equality of coercions

eqCoercionX :: RnEnv2 -> Coercion -> Coercion -> Bool

Compare two Coercions, with respect to an RnEnv2

seqCo :: Coercion -> ()

pprCo :: Coercion -> SDoc

pprParendCo :: Coercion -> SDoc

pprCoAxiom :: CoAxiom br -> SDoc

pprCoAxBranch :: TyCon -> CoAxBranch -> SDoc

pprCoAxBranchLHS :: TyCon -> CoAxBranch -> SDoc

pprCoAxBranchUser :: TyCon -> CoAxBranch -> SDoc

tidyCoAxBndrsForUser :: TidyEnv -> [Var] -> (TidyEnv, [Var])

etaExpandCoAxBranch :: CoAxBranch -> ([TyVar], [Type], Type)

tidyCo :: TidyEnv -> Coercion -> Coercion

Tidy a Coercion

See Note [Strictness in tidyType and friends]

tidyCos :: TidyEnv -> [Coercion] -> [Coercion]

promoteCoercion :: Coercion -> CoercionN

like mkKindCo, but aggressively & recursively optimizes to avoid using a KindCo constructor. The output role is nominal.

buildCoercion :: Type -> Type -> CoercionN

Assuming that two types are the same, ignoring coercions, find a nominal coercion between the types. This is useful when optimizing transitivity over coercion applications, where splitting two AppCos might yield different kinds. See Note [EtaAppCo] in GHC.Core.Coercion.Opt.

multToCo :: Mult -> Coercion

mkRuntimeRepCo :: HasDebugCallStack => Coercion -> Coercion

Given a coercion co1 :: (a :: TYPE r1) ~ (b :: TYPE r2), (or CONSTRAINT instead of TYPE) produce a coercion rep_co :: r1 ~ r2.

hasCoercionHoleTy :: Type -> Bool

Is there a coercion hole in this type?

hasCoercionHoleCo :: Coercion -> Bool

Is there a coercion hole in this coercion?

hasThisCoercionHoleTy :: Type -> CoercionHole -> Bool

setCoHoleType :: CoercionHole -> Type -> CoercionHole

Set the type of a CoercionHole

module GHC.Builtin.Types

module GHC.Driver.Env

module GHC.Types.Basic

module GHC.Types.Var.Set

module GHC.Types.Var.Env

module GHC.Types.Name.Set

module GHC.Types.Name.Env

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

class Uniquable a where

Class of things that we can obtain a Unique from

Methods

getUnique :: a -> Unique

Instances

Uniquable Label

Defined in GHC.Cmm.Dataflow.Label

Methods

getUnique :: Label -> Unique

Uniquable LocalReg

Defined in GHC.Cmm.Reg

Methods

getUnique :: LocalReg -> Unique

Uniquable Reg

so we can put regs in UniqSets

Defined in GHC.CmmToAsm.Reg.Graph.Base

Methods

getUnique :: Reg -> Unique

Uniquable SymName

Defined in GHC.CmmToAsm.Wasm.Types

Methods

getUnique :: SymName -> Unique

Uniquable Class

Defined in GHC.Core.Class

Methods

getUnique :: Class -> Unique

Uniquable CoAxiomRule

Defined in GHC.Core.Coercion.Axiom

Methods

getUnique :: CoAxiomRule -> Unique

Uniquable ConLike

Defined in GHC.Core.ConLike

Methods

getUnique :: ConLike -> Unique

Uniquable DataCon

Defined in GHC.Core.DataCon

Methods

getUnique :: DataCon -> Unique

Uniquable PatSyn

Defined in GHC.Core.PatSyn

Methods

getUnique :: PatSyn -> Unique

Uniquable CoercionHole

Defined in GHC.Core.TyCo.Rep

Methods

getUnique :: CoercionHole -> Unique

Uniquable TyCon

Defined in GHC.Core.TyCon

Methods

getUnique :: TyCon -> Unique

Uniquable FastString

Defined in GHC.Types.Unique

Methods

getUnique :: FastString -> Unique

Uniquable Ident

Defined in GHC.JS.Syntax

Methods

getUnique :: Ident -> Unique

Uniquable RealReg

Defined in GHC.Platform.Reg

Methods

getUnique :: RealReg -> Unique

Uniquable Reg

Defined in GHC.Platform.Reg

Methods

getUnique :: Reg -> Unique

Uniquable VirtualReg

Defined in GHC.Platform.Reg

Methods

getUnique :: VirtualReg -> Unique

Uniquable RegClass

Defined in GHC.Platform.Reg.Class

Methods

getUnique :: RegClass -> Unique

Uniquable EvBindsVar

Defined in GHC.Tc.Types.Evidence

Methods

getUnique :: EvBindsVar -> Unique

Uniquable SkolemInfo

Defined in GHC.Tc.Types.Origin

Methods

getUnique :: SkolemInfo -> Unique

Uniquable Name

Defined in GHC.Types.Name

Methods

getUnique :: Name -> Unique

Uniquable OccName

Defined in GHC.Types.Name.Occurrence

Methods

getUnique :: OccName -> Unique

Uniquable Unique

Defined in GHC.Types.Unique

Methods

getUnique :: Unique -> Unique

Uniquable Var

Defined in GHC.Types.Var

Methods

getUnique :: Var -> Unique

Uniquable PackageId

Defined in GHC.Unit.Info

Methods

getUnique :: PackageId -> Unique

Uniquable PackageName

Defined in GHC.Unit.Info

Methods

getUnique :: PackageName -> Unique

Uniquable Module

Defined in GHC.Unit.Types

Methods

getUnique :: Module -> Unique

Uniquable UnitId

Defined in GHC.Unit.Types

Methods

getUnique :: UnitId -> Unique

Uniquable FieldLabelString

Defined in GHC.Types.FieldLabel

Methods

getUnique :: FieldLabelString -> Unique

Uniquable ModuleName

Defined in GHC.Types.Unique

Methods

getUnique :: ModuleName -> Unique

Uniquable Int

Defined in GHC.Types.Unique

Methods

getUnique :: Int -> Unique

Uniquable (CoAxiom br)

Defined in GHC.Core.Coercion.Axiom

Methods

getUnique :: CoAxiom br -> Unique

Uniquable unit => Uniquable (Definite unit)

Defined in GHC.Unit.Types

Methods

getUnique :: Definite unit -> Unique

IsUnitId u => Uniquable (GenUnit u)

Defined in GHC.Unit.Types

Methods

getUnique :: GenUnit u -> Unique

module GHC.Types.Unique.Set

module GHC.Types.Unique.FM

module GHC.Data.FiniteMap

module GHC.Utils.Misc

module GHC.Serialized

module GHC.Types.SrcLoc

module GHC.Utils.Outputable

module GHC.Utils.Panic

module GHC.Types.Unique.Supply

module GHC.Data.FastString

module GHC.Tc.Errors.Hole.FitTypes

module GHC.Unit.Module.ModGuts

module GHC.Unit.Module.ModSummary

module GHC.Unit.Module.ModIface

module GHC.Types.Meta

module GHC.Types.SourceError

type PsWarning = PsMessage

type PsError = PsMessage

data Messages e

A collection of messages emitted by GHC during error reporting. A diagnostic message is typically a warning or an error. See Note [Messages].

INVARIANT: All the messages in this collection must be relevant, i.e. their Severity should not be SevIgnore. The smart constructor mkMessages will filter out any message which Severity is SevIgnore.

Instances

Foldable Messages

Defined in GHC.Types.Error

Methods

fold :: Monoid m => Messages m -> m

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

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Messages a -> a

foldl1 :: (a -> a -> a) -> Messages a -> a

toList :: Messages a -> [a]

null :: Messages a -> Bool

length :: Messages a -> Int

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

maximum :: Ord a => Messages a -> a

minimum :: Ord a => Messages a -> a

sum :: Num a => Messages a -> a

product :: Num a => Messages a -> a

Traversable Messages

Defined in GHC.Types.Error

Methods

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

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

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

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

Functor Messages

Defined in GHC.Types.Error

Methods

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

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

Monoid (Messages e)

Defined in GHC.Types.Error

Methods

mempty :: Messages e

mappend :: Messages e -> Messages e -> Messages e

mconcat :: [Messages e] -> Messages e

Semigroup (Messages e)

Defined in GHC.Types.Error

Methods

(<>) :: Messages e -> Messages e -> Messages e

sconcat :: NonEmpty (Messages e) -> Messages e

stimes :: Integral b => b -> Messages e -> Messages e

Diagnostic e => Outputable (Messages e)

Defined in GHC.Types.Error

Methods

ppr :: Messages e -> SDoc

data HsParsedModule

Getting Names

thNameToGhcName :: Name -> CoreM (Maybe Name)

Attempt to convert a Template Haskell name to one that GHC can understand. Original TH names such as those you get when you use the 'foo syntax will be translated to their equivalent GHC name exactly. Qualified or unqualified TH names will be dynamically bound to names in the module being compiled, if possible. Exact TH names will be bound to the name they represent, exactly.

thNameToGhcNameIO :: NameCache -> Name -> IO (Maybe Name)

Attempt to convert a Template Haskell name to one that GHC can understand. Original TH names such as those you get when you use the 'foo syntax will be translated to their equivalent GHC name exactly. Qualified or unqualified TH names will be dynamically bound to names in the module being compiled, if possible. Exact TH names will be bound to the name they represent, exactly.

One must be careful to consistently use the same NameCache to create identifier that might be compared. (C.f. how the ST Monad enforces that variables from separate runST invocations are never intermingled; it would be valid to use the same tricks for Names and NameCaches.)

For now, the easiest and recommended way to ensure a consistent NameCache is used it to retrieve the preexisting one from an active HscEnv. A single HscEnv is created per GHC "session", and this ensures everything in that session will get the same name cache.

Orphan instances

MonadThings CoreM

Methods

lookupThing :: Name -> CoreM TyThing

lookupId :: Name -> CoreM Id

lookupDataCon :: Name -> CoreM DataCon

lookupTyCon :: Name -> CoreM TyCon