Safe Haskell | None |
---|---|

Language | Haskell2010 |

Main functions for manipulating types and type-related things

- data TyThing
- data Type
- type KindOrType = Type
- type PredType = Type
- type ThetaType = [PredType]
- data Var
- type TyVar = Var
- isTyVar :: Var -> Bool
- mkTyVarTy :: TyVar -> Type
- mkTyVarTys :: [TyVar] -> [Type]
- getTyVar :: String -> Type -> TyVar
- getTyVar_maybe :: Type -> Maybe TyVar
- mkAppTy :: Type -> Type -> Type
- mkAppTys :: Type -> [Type] -> Type
- splitAppTy :: Type -> (Type, Type)
- splitAppTys :: Type -> (Type, [Type])
- splitAppTy_maybe :: Type -> Maybe (Type, Type)
- repSplitAppTy_maybe :: Type -> Maybe (Type, Type)
- mkFunTy :: Type -> Type -> Type
- mkFunTys :: [Type] -> Type -> Type
- splitFunTy :: Type -> (Type, Type)
- splitFunTy_maybe :: Type -> Maybe (Type, Type)
- splitFunTys :: Type -> ([Type], Type)
- splitFunTysN :: Int -> Type -> ([Type], Type)
- funResultTy :: Type -> Type
- funArgTy :: Type -> Type
- zipFunTys :: Outputable a => [a] -> Type -> ([(a, Type)], Type)
- mkTyConApp :: TyCon -> [Type] -> Type
- mkTyConTy :: TyCon -> Type
- tyConAppTyCon_maybe :: Type -> Maybe TyCon
- tyConAppArgs_maybe :: Type -> Maybe [Type]
- tyConAppTyCon :: Type -> TyCon
- tyConAppArgs :: Type -> [Type]
- splitTyConApp_maybe :: Type -> Maybe (TyCon, [Type])
- splitTyConApp :: Type -> (TyCon, [Type])
- tyConAppArgN :: Int -> Type -> Type
- nextRole :: Type -> Role
- mkForAllTy :: TyVar -> Type -> Type
- mkForAllTys :: [TyVar] -> Type -> Type
- splitForAllTy_maybe :: Type -> Maybe (TyVar, Type)
- splitForAllTys :: Type -> ([TyVar], Type)
- mkPiKinds :: [TyVar] -> Kind -> Kind
- mkPiType :: Var -> Type -> Type
- mkPiTypes :: [Var] -> Type -> Type
- applyTy :: Type -> KindOrType -> Type
- applyTys :: Type -> [KindOrType] -> Type
- applyTysD :: SDoc -> Type -> [Type] -> Type
- applyTysX :: [TyVar] -> Type -> [Type] -> Type
- dropForAlls :: Type -> Type
- mkNumLitTy :: Integer -> Type
- isNumLitTy :: Type -> Maybe Integer
- mkStrLitTy :: FastString -> Type
- isStrLitTy :: Type -> Maybe FastString
- coAxNthLHS :: CoAxiom br -> Int -> Type
- newTyConInstRhs :: TyCon -> [Type] -> Type
- mkFamilyTyConApp :: TyCon -> [Type] -> Type
- isDictLikeTy :: Type -> Bool
- mkEqPred :: Type -> Type -> PredType
- mkCoerciblePred :: Type -> Type -> PredType
- mkPrimEqPred :: Type -> Type -> Type
- mkReprPrimEqPred :: Type -> Type -> Type
- mkClassPred :: Class -> [Type] -> PredType
- isClassPred :: PredType -> Bool
- isEqPred :: PredType -> Bool
- isIPPred :: PredType -> Bool
- isIPPred_maybe :: Type -> Maybe (FastString, Type)
- isIPTyCon :: TyCon -> Bool
- isIPClass :: Class -> Bool
- data PredTree
- data EqRel
- eqRelRole :: EqRel -> Role
- classifyPredType :: PredType -> PredTree
- getClassPredTys :: PredType -> (Class, [Type])
- getClassPredTys_maybe :: PredType -> Maybe (Class, [Type])
- getEqPredTys :: PredType -> (Type, Type)
- getEqPredTys_maybe :: PredType -> Maybe (Role, Type, Type)
- getEqPredRole :: PredType -> Role
- predTypeEqRel :: PredType -> EqRel
- funTyCon :: TyCon
- isTypeVar :: Var -> Bool
- isKindVar :: Var -> Bool
- allDistinctTyVars :: [KindOrType] -> Bool
- isForAllTy :: Type -> Bool
- isTyVarTy :: Type -> Bool
- isFunTy :: Type -> Bool
- isDictTy :: Type -> Bool
- isPredTy :: Type -> Bool
- isVoidTy :: Type -> Bool
- isUnLiftedType :: Type -> Bool
- isUnboxedTupleType :: Type -> Bool
- isAlgType :: Type -> Bool
- isClosedAlgType :: Type -> Bool
- isPrimitiveType :: Type -> Bool
- isStrictType :: Type -> Bool
- type Kind = Type
- type SimpleKind = Kind
- type MetaKindVar = TyVar
- typeKind :: Type -> Kind
- anyKind :: Kind
- liftedTypeKind :: Kind
- unliftedTypeKind :: Kind
- openTypeKind :: Kind
- constraintKind :: Kind
- superKind :: Kind
- liftedTypeKindTyCon :: TyCon
- openTypeKindTyCon :: TyCon
- unliftedTypeKindTyCon :: TyCon
- constraintKindTyCon :: TyCon
- anyKindTyCon :: TyCon
- tyVarsOfType :: Type -> VarSet
- tyVarsOfTypes :: [Type] -> TyVarSet
- closeOverKinds :: TyVarSet -> TyVarSet
- expandTypeSynonyms :: Type -> Type
- typeSize :: Type -> Int
- varSetElemsKvsFirst :: VarSet -> [TyVar]
- eqType :: Type -> Type -> Bool
- eqTypeX :: RnEnv2 -> Type -> Type -> Bool
- eqTypes :: [Type] -> [Type] -> Bool
- cmpType :: Type -> Type -> Ordering
- cmpTypes :: [Type] -> [Type] -> Ordering
- eqPred :: PredType -> PredType -> Bool
- eqPredX :: RnEnv2 -> PredType -> PredType -> Bool
- cmpPred :: PredType -> PredType -> Ordering
- eqKind :: Kind -> Kind -> Bool
- eqTyVarBndrs :: RnEnv2 -> [TyVar] -> [TyVar] -> Maybe RnEnv2
- seqType :: Type -> ()
- seqTypes :: [Type] -> ()
- coreView :: Type -> Maybe Type
- tcView :: Type -> Maybe Type
- type UnaryType = Type
- data RepType
- flattenRepType :: RepType -> [UnaryType]
- repType :: Type -> RepType
- tyConsOfType :: Type -> NameEnv TyCon
- typePrimRep :: UnaryType -> PrimRep
- typeRepArity :: Arity -> Type -> RepArity
- type TvSubstEnv = TyVarEnv Type
- data TvSubst = TvSubst InScopeSet TvSubstEnv
- emptyTvSubstEnv :: TvSubstEnv
- emptyTvSubst :: TvSubst
- mkTvSubst :: InScopeSet -> TvSubstEnv -> TvSubst
- mkOpenTvSubst :: TvSubstEnv -> TvSubst
- zipOpenTvSubst :: [TyVar] -> [Type] -> TvSubst
- zipTopTvSubst :: [TyVar] -> [Type] -> TvSubst
- mkTopTvSubst :: [(TyVar, Type)] -> TvSubst
- notElemTvSubst :: CoVar -> TvSubst -> Bool
- getTvSubstEnv :: TvSubst -> TvSubstEnv
- setTvSubstEnv :: TvSubst -> TvSubstEnv -> TvSubst
- zapTvSubstEnv :: TvSubst -> TvSubst
- getTvInScope :: TvSubst -> InScopeSet
- extendTvInScope :: TvSubst -> Var -> TvSubst
- extendTvInScopeList :: TvSubst -> [Var] -> TvSubst
- extendTvSubst :: TvSubst -> TyVar -> Type -> TvSubst
- extendTvSubstList :: TvSubst -> [TyVar] -> [Type] -> TvSubst
- isInScope :: Var -> TvSubst -> Bool
- composeTvSubst :: InScopeSet -> TvSubstEnv -> TvSubstEnv -> TvSubstEnv
- zipTyEnv :: [TyVar] -> [Type] -> TvSubstEnv
- isEmptyTvSubst :: TvSubst -> Bool
- unionTvSubst :: TvSubst -> TvSubst -> TvSubst
- substTy :: TvSubst -> Type -> Type
- substTys :: TvSubst -> [Type] -> [Type]
- substTyWith :: [TyVar] -> [Type] -> Type -> Type
- substTysWith :: [TyVar] -> [Type] -> [Type] -> [Type]
- substTheta :: TvSubst -> ThetaType -> ThetaType
- substTyVar :: TvSubst -> TyVar -> Type
- substTyVars :: TvSubst -> [TyVar] -> [Type]
- substTyVarBndr :: TvSubst -> TyVar -> (TvSubst, TyVar)
- cloneTyVarBndr :: TvSubst -> TyVar -> Unique -> (TvSubst, TyVar)
- deShadowTy :: TyVarSet -> Type -> Type
- lookupTyVar :: TvSubst -> TyVar -> Maybe Type
- substKiWith :: [KindVar] -> [Kind] -> Kind -> Kind
- substKisWith :: [KindVar] -> [Kind] -> [Kind] -> [Kind]
- pprType :: Type -> SDoc
- pprParendType :: Type -> SDoc
- pprTypeApp :: TyCon -> [Type] -> SDoc
- pprTyThingCategory :: TyThing -> SDoc
- pprTyThing :: TyThing -> SDoc
- pprTvBndr :: TyVar -> SDoc
- pprTvBndrs :: [TyVar] -> SDoc
- pprForAll :: [TyVar] -> SDoc
- pprUserForAll :: [TyVar] -> SDoc
- pprSigmaType :: Type -> SDoc
- pprTheta :: ThetaType -> SDoc
- pprThetaArrowTy :: ThetaType -> SDoc
- pprClassPred :: Class -> [Type] -> SDoc
- pprKind :: Kind -> SDoc
- pprParendKind :: Kind -> SDoc
- pprSourceTyCon :: TyCon -> SDoc
- data TyPrec
- maybeParen :: TyPrec -> TyPrec -> SDoc -> SDoc
- pprSigmaTypeExtraCts :: Bool -> Type -> SDoc
- tidyType :: TidyEnv -> Type -> Type
- tidyTypes :: TidyEnv -> [Type] -> [Type]
- tidyOpenType :: TidyEnv -> Type -> (TidyEnv, Type)
- tidyOpenTypes :: TidyEnv -> [Type] -> (TidyEnv, [Type])
- tidyOpenKind :: TidyEnv -> Kind -> (TidyEnv, Kind)
- tidyTyVarBndr :: TidyEnv -> TyVar -> (TidyEnv, TyVar)
- tidyTyVarBndrs :: TidyEnv -> [TyVar] -> (TidyEnv, [TyVar])
- tidyFreeTyVars :: TidyEnv -> TyVarSet -> TidyEnv
- tidyOpenTyVar :: TidyEnv -> TyVar -> (TidyEnv, TyVar)
- tidyOpenTyVars :: TidyEnv -> [TyVar] -> (TidyEnv, [TyVar])
- tidyTyVarOcc :: TidyEnv -> TyVar -> TyVar
- tidyTopType :: Type -> Type
- tidyKind :: TidyEnv -> Kind -> Kind

