This class exposes the method resolveNames which will perform name resolution for all the fields in a datatype.

Example usage: we define a record that will hold the things we want to look up, using the Wear type family.

For example:

data MyData n
  = MyData
  { myClass       :: !( Wear n Class )
  , myTyCon       :: !( Wear n TyCon )
  , myDataCon     :: !( Wear n DataCon )
  , myPromDataCon :: !( Wear n (Promoted DataCon) )
  }
  deriving stock Generic
  deriving ResolveNames
    via Generically1 MyData

Now we can specify the names of the things which we want to look up, together with the modules and packages in which they belong:

myNames :: MyData Named
myNames = MyData
 { myClass = QualifiedName "MyClass" "My.Module" ( Just "my-pkg-name" )
 , ...
 }

Then we can call resolveNames:

resolvedNames :: MonadTcPlugin m => m (MyData Resolved)
resolvedNames = resolveNames myNames

This returns a record containing the looked up things we want, e.g. myClass :: Class, myPromDataCon :: TyCon, etc.

Resolve a collection of names.

See ResolveNames for further details.

Type-family used for higher-kinded data pattern.

This allows the same record to be re-used, as explained in the worked example for ResolveNames.

For instance, if one defines:

data MyData n
  = MyData
  { myClass :: !( Wear n Class )
  , myTyCon :: !( Wear n TyCon )
  }

then a record of type MyData Named is simply a record of textual names (a typeclass name and a type-constructor name, with associated module & packages), whereas a record of type MyData Resolved contains a typeclass's Class as well as a type-constructor's TyCon.

A QualifiedName is the name of something, together with the names of the module and package it comes from.

Type-level parameter to Wear type family, for higher-kinded data.

Wear Named thing is the identifier data passed in as an argument. Wear Resolved thing is the result of name resolving the thing.

This allows users to pass a record of names, of type MyData Named, and obtain a record of looked-up things, of type MyData Resolved.

Refer to ResolveNames for a worked example.

Use this to refer to a Promoted DataCon.

Type-class overloading things that can be looked up by name:

• classes,
• data constructors (as well as their promotion),
• type-constructors.

A type whose instances are defined generically, using the Generic1 representation. Generically1 is a higher-kinded version of Generically that uses Generic.

Generic instances can be derived for type constructors via Generically1 F using -XDerivingVia.

{-# LANGUAGE DeriveGeneric      #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE DerivingVia        #-}

import GHC.Generics (Generic)

data V4 a = V4 a a a a
  deriving stock (Functor, Generic1)

  deriving Applicative
  via Generically1 V4

This corresponds to Applicative instances defined by pointwise lifting:

instance Applicative V4 where
  pure :: a -> V4 a
  pure a = V4 a a a a

  liftA2 :: (a -> b -> c) -> (V4 a -> V4 b -> V4 c)
  liftA2 (·) (V4 a1 b1 c1 d1) (V4 a2 b2 c2 d2) =
    V4 (a1 · a2) (b1 · b2) (c1 · c2) (d1 · d2)

Historically this required modifying the type class to include generic method definitions (-XDefaultSignatures) and deriving it with the anyclass strategy (-XDeriveAnyClass). Having a /via type/ like Generically1 decouples the instance from the type class.

Since: base-4.17.0.0