Documentation

Apply arguments to a type constructor

Apply arguments to a function

Construct a tuple type given a list of types.

Construct a tuple value given a list of expressions.

Construct a tuple pattern given a list of patterns.

Apply arguments to a type constructor.

Generate many new names from a given base name.

Decompose an applied type into its individual components. For example, this:

Either Int Char

would be unfolded to this:

(ConT ''Either, [ConT ''Int, ConT ''Char])

This function ignores explicit parentheses and visible kind applications.

In an effort to prevent users from having to enable KindSignatures every time that they use lens' TH functionality, we strip off reified kind annotations from when:

1. The kind of a type does not contain any kind variables. If it *does* contain kind variables, we want to preserve them so that we can generate type signatures that preserve the dependency order of kind and type variables. (The data types in test/T917.hs contain examples where this is important.) This will require enabling PolyKinds, but since PolyKinds implies KindSignatures, we can at least accomplish two things at once.
2. The data type is not an instance of a data family. We make an exception for data family instances, since the presence or absence of a kind annotation can be the difference between typechecking or not. (See T917DataFam in tests/T917.hs for an example.) Moreover, the TypeFamilies extension implies KindSignatures.

Template Haskell wants type variables declared in a forall, so we find all free type variables in a given type and declare them.

This function works like quantifyType except that it takes a list of variables to exclude from quantification.

Convert a TyVarBndr into its corresponding Type.

Peel off a kind signature from a Type (if it has one).

A TyVarBndr with a BndrVis flag. This is used for TyVarBndrs in type-level declarations (e.g., the binders in data D @k (a :: k)).