# Main data types representing Types

Types are one of:

- Unboxed
- Iff its representation is other than a pointer Unboxed types are also unlifted.
- Lifted
- Iff it has bottom as an element. Closures always have lifted types: i.e. any let-bound identifier in Core must have a lifted type. Operationally, a lifted object is one that can be entered. Only lifted types may be unified with a type variable.
- Algebraic
- Iff it is a type with one or more constructors, whether
declared with
`data`

or`newtype`

. An algebraic type is one that can be deconstructed with a case expression. This is*not*the same as lifted types, because we also include unboxed tuples in this classification. - Data
- Iff it is a type declared with
`data`

, or a boxed tuple. - Primitive
- Iff it is a built-in type that can't be expressed in Haskell.

Currently, all primitive types are unlifted, but that's not necessarily
the case: for example, `Int`

could be primitive.

Some primitive types are unboxed, such as `Int#`

, whereas some are boxed
but unlifted (such as `ByteArray#`

). The only primitive types that we
classify as algebraic are the unboxed tuples.

Some examples of type classifications that may make this a bit clearer are:

Type primitive boxed lifted algebraic ----------------------------------------------------------------------------- Int# Yes No No No ByteArray# Yes Yes No No (# a, b #) Yes No No Yes ( a, b ) No Yes Yes Yes [a] No Yes Yes Yes

