Documentation

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

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

Apply arguments to a type constructor

Haskell's reserved identifiers, which cannot be used as names of functions or class methods.

This mirrors the check GHC applies to spliced declarations (okVarOcc/reservedIds in GHC.Utils.Lexeme from ghc-boot, on which we do not wish to depend). GHC 9.10 and later treat forall as an unconditional keyword, so it is included when building with those GHCs.

Identifiers reserved by GHC language extensions.

Identifiers that explicit-forall extensions reserve: forall.

Identifiers that the RecursiveDo extension reserves: mdo and rec.

Identifiers that the Arrows extension reserves: proc and rec.

Identifiers that the PatternSynonyms extension reserves: pattern.

Identifiers that the TransformListComp extension reserves: by and using.

Identifiers that the StaticPointers extension reserves: static.

Identifiers that the RoleAnnotations extension reserves: role.

This is provided for callers who want a conservative list of extension keywords. activeKeywords deliberately does not reject role, since it is still valid as a generated function or class method name.

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.

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

Convert a TyVarBndr into its corresponding Type.

Haskell keywords plus the identifiers reserved by enabled extensions that would make generated functions or class methods fail to parse.

Append an underscore to a name that belongs to the given set of reserved identifiers; leave all other names untouched.

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