A *source type* is a type that is a separate type as far as the type checker is
concerned, but which has a more low-level representation as far as Core-to-Core
passes and the rest of the back end is concerned.

You don't normally have to worry about this, as the utility functions in this module will automatically convert a source into a representation type if they are spotted, to the best of it's abilities. If you don't want this to happen, use the equivalent functions from the TcType module.

A typecheckable-thing, essentially anything that has a name

type KindOrType = Type Source

A type of the form `p`

of kind `Constraint`

represents a value whose type is
the Haskell predicate `p`

, where a predicate is what occurs before
the `=>`

in a Haskell type.

We use `PredType`

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

It can be expanded into its representation, but:

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

Consider these examples:

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

Here the `Eq a`

and `?x :: Int -> Int`

and `rl`

are all called "predicates"

## Constructing and deconstructing types

mkTyVarTys :: [TyVar] -> [Type] Source

getTyVar :: String -> Type -> TyVar Source

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`

splitAppTy :: Type -> (Type, Type) Source

Attempts to take a type application apart, as in `splitAppTy_maybe`

,
and panics if this is not possible

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

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.

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

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!

repSplitAppTy_maybe :: Type -> Maybe (Type, Type) Source

Does the AppTy split as in `splitAppTy_maybe`

, but assumes that
any Core view stuff is already done

mkFunTy :: Type -> Type -> Type infixr 3 Source

Creates a function type from the given argument and result type

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

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

splitFunTy_maybe :: Type -> Maybe (Type, Type) Source

Attempts to extract the argument and result types from a type

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

splitFunTysN :: Int -> Type -> ([Type], Type) Source

Split off exactly the given number argument types, and panics if that is not possible

funResultTy :: Type -> Type Source

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

zipFunTys :: Outputable a => [a] -> Type -> ([(a, Type)], Type) Source

Splits off argument types from the given type and associating them with the things in the input list from left to right. The final result type is returned, along with the resulting pairs of objects and types, albeit with the list of pairs in reverse order. Panics if there are not enough argument types for the input list.

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

A key function: builds a `TyConApp`

or `FunTy`

as appropriate to
its arguments. Applies its arguments to the constructor from left to right.

mkTyConTy :: TyCon -> Type Source

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

tyConAppTyCon_maybe :: Type -> Maybe TyCon Source

The same as `fst . splitTyConApp`

tyConAppArgs_maybe :: Type -> Maybe [Type] Source

The same as `snd . splitTyConApp`

tyConAppTyCon :: Type -> TyCon Source

tyConAppArgs :: Type -> [Type] Source

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

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

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

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`

tyConAppArgN :: Int -> Type -> Type Source

nextRole :: Type -> Role Source

What is the role assigned to the next parameter of this type? Usually,
this will be `Nominal`

, but if the type is a `TyConApp`

, we may be able to
do better. The type does *not* have to be well-kinded when applied for this
to work!

mkForAllTy :: TyVar -> Type -> Type Source

mkForAllTys :: [TyVar] -> Type -> Type Source

Wraps foralls over the type using the provided `TyVar`

s from left to right

splitForAllTy_maybe :: Type -> Maybe (TyVar, Type) Source

Attempts to take a forall type apart, returning the bound type variable and the remainder of the type

splitForAllTys :: Type -> ([TyVar], Type) Source

Attempts to take a forall type apart, returning all the immediate such bound
type variables and the remainder of the type. Always suceeds, even if that means
returning an empty list of `TyVar`

s

mkPiType :: Var -> Type -> Type Source

Makes a `(->)`

type or a forall type, depending
on whether it is given a type variable or a term variable.

applyTy :: Type -> KindOrType -> Type Source

Instantiate a forall type with one or more type arguments. Used when we have a polymorphic function applied to type args:

f t1 t2

We use `applyTys type-of-f [t1,t2]`

to compute the type of the expression.
Panics if no application is possible.

applyTys :: Type -> [KindOrType] -> Type Source

This function is interesting because:

- The function may have more for-alls than there are args
- Less obviously, it may have fewer for-alls

For case 2. think of:

applyTys (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 `undefined`

s type.

dropForAlls :: Type -> Type Source

Equivalent to `snd . splitForAllTys`

mkNumLitTy :: Integer -> Type Source

isNumLitTy :: Type -> Maybe Integer Source

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

mkStrLitTy :: FastString -> Type Source

isStrLitTy :: Type -> Maybe FastString Source

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

coAxNthLHS :: CoAxiom br -> Int -> Type Source

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

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

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.

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

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)

isDictLikeTy :: Type -> Bool Source

mkCoerciblePred :: Type -> Type -> PredType Source

mkPrimEqPred :: Type -> Type -> Type Source

mkReprPrimEqPred :: Type -> Type -> Type Source

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

isClassPred :: PredType -> Bool Source

isIPPred_maybe :: Type -> Maybe (FastString, Type) Source

getClassPredTys :: PredType -> (Class, [Type]) Source

getEqPredTys :: PredType -> (Type, Type) Source

getEqPredRole :: PredType -> Role Source

predTypeEqRel :: PredType -> EqRel Source

Get the equality relation relevant for a pred type.

## Common type constructors

## Predicates on types

allDistinctTyVars :: [KindOrType] -> Bool Source

isForAllTy :: Type -> Bool Source

isUnLiftedType :: Type -> Bool Source

See Type for what an unlifted type is

isUnboxedTupleType :: Type -> Bool Source

isAlgType :: Type -> Bool Source

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

isClosedAlgType :: Type -> Bool Source

See Type for what an algebraic type is.
Should only be applied to *types*, as opposed to e.g. partially
saturated type constructors. Closed type constructors are those
with a fixed right hand side, as opposed to e.g. associated types

isPrimitiveType :: Type -> Bool Source

Returns true of types that are opaque to Haskell.

isStrictType :: Type -> Bool Source

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`

.

# Main data types representing Kinds

The key type representing kinds in the compiler. Invariant: a kind is always in one of these forms:

FunTy k1 k2 TyConApp PrimTyCon [...] TyVar kv -- (during inference only) ForAll ... -- (for top-level coercions)

type SimpleKind = Kind Source

type MetaKindVar = TyVar Source

## Finding the kind of a type

## Common Kinds and SuperKinds

## Common Kind type constructors

# Type free variables

tyVarsOfType :: Type -> VarSet Source

NB: for type synonyms tyVarsOfType does *not* expand the synonym
tyVarsOfType returns only the free variables of a type
For example, tyVarsOfType (a::k) returns {a}, not including the
kind variable {k}

tyVarsOfTypes :: [Type] -> TyVarSet Source

closeOverKinds :: TyVarSet -> TyVarSet Source

expandTypeSynonyms :: Type -> Type Source

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.

varSetElemsKvsFirst :: VarSet -> [TyVar] Source

# Type comparison

eqType :: Type -> Type -> Bool Source

Type equality on source types. Does not look through `newtypes`

or
`PredType`

s, but it does look through type synonyms.
Watch out for horrible hack: See Note [Comparison with OpenTypeKind]

# Forcing evaluation of types

# Other views onto Types

coreView :: Type -> Maybe Type Source

In Core, we "look through" non-recursive newtypes and `PredTypes`

: this
function tries to obtain a different view of the supplied type given this

Strips off the *top layer only* of a type to give
its underlying representation type.
Returns Nothing if there is nothing to look through.

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

tcView :: Type -> Maybe Type Source

Similar to `coreView`

, but for the type checker, which just looks through synonyms

flattenRepType :: RepType -> [UnaryType] Source

repType :: Type -> RepType Source

Looks through:

- For-alls
- Synonyms
- Predicates
- All newtypes, including recursive ones, but not newtype families

It's useful in the back end of the compiler.

tyConsOfType :: Type -> NameEnv TyCon Source

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

# Type representation for the code generator

typePrimRep :: UnaryType -> PrimRep Source

Discovers the primitive representation of a more abstract `UnaryType`

typeRepArity :: Arity -> Type -> RepArity Source

# Main type substitution data types

Type substitution

The following invariants must hold of a `TvSubst`

:

- The in-scope set is needed
*only*to guide the generation of fresh uniques - In particular, the
*kind*of the type variables in the in-scope set is not relevant - The substitution is only applied ONCE! This is because in general such application will not reached a fixed point.

## Manipulating type substitutions

mkTvSubst :: InScopeSet -> TvSubstEnv -> TvSubst Source

mkOpenTvSubst :: TvSubstEnv -> TvSubst Source

Generates the in-scope set for the `TvSubst`

from the types in the incoming
environment, hence "open"

zipOpenTvSubst :: [TyVar] -> [Type] -> TvSubst Source

Generates the in-scope set for the `TvSubst`

from the types in the incoming
environment, hence "open"

zipTopTvSubst :: [TyVar] -> [Type] -> TvSubst Source

mkTopTvSubst :: [(TyVar, Type)] -> TvSubst Source

Called when doing top-level substitutions. Here we expect that the free vars of the range of the substitution will be empty.

notElemTvSubst :: CoVar -> TvSubst -> Bool Source

getTvSubstEnv :: TvSubst -> TvSubstEnv Source

setTvSubstEnv :: TvSubst -> TvSubstEnv -> TvSubst Source

zapTvSubstEnv :: TvSubst -> TvSubst Source

getTvInScope :: TvSubst -> InScopeSet Source

extendTvInScope :: TvSubst -> Var -> TvSubst Source

extendTvInScopeList :: TvSubst -> [Var] -> TvSubst Source

composeTvSubst :: InScopeSet -> TvSubstEnv -> TvSubstEnv -> TvSubstEnv Source

`(compose env1 env2)(x)`

is `env1(env2(x))`

; i.e. apply `env2`

then `env1`

.
It assumes that both are idempotent.
Typically, `env1`

is the refinement to a base substitution `env2`

zipTyEnv :: [TyVar] -> [Type] -> TvSubstEnv Source

isEmptyTvSubst :: TvSubst -> Bool Source

unionTvSubst :: TvSubst -> TvSubst -> TvSubst Source

## Performing substitution on types and kinds

substTyWith :: [TyVar] -> [Type] -> Type -> Type Source

Type substitution making use of an `TvSubst`

that
is assumed to be open, see `zipOpenTvSubst`

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

Type substitution making use of an `TvSubst`

that
is assumed to be open, see `zipOpenTvSubst`

substTyVar :: TvSubst -> TyVar -> Type Source

substTyVars :: TvSubst -> [TyVar] -> [Type] Source

deShadowTy :: TyVarSet -> Type -> Type Source

# Pretty-printing

pprParendType :: Type -> SDoc Source

pprTypeApp :: TyCon -> [Type] -> SDoc Source

pprTyThingCategory :: TyThing -> SDoc Source

pprTyThing :: TyThing -> SDoc Source

pprTvBndrs :: [TyVar] -> SDoc Source

pprUserForAll :: [TyVar] -> SDoc Source

pprSigmaType :: Type -> SDoc Source

pprThetaArrowTy :: ThetaType -> SDoc Source

pprClassPred :: Class -> [Type] -> SDoc Source

pprParendKind :: Kind -> SDoc Source

pprSourceTyCon :: TyCon -> SDoc Source

pprSigmaTypeExtraCts :: Bool -> Type -> SDoc Source

# Tidying type related things up for printing

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

Grabs the free type variables, tidies them
and then uses `tidyType`

to work over the type itself

tidyTyVarBndrs :: TidyEnv -> [TyVar] -> (TidyEnv, [TyVar]) Source

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.

tidyFreeTyVars :: TidyEnv -> TyVarSet -> TidyEnv Source

Add the free `TyVar`

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

tidyOpenTyVar :: TidyEnv -> TyVar -> (TidyEnv, TyVar) Source

Treat a new `TyVar`

as a binder, and give it a fresh tidy name
using the environment if one has not already been allocated. See
also `tidyTyVarBndr`

tidyTyVarOcc :: TidyEnv -> TyVar -> TyVar Source

tidyTopType :: Type -> Type Source

Calls `tidyType`

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